Try to predict when obj_get will fail and use constraints then

Summary:
Try to detect when we are about to try to resolve a method on a receiver where the type is so under-constrained (e.g., a variable with no interesting bounds) that it will definitely fail. In that case, try  constraint-based method inference to defer needing the type of the receiver. We don't do constraint-based always, because the error messages are currently degraded, but also because some features checks are not implemented yet. However, going to constraints when we are otherwise doomed to get a 4297 error, gives us some more completeness for inference.

This is gated behind an experimental_tc_feature flag `try_constraint_method_inference`, so we can control the roll out.

It also only works inside of expression trees, because there are a number of features that aren't implemented yet, but they aren't supported in expression trees
- some attributes (__Memoized, __IgnoreReadonly, __AcceptDisposable)
- noreturn
- explicit type applications for generics

There is also a config option `constraint_method_call` that enables constraints categorically, for testing purposes.

Also make constraints work with inout and named parameters

Reviewed By: andrewjkennedy

Differential Revision: D84817455

fbshipit-source-id: 20a6846e9318fe6605306853cda5c15362f90161

Author: Scott Owens

hphp/hack/src/options/typecheckerOptions.ml

@@ -62,6 +62,9 @@ let experimental_consider_type_const_enforceable =
 (** Resolve the this type inside enum classes using the proper context *)
 let experimental_sound_enum_class_type_const = "sound_enum_class_this_type"
 
+let experimental_try_constraint_method_inference =
+  "experimental_try_constraint_method_inference"
+
 let experimental_all =
   List.fold_right
     ~f:SSet.add
@@ -74,6 +77,7 @@ let experimental_all =
       experimental_supportdynamic_type_hint;
       experimental_consider_type_const_enforceable;
       experimental_sound_enum_class_type_const;
+      experimental_try_constraint_method_inference;
     ]
 
 let experimental_from_flags ~disallow_static_memoized =

hphp/hack/src/typing/typing.ml

@@ -6254,6 +6254,58 @@ end = struct
       | _ -> ((env, expr, ty), s))
     (* Call instance method *)
     | Obj_get (e1, (_, pos_id, Id m), nullflavor, Is_method) ->
+      (* We should use the constraint only if we're sure that immediately doing
+         obj_get will fail to get to concrete types. *)
+      let rec should_use_constraint seen env ty =
+        let (env, ty) = Env.expand_type env ty in
+        match get_node ty with
+        | Tdynamic
+        | Tprim _
+        | Ttuple _
+        | Tfun _
+        | Tshape _
+        | Toption _
+        | Tclass _
+        | Tvec_or_dict _
+        | Tclass_ptr _
+        | Tlabel _
+        | Tany _
+        | Tnonnull
+        | Tneg _
+        | Taccess _ ->
+          (* All of these can be handled by obj_get *)
+          (env, false)
+        | Tvar var ->
+          let bounds = Env.get_tyvar_lower_bounds env var in
+          should_use_constraint_for_inter
+            seen
+            env
+            (List.filter_map (Internal_type_set.to_list bounds) ~f:(fun ity ->
+                 match ity with
+                 | LoclType ty -> Some ty
+                 | _ -> None))
+        | Tunion ts ->
+          (* If one of the branches of the union won't resolve,
+             then obj_get will end up with a 4297 from trying to force solve *)
+          List.exists_env env ~f:(should_use_constraint seen) ts
+        | Tintersection ts -> should_use_constraint_for_inter seen env ts
+        | Tdependent (_, ty) -> should_use_constraint seen env ty
+        | Tgeneric name
+        | Tnewtype (name, _, _) ->
+          if not (SSet.mem name seen) then
+            let (env, ts) =
+              TUtils.get_concrete_supertypes ~abstract_enum:true env ty
+            in
+            should_use_constraint_for_inter (SSet.add name seen) env ts
+          else
+            (env, false)
+      and should_use_constraint_for_inter seen env ts =
+        match ts with
+        | [] -> (env, true)
+        | [ty] -> should_use_constraint seen env ty
+        | _ -> (env, false)
+        (* The constraint doesn't work well with intersections, so don't bother *)
+      in
       let (env, te1, ty1) =
         expr
           ~expected:None
@@ -6266,11 +6318,31 @@ end = struct
         | Regular -> None
         | Nullsafe -> Some p
       in
-      let use_constraint_inference =
+      (* These are the only kinds of calls that we support with constraint inference *)
+      let maybe_use_constraint_inference =
         List.is_empty explicit_targs
         && Option.is_none unpacked_element
         && Option.is_none nullsafe
-        && TCO.constraint_method_call env.genv.tcopt
+      in
+      let (env, use_constraint_inference) =
+        if
+          maybe_use_constraint_inference
+          && TCO.constraint_method_call env.genv.tcopt
+        then
+          (* Config tells us to use it for all supported functions *)
+          (env, true)
+        else if
+          maybe_use_constraint_inference
+          && Option.is_some env.in_expr_tree
+          && TypecheckerOptions.experimental_feature_enabled
+               (Env.get_tcopt env)
+               TypecheckerOptions.experimental_try_constraint_method_inference
+        then
+          (* Inside of an expression tree, we can use constraint inference if the appropriate experimental_tc_feature is enabled.
+             Many of the features that constraint inference doesn't support are not allowed in expression trees: inout, disposable, etc. *)
+          should_use_constraint SSet.empty env ty1
+        else
+          (env, false)
       in
       if use_constraint_inference then (
         (* Construct a function type from the types of the arguments, and check
@@ -6289,21 +6361,26 @@ end = struct
         in
         let arg_posl =
           List.map el ~f:(fun arg ->
-              match arg with
-              | Aast_defs.Ainout (_, (_, pos, e))
-              | Aast_defs.Anamed (_, (_, pos, e))
-              | Aast_defs.Anormal (_, pos, e) ->
-                (match e with
-                | ReadonlyExpr _ -> (pos, true)
-                | _ -> (pos, false)))
-        in
-        let make_param (pos, is_readonly) ty =
+              let (e, pos, name, is_inout) =
+                match arg with
+                | Aast_defs.Ainout (_, (_, pos, e)) -> (e, pos, None, true)
+                | Aast_defs.Anamed (n, (_, pos, e)) -> (e, pos, Some n, false)
+                | Aast_defs.Anormal (_, pos, e) -> (e, pos, None, false)
+              in
+              match e with
+              | ReadonlyExpr _ -> (pos, name, true, is_inout)
+              | _ -> (pos, name, false, is_inout))
+        in
+        let make_param (pos, name, is_readonly, is_inout) ty =
           {
             fp_pos = Pos_or_decl.of_raw_pos pos;
-            fp_name = None;
+            fp_name = Option.map ~f:snd name;
             fp_type = ty;
             fp_flags =
-              Typing_defs_flags.FunParam.(set_readonly is_readonly default);
+              Typing_defs_flags.FunParam.(
+                set_named
+                  (Option.is_some name)
+                  (set_inout is_inout (set_readonly is_readonly default)));
             fp_def_value = None;
           }
         in
@@ -6346,7 +6423,8 @@ end = struct
               (Some
                  {
                    hmm_explicit_targs = [];
-                   hmm_args_pos = List.map ~f:fst arg_posl;
+                   hmm_args_pos =
+                     List.map ~f:(fun (pos, _, _, _) -> pos) arg_posl;
                  })
         in
         let (env, ty_err_opt) =

hphp/hack/test/typecheck/expression_trees/nesting/vars/HH_FLAGS

@@ -1,2 +1,3 @@
 --extra-builtin ../../../../expr_tree.php
 --config enable_experimental_stx_features='{"await_in_splice":"OngoingRelease","expression_trees": "Unstable", "expression_tree_nested_bindings": "Unstable", "case_types": "Preview", "case_type_where_clauses": "Preview", "like_type_hints": "Unstable"}'
+--config enable_experimental_tc_features=experimental_try_constraint_method_inference

hphp/hack/test/typecheck/expression_trees/nesting/vars/simple_error.php.exp

@@ -4,9 +4,3 @@ Typing error (Typing[4110])
   Expected `int`
   File "expr_tree.php", line 153, characters 40-45:
   But got `string`
-ERROR: File "simple_error.php", line 7, characters 43-48:
-Was expecting an object but type is unknown (Typing[4297])
-  File "simple_error.php", line 7, characters 43-48:
-  It is unknown because type parameter `T` of `operationType` could not be determined. Please add explicit type parameters to the invocation of `operationType`
-  File "expr_tree.php", line 176, characters 8-8:
-    via this generic `T`

hphp/hack/test/typecheck/expression_trees/nesting/vars/simple_error.php.imp_pess_exp

@@ -4,9 +4,3 @@ Typing error (Typing[4110])
   Expected `int`
   File "expr_tree.php", line 153, characters 40-45:
   But got `string`
-ERROR: File "simple_error.php", line 7, characters 30-50:
-Typing error (Typing[4110])
-  File "expr_tree.php", line 175, characters 5-21:
-  Expected `ExprTreeOpType<nothing>`
-  File "expr_tree.php", line 144, characters 39-41:
-  But got `int`