[flow] Remove call result reason wrappers

Summary:
Delete `RFunctionCall`, `RConstructorCall`, and `RJSXFunctionCall` and their mapping and display cases. Call results and latent predicate calls now use location-only reasons. Missing-argument diagnostics were migrated to printed types in the preceding commit.

Changelog: [internal] Remove call result reason wrappers.

Reviewed By: gkz

Differential Revision: D126828382

fbshipit-source-id: 09bcff09e6c44337ed20e361c3056a1d52a85e65

Author: SamChou19815

rust_port/crates/flow_common/src/reason.rs

@@ -348,8 +348,6 @@ pub enum VirtualReasonDesc<L: Dupe> {
     RTupleElement,
     RTupleOutOfBoundsAccess(i32),
     RFunction(ReasonDescFunction),
-    RFunctionCall(Option<Arc<VirtualReasonDesc<L>>>),
-    RJSXFunctionCall(FlowSmolStr),
     RUnaryOperator(FlowSmolStr, Arc<VirtualReasonDesc<L>>),
     RBinaryOperator(
         Box<(
@@ -373,7 +371,6 @@ pub enum VirtualReasonDesc<L: Dupe> {
         member_name: FlowSmolStr,
     },
     REnumUnknownMembers(Arc<VirtualReasonDesc<L>>),
-    RConstructorCall(Option<Arc<VirtualReasonDesc<L>>>),
     RRecordType(FlowSmolStr),
     RType(FlowSmolStr),
     RTypeAlias(Box<(FlowSmolStr, Option<L>, Option<Arc<VirtualReasonDesc<L>>>)>),
@@ -454,7 +451,6 @@ impl<A: Dupe> VirtualReasonDesc<A> {
             RTupleUnknownElementFromInexact => RTupleUnknownElementFromInexact,
             RFunction(func) => RFunction(*func),
             RFunctionType => RFunctionType,
-            RJSXFunctionCall(s) => RJSXFunctionCall(s.dupe()),
             RFbt => RFbt,
             RUninitialized => RUninitialized,
             RPossiblyUninitialized => RPossiblyUninitialized,
@@ -535,7 +531,6 @@ impl<A: Dupe> VirtualReasonDesc<A> {
             RReactChildren => RReactChildren,
 
             // Recursive variants
-            RFunctionCall(d) => RFunctionCall(d.as_ref().map(|d| Arc::new(d.map_locs(f)))),
             RUnknownUnspecifiedProperty(d) => RUnknownUnspecifiedProperty(Arc::new(d.map_locs(f))),
             RUnaryOperator(s, d) => RUnaryOperator(s.dupe(), Arc::new(d.map_locs(f))),
             RBinaryOperator(box (s, d1, d2)) => RBinaryOperator(Box::new((
@@ -548,7 +543,6 @@ impl<A: Dupe> VirtualReasonDesc<A> {
                 Arc::new(d1.map_locs(f)),
                 Arc::new(d2.map_locs(f)),
             ))),
-            RConstructorCall(d) => RConstructorCall(d.as_ref().map(|d| Arc::new(d.map_locs(f)))),
             RTypeAlias(box (s, loc_opt, d)) => RTypeAlias(Box::new((
                 s.dupe(),
                 loc_opt.as_ref().map(f),
@@ -1294,13 +1288,8 @@ pub fn string_of_desc<L: Dupe>(desc: &VirtualReasonDesc<L>) -> String {
         // Functions
         RFunction(func) => format!("{}function", func.prefix()),
         RFunctionType => "function type".to_string(),
-        RFunctionCall(d) => format!(
-            "call of {}",
-            d.as_deref().map(string_of_desc).unwrap_or_default()
-        ),
 
         // JSX
-        RJSXFunctionCall(raw_jsx) => format!("`{}(...)`", raw_jsx),
         RFbt => "`<fbt/>`".to_string(),
 
         // Operators
@@ -1364,10 +1353,6 @@ pub fn string_of_desc<L: Dupe>(desc: &VirtualReasonDesc<L>) -> String {
 
         // Constructors
         RConstructor => "constructor".to_string(),
-        RConstructorCall(d) => format!(
-            "new {}",
-            d.as_deref().map(string_of_desc).unwrap_or_default()
-        ),
 
         // Records
         RRecordType(name) => format!("record `{}`", name),

rust_port/crates/flow_typing_errors/src/intermediate_error.rs

@@ -70,6 +70,7 @@ use flow_typing_type::type_::VirtualRootUseOp;
 use flow_typing_type::type_::VirtualUseOp;
 use flow_typing_type::type_::aconstraint::AnnotationInferenceOperation;
 use flow_typing_type::type_::fold_virtual_use_op;
+use flow_typing_type::type_::implicit_instantiation_reference_kind;
 use flow_typing_type::type_::root_of_use_op;
 use flow_typing_type::type_::type_or_type_desc::ErrorTypeDesc;
 use flow_typing_type::type_::type_or_type_desc::TypeOrTypeDescT;
@@ -3386,6 +3387,39 @@ where
         }
     };
 
+    let missing_argument_message =
+        |def: &VirtualReason<L>, op: &VirtualReason<L>, inner_use_op: &VirtualUseOp<L>| {
+            if let VirtualUseOp::Op(inner_root) = inner_use_op
+                && matches!(
+                    inner_root.as_ref(),
+                    VirtualRootUseOp::FunCall(..) | VirtualRootUseOp::FunCallMethod(..)
+                )
+            {
+                let def = def.dupe().update_desc(|desc| match desc {
+                    Some(VirtualReasonDesc::RFunctionType) => {
+                        Some(VirtualReasonDesc::RFunction(ReasonDescFunction::RNormal))
+                    }
+                    _ => desc,
+                });
+                Message::MessageFunctionRequiresAnotherArgument { def, from: None }
+            } else if op.desc(false).is_none()
+                && let Some(kind) = implicit_instantiation_reference_kind(inner_use_op)
+            {
+                Message::MessageFunctionRequiresAnotherArgumentFromCall {
+                    def: def.dupe(),
+                    call: ImplicitInstantiationReferenceData {
+                        loc: op.loc().dupe(),
+                        kind: kind.dupe(),
+                    },
+                }
+            } else {
+                Message::MessageFunctionRequiresAnotherArgument {
+                    def: def.dupe(),
+                    from: Some(op.dupe()),
+                }
+            }
+        };
+
     // An error between two incompatible types. A "lower" type and an "upper" type.
     let mk_incompatible_error = |additional_explanation: Option<Explanation<L>>,
                                  lower: VirtualReason<L>,
@@ -3447,30 +3481,7 @@ where
 
             VirtualUseOp::Frame(frame, inner_use_op) => match frame.as_ref() {
                 VirtualFrameUseOp::FunMissingArg(box FunMissingArgData { def, op, .. }) => {
-                    let message = match inner_use_op.as_ref() {
-                        VirtualUseOp::Op(inner_root) => match inner_root.as_ref() {
-                            VirtualRootUseOp::FunCall(..) | VirtualRootUseOp::FunCallMethod(..) => {
-                                let new_def = def.dupe().update_desc(|desc| match desc {
-                                    Some(VirtualReasonDesc::RFunctionType) => Some(
-                                        VirtualReasonDesc::RFunction(ReasonDescFunction::RNormal),
-                                    ),
-                                    _ => desc,
-                                });
-                                Message::MessageFunctionRequiresAnotherArgument {
-                                    def: new_def,
-                                    from: None,
-                                }
-                            }
-                            _ => Message::MessageFunctionRequiresAnotherArgument {
-                                def: def.dupe(),
-                                from: Some(op.dupe()),
-                            },
-                        },
-                        _ => Message::MessageFunctionRequiresAnotherArgument {
-                            def: def.dupe(),
-                            from: Some(op.dupe()),
-                        },
-                    };
+                    let message = missing_argument_message(def, op, inner_use_op);
                     mk_use_op_error_reason(
                         op,
                         use_op.clone(),
@@ -3733,29 +3744,7 @@ where
                 && let VirtualFrameUseOp::FunMissingArg(box FunMissingArgData { def, op, .. }) =
                     frame.as_ref()
             {
-                let message = match inner_use_op.as_ref() {
-                    VirtualUseOp::Op(inner_root)
-                        if matches!(
-                            inner_root.as_ref(),
-                            VirtualRootUseOp::FunCall(..) | VirtualRootUseOp::FunCallMethod(..)
-                        ) =>
-                    {
-                        let new_def = def.dupe().update_desc(|desc| match desc {
-                            Some(VirtualReasonDesc::RFunctionType) => {
-                                Some(VirtualReasonDesc::RFunction(ReasonDescFunction::RNormal))
-                            }
-                            _ => desc,
-                        });
-                        Message::MessageFunctionRequiresAnotherArgument {
-                            def: new_def,
-                            from: None,
-                        }
-                    }
-                    _ => Message::MessageFunctionRequiresAnotherArgument {
-                        def: def.dupe(),
-                        from: Some(op.dupe()),
-                    },
-                };
+                let message = missing_argument_message(def, op, inner_use_op);
                 mk_use_op_error_reason(op, use_op.clone(), explanation, message)
             } else {
                 let (((lower_loc, lower_desc), (upper_loc, upper_desc)), use_op) =
@@ -10699,6 +10688,13 @@ where
                     ref_(from),
                 ]),
             },
+            MessageFunctionRequiresAnotherArgumentFromCall { def, call } => {
+                friendly::Message(vec![
+                    ref_(def),
+                    text(" requires another argument from "),
+                    render_implicit_instantiation_reference(call),
+                ])
+            }
             MessageIncompatibleComponentRestParam(rest_param) => friendly::Message(vec![
                 text("Cannot use "),
                 ref_of_type(rest_param),

rust_port/crates/flow_typing_errors/src/intermediate_error_types.rs

@@ -2397,6 +2397,11 @@ pub enum Message<L: Dupe> {
         from: Option<VirtualReason<L>>,
     },
 
+    MessageFunctionRequiresAnotherArgumentFromCall {
+        def: VirtualReason<L>,
+        call: ImplicitInstantiationReferenceData<L>,
+    },
+
     MessageImportTypeAsTypeof(FlowSmolStr),
     MessageImportTypeAsValue(FlowSmolStr),
     MessageImportValueAsType(FlowSmolStr),

rust_port/crates/flow_typing_statement/src/statement.rs

@@ -7484,12 +7484,7 @@ fn expression_<'a>(
                         name,
                         callee_loc.dupe(),
                     )?;
-                    let reason_call = mk_reason(
-                        VirtualReasonDesc::RConstructorCall(
-                            desc_of_t(&id_t).cloned().map(Arc::new),
-                        ),
-                        loc.dupe(),
-                    );
+                    let reason_call = mk_reason(None, loc.dupe());
                     let use_op =
                         UseOp::Op(Arc::new(type_::RootUseOp::FunCall(Box::new(FunCallData {
                             op: reason.dupe(),
@@ -7551,10 +7546,7 @@ fn expression_<'a>(
                 }
                 None => (vec![], vec![], None),
             };
-            let reason = mk_reason(
-                VirtualReasonDesc::RConstructorCall(desc_of_t(&class_).cloned().map(Arc::new)),
-                loc.dupe(),
-            );
+            let reason = mk_reason(None, loc.dupe());
             let use_op = UseOp::Op(Arc::new(type_::RootUseOp::FunCall(Box::new(FunCallData {
                 op: mk_expression_reason(e),
                 fn_: mk_expression_reason(&inner.callee),
@@ -7943,10 +7935,7 @@ fn expression_<'a>(
             let tag_ast = expression(None, None, None, cx, &inner.tag)?;
             let (targts, targs_ast) = convert_call_targs_opt(cx, inner.targs.as_ref())?;
             let t = tag_ast.loc().1.dupe();
-            let reason = mk_reason(
-                RFunctionCall(desc_of_t(&t).cloned().map(Arc::new)),
-                loc.dupe(),
-            );
+            let reason = mk_reason(None, loc.dupe());
             let reason_array = mk_reason(VirtualReasonDesc::RArray, reason.loc().dupe());
             let ret_id = flow_typing_tvar::mk_no_wrap(cx, &reason);
             let ret_tvar = Tvar::new(reason.dupe(), ret_id as u32);
@@ -9148,12 +9137,7 @@ pub fn optional_chain<'a>(
                 } = inner.callee.deref() =>
             {
                 let (targts, targs) = convert_call_targs_opt(cx, inner.targs.as_ref())?;
-                let reason = mk_reason(
-                    VirtualReasonDesc::RFunctionCall(Some(
-                        VirtualReasonDesc::RCode(FlowSmolStr::new_inline("super")).into(),
-                    )),
-                    loc.dupe(),
-                );
+                let reason = mk_reason(None, loc.dupe());
                 let super_t = super_(cx, super_loc.dupe())?;
                 let (argts, arguments_ast) = arg_list(cx, &inner.arguments)?;
                 let super_reason = reason_of_t(&super_t).dupe();
@@ -10642,12 +10626,7 @@ pub fn optional_chain<'a>(
             };
             let get_reason: Box<dyn Fn(&Type) -> Reason + '_> = {
                 let loc = loc.dupe();
-                Box::new(move |lhs_t: &Type| {
-                    mk_reason(
-                        RFunctionCall(desc_of_t(lhs_t).cloned().map(Arc::new)),
-                        loc.dupe(),
-                    )
-                })
+                Box::new(move |_lhs_t: &Type| mk_reason(None, loc.dupe()))
             };
             let get_result: Box<
                 dyn Fn(&mut Context<'a>, &Vec<CallArg>, Reason, &Type) -> Result<Type, JobError>,
@@ -13851,10 +13830,7 @@ fn non_react_jsx_desugar<'a>(
     attributes: &[ast::jsx::OpeningAttribute<ALoc, ALoc>],
     children: Vec<type_::UnresolvedParam>,
 ) -> Result<(Type, Option<Type>, Option<Type>), CheckExprError> {
-    let reason = mk_reason(
-        VirtualReasonDesc::RJSXFunctionCall(FlowSmolStr::from(raw_jsx_expr)),
-        loc_element.dupe(),
-    );
+    let reason = mk_reason(None, loc_element.dupe());
     // A JSX element with no attributes should pass in null as the second arg
     let props = if attributes.is_empty() {
         type_::null::at(loc_opening.dupe())

rust_port/crates/flow_typing_utils/src/predicate_kit.rs

@@ -9,7 +9,6 @@ use std::cell::Cell;
 use std::cell::RefCell;
 use std::ops::Deref;
 use std::rc::Rc;
-use std::sync::Arc;
 
 use dupe::Dupe;
 use dupe::IterDupedExt;
@@ -72,7 +71,6 @@ use flow_typing_type::type_::union_rep;
 use flow_typing_type::type_::union_rep::QuickMemResult;
 use flow_typing_type::type_::unknown_use;
 use flow_typing_type::type_util;
-use flow_typing_type::type_util::desc_of_t;
 use flow_typing_type::type_util::loc_of_t;
 use flow_typing_type::type_util::reason_of_t;
 use flow_utils_concurrency::job_error::JobError;
@@ -735,10 +733,7 @@ fn predicate_no_concretization<'cx>(
                     let use_op = pred_funcall_info.0.dupe();
                     let targs = &pred_funcall_info.3;
                     let argts = &pred_funcall_info.4;
-                    let reason = mk_reason(
-                        VirtualReasonDesc::RFunctionCall(desc_of_t(fun_t).cloned().map(Arc::new)),
-                        loc,
-                    );
+                    let reason = mk_reason(None, loc);
                     call_latent_param_pred(
                         cx,
                         env,
@@ -760,10 +755,7 @@ fn predicate_no_concretization<'cx>(
                     let use_op = pred_funcall_info.0.dupe();
                     let targs = &pred_funcall_info.3;
                     let argts = &pred_funcall_info.4;
-                    let reason = mk_reason(
-                        VirtualReasonDesc::RFunctionCall(desc_of_t(fun_t).cloned().map(Arc::new)),
-                        loc,
-                    );
+                    let reason = mk_reason(None, loc);
                     call_latent_this_pred(
                         cx,
                         env,
@@ -940,10 +932,7 @@ fn predicate_no_concretization<'cx>(
             let use_op = pred_funcall_info.0.dupe();
             let targs = &pred_funcall_info.3;
             let argts = &pred_funcall_info.4;
-            let reason = mk_reason(
-                VirtualReasonDesc::RFunctionCall(desc_of_t(fun_t).cloned().map(Arc::new)),
-                loc,
-            );
+            let reason = mk_reason(None, loc);
             call_latent_param_pred(
                 cx,
                 env,
@@ -965,10 +954,7 @@ fn predicate_no_concretization<'cx>(
             let use_op = pred_funcall_info.0.dupe();
             let targs = &pred_funcall_info.3;
             let argts = &pred_funcall_info.4;
-            let reason = mk_reason(
-                VirtualReasonDesc::RFunctionCall(desc_of_t(fun_t).cloned().map(Arc::new)),
-                loc,
-            );
+            let reason = mk_reason(None, loc);
             call_latent_this_pred(
                 cx,
                 env,