Page MenuHomePhabricator
Differential D9992

[Flow202][native][skip-ci] [8/x] Fix incorrect ReactNav types in navigators & screens
ClosedPublic
Actions

Authored by ashoat on Nov 27 2023, 12:30 AM.
Tags
None
Referenced Files
Unknown Object (File)
Fri, Mar 21, 2:44 AM
Unknown Object (File)
Tue, Mar 18, 5:39 AM
Unknown Object (File)
Tue, Mar 18, 5:39 AM
Unknown Object (File)
Tue, Mar 18, 5:37 AM
Unknown Object (File)
Tue, Mar 18, 5:23 AM
Unknown Object (File)
Mon, Mar 3, 9:08 PM
Unknown Object (File)
Feb 14 2025, 5:23 AM
Unknown Object (File)
Feb 14 2025, 5:23 AM
View All 87 Files
Subscribers
None

Details

Reviewers
ginsu
atul
tomek
Commits
rCOMM589c1b17ac1e: [Flow202][native][skip-ci] [8/x] Fix incorrect ReactNav types in navigators &…
Summary

The new version of Flow is stricter with types, and exposed several errors in our typing of navigators and screens.

Some of these are pretty bad, but the good news is that Flow should make sure we don't make the same mistakes again going forward.

NOTE: CI will fail on this diff. I considered the possibility of fixing Flow errors BEFORE upgrading Flow, but it wasn't possible... in some cases, the fixes to support the new version of Flow caused errors in the old version. I could have hidden these type errors with $FlowFixMe lines and then later revert those, but that seemed like too much busy work.

Depends on D9991

Test Plan

Confirm the Flow errors go away

Diff Detail

Repository
rCOMM Comm
Lint
No Lint Coverage
Unit
No Test Coverage
Build Status
Buildable 24433
Build 210149: arc lint + arc unit

Revision Contents
Changeset List

Diff 33636

View Options

native/chat/chat.react.js

  • This file was added.
// @flow
import * as React from 'react';
import { type SetState } from 'lib/types/hook-types';
import { type RelationshipButton } from 'lib/types/relationship-types';
import { type ThreadInfo } from 'lib/types/thread-types';
import type { UserInfo } from 'lib/types/user-types';
import ThreadSettingsRelationshipButton from './thread-settings-relationship-button.react';
import css from './thread-settings-relationship-tab.css';
type Props = {
+threadSettingsOperationInProgress: boolean,
+threadInfo: ThreadInfo,
tomekUnsubmitted
Not Done
Inline Actions

These props aren't used. Shouldn't this give a warning?

tomek: These props aren't used. Shouldn't this give a warning?
jacekAuthorUnsubmitted
Done
Inline Actions

Interesting. I thought flow should indicate warning for such variables.

jacek: Interesting. I thought flow should indicate warning for such variables.
ashoatUnsubmitted
Not Done
Inline Actions

There can be a good reason for having a prop that you never use: to force the component to rerender. For instance, we do something similar here

ashoat: There can be a good reason for having a prop that you never use: to force the component to…
+setErrorMessage: SetState<string>,
+relationshipButtons: $ReadOnlyArray<RelationshipButton>,
+otherUserInfo: UserInfo,
};
function ThreadSettingsRelationshipTab(props: Props): React.Node {
const { relationshipButtons, otherUserInfo, setErrorMessage } = props;
const buttons = React.useMemo(() => {
return relationshipButtons.map(action => {
return (
<ThreadSettingsRelationshipButton
key={action}
relationshipButton={action}
otherUserInfo={otherUserInfo}
setErrorMessage={setErrorMessage}
tomekUnsubmitted
Not Done
Inline Actions

In ThreadSettingsRelationshipButton setErrorMessage is string => void but here we use SetState<string>. Is flow ok with that? Is there a good reason for having different types?

tomek: In `ThreadSettingsRelationshipButton` `setErrorMessage` is `string => void` but here we use…
jacekAuthorUnsubmitted
Done
Inline Actions

Flow is ok here. I'll replace the type in ...Button with SetState<string>

jacek: Flow is ok here. I'll replace the type in `...Button` with `SetState<string>`
/>
);
});
}, [otherUserInfo, relationshipButtons, setErrorMessage]);
return <div className={css.container}>{buttons}</div>;
}
export default ThreadSettingsRelationshipTab;
View Options

native/navigation/community-drawer-button.react.js

  • This file was added.
// @flow
import * as React from 'react';
import { type SetState } from 'lib/types/hook-types';
import { type RelationshipButton } from 'lib/types/relationship-types';
import { type ThreadInfo } from 'lib/types/thread-types';
import type { UserInfo } from 'lib/types/user-types';
import ThreadSettingsRelationshipButton from './thread-settings-relationship-button.react';
import css from './thread-settings-relationship-tab.css';
type Props = {
+threadSettingsOperationInProgress: boolean,
+threadInfo: ThreadInfo,
tomekUnsubmitted
Not Done
Inline Actions

These props aren't used. Shouldn't this give a warning?

tomek: These props aren't used. Shouldn't this give a warning?
jacekAuthorUnsubmitted
Done
Inline Actions

Interesting. I thought flow should indicate warning for such variables.

jacek: Interesting. I thought flow should indicate warning for such variables.
ashoatUnsubmitted
Not Done
Inline Actions

There can be a good reason for having a prop that you never use: to force the component to rerender. For instance, we do something similar here

ashoat: There can be a good reason for having a prop that you never use: to force the component to…
+setErrorMessage: SetState<string>,
+relationshipButtons: $ReadOnlyArray<RelationshipButton>,
+otherUserInfo: UserInfo,
};
function ThreadSettingsRelationshipTab(props: Props): React.Node {
const { relationshipButtons, otherUserInfo, setErrorMessage } = props;
const buttons = React.useMemo(() => {
return relationshipButtons.map(action => {
return (
<ThreadSettingsRelationshipButton
key={action}
relationshipButton={action}
otherUserInfo={otherUserInfo}
setErrorMessage={setErrorMessage}
tomekUnsubmitted
Not Done
Inline Actions

In ThreadSettingsRelationshipButton setErrorMessage is string => void but here we use SetState<string>. Is flow ok with that? Is there a good reason for having different types?

tomek: In `ThreadSettingsRelationshipButton` `setErrorMessage` is `string => void` but here we use…
jacekAuthorUnsubmitted
Done
Inline Actions

Flow is ok here. I'll replace the type in ...Button with SetState<string>

jacek: Flow is ok here. I'll replace the type in `...Button` with `SetState<string>`
/>
);
});
}, [otherUserInfo, relationshipButtons, setErrorMessage]);
return <div className={css.container}>{buttons}</div>;
}
export default ThreadSettingsRelationshipTab;
View Options

native/navigation/tab-router.js

  • This file was added.
// @flow
import * as React from 'react';
import { type SetState } from 'lib/types/hook-types';
import { type RelationshipButton } from 'lib/types/relationship-types';
import { type ThreadInfo } from 'lib/types/thread-types';
import type { UserInfo } from 'lib/types/user-types';
import ThreadSettingsRelationshipButton from './thread-settings-relationship-button.react';
import css from './thread-settings-relationship-tab.css';
type Props = {
+threadSettingsOperationInProgress: boolean,
+threadInfo: ThreadInfo,
tomekUnsubmitted
Not Done
Inline Actions

These props aren't used. Shouldn't this give a warning?

tomek: These props aren't used. Shouldn't this give a warning?
jacekAuthorUnsubmitted
Done
Inline Actions

Interesting. I thought flow should indicate warning for such variables.

jacek: Interesting. I thought flow should indicate warning for such variables.
ashoatUnsubmitted
Not Done
Inline Actions

There can be a good reason for having a prop that you never use: to force the component to rerender. For instance, we do something similar here

ashoat: There can be a good reason for having a prop that you never use: to force the component to…
+setErrorMessage: SetState<string>,
+relationshipButtons: $ReadOnlyArray<RelationshipButton>,
+otherUserInfo: UserInfo,
};
function ThreadSettingsRelationshipTab(props: Props): React.Node {
const { relationshipButtons, otherUserInfo, setErrorMessage } = props;
const buttons = React.useMemo(() => {
return relationshipButtons.map(action => {
return (
<ThreadSettingsRelationshipButton
key={action}
relationshipButton={action}
otherUserInfo={otherUserInfo}
setErrorMessage={setErrorMessage}
tomekUnsubmitted
Not Done
Inline Actions

In ThreadSettingsRelationshipButton setErrorMessage is string => void but here we use SetState<string>. Is flow ok with that? Is there a good reason for having different types?

tomek: In `ThreadSettingsRelationshipButton` `setErrorMessage` is `string => void` but here we use…
jacekAuthorUnsubmitted
Done
Inline Actions

Flow is ok here. I'll replace the type in ...Button with SetState<string>

jacek: Flow is ok here. I'll replace the type in `...Button` with `SetState<string>`
/>
);
});
}, [otherUserInfo, relationshipButtons, setErrorMessage]);
return <div className={css.container}>{buttons}</div>;
}
export default ThreadSettingsRelationshipTab;
View Options

native/profile/profile.react.js

  • This file was added.
// @flow
import * as React from 'react';
import { type SetState } from 'lib/types/hook-types';
import { type RelationshipButton } from 'lib/types/relationship-types';
import { type ThreadInfo } from 'lib/types/thread-types';
import type { UserInfo } from 'lib/types/user-types';
import ThreadSettingsRelationshipButton from './thread-settings-relationship-button.react';
import css from './thread-settings-relationship-tab.css';
type Props = {
+threadSettingsOperationInProgress: boolean,
+threadInfo: ThreadInfo,
tomekUnsubmitted
Not Done
Inline Actions

These props aren't used. Shouldn't this give a warning?

tomek: These props aren't used. Shouldn't this give a warning?
jacekAuthorUnsubmitted
Done
Inline Actions

Interesting. I thought flow should indicate warning for such variables.

jacek: Interesting. I thought flow should indicate warning for such variables.
ashoatUnsubmitted
Not Done
Inline Actions

There can be a good reason for having a prop that you never use: to force the component to rerender. For instance, we do something similar here

ashoat: There can be a good reason for having a prop that you never use: to force the component to…
+setErrorMessage: SetState<string>,
+relationshipButtons: $ReadOnlyArray<RelationshipButton>,
+otherUserInfo: UserInfo,
};
function ThreadSettingsRelationshipTab(props: Props): React.Node {
const { relationshipButtons, otherUserInfo, setErrorMessage } = props;
const buttons = React.useMemo(() => {
return relationshipButtons.map(action => {
return (
<ThreadSettingsRelationshipButton
key={action}
relationshipButton={action}
otherUserInfo={otherUserInfo}
setErrorMessage={setErrorMessage}
tomekUnsubmitted
Not Done
Inline Actions

In ThreadSettingsRelationshipButton setErrorMessage is string => void but here we use SetState<string>. Is flow ok with that? Is there a good reason for having different types?

tomek: In `ThreadSettingsRelationshipButton` `setErrorMessage` is `string => void` but here we use…
jacekAuthorUnsubmitted
Done
Inline Actions

Flow is ok here. I'll replace the type in ...Button with SetState<string>

jacek: Flow is ok here. I'll replace the type in `...Button` with `SetState<string>`
/>
);
});
}, [otherUserInfo, relationshipButtons, setErrorMessage]);
return <div className={css.container}>{buttons}</div>;
}
export default ThreadSettingsRelationshipTab;
View Options

native/profile/user-relationship-tooltip-modal.react.js

  • This file was added.
// @flow
import * as React from 'react';
import { type SetState } from 'lib/types/hook-types';
import { type RelationshipButton } from 'lib/types/relationship-types';
import { type ThreadInfo } from 'lib/types/thread-types';
import type { UserInfo } from 'lib/types/user-types';
import ThreadSettingsRelationshipButton from './thread-settings-relationship-button.react';
import css from './thread-settings-relationship-tab.css';
type Props = {
+threadSettingsOperationInProgress: boolean,
+threadInfo: ThreadInfo,
tomekUnsubmitted
Not Done
Inline Actions

These props aren't used. Shouldn't this give a warning?

tomek: These props aren't used. Shouldn't this give a warning?
jacekAuthorUnsubmitted
Done
Inline Actions

Interesting. I thought flow should indicate warning for such variables.

jacek: Interesting. I thought flow should indicate warning for such variables.
ashoatUnsubmitted
Not Done
Inline Actions

There can be a good reason for having a prop that you never use: to force the component to rerender. For instance, we do something similar here

ashoat: There can be a good reason for having a prop that you never use: to force the component to…
+setErrorMessage: SetState<string>,
+relationshipButtons: $ReadOnlyArray<RelationshipButton>,
+otherUserInfo: UserInfo,
};
function ThreadSettingsRelationshipTab(props: Props): React.Node {
const { relationshipButtons, otherUserInfo, setErrorMessage } = props;
const buttons = React.useMemo(() => {
return relationshipButtons.map(action => {
return (
<ThreadSettingsRelationshipButton
key={action}
relationshipButton={action}
otherUserInfo={otherUserInfo}
setErrorMessage={setErrorMessage}
tomekUnsubmitted
Not Done
Inline Actions

In ThreadSettingsRelationshipButton setErrorMessage is string => void but here we use SetState<string>. Is flow ok with that? Is there a good reason for having different types?

tomek: In `ThreadSettingsRelationshipButton` `setErrorMessage` is `string => void` but here we use…
jacekAuthorUnsubmitted
Done
Inline Actions

Flow is ok here. I'll replace the type in ...Button with SetState<string>

jacek: Flow is ok here. I'll replace the type in `...Button` with `SetState<string>`
/>
);
});
}, [otherUserInfo, relationshipButtons, setErrorMessage]);
return <div className={css.container}>{buttons}</div>;
}
export default ThreadSettingsRelationshipTab;
View Options

native/user-profile/user-profile-bottom-sheet-navigator.react.js

Loading...
View Options

native/user-profile/user-profile-bottom-sheet.react.js

Loading...