Extend type structure representation to support class refinements

Summary:
[Human here: this was produced by Claude, with another Claude reviewing it and suggesting fixes. It's a prerequisite to supporting aliases and type constants whose right-hand-side is a type refinement.]

Add runtime support for type refinements (`I with { type T = ... }`) in TypeStructures. Refinements are represented by adding an optional `with_refinements` dict field to class kinds (T_class, T_interface, T_trait, T_enum, T_unresolved) rather than introducing a new TypeStructureKind.

Each entry in `with_refinements` is keyed by the type/ctx constant name and contains:
- `is_ctx`: whether this is a context constant refinement
- `equals`: for exact refinements (`type T = X`)
- `as`: for upper-bounded refinements (`type T as X`)
- `super`: for lower-bounded refinements (`type T super X`)

Changes:
- Emitter (`emit_type_constant.rs`): emit `with_refinements` as a sibling field of `classname`/`kind` when processing `Hrefinement` hints, and allow refinements in type aliases and type constants
- Runtime (`type-structure.cpp`): resolve `with_refinements` during T_unresolved resolution, generate display names via `refinementTypeName()`, and coerce refinement member types in `coerceToTypeStructure`
- Helpers (`type-structure-helpers.cpp/defs.h`): add `get_ts_refinement_types_opt()` accessor and string constants for refinement fields
- HHBBC (`type-structure.cpp`): resolve refinement types at compile time and track references within refinement members for dependency analysis
- Handle `with_refinements` presence in event-hook.cpp, irgen-types.cpp, interp.cpp, and type-system.cpp switch cases
- Add tests covering exact, upper-bounded, lower-bounded, and ctx refinements for both type aliases and type constants

Reviewed By: dlreeves

Differential Revision: D94346411

fbshipit-source-id: c82eb43a3129a400c9bab45c616f3b9edaa25320

Author: Andrew Kennedy

hphp/hack/src/hackc/emitter/emit_class.rs

@@ -190,7 +190,7 @@ fn from_type_constant<'a>(
                 &[],
                 &BTreeMap::new(),
                 init,
-                TypeRefinementInHint::Disallowed,
+                TypeRefinementInHint::Allowed,
             )?)
         }
     };

hphp/hack/src/hackc/emitter/emit_type_constant.rs

@@ -15,13 +15,16 @@ use naming_special_names_rust::classes;
 use naming_special_names_rust::typehints;
 use options::Options;
 use oxidized::aast;
+use oxidized::aast_defs::CtxRefinement;
 use oxidized::aast_defs::Hint;
 use oxidized::aast_defs::Hint_;
 use oxidized::aast_defs::NastShapeInfo;
+use oxidized::aast_defs::Refinement;
 use oxidized::aast_defs::ShapeFieldInfo;
 use oxidized::aast_defs::TupleExtra;
 use oxidized::aast_defs::TupleExtraInfo;
 use oxidized::aast_defs::TupleInfo;
+use oxidized::aast_defs::TypeRefinement;
 use oxidized::ast;
 use oxidized::ast_defs;
 use oxidized::ast_defs::ShapeFieldName;
@@ -259,6 +262,110 @@ fn get_typevars(tparams: &[&str]) -> Vec<DictEntry> {
     }
 }
 
+fn refinement_to_entry(
+    opts: &Options,
+    tparams: &[&str],
+    targ_map: &BTreeMap<&str, i64>,
+    refinement: &Refinement,
+) -> Result<DictEntry> {
+    match refinement {
+        Refinement::Rtype(ast_defs::Id(_, name), tr) => {
+            let mut member = vec![];
+            member.push(encode_entry("is_ctx", TypedValue::Bool(false)));
+
+            match tr {
+                TypeRefinement::TRexact(hint) => {
+                    member.push(encode_entry(
+                        "equals",
+                        hint_to_type_constant(
+                            opts,
+                            tparams,
+                            targ_map,
+                            hint,
+                            TypeRefinementInHint::Allowed,
+                        )?,
+                    ));
+                }
+                TypeRefinement::TRloose(bounds) => {
+                    if !bounds.upper.is_empty() {
+                        member.push(encode_entry(
+                            "as",
+                            hints_to_type_constant(
+                                opts,
+                                tparams,
+                                targ_map,
+                                TypeRefinementInHint::Allowed,
+                                &bounds.upper,
+                            )?,
+                        ));
+                    }
+                    if !bounds.lower.is_empty() {
+                        member.push(encode_entry(
+                            "super",
+                            hints_to_type_constant(
+                                opts,
+                                tparams,
+                                targ_map,
+                                TypeRefinementInHint::Allowed,
+                                &bounds.lower,
+                            )?,
+                        ));
+                    }
+                }
+            }
+
+            Ok(encode_entry(name, TypedValue::dict(member)))
+        }
+        Refinement::Rctx(ast_defs::Id(_, name), cr) => {
+            let mut member = vec![];
+            member.push(encode_entry("is_ctx", TypedValue::Bool(true)));
+
+            match cr {
+                CtxRefinement::CRexact(hint) => {
+                    member.push(encode_entry(
+                        "equals",
+                        hint_to_type_constant(
+                            opts,
+                            tparams,
+                            targ_map,
+                            hint,
+                            TypeRefinementInHint::Allowed,
+                        )?,
+                    ));
+                }
+                CtxRefinement::CRloose(bounds) => {
+                    if let Some(upper) = &bounds.upper {
+                        member.push(encode_entry(
+                            "as",
+                            hints_to_type_constant(
+                                opts,
+                                tparams,
+                                targ_map,
+                                TypeRefinementInHint::Allowed,
+                                &[upper.clone()],
+                            )?,
+                        ));
+                    }
+                    if let Some(lower) = &bounds.lower {
+                        member.push(encode_entry(
+                            "super",
+                            hints_to_type_constant(
+                                opts,
+                                tparams,
+                                targ_map,
+                                TypeRefinementInHint::Allowed,
+                                &[lower.clone()],
+                            )?,
+                        ));
+                    }
+                }
+            }
+
+            Ok(encode_entry(name, TypedValue::dict(member)))
+        }
+    }
+}
+
 fn hint_to_type_constant_list(
     opts: &Options,
     tparams: &[&str],
@@ -469,24 +576,32 @@ fn hint_to_type_constant_list(
             )?);
             r
         }
-        Hint_::Hrefinement(h, _) => {
-            match type_refinement_in_hint {
-                TypeRefinementInHint::Disallowed => {
-                    let aast::Hint(pos, _) = h;
-                    return Err(Error::fatal_parse(pos, "Refinement in type structure"));
-                }
-                TypeRefinementInHint::Allowed => {
-                    // check recursively (e.g.: Class<T1, T2> with { ... })
-                    hint_to_type_constant_list(
-                        opts,
-                        tparams,
-                        targ_map,
-                        TypeRefinementInHint::Allowed,
-                        h,
-                    )?
-                }
+        Hint_::Hrefinement(h, refinements) => match type_refinement_in_hint {
+            TypeRefinementInHint::Disallowed => {
+                let aast::Hint(pos, _) = h;
+                return Err(Error::fatal_parse(pos, "Refinement in type structure"));
             }
-        }
+            TypeRefinementInHint::Allowed => {
+                let mut r = hint_to_type_constant_list(
+                    opts,
+                    tparams,
+                    targ_map,
+                    TypeRefinementInHint::Allowed,
+                    h,
+                )?;
+
+                let refinement_entries = refinements
+                    .iter()
+                    .map(|refinement| refinement_to_entry(opts, tparams, targ_map, refinement))
+                    .collect::<Result<Vec<_>>>()?;
+                r.push(encode_entry(
+                    "with_refinements",
+                    TypedValue::dict(refinement_entries),
+                ));
+
+                r
+            }
+        },
         Hint_::Habstr(_)
         | Hint_::Hdynamic
         | Hint_::HfunContext(_)
@@ -524,7 +639,7 @@ pub(crate) fn typedef_to_type_structure(
         opts,
         tparams,
         &BTreeMap::new(),
-        TypeRefinementInHint::Disallowed, // Note: only called by `emit_typedef
+        TypeRefinementInHint::Allowed, // Refinements are allowed in type aliases
         kind,
     )?;
     tconsts.append(&mut get_typevars(tparams));

hphp/hhbbc/type-structure.cpp

@@ -800,6 +800,52 @@ Resolution resolve_type_access(ResolveCtx& ctx, SArray ts) {
    .finish();
 }
 
+Resolution resolve_refinement_types(ResolveCtx& ctx, SArray ts) {
+  auto const refinements = get_ts_refinement_types_opt(ts);
+  if (!refinements) return Resolution{ TBottom, false };
+  assertx(refinements->isStatic());
+  assertx(refinements->isDictType());
+  auto const size = refinements->size();
+  auto membersBuilder = Builder::dict();
+  for (size_t i = 0; i < size; ++i) {
+    auto const k = refinements->nvGetKey(i);
+    auto const v = refinements->nvGetVal(i);
+    assertx(tvIsString(k));
+    assertx(tvIsDict(v));
+    auto const memberArr = val(v).parr;
+    auto memberBuilder = Builder::dict();
+
+    auto const isCtx = memberArr->get(s_is_ctx.get());
+    if (isCtx.is_init()) {
+      memberBuilder.set(s_is_ctx, isCtx);
+    }
+
+    auto const exact = memberArr->get(s_equals.get());
+    if (exact.is_init()) {
+      assertx(tvIsDict(exact));
+      auto exactRes = resolve_bespoke(ctx, val(exact).parr);
+      memberBuilder.set(s_equals, exactRes);
+    }
+
+    auto const upper = memberArr->get(s_as.get());
+    if (upper.is_init()) {
+      assertx(tvIsVec(upper));
+      auto upperRes = resolve_list(ctx, val(upper).parr);
+      memberBuilder.set(s_as, upperRes);
+    }
+
+    auto const lower = memberArr->get(s_super.get());
+    if (lower.is_init()) {
+      assertx(tvIsVec(lower));
+      auto lowerRes = resolve_list(ctx, val(lower).parr);
+      memberBuilder.set(s_super, lowerRes);
+    }
+
+    membersBuilder.set(sval(val(k).pstr), memberBuilder.finish());
+  }
+  return membersBuilder.finish();
+}
+
 Resolution resolve_unresolved(ResolveCtx& ctx, SArray ts) {
   auto b = Builder::copy(ts, TS::Kind::T_unresolved);
 
@@ -829,9 +875,14 @@ Resolution resolve_unresolved(ResolveCtx& ctx, SArray ts) {
 
     auto b = setKindAndName(kind, name);
     if (setExact) b.set(s_exact, make_tv<KindOfBoolean>(true));
+    b.resolve(s_generic_types, get_ts_generic_types_opt(ts),
+              ctx, resolve_list);
+    auto refinementRes = resolve_refinement_types(ctx, ts);
+    if (!refinementRes.type.is(BBottom)) {
+      b.set(s_with_refinements, refinementRes);
+    }
     return
-      b.resolve(s_generic_types, get_ts_generic_types_opt(ts),
-                ctx, resolve_list)
+      std::move(b)
         .optCopy(s_typevars, ts)
         .optCopy(s_alias, ts)
         .optCopy(s_case_type, ts)
@@ -1247,6 +1298,32 @@ void type_structure_references(SArray ts, SStringSet& names) {
     }
   };
 
+  auto const onRefinements = [&names, &onList] (SArray ts) {
+    auto const refinements = get_ts_refinement_types_opt(ts);
+    if (!refinements) return;
+    auto const size = refinements->size();
+    for (size_t i = 0; i < size; ++i) {
+      auto const v = refinements->nvGetVal(i);
+      assertx(tvIsDict(v));
+      auto const memberArr = val(v).parr;
+      auto const exact = memberArr->get(s_equals.get());
+      if (exact.is_init()) {
+        assertx(tvIsDict(exact));
+        type_structure_references(val(exact).parr, names);
+      }
+      auto const upper = memberArr->get(s_as.get());
+      if (upper.is_init()) {
+        assertx(tvIsVec(upper));
+        onList(val(upper).parr);
+      }
+      auto const lower = memberArr->get(s_super.get());
+      if (lower.is_init()) {
+        assertx(tvIsVec(lower));
+        onList(val(lower).parr);
+      }
+    }
+  };
+
   switch (get_ts_kind(ts)) {
     case TS::Kind::T_enum:
     case TS::Kind::T_trait:
@@ -1256,6 +1333,7 @@ void type_structure_references(SArray ts, SStringSet& names) {
     case TS::Kind::T_xhp:
       names.emplace(get_ts_classname(ts));
       onList(get_ts_generic_types_opt(ts));
+      onRefinements(ts);
       break;
     case TS::Kind::T_fun:
       type_structure_references(get_ts_return_type(ts), names);

hphp/runtime/base/type-structure-helpers-defs.h

@@ -49,6 +49,11 @@ extern const StaticString s_typevar_types;
 extern const StaticString s_union_types;
 extern const StaticString s_hh_this;
 extern const StaticString s_type_structure_non_existant_class;
+extern const StaticString s_with_refinements;
+extern const StaticString s_equals;
+extern const StaticString s_as;
+extern const StaticString s_super;
+extern const StaticString s_is_ctx;
 
 // Fixed error messages
 extern const StaticString s_reified_type_must_be_ts;
@@ -185,6 +190,14 @@ ALWAYS_INLINE const ArrayData* get_ts_union_types_opt(const ArrayData* ts) {
   return detail::get_ts_varray_opt(ts, s_union_types);
 }
 
+ALWAYS_INLINE const ArrayData* get_ts_refinement_types(const ArrayData* ts) {
+  return detail::get_ts_darray(ts, s_with_refinements);
+}
+
+ALWAYS_INLINE const ArrayData* get_ts_refinement_types_opt(const ArrayData* ts) {
+  return detail::get_ts_darray_opt(ts, s_with_refinements);
+}
+
 ALWAYS_INLINE const StringData* get_ts_classname(const ArrayData* ts) {
   return detail::get_ts_string(ts, s_classname);
 }

hphp/runtime/base/type-structure-helpers.cpp

@@ -71,6 +71,11 @@ const StaticString s_union_types("union_types");
 const StaticString s_hh_this(annotTypeName(AnnotType::This));
 const StaticString s_type_structure_non_existant_class(
   "HH\\__internal\\type_structure_non_existant_class");
+const StaticString s_with_refinements("with_refinements");
+const StaticString s_equals("equals");
+const StaticString s_as("as");
+const StaticString s_super("super");
+const StaticString s_is_ctx("is_ctx");
 
 // Fixed error messages
 const StaticString s_reified_type_must_be_ts(
@@ -1064,6 +1069,9 @@ bool errorOnIsAsExpressionInvalidTypes(const Array& ts, bool dryrun,
     case TypeStructure::Kind::T_enum:
     case TypeStructure::Kind::T_class:
     case TypeStructure::Kind::T_interface: {
+      if (ts.exists(s_with_refinements)) {
+        return err("a type with refinements");
+      }
       auto tv = ts.lookup(s_generic_types);
       return tv.is_init() ?
         errorOnIsAsExpressionInvalidTypesList(tv.val().parr, dryrun, true) :