[flow] Remove key-set regexp and key-mirror reason descriptions

Summary:
Delete `RKeySet`, `RRegExp`, and `RObjectKeyMirror`. Replace result descriptions with location-only reasons, preserving the original annotation and definition metadata behavior.

Keep the genuine `$KeyMirror` symbol as `RType` on both type-application operations. The builtin `RegExp`, key extraction, and key-mirror type operations are unchanged.

Changelog: [internal] Remove key-set regexp and key-mirror reason descriptions.

Reviewed By: gkz

Differential Revision: D127198876

fbshipit-source-id: 1b5371780d818a122ee8a2387137977a7e4abd64

Author: SamChou19815

rust_port/crates/flow_common/src/reason.rs

@@ -301,17 +301,14 @@ pub enum VirtualReasonDesc<L: Dupe> {
     RThis,
     RThisType,
     RImplicitInstantiation,
-    RKeySet,
     RPrototype,
     RObjectPrototype,
     RFunctionPrototype,
     RDestructuring,
     RDefaultValue,
     RConstructor,
-    RRegExp,
     RDummyPrototype,
     RDummyThis,
-    RObjectKeyMirror,
     RSomeProperty,
     RGlobalObject,
     RObjectPatternRestProp,
@@ -434,15 +431,13 @@ impl<A: Dupe> VirtualReasonDesc<A> {
             RThis => RThis,
             RThisType => RThisType,
             RImplicitInstantiation => RImplicitInstantiation,
-            RKeySet => RKeySet,
             RPrototype => RPrototype,
             RObjectPrototype => RObjectPrototype,
             RFunctionPrototype => RFunctionPrototype,
             RDestructuring => RDestructuring,
             RDefaultValue => RDefaultValue,
             RConstructor => RConstructor,
             RRecordType(s) => RRecordType(s.dupe()),
-            RRegExp => RRegExp,
             RDummyPrototype => RDummyPrototype,
             RDummyThis => RDummyThis,
             RType(n) => RType(n.dupe()),
@@ -465,7 +460,6 @@ impl<A: Dupe> VirtualReasonDesc<A> {
             RCode(s) => RCode(s.dupe()),
             RGlobalObject => RGlobalObject,
             ROpaqueType(s) => ROpaqueType(s.dupe()),
-            RObjectKeyMirror => RObjectKeyMirror,
             RRendersNothing => RRendersNothing,
             RObjectPatternRestProp => RObjectPatternRestProp,
             RArrayPatternRestProp => RArrayPatternRestProp,
@@ -523,8 +517,7 @@ impl<L: Dupe> VirtualReasonDesc<L> {
         match self.unwrap() {
             Some(
                 RNumber | RBigInt | RString | RSymbol | RUniqueSymbol | RBoolean | RStringLit(_)
-                | RNumberLit(_) | RBigIntLit(_) | RBooleanLit(_) | RFbt | RTemplateString | RKeySet
-                | RRegExp,
+                | RNumberLit(_) | RBigIntLit(_) | RBooleanLit(_) | RFbt | RTemplateString,
             ) => Scalar,
 
             Some(
@@ -1257,8 +1250,6 @@ pub fn string_of_desc<L: Dupe>(desc: &VirtualReasonDesc<L>) -> String {
         RThisType => "`this` type".to_string(),
         RImplicitInstantiation => "implicit instantiation".to_string(),
 
-        RKeySet => "key set".to_string(),
-
         // Prototypes
         RPrototype => "prototype".to_string(),
         RObjectPrototype => "object prototype".to_string(),
@@ -1275,10 +1266,8 @@ pub fn string_of_desc<L: Dupe>(desc: &VirtualReasonDesc<L>) -> String {
         RRecordType(name) => format!("record `{}`", name),
 
         // Misc
-        RRegExp => "regexp".to_string(),
         RDummyPrototype => "empty prototype object".to_string(),
         RDummyThis => "bound `this` in method".to_string(),
-        RObjectKeyMirror => "`$KeyMirror`".to_string(),
 
         // Type aliases and params
         RType(x) => format!("`{}`", prettify_react_util(x.as_str())),

rust_port/crates/flow_typing/src/ty_normalizer_flow.rs

@@ -13,7 +13,6 @@ use dupe::Dupe;
 use flow_aloc::ALoc;
 use flow_common::reason::Name;
 use flow_common::reason::Reason;
-use flow_common::reason::VirtualReasonDesc;
 use flow_common_ty::ty::ALocElt;
 use flow_common_ty::ty::ALocTy;
 use flow_common_ty::ty_printer;
@@ -108,10 +107,7 @@ impl NormalizerInput for FlowInput {
             flow_js::flow_non_speculating(env.cx, (&t, &use_t))?;
             match lookahead::peek_types(env.cx, &collector.collect_to_vec()) {
                 lookahead::Lookahead::LowerBounds(ref bounds) if bounds.len() == 1 => {
-                    let t = type_util::mod_reason_of_t(
-                        &|r| r.replace_desc(VirtualReasonDesc::RKeySet),
-                        &bounds[0],
-                    );
+                    let t = type_util::mod_reason_of_t(&|r| r.replace_desc(None), &bounds[0]);
                     cont(env, state, t)
                 }
                 _ => default(env, state),

rust_port/crates/flow_typing_flow_js/src/flow_js/dispatch.rs

@@ -2740,10 +2740,8 @@ fn __flow_impl<'cx>(
                             suggestion,
                         }))
                     } else {
-                        let keys = Type::new(KeysT(
-                            reason_o.dupe().replace_desc_new(VirtualReasonDesc::RKeySet),
-                            l.dupe(),
-                        ));
+                        let keys =
+                            Type::new(KeysT(reason_o.dupe().replace_desc_new(None), l.dupe()));
                         flow_js_utils::incompatible_types_error(key, &keys, use_op.dupe(), None)
                     };
                     flow_js_utils::add_output_with_env(cx, env, err)?;
@@ -2832,10 +2830,7 @@ fn __flow_impl<'cx>(
                     suggestion: None,
                 }))
             } else {
-                let keys = Type::new(KeysT(
-                    reason_o.dupe().replace_desc_new(VirtualReasonDesc::RKeySet),
-                    l.dupe(),
-                ));
+                let keys = Type::new(KeysT(reason_o.dupe().replace_desc_new(None), l.dupe()));
                 flow_js_utils::incompatible_types_error(key, &keys, use_op.dupe(), None)
             };
             flow_js_utils::add_output_with_env(cx, env, err)?;

rust_port/crates/flow_typing_statement/src/statement.rs

@@ -1660,7 +1660,7 @@ fn bigint_literal_inner<'a>(
 }
 
 pub fn regexp_literal<'a>(cx: &mut Context<'a>, loc: ALoc) -> Result<Type, JobError> {
-    let reason = mk_annot_reason(VirtualReasonDesc::RRegExp, loc);
+    let reason = mk_annot_reason(None, loc);
     flow_js::get_builtin_type_non_speculating(cx, &reason, None, "RegExp")
 }
 
@@ -14282,7 +14282,7 @@ fn static_method_call_object<'a>(
         let reason_clone = reason.dupe();
         let use_op_clone = use_op.dupe();
         tvar_resolver::mk_tvar_and_fully_resolve_where::<JobError>(cx, arr_reason, |cx, tvar| {
-            let keys_reason = reason_clone.dupe().replace_desc_new(RKeySet);
+            let keys_reason = reason_clone.dupe().replace_desc_new(None);
             flow_js::flow_non_speculating(
                 cx,
                 (

rust_port/crates/flow_typing_statement/src/type_annotation.rs

@@ -20,6 +20,7 @@ use flow_common::polarity::Polarity;
 use flow_common::reason;
 use flow_common::reason::Name;
 use flow_common::reason::Reason;
+use flow_common::reason::VirtualReasonDesc;
 use flow_common::subst_name::SubstName;
 use flow_data_structure_wrapper::ord_map::FlowOrdMap;
 use flow_data_structure_wrapper::ord_set::FlowOrdSet;
@@ -1343,7 +1344,7 @@ fn convert_inner<'a>(
             let argument_ast = convert_inner(cx, env, &inner.argument)?;
             let arg_t = argument_ast.loc().1.dupe();
             let t = Type::new(type_::TypeInner::KeysT(
-                reason::mk_reason(reason::VirtualReasonDesc::RKeySet, loc.dupe()),
+                reason::mk_reason(None, loc.dupe()),
                 arg_t,
             ));
             ast::types::Type::new(TypeInner::Keyof {
@@ -2538,10 +2539,7 @@ fn convert_inner<'a>(
                             let tp = ts.into_iter().next().unwrap();
                             Ok(reconstruct_ast(
                                 Type::new(type_::TypeInner::KeysT(
-                                    reason::mk_reason(
-                                        reason::VirtualReasonDesc::RKeySet,
-                                        loc.dupe(),
-                                    ),
+                                    reason::mk_reason(None, loc.dupe()),
                                     tp,
                                 )),
                                 None,
@@ -2713,14 +2711,14 @@ fn convert_inner<'a>(
                             let (ts, targs_ast) =
                                 convert_type_params(cx, env, inner.targs.as_ref())?;
                             let t1 = ts.into_iter().next().unwrap();
-                            let reason = reason::mk_reason(
-                                reason::VirtualReasonDesc::RObjectKeyMirror,
-                                loc.dupe(),
-                            );
+                            let reason = reason::mk_reason(None, loc.dupe());
+                            let type_reason = reason.dupe().replace_desc(VirtualReasonDesc::RType(
+                                FlowSmolStr::new_inline("$KeyMirror"),
+                            ));
                             let result_t =
                                 FlowJs::mk_possibly_evaluated_destructor_for_annotations(
                                     cx,
-                                    use_op(&reason),
+                                    use_op(&type_reason),
                                     &reason,
                                     &t1,
                                     &type_::Destructor::TypeMap(type_::TypeMap::ObjectKeyMirror),

rust_port/crates/flow_typing_utils/src/type_sig_merge.rs

@@ -2423,7 +2423,7 @@ fn merge_annot<'cx>(
             })
         }
         Annot::Keys(box (loc, t)) => {
-            let reason = reason::mk_reason(RKeySet, loc.dupe());
+            let reason = reason::mk_reason(None, loc.dupe());
             let t = merge_impl(env, cx, file, t, false, false);
             Type::new(type_::TypeInner::KeysT(reason, t))
         }
@@ -2576,9 +2576,11 @@ fn merge_annot<'cx>(
         }
         Annot::ObjKeyMirror(inner) => {
             let AnnotObjKeyMirror { loc, obj } = inner.as_ref();
-            let reason = reason::mk_reason(RObjectKeyMirror, loc.dupe());
+            let reason = reason::mk_reason(None, loc.dupe());
             let use_op = type_::UseOp::Op(Arc::new(type_::RootUseOp::TypeApplication {
-                type_: reason.dupe(),
+                type_: reason
+                    .dupe()
+                    .replace_desc(RType(FlowSmolStr::new_inline("$KeyMirror"))),
             }));
             let obj = merge_impl(env, cx, file, obj, false, false);
             let id = eval_id_of_aloc(cx, loc.dupe());