@@ -843,14 +843,6 @@ let is_literal_function_reason r =
 | RFunction _ -> true
 | _ -> false
 
-let is_literal_union_reason r =
-match desc_of_reason r with
-| RInferredUnionElemArray _
-| RConditional
-| RLogical _ ->
-true
-| _ -> false
-
 let is_lib_reason r =
 r.loc |> ALoc.source |> Base.Option.value_map ~default:false ~f:File_key.is_lib_file
 

@@ -281,8 +281,6 @@ val is_literal_array_reason : 'loc virtual_reason -> bool
 
 val is_literal_function_reason : 'loc virtual_reason -> bool
 
-val is_literal_union_reason : 'loc virtual_reason -> bool
-
 val is_lib_reason : reason -> bool
 
 val is_lib_reason_def : reason -> bool

@@ -302,10 +302,20 @@ let rec dump_t_ (depth, tvars) cx t =
 | IntersectionT (_, rep) ->
 p ~extra:(spf "[%s]" (String.concat "; " (Base.List.map ~f:kid (InterRep.members rep)))) t
 | UnionT (_, rep) ->
+let kind_str =
+match UnionRep.union_kind rep with
+| UnionRep.ProvidersKind -> "ProvidersKind"
+| UnionRep.ConditionalKind -> "ConditionalKind"
+| UnionRep.ImplicitInstiationKind -> "ImplicitInstiationKind"
+| UnionRep.ResolvedKind -> "ResolvedKind"
+| UnionRep.LogicalKind -> "LogicalKind"
+| UnionRep.UnknownKind -> "UnknownKind"
+in
 p
 ~extra:
 (spf
-"[%s]%s"
+"(kind=%s)[%s]%s"
+kind_str
 (String.concat "; " (Base.List.map ~f:kid (UnionRep.members rep)))
 (UnionRep.string_of_specialization rep)
 )

@@ -212,7 +212,8 @@ let resolve_hint cx loc hint : Type_hint.concr_hint =
 Type_env.checked_find_loc_env_write cx Env_api.OrdinaryNameLoc loc
 )
 in
-UnionT (mk_reason (RCustom "providers") loc, UnionRep.make ~synthetic:true t1 t2 ts)
+UnionT
+(mk_reason (RCustom "providers") loc, UnionRep.make ~kind:UnionRep.ProvidersKind t1 t2 ts)
 | WriteLocHint (kind, loc) -> Type_env.checked_find_loc_env_write cx kind loc
 | StringLiteralType name ->
 DefT

@@ -58,14 +58,14 @@ let rec collect_lowers ~filter_empty cx seen acc = function
 (* Everything else becomes part of the merge typed *)
 | _ -> collect_lowers ~filter_empty cx seen (t :: acc) ts)
 
-let merge_tvar_opt ?(filter_empty = false) cx r id =
+let merge_tvar_opt ?(filter_empty = false) ?(union_kind = UnionRep.ResolvedKind) cx r id =
 let lowers =
 let seen = ISet.singleton id in
 collect_lowers cx seen [] (possible_types cx id) ~filter_empty
 in
 match lowers with
 | [t] -> Some t
-| t0 :: t1 :: ts -> Some (UnionT (r, UnionRep.make ~synthetic:true t0 t1 ts))
+| t0 :: t1 :: ts -> Some (UnionT (r, UnionRep.make ~kind:union_kind t0 t1 ts))
 | [] -> None
 
 let merge_tvar ?(filter_empty = false) ~no_lowers cx r id =

@@ -602,7 +602,8 @@ module Make (Observer : OBSERVER) (Flow : Flow_common.S) : S = struct
 match tuple_ts with
 | [] -> EmptyT.why reason
 | [t] -> t
-| t0 :: t1 :: ts -> UnionT (reason, UnionRep.make t0 t1 ts)
+| t0 :: t1 :: ts ->
+UnionT (reason, UnionRep.make ~kind:UnionRep.ImplicitInstiationKind t0 t1 ts)
 in
 let len = Base.List.length tuple_ts in
 let t =
@@ -775,7 +776,7 @@ module Make (Observer : OBSERVER) (Flow : Flow_common.S) : S = struct
 |> union_flatten_list
 |> generalize_singletons cx
 |> Base.List.filter ~f:(fun t -> not @@ Flow_js_utils.TvarVisitors.has_placeholders cx t)
-|> TypeUtil.union_of_ts_opt r)
+|> TypeUtil.union_of_ts_opt ~kind:UnionRep.ImplicitInstiationKind r)
 | t -> Some t
 
 let on_missing_bounds cx ~use_op tparam ~default_bound ~tparam_binder_reason ~instantiation_reason

@@ -53,6 +53,21 @@ let is_builtin_promise =
 in
 (fun cx t -> loop cx ISet.empty t)
 
+let is_literal_union r rep =
+let open UnionRep in
+match union_kind rep with
+| ConditionalKind
+| ImplicitInstiationKind
+| LogicalKind ->
+true
+| ProvidersKind
+| ResolvedKind
+| UnknownKind ->
+let open Reason in
+(match desc_of_reason r with
+| RInferredUnionElemArray _ -> true
+| _ -> false)
+
 (**
 * [generalize_singletons cx ~force_general t] walks a `t` and replacing instances
 * of singleton types that originate from literals with the general version of the
@@ -109,7 +124,7 @@ let generalize_singletons =
 | TypeAppT { type_; _ } when is_builtin_promise cx type_ ->
 (* async expressions will wrap result in Promise<>, so we need to descend here *)
 super#type_ cx force_general t
-| UnionT (r, _) when is_literal_union_reason r -> super#type_ cx force_general t
+| UnionT (r, rep) when is_literal_union r rep -> 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)

@@ -3296,7 +3296,7 @@ module Make
 | (false, true) -> t1
 (* Both sides threw--see below for where we re-raise *)
 | (true, true) -> EmptyT.at loc
-| (false, false) -> UnionT (reason, UnionRep.make ~synthetic:true t1 t2 [])
+| (false, false) -> UnionT (reason, UnionRep.make ~kind:UnionRep.ConditionalKind t1 t2 [])
 (* NOTE: In general it is dangerous to express the least upper bound of
 some types as a union: it might pin down the least upper bound
 prematurely (before all the types have been inferred), and when the

@@ -2323,13 +2323,21 @@ end
 and UnionRep : sig
 type t
 
+type union_kind =
+| ProvidersKind
+| ConditionalKind
+| ImplicitInstiationKind
+| ResolvedKind
+| LogicalKind
+| UnknownKind
+
 val same_source : t -> t -> bool
 
 val same_structure : t -> t -> bool
 
 (** build a rep from list of members *)
 val make :
-?source_aloc:ALoc.id -> ?synthetic:bool -> TypeTerm.t -> TypeTerm.t -> TypeTerm.t list -> t
+?source_aloc:ALoc.id -> ?kind:union_kind -> TypeTerm.t -> TypeTerm.t -> TypeTerm.t list -> t
 
 (** members in declaration order *)
 val members : t -> TypeTerm.t list
@@ -2342,6 +2350,8 @@ and UnionRep : sig
 
 val is_synthetic : t -> bool
 
+val union_kind : t -> union_kind
+
 (** map rep r to rep r' along type mapping f. if nothing would be changed,
 returns the physically-identical rep. *)
 val ident_map : ?always_keep_source:bool -> (TypeTerm.t -> TypeTerm.t) -> t -> t
@@ -2475,6 +2485,14 @@ end = struct
 | NoCandidateMembers
 | NoCommonKeys
 
+type union_kind =
+| ProvidersKind
+| ConditionalKind
+| ImplicitInstiationKind
+| ResolvedKind
+| LogicalKind
+| UnknownKind
+
 type t = {
 t0: TypeTerm.t;
 t1: TypeTerm.t;
@@ -2488,7 +2506,7 @@ end = struct
 (* A union is synthetic roughly when it does not emerge from an annotation,
 * e.g. when it emerges as the collection of lower bounds during implicit
 * instantiation. *)
-synthetic: bool;
+kind: union_kind;
 }
 
 let same_source { source_aloc = s1; _ } { source_aloc = s2; _ } =
@@ -2524,7 +2542,12 @@ end = struct
 | DefT (_, NullT) -> Some NullTag
 | _ -> None
 
-let is_synthetic { synthetic; _ } = synthetic
+let is_synthetic { kind; _ } =
+match kind with
+| UnknownKind -> false
+| _ -> true
+
+let union_kind { kind; _ } = kind
 
 (** given a list of members, build a rep.
 specialized reps are used on compatible type lists *)
@@ -2539,14 +2562,14 @@ end = struct
 | _ -> None
 end
 in
-fun ?source_aloc ?(synthetic = false) t0 t1 ts ->
+fun ?source_aloc ?(kind = UnknownKind) t0 t1 ts ->
 let enum =
 Base.Option.(
 mk_enum (UnionEnumSet.empty, tag_of_member t0) (t0 :: t1 :: ts) >>| fun (tset, tag) ->
 EnumUnion (tset, tag)
 )
 in
-{ t0; t1; ts; source_aloc; specialization = ref enum; synthetic }
+{ t0; t1; ts; source_aloc; specialization = ref enum; kind }
 
 let members { t0; t1; ts; _ } = t0 :: t1 :: ts
 
@@ -2559,7 +2582,8 @@ end = struct
 | t0 :: t1 :: ts -> make t0 t1 ts
 | _ -> failwith "impossible"
 
-let ident_map ?(always_keep_source = false) f ({ t0; t1; ts; source_aloc = source; _ } as rep) =
+let ident_map
+?(always_keep_source = false) f ({ t0; t1; ts; source_aloc = source; kind; _ } as rep) =
 let t0_ = f t0 in
 let t1_ = f t1 in
 let ts_ = ListUtils.ident_map f ts in
@@ -2571,7 +2595,7 @@ end = struct
 else
 None
 in
-make ?source_aloc t0_ t1_ ts_
+make ?source_aloc ~kind t0_ t1_ ts_
 else
 rep
 

@@ -765,21 +765,21 @@ let map_annotated_or_inferred f = function
 (* Creates a union from a list of types. Since unions require a minimum of two
 types this function will return an empty type when there are no types in the
 list, or the list head when there is one type in the list. *)
-let union_of_ts reason ts =
+let union_of_ts ?(kind = UnionRep.UnknownKind) reason ts =
 match ts with
 (* If we have no types then this is an error. *)
 | [] -> DefT (reason, EmptyT)
 (* If we only have one type then only that should be used. *)
 | [t0] -> t0
 (* If we have more than one type then we make a union type. *)
-| t0 :: t1 :: ts -> UnionT (reason, UnionRep.make t0 t1 ts)
+| t0 :: t1 :: ts -> UnionT (reason, UnionRep.make ~kind t0 t1 ts)
 
-let union_of_ts_opt reason ts =
+let union_of_ts_opt ?(kind = UnionRep.UnknownKind) reason ts =
 match ts with
 | [] -> None
 | [t0] -> Some t0
 (* If we have more than one type then we make a union type. *)
-| t0 :: t1 :: ts -> Some (UnionT (reason, UnionRep.make t0 t1 ts))
+| t0 :: t1 :: ts -> Some (UnionT (reason, UnionRep.make ~kind t0 t1 ts))
 
 let annotated_or_inferred_of_option ~default = function
 | Some t -> Annotated t

@@ -91,9 +91,9 @@ val type_t_of_annotated_or_inferred : Type.annotated_or_inferred -> Type.t
 val map_annotated_or_inferred :
 (Type.t -> Type.t) -> Type.annotated_or_inferred -> Type.annotated_or_inferred
 
-val union_of_ts : reason -> Type.t list -> Type.t
+val union_of_ts : ?kind:Type.UnionRep.union_kind -> reason -> Type.t list -> Type.t
 
-val union_of_ts_opt : reason -> Type.t list -> Type.t option
+val union_of_ts_opt : ?kind:Type.UnionRep.union_kind -> reason -> Type.t list -> Type.t option
 
 val annotated_or_inferred_of_option : default:Type.t -> Type.t option -> Type.annotated_or_inferred
 

@@ -184,7 +184,8 @@ let provider_type_for_def_loc ?(intersect = false) cx env def_loc =
 | t1 :: t2 :: ts when intersect ->
 IntersectionT (mk_reason (RCustom "providers") def_loc, InterRep.make t1 t2 ts)
 | t1 :: t2 :: ts ->
-UnionT (mk_reason (RCustom "providers") def_loc, UnionRep.make ~synthetic:true t1 t2 ts)
+UnionT
+(mk_reason (RCustom "providers") def_loc, UnionRep.make ~kind:UnionRep.ProvidersKind t1 t2 ts)
 
 (*************)
 (* Reading *)
@@ -800,7 +801,9 @@ let constraining_type ~default cx name loc =
 | Some [t] -> t
 | Some (t1 :: t2 :: ts) ->
 UnionT
-(mk_reason (RIdentifier (OrdinaryName name)) loc, UnionRep.make ~synthetic:true t1 t2 ts))
+( mk_reason (RIdentifier (OrdinaryName name)) loc,
+UnionRep.make ~kind:UnionRep.ProvidersKind t1 t2 ts
+))
 
 (*************)
 (* Writing *)

@@ -375,7 +375,9 @@ module Operators = struct
 let id = Tvar.mk_no_wrap cx reason in
 let tout = (reason, id) in
 f tout;
-match Flow_js_utils.merge_tvar_opt ~filter_empty:true cx reason id with
+match
+Flow_js_utils.merge_tvar_opt ~filter_empty:true ~union_kind:UnionRep.LogicalKind cx reason id
+with
 | Some t -> t
 | None -> Tvar_resolver.default_no_lowers reason
 

@@ -527,3 +527,17 @@ function test_async() {
 const x = new AsyncSelector(async () => ({title: ''}));
 x as AsyncSelector<Promise<{title: string}>>; // okay '' has generalized to string
 }
+
+function test_logical_nullish() {
+declare const x: ?('a' | 'b');
+declare var arr: Array<void>;
+const mappedArr = arr.map(_ => ({
+prop: x ?? 'c',
+}));
+mappedArr[0].prop = 'd'; // okay - 'c' causes generalization to string
+}
+function test_array_elem_union() {
+declare function foo<T>(create: T): T;
+const strings = foo(['a', 'b']);
+strings.push("c"); // okay
+}