@@ -300,7 +300,19 @@ let rec dump_t_ (depth, tvars) cx t =
 t
 | MaybeT (_, arg) -> p ~extra:(kid arg) t
 | IntersectionT (_, rep) ->
-p ~extra:(spf "[%s]" (String.concat "; " (Base.List.map ~f:kid (InterRep.members rep)))) t
+let kind_str =
+match InterRep.inter_kind rep with
+| InterRep.ImplicitInstiationKind -> "ImplicitInstiationKind"
+| InterRep.UnknownKind -> "UnknownKind"
+in
+p
+~extra:
+(spf
+"(kind=%s)[%s]"
+kind_str
+(String.concat "; " (Base.List.map ~f:kid (InterRep.members rep)))
+)
+t
 | UnionT (_, rep) ->
 let kind_str =
 match UnionRep.union_kind rep with

@@ -708,22 +708,39 @@ module Make (Observer : OBSERVER) (Flow : Flow_common.S) : S = struct
 | (UpperT t', UpperT t) ->
 (match (t', t) with
 | (IntersectionT (_, rep1), IntersectionT (_, rep2)) ->
-UpperT (IntersectionT (upper_r, InterRep.append (InterRep.members rep2) rep1))
+UpperT
+(IntersectionT
+( upper_r,
+InterRep.append
+~kind:InterRep.ImplicitInstiationKind
+(InterRep.members rep2)
+rep1
+)
+)
 | (_, IntersectionT (_, rep)) ->
 if Base.List.mem (InterRep.members rep) t' ~equal then
 UpperT t
 else
-UpperT (IntersectionT (upper_r, InterRep.append [t'] rep))
+UpperT
+(IntersectionT
+(upper_r, InterRep.append ~kind:InterRep.ImplicitInstiationKind [t'] rep)
+)
 | (IntersectionT (_, rep), _) ->
 if Base.List.mem (InterRep.members rep) t ~equal then
 UpperT t'
 else
-UpperT (IntersectionT (upper_r, InterRep.append [t] rep))
+UpperT
+(IntersectionT
+(upper_r, InterRep.append ~kind:InterRep.ImplicitInstiationKind [t] rep)
+)
 | (t', t) ->
 if equal t' t then
 UpperT t
 else
-UpperT (IntersectionT (upper_r, InterRep.make t' t [])))
+UpperT
+(IntersectionT
+(upper_r, InterRep.make ~kind:InterRep.ImplicitInstiationKind t' t [])
+))
 | (UpperT _, UpperEmpty) -> acc
 | (UpperEmpty, UpperEmpty) -> acc)
 UpperEmpty)

@@ -125,6 +125,11 @@ let generalize_singletons =
 (* async expressions will wrap result in Promise<>, so we need to descend here *)
 super#type_ cx force_general t
 | UnionT (r, rep) when is_literal_union r rep -> super#type_ cx force_general t
+| IntersectionT (_, rep)
+when match InterRep.inter_kind rep with
+| InterRep.ImplicitInstiationKind -> true
+| InterRep.UnknownKind -> false ->
+super#type_ cx force_general t
 | DefT (r, SingletonStrT { from_annot = false; value }) ->
 if force_general || Context.natural_inference_local_primitive_literals_full cx then
 DefT (replace_desc_reason RString r, StrGeneralT AnyLiteral)

@@ -2925,8 +2925,12 @@ end
 and InterRep : sig
 type t
 
+type inter_kind =
+| ImplicitInstiationKind
+| UnknownKind
+
 (** build rep from list of members *)
-val make : TypeTerm.t -> TypeTerm.t -> TypeTerm.t list -> t
+val make : ?kind:inter_kind -> TypeTerm.t -> TypeTerm.t -> TypeTerm.t list -> t
 
 (** member list in declaration order *)
 val members : t -> TypeTerm.t list
@@ -2936,33 +2940,39 @@ and InterRep : sig
 (** map rep r to rep r' along type mapping f. drops history *)
 val map : (TypeTerm.t -> TypeTerm.t) -> t -> t
 
-val append : TypeTerm.t list -> t -> t
+val append : ?kind:inter_kind -> TypeTerm.t list -> t -> t
 
 (** map rep r to rep r' along type mapping f. drops history. if nothing would
 be changed, returns the physically-identical rep. *)
 val ident_map : (TypeTerm.t -> TypeTerm.t) -> t -> t
+
+val inter_kind : t -> inter_kind
 end = struct
+type inter_kind =
+| ImplicitInstiationKind
+| UnknownKind
+
 (** intersection rep is:
 - member list in declaration order
 *)
-type t = TypeTerm.t * TypeTerm.t * TypeTerm.t list
+type t = TypeTerm.t * TypeTerm.t * TypeTerm.t list * inter_kind
 
-let make t0 t1 ts = (t0, t1, ts)
+let make ?(kind = UnknownKind) t0 t1 ts = (t0, t1, ts, kind)
 
-let members (t0, t1, ts) = t0 :: t1 :: ts
+let members (t0, t1, ts, _) = t0 :: t1 :: ts
 
-let members_nel (t0, t1, ts) = (t0, (t1, ts))
+let members_nel (t0, t1, ts, _) = (t0, (t1, ts))
 
-let map f (t0, t1, ts) = make (f t0) (f t1) (Base.List.map ~f ts)
+let map f (t0, t1, ts, kind) = make ~kind (f t0) (f t1) (Base.List.map ~f ts)
 
-let mem t (t0, t1, ts) = t = t0 || t = t1 || Base.List.mem ts t ~equal:( = )
+let mem t (t0, t1, ts, _) = t = t0 || t = t1 || Base.List.mem ts t ~equal:( = )
 
-let append ts2 rep =
+let append ?(kind = UnknownKind) ts2 rep =
 let ts2 = Base.List.filter ts2 ~f:(fun t -> not (mem t rep)) in
-let (t0, t1, ts1) = rep in
-make t0 t1 (Base.List.append ts1 ts2)
+let (t0, t1, ts1, _) = rep in
+make ~kind t0 t1 (Base.List.append ts1 ts2)
 
-let ident_map f ((t0, t1, ts) as rep) =
+let ident_map f ((t0, t1, ts, kind) as rep) =
 let t0_ = f t0 in
 let t1_ = f t1 in
 let changed = t0_ != t0 || t1_ != t1 in
@@ -2975,9 +2985,11 @@ end = struct
 ts
 in
 if changed then
-make t0_ t1_ (List.rev rev_ts)
+make ~kind t0_ t1_ (List.rev rev_ts)
 else
 rep
+
+let inter_kind (_, _, _, kind) = kind
 end
 
 and Object : sig

@@ -541,3 +541,15 @@ function test_array_elem_union() {
 const strings = foo(['a', 'b']);
 strings.push("c"); // okay
 }
+
+function test_generalize_under_intersection() {
+declare function foo<V>(
+v: $Exact<V>,
+cb: (data: $Exact<V>) => void,
+): void;
+
+foo(
+{f:1},
+(x: {f: number}) => {}, // okay, type of `1` should generalize
+);
+}