Properly type HH\type_structure_classname

Summary: The `type_stucture_classname` helper has existed forever as a compilation target, just withheld from typing support. This factors out the type constant resolution logic from the `type_structure` function and applies it to the helper.

Reviewed By: mheiber

Differential Revision: D95327521

fbshipit-source-id: 4ac84f646960d42c10ff6985f6e72bbac8413c06

Author: vassilmladenov

hphp/hack/hhi/typestructure.hhi

@@ -124,6 +124,15 @@ namespace HH {
   // type_structure(C::class or new C, 'type_const_name')
   //   : TypeStructure
 
+  /*
+   * Replacement for type_structure(C::class, 'T')['classname']
+   * for type constants that point to classes.
+   */
+  function type_structure_classname(
+    mixed $cls_or_obj,
+    string $cns_name,
+  )[]: \HH\FIXME\MISSING_RETURN_TYPE;
+
   /*
    * Retrieves the TypeStructure for a type alias.
    */

hphp/hack/src/naming/naming_special_names.ml

@@ -1095,6 +1095,8 @@ module StdlibFunctions = struct
 
   let type_structure = "\\HH\\type_structure"
 
+  let type_structure_classname = "\\HH\\type_structure_classname"
+
   let array_mark_legacy = "\\HH\\array_mark_legacy"
 
   let array_unmark_legacy = "\\HH\\array_unmark_legacy"
@@ -1112,6 +1114,7 @@ module StdlibFunctions = struct
         PseudoFunctions.isset;
         PseudoFunctions.unset;
         type_structure;
+        type_structure_classname;
         PseudoFunctions.unsafe_cast;
         PseudoFunctions.unsafe_nonnull_cast;
       ]

hphp/hack/src/typing/typing.ml

@@ -5916,8 +5916,7 @@ end = struct
       let result = make_call env te tal tel typed_unpack_element ty in
       (result, should_forget_fakes)
     in
-    let type_structure_impl pos e1 e2 =
-      let should_forget_fakes = false in
+    let type_structure_impl ~fn pos e1 e2 =
       match Aast_utils.arg_to_expr e2 with
       | (_, p, String cst) ->
         (* find the class constant implicitly defined by the typeconst *)
@@ -5952,19 +5951,18 @@ end = struct
               Typing_error.(
                 primary
                 @@ Primary.Illegal_type_structure
-                     { pos; msg = "Could not resolve the type constant" })
+                     { pos; msg = "Could not resolve the type constant"; fn })
           | _ -> ()
         in
-        (result, should_forget_fakes)
+        result
       | _ ->
         Typing_error_utils.add_typing_error
           ~env
           Typing_error.(
             primary
             @@ Primary.Illegal_type_structure
-                 { pos; msg = "Second argument is not a string" });
-        let result = expr_error env pos e in
-        (result, should_forget_fakes)
+                 { pos; msg = "Second argument is not a string"; fn });
+        expr_error env pos e
     in
     match fun_expr with
     (* Special top-level function *)
@@ -6129,8 +6127,52 @@ end = struct
         when String.equal type_structure SN.StdlibFunctions.type_structure
              && Int.equal (List.length el) 2
              && Option.is_none unpacked_element ->
+        let should_forget_fakes = false in
+        (match el with
+        | [e1; e2] ->
+          let result = type_structure_impl ~fn:type_structure pos e1 e2 in
+          (result, should_forget_fakes)
+        | _ -> assert false)
+      | type_structure_classname
+        when String.equal
+               type_structure_classname
+               SN.StdlibFunctions.type_structure_classname
+             && Int.equal (List.length el) 2
+             && Option.is_none unpacked_element ->
+        let should_forget_fakes = false in
         (match el with
-        | [e1; e2] -> type_structure_impl pos e1 e2
+        | [e1; e2] ->
+          let (env, te, const_ty) =
+            type_structure_impl ~fn:type_structure_classname pos e1 e2
+          in
+          let (env, const_ty) = Env.expand_type env const_ty in
+          let (env, const_ty) =
+            Typing_dynamic_utils.strip_dynamic env const_ty
+          in
+          let result =
+            match get_node const_ty with
+            | Tnewtype (name, [ty_arg], _)
+              when String.equal name SN.FB.cTypeStructure ->
+              if Typing_structure.is_enum_or_classish env ty_arg then
+                let ty = MakeType.classname (get_reason const_ty) [ty_arg] in
+                (env, te, ty)
+              else begin
+                Typing_error_utils.add_typing_error
+                  ~env
+                  Typing_error.(
+                    primary
+                    @@ Primary.Illegal_type_structure
+                         {
+                           pos;
+                           msg =
+                             "The type constant does not resolve to a classish type";
+                           fn = type_structure_classname;
+                         });
+                expr_error env pos e
+              end
+            | _ -> expr_error env pos e
+          in
+          (result, should_forget_fakes)
         | _ -> assert false)
       | _ -> dispatch_id env id
     end

hphp/hack/src/typing/typing_error.ml

@@ -857,6 +857,7 @@ module Primary = struct
     | Illegal_type_structure of {
         pos: Pos.t;
         msg: string;
+        fn: string;
       }
     | Illegal_typeconst_direct_access of Pos.t
     | Wrong_expression_kind_attribute of {

hphp/hack/src/typing/typing_error.mli

@@ -821,6 +821,7 @@ module Primary : sig
     | Illegal_type_structure of {
         pos: Pos.t;
         msg: string;
+        fn: string;
       }
     | Illegal_typeconst_direct_access of Pos.t
     | Wrong_expression_kind_attribute of {

hphp/hack/src/typing/typing_error_utils.ml

@@ -2949,11 +2949,13 @@ end = struct
     let claim = lazy (p, "Not a valid class name") in
     create ~code:Error_code.InvalidClassname ~claim ()
 
-  let illegal_type_structure pos msg =
+  let illegal_type_structure pos msg fn =
     let claim =
       lazy
         (let msg =
-           "The two arguments to `type_structure()` must be:"
+           "The two arguments to `"
+           ^ Utils.strip_ns fn
+           ^ "()` must be:"
            ^ "\n - first: `ValidClassname::class` or an object of that class"
            ^ "\n - second: a single-quoted string literal containing the name"
            ^ " of a type constant of that class\n"
@@ -4989,7 +4991,8 @@ end = struct
     | Cannot_declare_constant { pos; class_pos; class_name } ->
       cannot_declare_constant pos (class_pos, class_name)
     | Invalid_classname pos -> invalid_classname pos
-    | Illegal_type_structure { pos; msg } -> illegal_type_structure pos msg
+    | Illegal_type_structure { pos; msg; fn } ->
+      illegal_type_structure pos msg fn
     | Illegal_typeconst_direct_access pos -> illegal_typeconst_direct_access pos
     | Wrong_expression_kind_attribute
         {

hphp/hack/src/typing/typing_structure.ml

@@ -55,6 +55,31 @@ let make_ts : Typing_env_types.env -> locl_ty -> Typing_env_types.env * locl_ty
     (* Should not hit this because TypeStructure should always be defined *)
     (env, MakeType.dynamic r)
 
+(* Does this type contain only enum or object instances?
+ * These are the types that can be represented using classname
+ *)
+let rec is_enum_or_classish env ty =
+  match get_node ty with
+  | Tnewtype (cid, _, _) when Env.is_enum env cid -> true
+  | Tintersection tys -> List.exists tys ~f:(is_enum_or_classish env)
+  | Tunion tys -> List.for_all tys ~f:(is_enum_or_classish env)
+  | Tclass ((_, x), _, _)
+    when not
+           (String.equal x SN.Collections.cVec
+           || String.equal x SN.Collections.cDict
+           || String.equal x SN.Collections.cKeyset) ->
+    true
+  | Tgeneric _ ->
+    let (_env, tyl) =
+      TUtils.get_concrete_supertypes
+        ~expand_supportdyn:true
+        ~abstract_enum:false
+        env
+        ty
+    in
+    List.exists tyl ~f:(is_enum_or_classish env)
+  | _ -> false
+
 let rec transform_shapemap ?(nullable = false) env pos ty shape =
   let ((env, ty_err_opt), ty) =
     Typing_solver.expand_type_and_solve
@@ -96,28 +121,7 @@ let rec transform_shapemap ?(nullable = false) env pos ty shape =
     (* Does this type contain only enum or object instances?
      * These are the types that can be represented using classname
      *)
-    let rec is_enum_or_classish ty =
-      match get_node ty with
-      | Tnewtype (cid, _, _) when Env.is_enum env cid -> true
-      | Tintersection tys -> List.exists tys ~f:is_enum_or_classish
-      | Tunion tys -> List.for_all tys ~f:is_enum_or_classish
-      | Tclass ((_, x), _, _)
-        when not
-               (String.equal x SN.Collections.cVec
-               || String.equal x SN.Collections.cDict
-               || String.equal x SN.Collections.cKeyset) ->
-        true
-      | Tgeneric _ ->
-        let (_env, tyl) =
-          TUtils.get_concrete_supertypes
-            ~expand_supportdyn:true
-            ~abstract_enum:false
-            env
-            ty
-        in
-        List.exists tyl ~f:is_enum_or_classish
-      | _ -> false
-    in
+    let is_enum_or_classish ty = is_enum_or_classish env ty in
     let supportdyn = supportdyn || supportdyn_bound in
     let transform_shape_field field { sft_ty; sft_optional } (env, shape) =
       (* Accumulates the provided type for this iteration of the fold, adding

hphp/hack/src/typing/typing_structure.mli

@@ -6,6 +6,8 @@
  *
  *)
 
+val is_enum_or_classish : Typing_env_types.env -> Typing_defs.locl_ty -> bool
+
 val transform_shapemap :
   ?nullable:bool ->
   Typing_env_types.env ->

hphp/hack/test/typecheck/type_structure/classname_tyvar.php

@@ -0,0 +1,23 @@
+<?hh  
+
+abstract class A {
+  abstract const type T;
+  abstract const type T2 as A;
+}
+
+function expect_string(string $s): void {}
+class Test {
+  private static function foo(
+    classname<A> $kls,
+    dynamic $d,
+  ): void {
+    expect_string(type_structure(HH\classname_to_class($kls), 'T')['classname']);
+    expect_string(HH\type_structure_classname(HH\classname_to_class($kls), 'T'));
+
+    expect_string(type_structure(HH\classname_to_class($kls), 'T2')['classname']);
+    expect_string(HH\type_structure_classname(HH\classname_to_class($kls), 'T2'));
+
+    expect_string(type_structure(HH\classname_to_class($d), 'T')['classname']);
+    expect_string(HH\type_structure_classname(HH\classname_to_class($d), 'T'));
+  }
+}

hphp/hack/test/typecheck/type_structure/classname_tyvar.php.exp

@@ -0,0 +1,21 @@
+ERROR: File "classname_tyvar.php", line 14, characters 68-78:
+This shape doesn't have a field `classname` (Typing[4108])
+  File "typestructure.hhi", line 59, characters 31-699:
+  The shape is defined here
+ERROR: File "classname_tyvar.php", line 15, characters 19-45:
+The two arguments to `HH\type_structure_classname()` must be:
+ - first: `ValidClassname::class` or an object of that class
+ - second: a single-quoted string literal containing the name of a type constant of that class
+The type constant does not resolve to a classish type (Typing[4150])
+ERROR: File "classname_tyvar.php", line 20, characters 56-57:
+Invalid argument (Typing[4110])
+  File "classname.hhi", line 51, characters 43-63:
+  Expected `classname<_>`
+  File "classname_tyvar.php", line 12, characters 5-11:
+  But got `dynamic`
+ERROR: File "classname_tyvar.php", line 21, characters 69-70:
+Invalid argument (Typing[4110])
+  File "classname.hhi", line 51, characters 43-63:
+  Expected `classname<_>`
+  File "classname_tyvar.php", line 12, characters 5-11:
+  But got `dynamic`