Intern ItemRef

Author: Nadrieril

engine/lib/concrete_ident/concrete_ident.ml

@@ -485,7 +485,7 @@ module MakeRenderAPI (NP : NAME_POLICY) : RENDER_API = struct
       let*? _no_generics = List.is_empty impl_infos.generics.params in
       match impl_infos.trait_ref with
       | None -> Some ty
-      | Some { def_id = trait; generic_args = [ _self ]; _ } ->
+      | Some { value = { def_id = trait; generic_args = [ _self ]; _ }; _ } ->
           let* trait = Explicit_def_id.of_def_id trait in
           let trait = View.of_def_id trait in
           let*? _same_ns = [%eq: View.ModPath.t] namespace trait.mod_path in

engine/lib/concrete_ident/thir_simple_types.ml

@@ -58,15 +58,16 @@ let to_string ~(namespace : View.ModPath.t) :
     | Float F32 -> Some "f32"
     | Float F64 -> Some "f64"
     | Tuple [] -> Some "unit"
-    | Adt { def_id; generic_args = []; _ } -> Option.map ~f:escape (adt def_id)
+    | Adt { value = { def_id; generic_args = []; _ }; _ } ->
+        Option.map ~f:escape (adt def_id)
     | _ -> None
   in
   let apply left right = left ^ "_of_" ^ right in
   let rec arity1 (ty : Types.node_for__ty_kind) =
     match ty.value with
     | Slice sub -> arity1 sub |> Option.map ~f:(apply "slice")
     | Ref (_, sub, _) -> arity1 sub |> Option.map ~f:(apply "ref")
-    | Adt { def_id; generic_args = [ Type arg ]; _ } ->
+    | Adt { value = { def_id; generic_args = [ Type arg ]; _ }; _ } ->
         let* adt = adt def_id in
         let* arg = arity1 arg in
         Some (apply adt arg)

engine/lib/import_thir.ml

@@ -11,7 +11,7 @@ module Thir = struct
   type generic_param_kind = generic_param_kind_for__decorated_for__expr_kind
   type trait_item = trait_item_for__decorated_for__expr_kind
   type ty = node_for__ty_kind
-  type item_ref = unboxed_item_ref
+  type item_ref = node_for__item_ref_contents
   type trait_ref = item_ref
 end
 
@@ -514,8 +514,14 @@ end) : EXPR = struct
           let f = c_expr fun' in
           match fun'.contents with
           | GlobalName
-              { item = { def_id = id; generic_args; impl_exprs; in_trait }; _ }
-            ->
+              {
+                item =
+                  {
+                    value = { def_id = id; generic_args; impl_exprs; in_trait };
+                    _;
+                  };
+                _;
+              } ->
               let f = { f with e = GlobalVar (def_id ~value:true id) } in
               let bounds_impls = List.map ~f:(c_impl_expr e.span) impl_exprs in
               let generic_args =
@@ -637,7 +643,8 @@ end) : EXPR = struct
               trait = None (* TODO: see issue #328 *);
               bounds_impls = [];
             }
-      | GlobalName { item = { def_id = id; _ }; constructor = _ } ->
+      | GlobalName { item = { value = { def_id = id; _ }; _ }; constructor = _ }
+        ->
           GlobalVar (def_id ~value:true id)
       | UpvarRef { var_hir_id = id; _ } -> LocalVar (local_ident Expr id)
       | Borrow { arg; borrow_kind = kind } ->
@@ -726,7 +733,11 @@ end) : EXPR = struct
                      })
                    l))
       | NamedConst
-          { item = { def_id = id; generic_args; in_trait = impl; _ }; _ } ->
+          {
+            item =
+              { value = { def_id = id; generic_args; in_trait = impl; _ }; _ };
+            _;
+          } ->
           let f = GlobalVar (def_id ~value:true id) in
           let args = List.map ~f:(c_generic_value e.span) generic_args in
           let const_args =
@@ -1025,7 +1036,7 @@ end) : EXPR = struct
           else List.map ~f:(c_ty span) inputs
         in
         TArrow (inputs, c_ty span output)
-    | Adt { def_id = id; generic_args; _ } ->
+    | Adt { value = { def_id = id; generic_args; _ }; _ } ->
         let ident = def_id ~value:false id in
         let args = List.map ~f:(c_generic_value span) generic_args in
         TApp { ident; args }
@@ -1110,15 +1121,15 @@ end) : EXPR = struct
     let goal = c_trait_ref span ie.trait.value in
     let impl = { kind = c_impl_expr_atom span ie.impl; goal } in
     match ie.impl with
-    | Concrete { impl_exprs = []; _ } -> impl
-    | Concrete { impl_exprs; _ } ->
+    | Concrete { value = { impl_exprs = []; _ }; _ } -> impl
+    | Concrete { value = { impl_exprs; _ }; _ } ->
         let args = List.map ~f:(c_impl_expr span) impl_exprs in
         { kind = ImplApp { impl; args }; goal }
     | _ -> impl
 
   and c_trait_ref span (tr : Thir.trait_ref) : trait_goal =
-    let trait = Concrete_ident.of_def_id ~value:false tr.def_id in
-    let args = List.map ~f:(c_generic_value span) tr.generic_args in
+    let trait = Concrete_ident.of_def_id ~value:false tr.value.def_id in
+    let args = List.map ~f:(c_generic_value span) tr.value.generic_args in
     { trait; args }
 
   and c_impl_expr_atom (span : Thir.span) (ie : Thir.impl_expr_atom) :
@@ -1132,7 +1143,7 @@ end) : EXPR = struct
           let ident =
             { goal = c_trait_ref span trait_ref; name = predicate_id }
           in
-          let item = Concrete_ident.of_def_id ~value:false item.def_id in
+          let item = Concrete_ident.of_def_id ~value:false item.value.def_id in
           let trait_ref = c_trait_ref span trait_ref in
           Projection
             { impl = { kind = item_kind; goal = trait_ref }; ident; item }
@@ -1145,7 +1156,7 @@ end) : EXPR = struct
           Parent { impl = { kind = item_kind; goal = trait_ref }; ident }
     in
     match ie with
-    | Concrete { def_id; generic_args; _ } ->
+    | Concrete { value = { def_id; generic_args; _ }; _ } ->
         let trait = Concrete_ident.of_def_id ~value:false def_id in
         let args = List.map ~f:(c_generic_value span) generic_args in
         Concrete { trait; args }
@@ -1242,8 +1253,12 @@ end) : EXPR = struct
       generic_constraint option =
     match kind with
     | Trait { is_positive = true; trait_ref } ->
-        let args = List.map ~f:(c_generic_value span) trait_ref.generic_args in
-        let trait = Concrete_ident.of_def_id ~value:false trait_ref.def_id in
+        let args =
+          List.map ~f:(c_generic_value span) trait_ref.value.generic_args
+        in
+        let trait =
+          Concrete_ident.of_def_id ~value:false trait_ref.value.def_id
+        in
         Some (GCType { goal = { trait; args }; name = id })
     | Projection { impl_expr; assoc_item; ty } ->
         let impl = c_impl_expr span impl_expr in
@@ -1770,9 +1785,10 @@ and c_item_unwrapped ~ident ~type_only (item : Thir.item) : item list =
              generics = c_generics generics;
              self_ty = c_ty item.span self_ty;
              of_trait =
-               ( Concrete_ident.of_def_id ~value:false of_trait.def_id,
-                 List.map ~f:(c_generic_value item.span) of_trait.generic_args
-               );
+               ( Concrete_ident.of_def_id ~value:false of_trait.value.def_id,
+                 List.map
+                   ~f:(c_generic_value item.span)
+                   of_trait.value.generic_args );
              items;
              parent_bounds =
                List.filter_map

engine/lib/import_thir.mli

@@ -1,7 +1,7 @@
 val import_ty : Types.span -> Types.node_for__ty_kind -> Ast.Rust.ty
 
 val import_trait_ref :
-  Types.span -> Types.unboxed_item_ref -> Ast.Rust.trait_goal
+  Types.span -> Types.node_for__item_ref_contents -> Ast.Rust.trait_goal
 
 val import_clause :
   Types.span -> Types.clause -> Ast.Rust.generic_constraint option

engine/utils/ocaml_of_json_schema/ocaml_of_json_schema.js

@@ -576,6 +576,7 @@ end
     let items = Object.entries(definitions)
         .map(([name, def]) => ['Node_for_TyKind' == name ? 'node_for_ty_kind_generated' : name, def])
         .map(([name, def]) => ['Node_for_DefIdContents' == name ? 'node_for_def_id_contents_generated' : name, def])
+        .map(([name, def]) => ['Node_for_ItemRefContents' == name ? 'node_for_item_ref_contents_generated' : name, def])
         .map(
             ([name, def]) => export_definition(name, def)
         ).filter(x => x instanceof Object);
@@ -611,9 +612,10 @@ open ParseError
     impl += `
 and node_for__ty_kind = node_for_ty_kind_generated
 and node_for__def_id_contents = node_for_def_id_contents_generated
+and node_for__item_ref_contents = node_for_item_ref_contents_generated
 
 
-type map_types = ${"[`TyKind of ty_kind | `DefIdContents of def_id_contents]"}
+type map_types = ${"[`TyKind of ty_kind | `DefIdContents of def_id_contents | `ItemRefContents of item_ref_contents]"}
 let cache_map: (int64, ${"[ `Value of map_types | `JSON of Yojson.Safe.t ]"}) Base.Hashtbl.t = Base.Hashtbl.create (module Base.Int64)
 
 module Exn = struct
@@ -667,6 +669,15 @@ and node_for__def_id_contents_of_yojson (o: Yojson.Safe.t): node_for__def_id_con
            o
    in
    {value; id = Base.Int64.zero}
+and node_for__item_ref_contents_of_yojson (o: Yojson.Safe.t): node_for__item_ref_contents =
+   let (value, _id) =
+       table_id_node_of_yojson "ItemRefContents"
+           (fun value -> \`ItemRefContents value)
+           (function | \`ItemRefContents value -> Some value | _ -> None)
+           item_ref_contents_of_yojson
+           o
+   in
+   {value; id = Base.Int64.zero}
 `;
     impl += ('');
     impl += ('let rec ' + items.map(({ name, type, parse, to_json }) =>
@@ -675,6 +686,7 @@ and node_for__def_id_contents_of_yojson (o: Yojson.Safe.t): node_for__def_id_con
     impl += `
 and yojson_of_node_for__ty_kind {value; id} = yojson_of_node_for_ty_kind_generated {value; id}
 and yojson_of_node_for__def_id_contents {value; id} = yojson_of_node_for_def_id_contents_generated {value; id}
+and yojson_of_node_for__item_ref_contents {value; id} = yojson_of_node_for_item_ref_contents_generated {value; id}
 end
 
 open struct

frontend/exporter/src/id_table.rs

@@ -48,6 +48,7 @@ impl Session {
 pub enum Value {
     Ty(Arc<TyKind>),
     DefId(Arc<DefIdContents>),
+    ItemRef(Arc<ItemRefContents>),
 }
 
 impl SupportedType<Value> for TyKind {
@@ -74,6 +75,18 @@ impl SupportedType<Value> for DefIdContents {
     }
 }
 
+impl SupportedType<Value> for ItemRefContents {
+    fn to_types(value: Arc<Self>) -> Value {
+        Value::ItemRef(value)
+    }
+    fn from_types(t: &Value) -> Option<Arc<Self>> {
+        match t {
+            Value::ItemRef(value) => Some(value.clone()),
+            _ => None,
+        }
+    }
+}
+
 /// A node is a bundle of an ID with a value.
 #[derive(Deserialize, Serialize, Debug, JsonSchema, PartialEq, Eq, PartialOrd, Ord)]
 #[serde(into = "serde_repr::NodeRepr<T>")]

frontend/exporter/src/traits.rs

@@ -57,10 +57,12 @@ impl<'tcx, S: UnderOwnerState<'tcx>> SInto<S, ImplExprPathChunk> for resolution:
                 index,
                 ..
             } => ImplExprPathChunk::AssocItem {
-                item: UnboxedItemRef::new(
+                item: ItemRef::new(
+                    s,
                     item.def_id.sinto(s),
                     generic_args.sinto(s),
                     impl_exprs.sinto(s),
+                    None,
                 ),
                 assoc_item: item.sinto(s),
                 predicate: predicate.sinto(s),
@@ -87,10 +89,12 @@ impl<'tcx, S: UnderOwnerState<'tcx>> SInto<S, ImplExprPathChunk> for resolution:
 pub enum ImplExprAtom {
     /// A concrete `impl Trait for Type {}` item.
     #[custom_arm(FROM_TYPE::Concrete { def_id, generics, impl_exprs } => TO_TYPE::Concrete(
-        UnboxedItemRef::new(
+        ItemRef::new(
+            s,
             def_id.sinto(s),
             generics.sinto(s),
             impl_exprs.sinto(s),
+            None,
         )
     ),)]
     Concrete(ItemRef),
@@ -285,12 +289,13 @@ pub fn translate_item_ref<'tcx, S: UnderOwnerState<'tcx>>(
         impl_exprs.drain(0..num_trait_trait_clauses);
     }
 
-    Box::new(UnboxedItemRef {
+    (ItemRefContents {
         def_id: def_id.sinto(s),
         generic_args,
         impl_exprs,
         in_trait: trait_info,
     })
+    .intern(s)
 }
 
 /// Solve the trait obligations for a specific item use (for example, a method call, an ADT, etc.)

frontend/exporter/src/types/mir.rs

@@ -259,8 +259,10 @@ fn translate_mir_const<'tcx, S: UnderOwnerState<'tcx>>(
             match ucv.promoted {
                 Some(promoted) => {
                     let mut item = translate_item_ref(s, ucv.def, ucv.args);
-                    // Construct a def_id for the promoted constant.
-                    item.def_id = item.def_id.make_promoted_child(s, promoted.sinto(s));
+                    item.mutate(s, |item| {
+                        // Construct a def_id for the promoted constant.
+                        item.def_id = item.def_id.make_promoted_child(s, promoted.sinto(s));
+                    });
                     Promoted(item)
                 }
                 None => Value(match translate_constant_reference(s, span, ucv.shrink()) {