{"files":[{"status":"A","path":"compiler\/packages\/babel-plugin-react-compiler\/src\/Flood\/FlowTypes.ts"},{"status":"A","path":"compiler\/packages\/babel-plugin-react-compiler\/src\/Flood\/TypeErrors.ts"},{"status":"A","path":"compiler\/packages\/babel-plugin-react-compiler\/src\/Flood\/TypeUtils.ts"},{"status":"A","path":"compiler\/packages\/babel-plugin-react-compiler\/src\/Flood\/Types.ts"},{"status":"M","path":"compiler\/packages\/babel-plugin-react-compiler\/src\/HIR\/Environment.ts"},{"status":"M","path":"compiler\/packages\/babel-plugin-react-compiler\/src\/ReactiveScopes\/MergeReactiveScopesThatInvalidateTogether.ts"},{"status":"M","path":"compiler\/packages\/babel-plugin-react-compiler\/src\/Utils\/DisjointSet.ts"},{"status":"M","path":"compiler\/packages\/babel-plugin-react-compiler\/src\/Utils\/utils.ts"}],"parents":["fa212fc2b14c2262849c8eab01e7c1895cb20c63"],"body":"all credit on the Flood\/ code goes to @mvitousek and @jbrown215, i'm\njust the one upstreaming it","patch":"diff --git a\/compiler\/packages\/babel-plugin-react-compiler\/src\/Flood\/FlowTypes.ts b\/compiler\/packages\/babel-plugin-react-compiler\/src\/Flood\/FlowTypes.ts\nnew file mode 100644\nindex 0000000000..c63feb830f\n--- \/dev\/null\n+++ b\/compiler\/packages\/babel-plugin-react-compiler\/src\/Flood\/FlowTypes.ts\n@@ -0,0 +1,752 @@\n+\/**\n+ * TypeScript definitions for Flow type JSON representations\n+ * Based on the output of \/data\/sandcastle\/boxes\/fbsource\/fbcode\/flow\/src\/typing\/convertTypes.ml\n+ *\/\n+\n+\/\/ Base type for all Flow types with a kind field\n+export interface BaseFlowType {\n+ kind: string;\n+}\n+\n+\/\/ Type for representing polarity\n+export type Polarity = 'positive' | 'negative' | 'neutral';\n+\n+\/\/ Type for representing a name that might be null\n+export type OptionalName = string | null;\n+\n+\/\/ Open type\n+export interface OpenType extends BaseFlowType {\n+ kind: 'Open';\n+}\n+\n+\/\/ Def type\n+export interface DefType extends BaseFlowType {\n+ kind: 'Def';\n+ def: DefT;\n+}\n+\n+\/\/ Eval type\n+export interface EvalType extends BaseFlowType {\n+ kind: 'Eval';\n+ type: FlowType;\n+ destructor: Destructor;\n+}\n+\n+\/\/ Generic type\n+export interface GenericType extends BaseFlowType {\n+ kind: 'Generic';\n+ name: string;\n+ bound: FlowType;\n+ no_infer: boolean;\n+}\n+\n+\/\/ ThisInstance type\n+export interface ThisInstanceType extends BaseFlowType {\n+ kind: 'ThisInstance';\n+ instance: InstanceT;\n+ is_this: boolean;\n+ name: string;\n+}\n+\n+\/\/ ThisTypeApp type\n+export interface ThisTypeAppType extends BaseFlowType {\n+ kind: 'ThisTypeApp';\n+ t1: FlowType;\n+ t2: FlowType;\n+ t_list?: Array;\n+}\n+\n+\/\/ TypeApp type\n+export interface TypeAppType extends BaseFlowType {\n+ kind: 'TypeApp';\n+ type: FlowType;\n+ targs: Array;\n+ from_value: boolean;\n+ use_desc: boolean;\n+}\n+\n+\/\/ FunProto type\n+export interface FunProtoType extends BaseFlowType {\n+ kind: 'FunProto';\n+}\n+\n+\/\/ ObjProto type\n+export interface ObjProtoType extends BaseFlowType {\n+ kind: 'ObjProto';\n+}\n+\n+\/\/ NullProto type\n+export interface NullProtoType extends BaseFlowType {\n+ kind: 'NullProto';\n+}\n+\n+\/\/ FunProtoBind type\n+export interface FunProtoBindType extends BaseFlowType {\n+ kind: 'FunProtoBind';\n+}\n+\n+\/\/ Intersection type\n+export interface IntersectionType extends BaseFlowType {\n+ kind: 'Intersection';\n+ members: Array;\n+}\n+\n+\/\/ Union type\n+export interface UnionType extends BaseFlowType {\n+ kind: 'Union';\n+ members: Array;\n+}\n+\n+\/\/ Maybe type\n+export interface MaybeType extends BaseFlowType {\n+ kind: 'Maybe';\n+ type: FlowType;\n+}\n+\n+\/\/ Optional type\n+export interface OptionalType extends BaseFlowType {\n+ kind: 'Optional';\n+ type: FlowType;\n+ use_desc: boolean;\n+}\n+\n+\/\/ Keys type\n+export interface KeysType extends BaseFlowType {\n+ kind: 'Keys';\n+ type: FlowType;\n+}\n+\n+\/\/ Annot type\n+export interface AnnotType extends BaseFlowType {\n+ kind: 'Annot';\n+ type: FlowType;\n+ use_desc: boolean;\n+}\n+\n+\/\/ Opaque type\n+export interface OpaqueType extends BaseFlowType {\n+ kind: 'Opaque';\n+ opaquetype: {\n+ opaque_id: string;\n+ underlying_t: FlowType | null;\n+ super_t: FlowType | null;\n+ opaque_type_args: Array<{\n+ name: string;\n+ type: FlowType;\n+ polarity: Polarity;\n+ }>;\n+ opaque_name: string;\n+ };\n+}\n+\n+\/\/ Namespace type\n+export interface NamespaceType extends BaseFlowType {\n+ kind: 'Namespace';\n+ namespace_symbol: {\n+ symbol: string;\n+ };\n+ values_type: FlowType;\n+ types_tmap: PropertyMap;\n+}\n+\n+\/\/ Any type\n+export interface AnyType extends BaseFlowType {\n+ kind: 'Any';\n+}\n+\n+\/\/ StrUtil type\n+export interface StrUtilType extends BaseFlowType {\n+ kind: 'StrUtil';\n+ op: 'StrPrefix' | 'StrSuffix';\n+ prefix?: string;\n+ suffix?: string;\n+ remainder?: FlowType;\n+}\n+\n+\/\/ TypeParam definition\n+export interface TypeParam {\n+ name: string;\n+ bound: FlowType;\n+ polarity: Polarity;\n+ default: FlowType | null;\n+}\n+\n+\/\/ EnumInfo types\n+export type EnumInfo = ConcreteEnum | AbstractEnum;\n+\n+export interface ConcreteEnum {\n+ kind: 'ConcreteEnum';\n+ enum_name: string;\n+ enum_id: string;\n+ members: Array;\n+ representation_t: FlowType;\n+ has_unknown_members: boolean;\n+}\n+\n+export interface AbstractEnum {\n+ kind: 'AbstractEnum';\n+ representation_t: FlowType;\n+}\n+\n+\/\/ CanonicalRendersForm types\n+export type CanonicalRendersForm =\n+ | InstrinsicRenders\n+ | NominalRenders\n+ | StructuralRenders\n+ | DefaultRenders;\n+\n+export interface InstrinsicRenders {\n+ kind: 'InstrinsicRenders';\n+ name: string;\n+}\n+\n+export interface NominalRenders {\n+ kind: 'NominalRenders';\n+ renders_id: string;\n+ renders_name: string;\n+ renders_super: FlowType;\n+}\n+\n+export interface StructuralRenders {\n+ kind: 'StructuralRenders';\n+ renders_variant: 'RendersNormal' | 'RendersMaybe' | 'RendersStar';\n+ renders_structural_type: FlowType;\n+}\n+\n+export interface DefaultRenders {\n+ kind: 'DefaultRenders';\n+}\n+\n+\/\/ InstanceT definition\n+export interface InstanceT {\n+ inst: InstType;\n+ static: FlowType;\n+ super: FlowType;\n+ implements: Array;\n+}\n+\n+\/\/ InstType definition\n+export interface InstType {\n+ class_name: string | null;\n+ class_id: string;\n+ type_args: Array<{\n+ name: string;\n+ type: FlowType;\n+ polarity: Polarity;\n+ }>;\n+ own_props: PropertyMap;\n+ proto_props: PropertyMap;\n+ call_t: null | {\n+ id: number;\n+ call: FlowType;\n+ };\n+}\n+\n+\/\/ DefT types\n+export type DefT =\n+ | NumGeneralType\n+ | StrGeneralType\n+ | BoolGeneralType\n+ | BigIntGeneralType\n+ | EmptyType\n+ | MixedType\n+ | NullType\n+ | VoidType\n+ | SymbolType\n+ | FunType\n+ | ObjType\n+ | ArrType\n+ | ClassType\n+ | InstanceType\n+ | SingletonStrType\n+ | NumericStrKeyType\n+ | SingletonNumType\n+ | SingletonBoolType\n+ | SingletonBigIntType\n+ | TypeType\n+ | PolyType\n+ | ReactAbstractComponentType\n+ | RendersType\n+ | EnumValueType\n+ | EnumObjectType;\n+\n+export interface NumGeneralType extends BaseFlowType {\n+ kind: 'NumGeneral';\n+}\n+\n+export interface StrGeneralType extends BaseFlowType {\n+ kind: 'StrGeneral';\n+}\n+\n+export interface BoolGeneralType extends BaseFlowType {\n+ kind: 'BoolGeneral';\n+}\n+\n+export interface BigIntGeneralType extends BaseFlowType {\n+ kind: 'BigIntGeneral';\n+}\n+\n+export interface EmptyType extends BaseFlowType {\n+ kind: 'Empty';\n+}\n+\n+export interface MixedType extends BaseFlowType {\n+ kind: 'Mixed';\n+}\n+\n+export interface NullType extends BaseFlowType {\n+ kind: 'Null';\n+}\n+\n+export interface VoidType extends BaseFlowType {\n+ kind: 'Void';\n+}\n+\n+export interface SymbolType extends BaseFlowType {\n+ kind: 'Symbol';\n+}\n+\n+export interface FunType extends BaseFlowType {\n+ kind: 'Fun';\n+ static: FlowType;\n+ funtype: FunTypeObj;\n+}\n+\n+export interface ObjType extends BaseFlowType {\n+ kind: 'Obj';\n+ objtype: ObjTypeObj;\n+}\n+\n+export interface ArrType extends BaseFlowType {\n+ kind: 'Arr';\n+ arrtype: ArrTypeObj;\n+}\n+\n+export interface ClassType extends BaseFlowType {\n+ kind: 'Class';\n+ type: FlowType;\n+}\n+\n+export interface InstanceType extends BaseFlowType {\n+ kind: 'Instance';\n+ instance: InstanceT;\n+}\n+\n+export interface SingletonStrType extends BaseFlowType {\n+ kind: 'SingletonStr';\n+ from_annot: boolean;\n+ value: string;\n+}\n+\n+export interface NumericStrKeyType extends BaseFlowType {\n+ kind: 'NumericStrKey';\n+ number: string;\n+ string: string;\n+}\n+\n+export interface SingletonNumType extends BaseFlowType {\n+ kind: 'SingletonNum';\n+ from_annot: boolean;\n+ number: string;\n+ string: string;\n+}\n+\n+export interface SingletonBoolType extends BaseFlowType {\n+ kind: 'SingletonBool';\n+ from_annot: boolean;\n+ value: boolean;\n+}\n+\n+export interface SingletonBigIntType extends BaseFlowType {\n+ kind: 'SingletonBigInt';\n+ from_annot: boolean;\n+ value: string;\n+}\n+\n+export interface TypeType extends BaseFlowType {\n+ kind: 'Type';\n+ type_kind: TypeTKind;\n+ type: FlowType;\n+}\n+\n+export type TypeTKind =\n+ | 'TypeAliasKind'\n+ | 'TypeParamKind'\n+ | 'OpaqueKind'\n+ | 'ImportTypeofKind'\n+ | 'ImportClassKind'\n+ | 'ImportEnumKind'\n+ | 'InstanceKind'\n+ | 'RenderTypeKind';\n+\n+export interface PolyType extends BaseFlowType {\n+ kind: 'Poly';\n+ tparams: Array;\n+ t_out: FlowType;\n+ id: string;\n+}\n+\n+export interface ReactAbstractComponentType extends BaseFlowType {\n+ kind: 'ReactAbstractComponent';\n+ config: FlowType;\n+ renders: FlowType;\n+ instance: ComponentInstance;\n+ component_kind: ComponentKind;\n+}\n+\n+export type ComponentInstance =\n+ | {kind: 'RefSetterProp'; type: FlowType}\n+ | {kind: 'Omitted'};\n+\n+export type ComponentKind =\n+ | {kind: 'Structural'}\n+ | {kind: 'Nominal'; id: string; name: string; types: Array | null};\n+\n+export interface RendersType extends BaseFlowType {\n+ kind: 'Renders';\n+ form: CanonicalRendersForm;\n+}\n+\n+export interface EnumValueType extends BaseFlowType {\n+ kind: 'EnumValue';\n+ enum_info: EnumInfo;\n+}\n+\n+export interface EnumObjectType extends BaseFlowType {\n+ kind: 'EnumObject';\n+ enum_value_t: FlowType;\n+ enum_info: EnumInfo;\n+}\n+\n+\/\/ ObjKind types\n+export type ObjKind =\n+ | {kind: 'Exact'}\n+ | {kind: 'Inexact'}\n+ | {kind: 'Indexed'; dicttype: DictType};\n+\n+\/\/ DictType definition\n+export interface DictType {\n+ dict_name: string | null;\n+ key: FlowType;\n+ value: FlowType;\n+ dict_polarity: Polarity;\n+}\n+\n+\/\/ ArrType types\n+export type ArrTypeObj = ArrayAT | TupleAT | ROArrayAT;\n+\n+export interface ArrayAT {\n+ kind: 'ArrayAT';\n+ elem_t: FlowType;\n+}\n+\n+export interface TupleAT {\n+ kind: 'TupleAT';\n+ elem_t: FlowType;\n+ elements: Array;\n+ min_arity: number;\n+ max_arity: number;\n+ inexact: boolean;\n+}\n+\n+export interface ROArrayAT {\n+ kind: 'ROArrayAT';\n+ elem_t: FlowType;\n+}\n+\n+\/\/ TupleElement definition\n+export interface TupleElement {\n+ name: string | null;\n+ t: FlowType;\n+ polarity: Polarity;\n+ optional: boolean;\n+}\n+\n+\/\/ Flags definition\n+export interface Flags {\n+ obj_kind: ObjKind;\n+}\n+\n+\/\/ Property types\n+export type Property =\n+ | FieldProperty\n+ | GetProperty\n+ | SetProperty\n+ | GetSetProperty\n+ | MethodProperty;\n+\n+export interface FieldProperty {\n+ kind: 'Field';\n+ type: FlowType;\n+ polarity: Polarity;\n+}\n+\n+export interface GetProperty {\n+ kind: 'Get';\n+ type: FlowType;\n+}\n+\n+export interface SetProperty {\n+ kind: 'Set';\n+ type: FlowType;\n+}\n+\n+export interface GetSetProperty {\n+ kind: 'GetSet';\n+ get_type: FlowType;\n+ set_type: FlowType;\n+}\n+\n+export interface MethodProperty {\n+ kind: 'Method';\n+ type: FlowType;\n+}\n+\n+\/\/ PropertyMap definition\n+export interface PropertyMap {\n+ [key: string]: Property; \/\/ For other properties in the map\n+}\n+\n+\/\/ ObjType definition\n+export interface ObjTypeObj {\n+ flags: Flags;\n+ props: PropertyMap;\n+ proto_t: FlowType;\n+ call_t: number | null;\n+}\n+\n+\/\/ FunType definition\n+export interface FunTypeObj {\n+ this_t: {\n+ type: FlowType;\n+ status: ThisStatus;\n+ };\n+ params: Array<{\n+ name: string | null;\n+ type: FlowType;\n+ }>;\n+ rest_param: null | {\n+ name: string | null;\n+ type: FlowType;\n+ };\n+ return_t: FlowType;\n+ type_guard: null | {\n+ inferred: boolean;\n+ param_name: string;\n+ type_guard: FlowType;\n+ one_sided: boolean;\n+ };\n+ effect: Effect;\n+}\n+\n+\/\/ ThisStatus types\n+export type ThisStatus =\n+ | {kind: 'This_Method'; unbound: boolean}\n+ | {kind: 'This_Function'};\n+\n+\/\/ Effect types\n+export type Effect =\n+ | {kind: 'HookDecl'; id: string}\n+ | {kind: 'HookAnnot'}\n+ | {kind: 'ArbitraryEffect'}\n+ | {kind: 'AnyEffect'};\n+\n+\/\/ Destructor types\n+export type Destructor =\n+ | NonMaybeTypeDestructor\n+ | PropertyTypeDestructor\n+ | ElementTypeDestructor\n+ | OptionalIndexedAccessNonMaybeTypeDestructor\n+ | OptionalIndexedAccessResultTypeDestructor\n+ | ExactTypeDestructor\n+ | ReadOnlyTypeDestructor\n+ | PartialTypeDestructor\n+ | RequiredTypeDestructor\n+ | SpreadTypeDestructor\n+ | SpreadTupleTypeDestructor\n+ | RestTypeDestructor\n+ | ValuesTypeDestructor\n+ | ConditionalTypeDestructor\n+ | TypeMapDestructor\n+ | ReactElementPropsTypeDestructor\n+ | ReactElementConfigTypeDestructor\n+ | ReactCheckComponentConfigDestructor\n+ | ReactDRODestructor\n+ | MakeHooklikeDestructor\n+ | MappedTypeDestructor\n+ | EnumTypeDestructor;\n+\n+export interface NonMaybeTypeDestructor {\n+ kind: 'NonMaybeType';\n+}\n+\n+export interface PropertyTypeDestructor {\n+ kind: 'PropertyType';\n+ name: string;\n+}\n+\n+export interface ElementTypeDestructor {\n+ kind: 'ElementType';\n+ index_type: FlowType;\n+}\n+\n+export interface OptionalIndexedAccessNonMaybeTypeDestructor {\n+ kind: 'OptionalIndexedAccessNonMaybeType';\n+ index: OptionalIndexedAccessIndex;\n+}\n+\n+export type OptionalIndexedAccessIndex =\n+ | {kind: 'StrLitIndex'; name: string}\n+ | {kind: 'TypeIndex'; type: FlowType};\n+\n+export interface OptionalIndexedAccessResultTypeDestructor {\n+ kind: 'OptionalIndexedAccessResultType';\n+}\n+\n+export interface ExactTypeDestructor {\n+ kind: 'ExactType';\n+}\n+\n+export interface ReadOnlyTypeDestructor {\n+ kind: 'ReadOnlyType';\n+}\n+\n+export interface PartialTypeDestructor {\n+ kind: 'PartialType';\n+}\n+\n+export interface RequiredTypeDestructor {\n+ kind: 'RequiredType';\n+}\n+\n+export interface SpreadTypeDestructor {\n+ kind: 'SpreadType';\n+ target: SpreadTarget;\n+ operands: Array;\n+ operand_slice: Slice | null;\n+}\n+\n+export type SpreadTarget =\n+ | {kind: 'Value'; make_seal: 'Sealed' | 'Frozen' | 'As_Const'}\n+ | {kind: 'Annot'; make_exact: boolean};\n+\n+export type SpreadOperand = {kind: 'Type'; type: FlowType} | Slice;\n+\n+export interface Slice {\n+ kind: 'Slice';\n+ prop_map: PropertyMap;\n+ generics: Array;\n+ dict: DictType | null;\n+ reachable_targs: Array<{\n+ type: FlowType;\n+ polarity: Polarity;\n+ }>;\n+}\n+\n+export interface SpreadTupleTypeDestructor {\n+ kind: 'SpreadTupleType';\n+ inexact: boolean;\n+ resolved_rev: string;\n+ unresolved: string;\n+}\n+\n+export interface RestTypeDestructor {\n+ kind: 'RestType';\n+ merge_mode: RestMergeMode;\n+ type: FlowType;\n+}\n+\n+export type RestMergeMode =\n+ | {kind: 'SpreadReversal'}\n+ | {kind: 'ReactConfigMerge'; polarity: Polarity}\n+ | {kind: 'Omit'};\n+\n+export interface ValuesTypeDestructor {\n+ kind: 'ValuesType';\n+}\n+\n+export interface ConditionalTypeDestructor {\n+ kind: 'ConditionalType';\n+ distributive_tparam_name: string | null;\n+ infer_tparams: string;\n+ extends_t: FlowType;\n+ true_t: FlowType;\n+ false_t: FlowType;\n+}\n+\n+export interface TypeMapDestructor {\n+ kind: 'ObjectKeyMirror';\n+}\n+\n+export interface ReactElementPropsTypeDestructor {\n+ kind: 'ReactElementPropsType';\n+}\n+\n+export interface ReactElementConfigTypeDestructor {\n+ kind: 'ReactElementConfigType';\n+}\n+\n+export interface ReactCheckComponentConfigDestructor {\n+ kind: 'ReactCheckComponentConfig';\n+ props: {\n+ [key: string]: Property;\n+ };\n+}\n+\n+export interface ReactDRODestructor {\n+ kind: 'ReactDRO';\n+ dro_type:\n+ | 'HookReturn'\n+ | 'HookArg'\n+ | 'Props'\n+ | 'ImmutableAnnot'\n+ | 'DebugAnnot';\n+}\n+\n+export interface MakeHooklikeDestructor {\n+ kind: 'MakeHooklike';\n+}\n+\n+export interface MappedTypeDestructor {\n+ kind: 'MappedType';\n+ homomorphic: Homomorphic;\n+ distributive_tparam_name: string | null;\n+ property_type: FlowType;\n+ mapped_type_flags: {\n+ variance: Polarity;\n+ optional: 'MakeOptional' | 'RemoveOptional' | 'KeepOptionality';\n+ };\n+}\n+\n+export type Homomorphic =\n+ | {kind: 'Homomorphic'}\n+ | {kind: 'Unspecialized'}\n+ | {kind: 'SemiHomomorphic'; type: FlowType};\n+\n+export interface EnumTypeDestructor {\n+ kind: 'EnumType';\n+}\n+\n+\/\/ Union of all possible Flow types\n+export type FlowType =\n+ | OpenType\n+ | DefType\n+ | EvalType\n+ | GenericType\n+ | ThisInstanceType\n+ | ThisTypeAppType\n+ | TypeAppType\n+ | FunProtoType\n+ | ObjProtoType\n+ | NullProtoType\n+ | FunProtoBindType\n+ | IntersectionType\n+ | UnionType\n+ | MaybeType\n+ | OptionalType\n+ | KeysType\n+ | AnnotType\n+ | OpaqueType\n+ | NamespaceType\n+ | AnyType\n+ | StrUtilType;\ndiff --git a\/compiler\/packages\/babel-plugin-react-compiler\/src\/Flood\/TypeErrors.ts b\/compiler\/packages\/babel-plugin-react-compiler\/src\/Flood\/TypeErrors.ts\nnew file mode 100644\nindex 0000000000..fa3f551ff5\n--- \/dev\/null\n+++ b\/compiler\/packages\/babel-plugin-react-compiler\/src\/Flood\/TypeErrors.ts\n@@ -0,0 +1,131 @@\n+import {CompilerError, SourceLocation} from '..';\n+import {\n+ ConcreteType,\n+ printConcrete,\n+ printType,\n+ StructuralValue,\n+ Type,\n+ VariableId,\n+} from '.\/Types';\n+\n+export function unsupportedLanguageFeature(\n+ desc: string,\n+ loc: SourceLocation,\n+): never {\n+ CompilerError.throwInvalidJS({\n+ reason: `Typedchecker does not currently support language feature: ${desc}`,\n+ loc,\n+ });\n+}\n+\n+export type UnificationError =\n+ | {\n+ kind: 'TypeUnification';\n+ left: ConcreteType;\n+ right: ConcreteType;\n+ }\n+ | {\n+ kind: 'StructuralUnification';\n+ left: StructuralValue;\n+ right: ConcreteType;\n+ };\n+\n+function printUnificationError(err: UnificationError): string {\n+ if (err.kind === 'TypeUnification') {\n+ return `${printConcrete(err.left, printType)} is incompatible with ${printConcrete(err.right, printType)}`;\n+ } else {\n+ return `structural ${err.left.kind} is incompatible with ${printConcrete(err.right, printType)}`;\n+ }\n+}\n+\n+export function raiseUnificationErrors(\n+ errs: null | Array,\n+ loc: SourceLocation,\n+): void {\n+ if (errs != null) {\n+ if (errs.length === 0) {\n+ CompilerError.invariant(false, {\n+ reason: 'Should not have array of zero errors',\n+ loc,\n+ });\n+ } else if (errs.length === 1) {\n+ CompilerError.throwInvalidJS({\n+ reason: `Unable to unify types because ${printUnificationError(errs[0])}`,\n+ loc,\n+ });\n+ } else {\n+ const messages = errs\n+ .map(err => `\\t* ${printUnificationError(err)}`)\n+ .join('\\n');\n+ CompilerError.throwInvalidJS({\n+ reason: `Unable to unify types because:\\n${messages}`,\n+ loc,\n+ });\n+ }\n+ }\n+}\n+\n+export function unresolvableTypeVariable(\n+ id: VariableId,\n+ loc: SourceLocation,\n+): never {\n+ CompilerError.throwInvalidJS({\n+ reason: `Unable to resolve free variable ${id} to a concrete type`,\n+ loc,\n+ });\n+}\n+\n+export function cannotAddVoid(explicit: boolean, loc: SourceLocation): never {\n+ if (explicit) {\n+ CompilerError.throwInvalidJS({\n+ reason: `Undefined is not a valid operand of \\`+\\``,\n+ loc,\n+ });\n+ } else {\n+ CompilerError.throwInvalidJS({\n+ reason: `Value may be undefined, which is not a valid operand of \\`+\\``,\n+ loc,\n+ });\n+ }\n+}\n+\n+export function unsupportedTypeAnnotation(\n+ desc: string,\n+ loc: SourceLocation,\n+): never {\n+ CompilerError.throwInvalidJS({\n+ reason: `Typedchecker does not currently support type annotation: ${desc}`,\n+ loc,\n+ });\n+}\n+\n+export function checkTypeArgumentArity(\n+ desc: string,\n+ expected: number,\n+ actual: number,\n+ loc: SourceLocation,\n+): void {\n+ if (expected !== actual) {\n+ CompilerError.throwInvalidJS({\n+ reason: `Expected ${desc} to have ${expected} type parameters, got ${actual}`,\n+ loc,\n+ });\n+ }\n+}\n+\n+export function notAFunction(desc: string, loc: SourceLocation): void {\n+ CompilerError.throwInvalidJS({\n+ reason: `Cannot call ${desc} because it is not a function`,\n+ loc,\n+ });\n+}\n+\n+export function notAPolymorphicFunction(\n+ desc: string,\n+ loc: SourceLocation,\n+): void {\n+ CompilerError.throwInvalidJS({\n+ reason: `Cannot call ${desc} with type arguments because it is not a polymorphic function`,\n+ loc,\n+ });\n+}\ndiff --git a\/compiler\/packages\/babel-plugin-react-compiler\/src\/Flood\/TypeUtils.ts b\/compiler\/packages\/babel-plugin-react-compiler\/src\/Flood\/TypeUtils.ts\nnew file mode 100644\nindex 0000000000..0a514f090d\n--- \/dev\/null\n+++ b\/compiler\/packages\/babel-plugin-react-compiler\/src\/Flood\/TypeUtils.ts\n@@ -0,0 +1,312 @@\n+import {GeneratedSource} from '..\/HIR';\n+import {assertExhaustive} from '..\/Utils\/utils';\n+import {unsupportedLanguageFeature} from '.\/TypeErrors';\n+import {\n+ ConcreteType,\n+ ResolvedType,\n+ TypeParameter,\n+ TypeParameterId,\n+ DEBUG,\n+ printConcrete,\n+ printType,\n+} from '.\/Types';\n+\n+export function substitute(\n+ type: ConcreteType,\n+ typeParameters: Array>,\n+ typeArguments: Array,\n+): ResolvedType {\n+ const substMap = new Map();\n+ for (let i = 0; i < typeParameters.length; i++) {\n+ \/\/ TODO: Length checks to make sure type params match up with args\n+ const typeParameter = typeParameters[i];\n+ const typeArgument = typeArguments[i];\n+ substMap.set(typeParameter.id, typeArgument);\n+ }\n+ const substitutionFunction = (t: ResolvedType): ResolvedType => {\n+ \/\/ TODO: We really want a stateful mapper or visitor here so that we can model nested polymorphic types\n+ if (t.type.kind === 'Generic' && substMap.has(t.type.id)) {\n+ const substitutedType = substMap.get(t.type.id)!;\n+ return substitutedType;\n+ }\n+\n+ return {\n+ kind: 'Concrete',\n+ type: mapType(substitutionFunction, t.type),\n+ platform: t.platform,\n+ };\n+ };\n+\n+ const substituted = mapType(substitutionFunction, type);\n+\n+ if (DEBUG) {\n+ let substs = '';\n+ for (let i = 0; i < typeParameters.length; i++) {\n+ const typeParameter = typeParameters[i];\n+ const typeArgument = typeArguments[i];\n+ substs += `[${typeParameter.name}${typeParameter.id} := ${printType(typeArgument)}]`;\n+ }\n+ console.log(\n+ `${printConcrete(type, printType)}${substs} = ${printConcrete(substituted, printType)}`,\n+ );\n+ }\n+\n+ return {kind: 'Concrete', type: substituted, platform: \/* TODO *\/ 'shared'};\n+}\n+\n+export function mapType(\n+ f: (t: T) => U,\n+ type: ConcreteType,\n+): ConcreteType {\n+ switch (type.kind) {\n+ case 'Mixed':\n+ case 'Number':\n+ case 'String':\n+ case 'Boolean':\n+ case 'Void':\n+ return type;\n+\n+ case 'Nullable':\n+ return {\n+ kind: 'Nullable',\n+ type: f(type.type),\n+ };\n+\n+ case 'Array':\n+ return {\n+ kind: 'Array',\n+ element: f(type.element),\n+ };\n+\n+ case 'Set':\n+ return {\n+ kind: 'Set',\n+ element: f(type.element),\n+ };\n+\n+ case 'Map':\n+ return {\n+ kind: 'Map',\n+ key: f(type.key),\n+ value: f(type.value),\n+ };\n+\n+ case 'Function':\n+ return {\n+ kind: 'Function',\n+ typeParameters:\n+ type.typeParameters?.map(param => ({\n+ id: param.id,\n+ name: param.name,\n+ bound: f(param.bound),\n+ })) ?? null,\n+ params: type.params.map(f),\n+ returnType: f(type.returnType),\n+ };\n+\n+ case 'Component': {\n+ return {\n+ kind: 'Component',\n+ children: type.children != null ? f(type.children) : null,\n+ props: new Map([...type.props.entries()].map(([k, v]) => [k, f(v)])),\n+ };\n+ }\n+\n+ case 'Generic':\n+ return {\n+ kind: 'Generic',\n+ id: type.id,\n+ bound: f(type.bound),\n+ };\n+\n+ case 'Object':\n+ return type;\n+\n+ case 'Tuple':\n+ return {\n+ kind: 'Tuple',\n+ id: type.id,\n+ members: type.members.map(f),\n+ };\n+\n+ case 'Structural':\n+ return type;\n+\n+ case 'Enum':\n+ case 'Union':\n+ case 'Instance':\n+ unsupportedLanguageFeature(type.kind, GeneratedSource);\n+\n+ default:\n+ assertExhaustive(type, 'Unknown type kind');\n+ }\n+}\n+\n+export function diff(\n+ a: ConcreteType,\n+ b: ConcreteType,\n+ onChild: (a: T, b: T) => R,\n+ onChildMismatch: (child: R, cur: R) => R,\n+ onMismatch: (a: ConcreteType, b: ConcreteType, cur: R) => R,\n+ init: R,\n+): R {\n+ let errors = init;\n+\n+ \/\/ Check if kinds match\n+ if (a.kind !== b.kind) {\n+ errors = onMismatch(a, b, errors);\n+ return errors;\n+ }\n+\n+ \/\/ Based on kind, check other properties\n+ switch (a.kind) {\n+ case 'Mixed':\n+ case 'Number':\n+ case 'String':\n+ case 'Boolean':\n+ case 'Void':\n+ \/\/ Simple types, no further checks needed\n+ break;\n+\n+ case 'Nullable':\n+ \/\/ Check the nested type\n+ errors = onChildMismatch(onChild(a.type, (b as typeof a).type), errors);\n+ break;\n+\n+ case 'Array':\n+ case 'Set':\n+ \/\/ Check the element type\n+ errors = onChildMismatch(\n+ onChild(a.element, (b as typeof a).element),\n+ errors,\n+ );\n+ break;\n+\n+ case 'Map':\n+ \/\/ Check both key and value types\n+ errors = onChildMismatch(onChild(a.key, (b as typeof a).key), errors);\n+ errors = onChildMismatch(onChild(a.value, (b as typeof a).value), errors);\n+ break;\n+\n+ case 'Function': {\n+ const bFunc = b as typeof a;\n+\n+ \/\/ Check type parameters\n+ if ((a.typeParameters == null) !== (bFunc.typeParameters == null)) {\n+ errors = onMismatch(a, b, errors);\n+ }\n+\n+ if (a.typeParameters != null && bFunc.typeParameters != null) {\n+ if (a.typeParameters.length !== bFunc.typeParameters.length) {\n+ errors = onMismatch(a, b, errors);\n+ }\n+\n+ \/\/ Type parameters are just numbers, so we can compare them directly\n+ for (let i = 0; i < a.typeParameters.length; i++) {\n+ if (a.typeParameters[i] !== bFunc.typeParameters[i]) {\n+ errors = onMismatch(a, b, errors);\n+ }\n+ }\n+ }\n+\n+ \/\/ Check parameters\n+ if (a.params.length !== bFunc.params.length) {\n+ errors = onMismatch(a, b, errors);\n+ }\n+\n+ for (let i = 0; i < a.params.length; i++) {\n+ errors = onChildMismatch(onChild(a.params[i], bFunc.params[i]), errors);\n+ }\n+\n+ \/\/ Check return type\n+ errors = onChildMismatch(onChild(a.returnType, bFunc.returnType), errors);\n+ break;\n+ }\n+\n+ case 'Component': {\n+ const bComp = b as typeof a;\n+\n+ \/\/ Check children\n+ if (a.children !== bComp.children) {\n+ errors = onMismatch(a, b, errors);\n+ }\n+\n+ \/\/ Check props\n+ if (a.props.size !== bComp.props.size) {\n+ errors = onMismatch(a, b, errors);\n+ }\n+\n+ for (const [k, v] of a.props) {\n+ const bProp = bComp.props.get(k);\n+ if (bProp == null) {\n+ errors = onMismatch(a, b, errors);\n+ } else {\n+ errors = onChildMismatch(onChild(v, bProp), errors);\n+ }\n+ }\n+\n+ break;\n+ }\n+\n+ case 'Generic': {\n+ \/\/ Check that the type parameter IDs match\n+ if (a.id !== (b as typeof a).id) {\n+ errors = onMismatch(a, b, errors);\n+ }\n+ break;\n+ }\n+ case 'Structural': {\n+ const bStruct = b as typeof a;\n+\n+ \/\/ Check that the structural IDs match\n+ if (a.id !== bStruct.id) {\n+ errors = onMismatch(a, b, errors);\n+ }\n+ break;\n+ }\n+ case 'Object': {\n+ const bNom = b as typeof a;\n+\n+ \/\/ Check that the nominal IDs match\n+ if (a.id !== bNom.id) {\n+ errors = onMismatch(a, b, errors);\n+ }\n+ break;\n+ }\n+\n+ case 'Tuple': {\n+ const bTuple = b as typeof a;\n+\n+ \/\/ Check that the tuple IDs match\n+ if (a.id !== bTuple.id) {\n+ errors = onMismatch(a, b, errors);\n+ }\n+ for (let i = 0; i < a.members.length; i++) {\n+ errors = onChildMismatch(\n+ onChild(a.members[i], bTuple.members[i]),\n+ errors,\n+ );\n+ }\n+\n+ break;\n+ }\n+\n+ case 'Enum':\n+ case 'Instance':\n+ case 'Union': {\n+ unsupportedLanguageFeature(a.kind, GeneratedSource);\n+ }\n+\n+ default:\n+ assertExhaustive(a, 'Unknown type kind');\n+ }\n+\n+ return errors;\n+}\n+\n+export function filterOptional(t: ResolvedType): ResolvedType {\n+ if (t.kind === 'Concrete' && t.type.kind === 'Nullable') {\n+ return t.type.type;\n+ }\n+ return t;\n+}\ndiff --git a\/compiler\/packages\/babel-plugin-react-compiler\/src\/Flood\/Types.ts b\/compiler\/packages\/babel-plugin-react-compiler\/src\/Flood\/Types.ts\nnew file mode 100644\nindex 0000000000..b4f91ab478\n--- \/dev\/null\n+++ b\/compiler\/packages\/babel-plugin-react-compiler\/src\/Flood\/Types.ts\n@@ -0,0 +1,1001 @@\n+import {CompilerError, SourceLocation} from '..';\n+import {\n+ Environment,\n+ GeneratedSource,\n+ HIRFunction,\n+ Identifier,\n+ IdentifierId,\n+} from '..\/HIR';\n+import * as t from '@babel\/types';\n+import * as TypeErrors from '.\/TypeErrors';\n+import {assertExhaustive} from '..\/Utils\/utils';\n+\n+export const DEBUG = false;\n+\n+export type Type =\n+ | {kind: 'Concrete'; type: ConcreteType; platform: Platform}\n+ | {kind: 'Variable'; id: VariableId};\n+\n+export type ResolvedType = {\n+ kind: 'Concrete';\n+ type: ConcreteType;\n+ platform: Platform;\n+};\n+\n+export type ComponentType = {\n+ kind: 'Component';\n+ props: Map;\n+ children: null | T;\n+};\n+export type ConcreteType =\n+ | {kind: 'Enum'}\n+ | {kind: 'Mixed'}\n+ | {kind: 'Number'}\n+ | {kind: 'String'}\n+ | {kind: 'Boolean'}\n+ | {kind: 'Void'}\n+ | {kind: 'Nullable'; type: T}\n+ | {kind: 'Array'; element: T}\n+ | {kind: 'Set'; element: T}\n+ | {kind: 'Map'; key: T; value: T}\n+ | {\n+ kind: 'Function';\n+ typeParameters: null | Array>;\n+ params: Array;\n+ returnType: T;\n+ }\n+ | ComponentType\n+ | {kind: 'Generic'; id: TypeParameterId; bound: T}\n+ | {\n+ kind: 'Object';\n+ id: NominalId;\n+ members: Map;\n+ }\n+ | {\n+ kind: 'Tuple';\n+ id: NominalId;\n+ members: Array;\n+ }\n+ | {kind: 'Structural'; id: LinearId}\n+ | {kind: 'Union'; members: Array}\n+ | {kind: 'Instance'; name: string; members: Map};\n+\n+export type StructuralValue =\n+ | {\n+ kind: 'Function';\n+ fn: HIRFunction;\n+ }\n+ | {\n+ kind: 'Object';\n+ members: Map;\n+ }\n+ | {\n+ kind: 'Array';\n+ elementType: ResolvedType;\n+ };\n+\n+export type Structural = {\n+ type: StructuralValue;\n+ consumed: boolean;\n+};\n+\/\/ TODO: create a kind: \"Alias\"\n+\n+\/\/ type T = { foo: X}\n+\n+\/**\n+ *\n+ * function apply(x: A, f: A => B): B { }\n+ *\n+ * apply(42, x => String(x));\n+ *\n+ * f({foo: 42})\n+ *\n+ * f([HOLE]) -----> {foo: 42} with context NominalType\n+ *\n+ * $0 = Object {foo: 42}\n+ * $1 = LoadLocal \"f\"\n+ * $2 = Call $1, [$0]\n+ *\n+ * ContextMap:\n+ * $2 => ??\n+ * $1 => [HOLE]($0)\n+ * $0 => $1([HOLE])\n+ *\/\n+\n+\/*\n+ *const g = {foo: 42} as NominalType \/\/ ok\n+ *\n+ *\n+ *function f(x: NominalType) { ... }\n+ *f()\n+ *\n+ *const y: NominalType = {foo: 42}\n+ *\n+ *\n+ *\/\n+\n+\/**\n+ * \/\/ Mike: maybe this could be the ideal?\n+ *type X = nominal('registryNameX', {\n+ *value: number,\n+ *});\n+ *\n+ * \/\/ For now:\n+ *opaque type X = { \/\/ creates a new nominal type\n+ *value: number,\n+ *};\n+ *\n+ *type Y = X; \/\/ creates a type alias\n+ *\n+ *type Z = number; \/\/ creates a type alias\n+ *\n+ *\n+ * \/\/ (todo: disallowed)\n+ *type X' = {\n+ *value: number,\n+ *}\n+ *\/\n+\n+export type TypeParameter = {\n+ name: string;\n+ id: TypeParameterId;\n+ bound: T;\n+};\n+\n+const opaqueLinearId = Symbol();\n+export type LinearId = number & {\n+ [opaqueLinearId]: 'LinearId';\n+};\n+\n+export function makeLinearId(id: number): LinearId {\n+ CompilerError.invariant(id >= 0 && Number.isInteger(id), {\n+ reason: 'Expected LinearId id to be a non-negative integer',\n+ description: null,\n+ loc: null,\n+ suggestions: null,\n+ });\n+ return id as LinearId;\n+}\n+\n+const opaqueTypeParameterId = Symbol();\n+export type TypeParameterId = number & {\n+ [opaqueTypeParameterId]: 'TypeParameterId';\n+};\n+\n+export function makeTypeParameterId(id: number): TypeParameterId {\n+ CompilerError.invariant(id >= 0 && Number.isInteger(id), {\n+ reason: 'Expected TypeParameterId to be a non-negative integer',\n+ description: null,\n+ loc: null,\n+ suggestions: null,\n+ });\n+ return id as TypeParameterId;\n+}\n+\n+const opaqueNominalId = Symbol();\n+export type NominalId = number & {\n+ [opaqueNominalId]: 'NominalId';\n+};\n+\n+export function makeNominalId(id: number): NominalId {\n+ return id as NominalId;\n+}\n+\n+const opaqueVariableId = Symbol();\n+export type VariableId = number & {\n+ [opaqueVariableId]: 'VariableId';\n+};\n+\n+export function makeVariableId(id: number): VariableId {\n+ CompilerError.invariant(id >= 0 && Number.isInteger(id), {\n+ reason: 'Expected VariableId id to be a non-negative integer',\n+ description: null,\n+ loc: null,\n+ suggestions: null,\n+ });\n+ return id as VariableId;\n+}\n+\n+import {inspect} from 'util';\n+import {FlowType} from '.\/FlowTypes';\n+export function printConcrete(\n+ type: ConcreteType,\n+ printType: (_: T) => string,\n+): string {\n+ switch (type.kind) {\n+ case 'Mixed':\n+ return 'mixed';\n+ case 'Number':\n+ return 'number';\n+ case 'String':\n+ return 'string';\n+ case 'Boolean':\n+ return 'boolean';\n+ case 'Void':\n+ return 'void';\n+ case 'Nullable':\n+ return `${printType(type.type)} | void`;\n+ case 'Array':\n+ return `Array<${printType(type.element)}>`;\n+ case 'Set':\n+ return `Set<${printType(type.element)}>`;\n+ case 'Map':\n+ return `Map<${printType(type.key)}, ${printType(type.value)}>`;\n+ case 'Function': {\n+ const typeParams = type.typeParameters\n+ ? `<${type.typeParameters.map(tp => `T${tp}`).join(', ')}>`\n+ : '';\n+ const params = type.params.map(printType).join(', ');\n+ const returnType = printType(type.returnType);\n+ return `${typeParams}(${params}) => ${returnType}`;\n+ }\n+ case 'Component': {\n+ const params = [...type.props.entries()]\n+ .map(([k, v]) => `${k}: ${printType(v)}`)\n+ .join(', ');\n+ const comma = type.children != null && type.props.size > 0 ? ', ' : '';\n+ const children =\n+ type.children != null ? `children: ${printType(type.children)}` : '';\n+ return `component (${params}${comma}${children})`;\n+ }\n+ case 'Generic':\n+ return `T${type.id}`;\n+ case 'Object': {\n+ const name = `Object ${inspect([...type.members.keys()])}`;\n+ return `${name}`;\n+ }\n+ case 'Tuple': {\n+ const name = `Tuple ${type.members}`;\n+ return `${name}`;\n+ }\n+ case 'Structural': {\n+ const name = `Structural ${type.id}`;\n+ return `${name}`;\n+ }\n+ case 'Enum': {\n+ return 'TODO enum printing';\n+ }\n+ case 'Union': {\n+ return type.members.map(printType).join(' | ');\n+ }\n+ case 'Instance': {\n+ return type.name;\n+ }\n+ default:\n+ assertExhaustive(type, `Unknown type: ${JSON.stringify(type)}`);\n+ }\n+}\n+\n+export function printType(type: Type): string {\n+ switch (type.kind) {\n+ case 'Concrete':\n+ return printConcrete(type.type, printType);\n+ case 'Variable':\n+ return `$${type.id}`;\n+ default:\n+ assertExhaustive(type, `Unknown type: ${JSON.stringify(type)}`);\n+ }\n+}\n+\n+export function printResolved(type: ResolvedType): string {\n+ return printConcrete(type.type, printResolved);\n+}\n+\n+type Platform = 'client' | 'server' | 'shared';\n+\n+const DUMMY_NOMINAL = makeNominalId(0);\n+\n+function convertFlowType(flowType: FlowType, loc: string): ResolvedType {\n+ let nextGenericId = 0;\n+ function convertFlowTypeImpl(\n+ flowType: FlowType,\n+ loc: string,\n+ genericEnv: Map,\n+ platform: Platform,\n+ poly: null | Array> = null,\n+ ): ResolvedType {\n+ switch (flowType.kind) {\n+ case 'TypeApp': {\n+ if (\n+ flowType.type.kind === 'Def' &&\n+ flowType.type.def.kind === 'Poly' &&\n+ flowType.type.def.t_out.kind === 'Def' &&\n+ flowType.type.def.t_out.def.kind === 'Type' &&\n+ flowType.type.def.t_out.def.type.kind === 'Opaque' &&\n+ flowType.type.def.t_out.def.type.opaquetype.opaque_name ===\n+ 'Client' &&\n+ flowType.targs.length === 1\n+ ) {\n+ return convertFlowTypeImpl(\n+ flowType.targs[0],\n+ loc,\n+ genericEnv,\n+ 'client',\n+ );\n+ } else if (\n+ flowType.type.kind === 'Def' &&\n+ flowType.type.def.kind === 'Poly' &&\n+ flowType.type.def.t_out.kind === 'Def' &&\n+ flowType.type.def.t_out.def.kind === 'Type' &&\n+ flowType.type.def.t_out.def.type.kind === 'Opaque' &&\n+ flowType.type.def.t_out.def.type.opaquetype.opaque_name ===\n+ 'Server' &&\n+ flowType.targs.length === 1\n+ ) {\n+ return convertFlowTypeImpl(\n+ flowType.targs[0],\n+ loc,\n+ genericEnv,\n+ 'server',\n+ );\n+ }\n+ return Resolved.todo(platform);\n+ }\n+ case 'Open':\n+ return Resolved.mixed(platform);\n+ case 'Any':\n+ return Resolved.todo(platform);\n+ case 'Annot':\n+ return convertFlowTypeImpl(\n+ flowType.type,\n+ loc,\n+ genericEnv,\n+ platform,\n+ poly,\n+ );\n+ case 'Opaque': {\n+ if (\n+ flowType.opaquetype.opaque_name === 'Client' &&\n+ flowType.opaquetype.super_t != null\n+ ) {\n+ return convertFlowTypeImpl(\n+ flowType.opaquetype.super_t,\n+ loc,\n+ genericEnv,\n+ 'client',\n+ );\n+ }\n+ if (\n+ flowType.opaquetype.opaque_name === 'Server' &&\n+ flowType.opaquetype.super_t != null\n+ ) {\n+ return convertFlowTypeImpl(\n+ flowType.opaquetype.super_t,\n+ loc,\n+ genericEnv,\n+ 'server',\n+ );\n+ }\n+ const t =\n+ flowType.opaquetype.underlying_t ?? flowType.opaquetype.super_t;\n+ if (t != null) {\n+ return convertFlowTypeImpl(t, loc, genericEnv, platform, poly);\n+ } else {\n+ return Resolved.todo(platform);\n+ }\n+ }\n+ case 'Def': {\n+ switch (flowType.def.kind) {\n+ case 'EnumValue':\n+ return convertFlowTypeImpl(\n+ flowType.def.enum_info.representation_t,\n+ loc,\n+ genericEnv,\n+ platform,\n+ poly,\n+ );\n+ case 'EnumObject':\n+ return Resolved.enum(platform);\n+ case 'Empty':\n+ return Resolved.todo(platform);\n+ case 'Instance': {\n+ const members = new Map();\n+ for (const key in flowType.def.instance.inst.own_props) {\n+ const prop = flowType.def.instance.inst.own_props[key];\n+ if (prop.kind === 'Field') {\n+ members.set(\n+ key,\n+ convertFlowTypeImpl(prop.type, loc, genericEnv, platform),\n+ );\n+ } else {\n+ CompilerError.invariant(false, {\n+ reason: `Unsupported property kind ${prop.kind}`,\n+ loc: GeneratedSource,\n+ });\n+ }\n+ }\n+ return Resolved.class(\n+ flowType.def.instance.inst.class_name ?? '[anonymous class]',\n+ members,\n+ platform,\n+ );\n+ }\n+ case 'Type':\n+ return convertFlowTypeImpl(\n+ flowType.def.type,\n+ loc,\n+ genericEnv,\n+ platform,\n+ poly,\n+ );\n+ case 'NumGeneral':\n+ case 'SingletonNum':\n+ return Resolved.number(platform);\n+ case 'StrGeneral':\n+ case 'SingletonStr':\n+ return Resolved.string(platform);\n+ case 'BoolGeneral':\n+ case 'SingletonBool':\n+ return Resolved.boolean(platform);\n+ case 'Void':\n+ return Resolved.void(platform);\n+ case 'Null':\n+ return Resolved.void(platform);\n+ case 'Mixed':\n+ return Resolved.mixed(platform);\n+ case 'Arr': {\n+ if (\n+ flowType.def.arrtype.kind === 'ArrayAT' ||\n+ flowType.def.arrtype.kind === 'ROArrayAT'\n+ ) {\n+ return Resolved.array(\n+ convertFlowTypeImpl(\n+ flowType.def.arrtype.elem_t,\n+ loc,\n+ genericEnv,\n+ platform,\n+ ),\n+ platform,\n+ );\n+ } else {\n+ return Resolved.tuple(\n+ DUMMY_NOMINAL,\n+ flowType.def.arrtype.elements.map(t =>\n+ convertFlowTypeImpl(t.t, loc, genericEnv, platform),\n+ ),\n+ platform,\n+ );\n+ }\n+ }\n+ case 'Obj': {\n+ const members = new Map();\n+ for (const key in flowType.def.objtype.props) {\n+ const prop = flowType.def.objtype.props[key];\n+ if (prop.kind === 'Field') {\n+ members.set(\n+ key,\n+ convertFlowTypeImpl(prop.type, loc, genericEnv, platform),\n+ );\n+ } else {\n+ CompilerError.invariant(false, {\n+ reason: `Unsupported property kind ${prop.kind}`,\n+ loc: GeneratedSource,\n+ });\n+ }\n+ }\n+ return Resolved.object(DUMMY_NOMINAL, members, platform);\n+ }\n+ case 'Class': {\n+ if (flowType.def.type.kind === 'ThisInstance') {\n+ const members = new Map();\n+ for (const key in flowType.def.type.instance.inst.own_props) {\n+ const prop = flowType.def.type.instance.inst.own_props[key];\n+ if (prop.kind === 'Field') {\n+ members.set(\n+ key,\n+ convertFlowTypeImpl(prop.type, loc, genericEnv, platform),\n+ );\n+ } else {\n+ CompilerError.invariant(false, {\n+ reason: `Unsupported property kind ${prop.kind}`,\n+ loc: GeneratedSource,\n+ });\n+ }\n+ }\n+ return Resolved.class(\n+ flowType.def.type.instance.inst.class_name ??\n+ '[anonymous class]',\n+ members,\n+ platform,\n+ );\n+ }\n+ CompilerError.invariant(false, {\n+ reason: `Unsupported class instance type ${flowType.def.type.kind}`,\n+ loc: GeneratedSource,\n+ });\n+ }\n+ case 'Fun':\n+ return Resolved.function(\n+ poly,\n+ flowType.def.funtype.params.map(p =>\n+ convertFlowTypeImpl(p.type, loc, genericEnv, platform),\n+ ),\n+ convertFlowTypeImpl(\n+ flowType.def.funtype.return_t,\n+ loc,\n+ genericEnv,\n+ platform,\n+ ),\n+ platform,\n+ );\n+ case 'Poly': {\n+ let newEnv = genericEnv;\n+ const poly = flowType.def.tparams.map(p => {\n+ const id = makeTypeParameterId(nextGenericId++);\n+ const bound = convertFlowTypeImpl(p.bound, loc, newEnv, platform);\n+ newEnv = new Map(newEnv);\n+ newEnv.set(p.name, id);\n+ return {\n+ name: p.name,\n+ id,\n+ bound,\n+ };\n+ });\n+ return convertFlowTypeImpl(\n+ flowType.def.t_out,\n+ loc,\n+ newEnv,\n+ platform,\n+ poly,\n+ );\n+ }\n+ case 'ReactAbstractComponent': {\n+ const props = new Map();\n+ let children: ResolvedType | null = null;\n+ const propsType = convertFlowTypeImpl(\n+ flowType.def.config,\n+ loc,\n+ genericEnv,\n+ platform,\n+ );\n+\n+ if (propsType.type.kind === 'Object') {\n+ propsType.type.members.forEach((v, k) => {\n+ if (k === 'children') {\n+ children = v;\n+ } else {\n+ props.set(k, v);\n+ }\n+ });\n+ } else {\n+ CompilerError.invariant(false, {\n+ reason: `Unsupported component props type ${propsType.type.kind}`,\n+ loc: GeneratedSource,\n+ });\n+ }\n+\n+ return Resolved.component(props, children, platform);\n+ }\n+ case 'Renders':\n+ return Resolved.todo(platform);\n+ default:\n+ TypeErrors.unsupportedTypeAnnotation('Renders', GeneratedSource);\n+ }\n+ }\n+ case 'Generic': {\n+ const id = genericEnv.get(flowType.name);\n+ if (id == null) {\n+ TypeErrors.unsupportedTypeAnnotation(flowType.name, GeneratedSource);\n+ }\n+ return Resolved.generic(\n+ id,\n+ platform,\n+ convertFlowTypeImpl(flowType.bound, loc, genericEnv, platform),\n+ );\n+ }\n+ case 'Union': {\n+ const members = flowType.members.map(t =>\n+ convertFlowTypeImpl(t, loc, genericEnv, platform),\n+ );\n+ if (members.length === 1) {\n+ return members[0];\n+ }\n+ if (\n+ members[0].type.kind === 'Number' ||\n+ members[0].type.kind === 'String' ||\n+ members[0].type.kind === 'Boolean'\n+ ) {\n+ const dupes = members.filter(\n+ t => t.type.kind === members[0].type.kind,\n+ );\n+ if (dupes.length === members.length) {\n+ return members[0];\n+ }\n+ }\n+ if (\n+ members[0].type.kind === 'Array' &&\n+ (members[0].type.element.type.kind === 'Number' ||\n+ members[0].type.element.type.kind === 'String' ||\n+ members[0].type.element.type.kind === 'Boolean')\n+ ) {\n+ const first = members[0].type.element;\n+ const dupes = members.filter(\n+ t =>\n+ t.type.kind === 'Array' &&\n+ t.type.element.type.kind === first.type.kind,\n+ );\n+ if (dupes.length === members.length) {\n+ return members[0];\n+ }\n+ }\n+ return Resolved.union(members, platform);\n+ }\n+ case 'Eval': {\n+ if (\n+ flowType.destructor.kind === 'ReactDRO' ||\n+ flowType.destructor.kind === 'ReactCheckComponentConfig'\n+ ) {\n+ return convertFlowTypeImpl(\n+ flowType.type,\n+ loc,\n+ genericEnv,\n+ platform,\n+ poly,\n+ );\n+ }\n+ TypeErrors.unsupportedTypeAnnotation(\n+ `EvalT(${flowType.destructor.kind})`,\n+ GeneratedSource,\n+ );\n+ }\n+ case 'Optional': {\n+ return Resolved.union(\n+ [\n+ convertFlowTypeImpl(flowType.type, loc, genericEnv, platform),\n+ Resolved.void(platform),\n+ ],\n+ platform,\n+ );\n+ }\n+ default:\n+ TypeErrors.unsupportedTypeAnnotation(flowType.kind, GeneratedSource);\n+ }\n+ }\n+ return convertFlowTypeImpl(flowType, loc, new Map(), 'shared');\n+}\n+\n+export interface ITypeEnv {\n+ popGeneric(name: string): void;\n+ getGeneric(name: string): null | TypeParameter;\n+ pushGeneric(\n+ name: string,\n+ binding: {name: string; id: TypeParameterId; bound: ResolvedType},\n+ ): void;\n+ getType(id: Identifier): ResolvedType;\n+ getTypeOrNull(id: Identifier): ResolvedType | null;\n+ setType(id: Identifier, type: ResolvedType): void;\n+ nextNominalId(): NominalId;\n+ nextTypeParameterId(): TypeParameterId;\n+ moduleEnv: Map;\n+ addBinding(bindingIdentifier: t.Identifier, type: ResolvedType): void;\n+ resolveBinding(bindingIdentifier: t.Identifier): ResolvedType | null;\n+}\n+\n+function serializeLoc(location: t.SourceLocation): string {\n+ return `${location.start.line}:${location.start.column}-${location.end.line}:${location.end.column}`;\n+}\n+\n+function buildTypeEnvironment(\n+ flowOutput: Array<{loc: t.SourceLocation; type: string}>,\n+): Map {\n+ const result: Map = new Map();\n+ for (const item of flowOutput) {\n+ const loc: t.SourceLocation = {\n+ start: {\n+ line: item.loc.start.line,\n+ column: item.loc.start.column - 1,\n+ index: item.loc.start.index,\n+ },\n+ end: item.loc.end,\n+ filename: item.loc.filename,\n+ identifierName: item.loc.identifierName,\n+ };\n+\n+ result.set(serializeLoc(loc), item.type);\n+ }\n+ return result;\n+}\n+\n+let lastFlowSource: string | null = null;\n+let lastFlowResult: any = null;\n+\n+export class FlowTypeEnv implements ITypeEnv {\n+ moduleEnv: Map = new Map();\n+ #nextNominalId: number = 0;\n+ #nextTypeParameterId: number = 0;\n+\n+ #types: Map = new Map();\n+ #bindings: Map = new Map();\n+ #generics: Array<[string, TypeParameter]> = [];\n+ #flowTypes: Map = new Map();\n+\n+ init(env: Environment, source: string): void {\n+ \/\/ TODO: use flow-js only for web environments (e.g. playground)\n+ CompilerError.invariant(env.config.flowTypeProvider != null, {\n+ reason: 'Expected flowDumpTypes to be defined in environment config',\n+ loc: GeneratedSource,\n+ });\n+ let stdout: any;\n+ if (source === lastFlowSource) {\n+ stdout = lastFlowResult;\n+ } else {\n+ lastFlowSource = source;\n+ lastFlowResult = env.config.flowTypeProvider(source);\n+ stdout = lastFlowResult;\n+ }\n+ const flowTypes = buildTypeEnvironment(stdout);\n+ const resolvedFlowTypes = new Map();\n+ for (const [loc, type] of flowTypes) {\n+ if (typeof loc === 'symbol') continue;\n+ resolvedFlowTypes.set(loc, convertFlowType(JSON.parse(type), loc));\n+ }\n+ \/\/ =console.log(resolvedFlowTypes);\n+ this.#flowTypes = resolvedFlowTypes;\n+ }\n+\n+ setType(identifier: Identifier, type: ResolvedType): void {\n+ if (\n+ typeof identifier.loc !== 'symbol' &&\n+ this.#flowTypes.has(serializeLoc(identifier.loc))\n+ ) {\n+ return;\n+ }\n+ this.#types.set(identifier.id, type);\n+ }\n+\n+ getType(identifier: Identifier): ResolvedType {\n+ const result = this.getTypeOrNull(identifier);\n+ if (result == null) {\n+ throw new Error(\n+ `Type not found for ${identifier.id}, ${typeof identifier.loc === 'symbol' ? 'generated loc' : serializeLoc(identifier.loc)}`,\n+ );\n+ }\n+ return result;\n+ }\n+\n+ getTypeOrNull(identifier: Identifier): ResolvedType | null {\n+ const result = this.#types.get(identifier.id) ?? null;\n+ if (result == null && typeof identifier.loc !== 'symbol') {\n+ const flowType = this.#flowTypes.get(serializeLoc(identifier.loc));\n+ return flowType ?? null;\n+ }\n+ return result;\n+ }\n+\n+ getTypeByLoc(loc: SourceLocation): ResolvedType | null {\n+ if (typeof loc === 'symbol') {\n+ return null;\n+ }\n+ const flowType = this.#flowTypes.get(serializeLoc(loc));\n+ return flowType ?? null;\n+ }\n+\n+ nextNominalId(): NominalId {\n+ return makeNominalId(this.#nextNominalId++);\n+ }\n+\n+ nextTypeParameterId(): TypeParameterId {\n+ return makeTypeParameterId(this.#nextTypeParameterId++);\n+ }\n+\n+ addBinding(bindingIdentifier: t.Identifier, type: ResolvedType): void {\n+ this.#bindings.set(bindingIdentifier, type);\n+ }\n+\n+ resolveBinding(bindingIdentifier: t.Identifier): ResolvedType | null {\n+ return this.#bindings.get(bindingIdentifier) ?? null;\n+ }\n+\n+ pushGeneric(name: string, generic: TypeParameter): void {\n+ this.#generics.unshift([name, generic]);\n+ }\n+\n+ popGeneric(name: string): void {\n+ for (let i = 0; i < this.#generics.length; i++) {\n+ if (this.#generics[i][0] === name) {\n+ this.#generics.splice(i, 1);\n+ return;\n+ }\n+ }\n+ }\n+\n+ \/**\n+ * Look up bound polymorphic types\n+ * @param name\n+ * @returns\n+ *\/\n+ getGeneric(name: string): null | TypeParameter {\n+ for (const [eltName, param] of this.#generics) {\n+ if (name === eltName) {\n+ return param;\n+ }\n+ }\n+ return null;\n+ }\n+}\n+const Primitives = {\n+ number(platform: Platform): Type & ResolvedType {\n+ return {kind: 'Concrete', type: {kind: 'Number'}, platform};\n+ },\n+ string(platform: Platform): Type & ResolvedType {\n+ return {kind: 'Concrete', type: {kind: 'String'}, platform};\n+ },\n+ boolean(platform: Platform): Type & ResolvedType {\n+ return {kind: 'Concrete', type: {kind: 'Boolean'}, platform};\n+ },\n+ void(platform: Platform): Type & ResolvedType {\n+ return {kind: 'Concrete', type: {kind: 'Void'}, platform};\n+ },\n+ mixed(platform: Platform): Type & ResolvedType {\n+ return {kind: 'Concrete', type: {kind: 'Mixed'}, platform};\n+ },\n+ enum(platform: Platform): Type & ResolvedType {\n+ return {kind: 'Concrete', type: {kind: 'Enum'}, platform};\n+ },\n+ todo(platform: Platform): Type & ResolvedType {\n+ return {kind: 'Concrete', type: {kind: 'Mixed'}, platform};\n+ },\n+};\n+\n+export const Resolved = {\n+ ...Primitives,\n+ nullable(type: ResolvedType, platform: Platform): ResolvedType {\n+ return {kind: 'Concrete', type: {kind: 'Nullable', type}, platform};\n+ },\n+ array(element: ResolvedType, platform: Platform): ResolvedType {\n+ return {kind: 'Concrete', type: {kind: 'Array', element}, platform};\n+ },\n+ set(element: ResolvedType, platform: Platform): ResolvedType {\n+ return {kind: 'Concrete', type: {kind: 'Set', element}, platform};\n+ },\n+ map(\n+ key: ResolvedType,\n+ value: ResolvedType,\n+ platform: Platform,\n+ ): ResolvedType {\n+ return {kind: 'Concrete', type: {kind: 'Map', key, value}, platform};\n+ },\n+ function(\n+ typeParameters: null | Array>,\n+ params: Array,\n+ returnType: ResolvedType,\n+ platform: Platform,\n+ ): ResolvedType {\n+ return {\n+ kind: 'Concrete',\n+ type: {kind: 'Function', typeParameters, params, returnType},\n+ platform,\n+ };\n+ },\n+ component(\n+ props: Map,\n+ children: ResolvedType | null,\n+ platform: Platform,\n+ ): ResolvedType {\n+ return {\n+ kind: 'Concrete',\n+ type: {kind: 'Component', props, children},\n+ platform,\n+ };\n+ },\n+ object(\n+ id: NominalId,\n+ members: Map,\n+ platform: Platform,\n+ ): ResolvedType {\n+ return {\n+ kind: 'Concrete',\n+ type: {\n+ kind: 'Object',\n+ id,\n+ members,\n+ },\n+ platform,\n+ };\n+ },\n+ class(\n+ name: string,\n+ members: Map,\n+ platform: Platform,\n+ ): ResolvedType {\n+ return {\n+ kind: 'Concrete',\n+ type: {\n+ kind: 'Instance',\n+ name,\n+ members,\n+ },\n+ platform,\n+ };\n+ },\n+ tuple(\n+ id: NominalId,\n+ members: Array,\n+ platform: Platform,\n+ ): ResolvedType {\n+ return {\n+ kind: 'Concrete',\n+ type: {\n+ kind: 'Tuple',\n+ id,\n+ members,\n+ },\n+ platform,\n+ };\n+ },\n+ generic(\n+ id: TypeParameterId,\n+ platform: Platform,\n+ bound = Primitives.mixed(platform),\n+ ): ResolvedType {\n+ return {\n+ kind: 'Concrete',\n+ type: {\n+ kind: 'Generic',\n+ id,\n+ bound,\n+ },\n+ platform,\n+ };\n+ },\n+ union(members: Array, platform: Platform): ResolvedType {\n+ return {\n+ kind: 'Concrete',\n+ type: {\n+ kind: 'Union',\n+ members,\n+ },\n+ platform,\n+ };\n+ },\n+};\n+\n+\/*\n+ * export const Types = {\n+ * ...Primitives,\n+ * variable(env: TypeEnv): Type {\n+ * return env.nextTypeVariable();\n+ * },\n+ * nullable(type: Type): Type {\n+ * return {kind: 'Concrete', type: {kind: 'Nullable', type}};\n+ * },\n+ * array(element: Type): Type {\n+ * return {kind: 'Concrete', type: {kind: 'Array', element}};\n+ * },\n+ * set(element: Type): Type {\n+ * return {kind: 'Concrete', type: {kind: 'Set', element}};\n+ * },\n+ * map(key: Type, value: Type): Type {\n+ * return {kind: 'Concrete', type: {kind: 'Map', key, value}};\n+ * },\n+ * function(\n+ * typeParameters: null | Array>,\n+ * params: Array,\n+ * returnType: Type,\n+ * ): Type {\n+ * return {\n+ * kind: 'Concrete',\n+ * type: {kind: 'Function', typeParameters, params, returnType},\n+ * };\n+ * },\n+ * component(\n+ * props: Map,\n+ * children: Type | null,\n+ * ): Type {\n+ * return {\n+ * kind: 'Concrete',\n+ * type: {kind: 'Component', props, children},\n+ * };\n+ * },\n+ * object(id: NominalId, members: Map): Type {\n+ * return {\n+ * kind: 'Concrete',\n+ * type: {\n+ * kind: 'Object',\n+ * id,\n+ * members,\n+ * },\n+ * };\n+ * },\n+ * };\n+ *\/\ndiff --git a\/compiler\/packages\/babel-plugin-react-compiler\/src\/HIR\/Environment.ts b\/compiler\/packages\/babel-plugin-react-compiler\/src\/HIR\/Environment.ts\nindex 0ac59a8982..957c5ab84a 100644\n--- a\/compiler\/packages\/babel-plugin-react-compiler\/src\/HIR\/Environment.ts\n+++ b\/compiler\/packages\/babel-plugin-react-compiler\/src\/HIR\/Environment.ts\n@@ -49,6 +49,7 @@ import {\n } from '.\/ObjectShape';\n import {Scope as BabelScope, NodePath} from '@babel\/traverse';\n import {TypeSchema} from '.\/TypeSchema';\n+import {FlowTypeEnv} from '..\/Flood\/Types';\n \n export const ReactElementSymbolSchema = z.object({\n elementSymbol: z.union([\n@@ -243,6 +244,12 @@ export const EnvironmentConfigSchema = z.object({\n *\/\n enableUseTypeAnnotations: z.boolean().default(false),\n \n+ \/**\n+ * Allows specifying a function that can populate HIR with type information from\n+ * Flow\n+ *\/\n+ flowTypeProvider: z.nullable(z.function().args(z.string())).default(null),\n+\n \/**\n * Enable a new model for mutability and aliasing inference\n *\/\n@@ -697,6 +704,8 @@ export class Environment {\n #hoistedIdentifiers: Set;\n parentFunction: NodePath;\n \n+ #flowTypeEnvironment: FlowTypeEnv | null;\n+\n constructor(\n scope: BabelScope,\n fnType: ReactFunctionType,\n@@ -765,6 +774,26 @@ export class Environment {\n this.parentFunction = parentFunction;\n this.#contextIdentifiers = contextIdentifiers;\n this.#hoistedIdentifiers = new Set();\n+\n+ if (config.flowTypeProvider != null) {\n+ this.#flowTypeEnvironment = new FlowTypeEnv();\n+ CompilerError.invariant(code != null, {\n+ reason:\n+ 'Expected Environment to be initialized with source code when a Flow type provider is specified',\n+ loc: null,\n+ });\n+ this.#flowTypeEnvironment.init(this, code);\n+ } else {\n+ this.#flowTypeEnvironment = null;\n+ }\n+ }\n+\n+ get typeContext(): FlowTypeEnv {\n+ CompilerError.invariant(this.#flowTypeEnvironment != null, {\n+ reason: 'Flow type environment not initialized',\n+ loc: null,\n+ });\n+ return this.#flowTypeEnvironment;\n }\n \n get isInferredMemoEnabled(): boolean {\ndiff --git a\/compiler\/packages\/babel-plugin-react-compiler\/src\/ReactiveScopes\/MergeReactiveScopesThatInvalidateTogether.ts b\/compiler\/packages\/babel-plugin-react-compiler\/src\/ReactiveScopes\/MergeReactiveScopesThatInvalidateTogether.ts\nindex ea2f798770..a7acf5d662 100644\n--- a\/compiler\/packages\/babel-plugin-react-compiler\/src\/ReactiveScopes\/MergeReactiveScopesThatInvalidateTogether.ts\n+++ b\/compiler\/packages\/babel-plugin-react-compiler\/src\/ReactiveScopes\/MergeReactiveScopesThatInvalidateTogether.ts\n@@ -504,7 +504,7 @@ function canMergeScopes(\n return false;\n }\n \n-function isAlwaysInvalidatingType(type: Type): boolean {\n+export function isAlwaysInvalidatingType(type: Type): boolean {\n switch (type.kind) {\n case 'Object': {\n switch (type.shapeId) {\ndiff --git a\/compiler\/packages\/babel-plugin-react-compiler\/src\/Utils\/DisjointSet.ts b\/compiler\/packages\/babel-plugin-react-compiler\/src\/Utils\/DisjointSet.ts\nindex 449064ef32..566732c2bb 100644\n--- a\/compiler\/packages\/babel-plugin-react-compiler\/src\/Utils\/DisjointSet.ts\n+++ b\/compiler\/packages\/babel-plugin-react-compiler\/src\/Utils\/DisjointSet.ts\n@@ -78,6 +78,10 @@ export default class DisjointSet {\n return root;\n }\n \n+ has(item: T): boolean {\n+ return this.#entries.has(item);\n+ }\n+\n \/*\n * Forces the set into canonical form, ie with all items pointing directly to\n * their root, and returns a Map representing the mapping of items to their roots.\ndiff --git a\/compiler\/packages\/babel-plugin-react-compiler\/src\/Utils\/utils.ts b\/compiler\/packages\/babel-plugin-react-compiler\/src\/Utils\/utils.ts\nindex e5fbacfc77..897614015f 100644\n--- a\/compiler\/packages\/babel-plugin-react-compiler\/src\/Utils\/utils.ts\n+++ b\/compiler\/packages\/babel-plugin-react-compiler\/src\/Utils\/utils.ts\n@@ -33,12 +33,12 @@ export function assertExhaustive(_: never, errorMsg: string): never {\n \/\/ Modifies @param array in place, retaining only the items where the predicate returns true.\n export function retainWhere(\n array: Array,\n- predicate: (item: T) => boolean,\n+ predicate: (item: T, index: number) => boolean,\n ): void {\n let writeIndex = 0;\n for (let readIndex = 0; readIndex < array.length; readIndex++) {\n const item = array[readIndex];\n- if (predicate(item) === true) {\n+ if (predicate(item, readIndex) === true) {\n array[writeIndex++] = item;\n }\n }\n","commit":{"authorName":"Joseph Savona","authorEmail":"6425824+josephsavona@users.noreply.github.com","authoredAt":"2025-08-06T15:58:07-07:00","shortRevision":"c403a7c548","revision":"c403a7c54805e1198bfdad7fc97f33a792359a77","subject":"[compiler] Upstream experimental flow integration (#34121)"}}

dillon1000/react

Files changed