Support constant trait objects

This adds support for compiling constant values that are trait objects (e.g.,
`const X: &dyn Trait = &0u32`). Like other references to unsized values, these
require adding special cases to `make_allocation_body` and
`try_render_ref_opty` in order to support:

* `make_allocation_body` unpacks the trait object to get the underlying type
  and then renders the constant based on that type.
* `try_render_ref_opty` constructs a special `"trait_object"` constant that
  references the allocation body's `DefId`, along with the `DefId`s for the
  trait object's principal trait (`trait_id`) and vtable (`vtable`). These
  `DefId`s are used on the `crucible-mir` side to construct a trait object
  value when translating the MIR JSON into Crucible.

  (Note that trait objects without a principal trait are not yet supported.
  See #239 for more information on this point.)

Note that because `"trait_object"` is a new part of the schema, I needed to
bump the schema version number to `9`.

Fixes #237.

Author: RyanGlScott

SCHEMA_CHANGELOG.md

@@ -3,6 +3,20 @@ The following document describes the changes to the JSON schema that
 as a changelog for the code in the `mir-json` tools themselves, which are
 versioned separately.)
 
+## 9
+
+Add `trait_object`, which represents constant trait objects such as `const X:
+&dyn Trait = &0u32`. These include three fields:
+
+* `def_id`: the `DefId` for the constant reference backing the trait object.
+  This is the same as in `"static_ref"` and `"slice"` constant values.
+
+* `trait_id`: the `DefId` for the principal trait bound in the trait object.
+  This plays a similar role as the `trait_id` field in `Dynamic` types.
+
+* `vtable`: the `DefId` for the trait object's vtable. This plays a similar
+  role as the `vtable` field in `UnsizeVtable` cast kinds.
+
 ## 8
 
 Add details to the `InlineType` case for `TyKind::Coroutine` and to the

doc/mir-json-schema.ts

@@ -286,6 +286,7 @@ type ConstVal =
   | { kind: "closure", upvars: ConstVal[] }
   | { kind: "coroutine_closure", upvars: ConstVal[] }
   | { kind: "fn_ptr", "def_id": DefId }
+  | { kind: "trait_object", def_id: DefId, trait_id: DefId, vtable: DefId }
 
 
 

src/analyz/mod.rs

@@ -1195,13 +1195,6 @@ fn emit_vtable<'tcx>(
     emit_new_defs(ms, out)
 }
 
-fn vtable_name<'tcx>(
-    mir: &mut MirState<'_, 'tcx>,
-    trait_ref: ty::PolyTraitRef<'tcx>,
-) -> String {
-    ext_def_id_str(mir.tcx, trait_ref.def_id(), "_vtbl", trait_ref)
-}
-
 fn build_vtable_items<'tcx>(
     mir: &mut MirState<'_, 'tcx>,
     trait_ref: ty::PolyTraitRef<'tcx>,

src/analyz/ty_json.rs

@@ -7,7 +7,8 @@ use rustc_index::{IndexVec, Idx};
 use rustc_middle::mir;
 use rustc_middle::ty::CoroutineArgsExt;
 use rustc_const_eval::interpret::{
-    self, InterpCx, InterpResult, MPlaceTy, OffsetMode, Projectable,
+    self, InterpCx, InterpResult, MemPlaceMeta, MPlaceTy, OffsetMode,
+    Projectable,
 };
 use rustc_middle::ty;
 use rustc_middle::ty::{AdtKind, DynKind, TyCtxt, TypeVisitableExt};
@@ -244,6 +245,13 @@ pub fn trait_inst_id_str<'tcx>(
     }
 }
 
+pub fn vtable_name<'tcx>(
+    mir: &mut MirState<'_, 'tcx>,
+    trait_ref: ty::PolyTraitRef<'tcx>,
+) -> String {
+    ext_def_id_str(mir.tcx, trait_ref.def_id(), "_vtbl", trait_ref)
+}
+
 /// Get the mangled name of a monomorphic function.  As a side effect, this marks the function as
 /// "used", so its body will be emitted too.
 pub fn get_fn_def_name<'tcx>(
@@ -1460,6 +1468,24 @@ fn make_allocation_body<'tcx>(
 ) -> serde_json::Value {
     let tcx = mir.tcx;
 
+    fn do_default<'tcx>(
+        mir: &mut MirState<'_, 'tcx>,
+        icx: &mut interpret::InterpCx<'tcx, RenderConstMachine<'tcx>>,
+        rty: ty::Ty<'tcx>,
+        d: &MPlaceTy<'tcx>,
+    ) -> serde_json::Value {
+        let rlayout = mir.tcx.layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(rty)).unwrap();
+        let mpty: MPlaceTy = d.offset_with_meta(Size::ZERO, OffsetMode::Inbounds, d.meta(), rlayout, icx).unwrap();
+        let rendered = try_render_opty(mir, icx, &mpty.into());
+
+        json!({
+            "kind": "constant",
+            "mutable": false,
+            "ty": rty.to_json(mir),
+            "rendered": rendered,
+        })
+    }
+
     if !is_mut {
         /// Common logic for emitting `"kind": "strbody"` constants, shared by the `str` and `CStr`
         /// cases.
@@ -1490,10 +1516,15 @@ fn make_allocation_body<'tcx>(
         }
 
         match *rty.kind() {
-            // Special cases for &str, &CStr, and &[T]
+            // Special cases for references to unsized types. Currently, the
+            // following are supported:
+            //
+            // * String slices (&str and &CStr)
+            // * Array slices (&[T])
+            // * Trait objects (&dyn Trait)
             //
-            // These and the ones in try_render_ref_opty below should be
-            // kept in sync.
+            // These special cases and the ones in try_render_ref_opty below
+            // should be kept in sync.
             ty::TyKind::Str => {
                 let len = d.len(icx).unwrap();
                 return do_strbody(mir, icx, d, len);
@@ -1527,21 +1558,16 @@ fn make_allocation_body<'tcx>(
                     "rendered": rendered,
                 });
             },
+            ty::TyKind::Dynamic(ref preds, _, _) => {
+                let unpacked_d = unpack_dyn_place(icx, d, preds).unwrap();
+                return do_default(mir, icx, unpacked_d.layout.ty, &unpacked_d);
+            },
             _ => ()
         }
     }
 
     // Default case
-    let rlayout = tcx.layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(rty)).unwrap();
-    let mpty: MPlaceTy = d.offset_with_meta(Size::ZERO, OffsetMode::Inbounds, d.meta(), rlayout, icx).unwrap();
-    let rendered = try_render_opty(mir, icx, &mpty.into());
-
-    return json!({
-        "kind": "constant",
-        "mutable": false,
-        "ty": rty.to_json(mir),
-        "rendered": rendered,
-    });
+    return do_default(mir, icx, rty, d);
 }
 
 fn try_render_ref_opty<'tcx>(
@@ -1601,24 +1627,60 @@ fn try_render_ref_opty<'tcx>(
     assert!(d_offset == Size::ZERO, "cannot handle nonzero reference offsets");
 
     if !is_mut {
-        // Special cases for &str, &CStr, and &[T]
-        //
-        // These and the ones in make_allocation_body above should be kept in sync.
-        let do_slice_special_case = match *rty.kind() {
-            ty::TyKind::Str | ty::TyKind::Slice(_) => true,
-            ty::TyKind::Adt(adt_def, _) if tcx.is_lang_item(adt_def.did(), LangItem::CStr) => true,
-            _ => false,
-        };
-        if do_slice_special_case {
+        fn do_slice<'tcx>(
+            icx: &mut interpret::InterpCx<'tcx, RenderConstMachine<'tcx>>,
+            d: &MPlaceTy<'tcx>,
+            def_id_json: serde_json::Value,
+        ) -> serde_json::Value {
             // `<MPlaceTy as Projectable>::len` asserts that the input must have `Slice` or
             // `Str` type.  However, the implementation it uses works fine on `CStr` too, so we
             // copy-paste the code here.
             let len = d.meta().unwrap_meta().to_target_usize(icx).unwrap();
-            return Some(json!({
+            json!({
                 "kind": "slice",
                 "def_id": def_id_json,
                 "len": len
-            }))
+            })
+        }
+
+        // Special cases for references to unsized types. Currently, the
+        // following are supported:
+        //
+        // * String slices (&str and &CStr)
+        // * Array slices (&[T])
+        // * Trait objects (&dyn Trait)
+        //
+        // These special cases and the ones in make_allocation_body above should be kept in sync.
+        match *rty.kind() {
+            ty::TyKind::Str | ty::TyKind::Slice(_) =>
+                return Some(do_slice(icx, &d, def_id_json)),
+            ty::TyKind::Adt(adt_def, _) if tcx.is_lang_item(adt_def.did(), LangItem::CStr) =>
+                return Some(do_slice(icx, &d, def_id_json)),
+            ty::TyKind::Dynamic(ref preds, _, _) => {
+                let self_ty = unpack_dyn_ty(icx, &d, preds).unwrap();
+                let vtable_desc = preds.principal().map(|pred| pred.with_self_ty(tcx, self_ty));
+                match vtable_desc {
+                    Some(vtable_desc) => {
+                        mir.used.vtables.insert(vtable_desc);
+                        let ti = TraitInst::from_dynamic_predicates(tcx, preds);
+                        return Some(json!({
+                            "kind": "trait_object",
+                            "def_id": def_id_json,
+                            "trait_id": trait_inst_id_str(tcx, &ti),
+                            "vtable": vtable_name(mir, vtable_desc),
+                        }))
+                    },
+                    None =>
+                        // If there is no principal trait bound, then all of
+                        // the trait bounds are auto traits. We do not
+                        // currently support computing vtables for these sorts
+                        // of trait objects (see #239).
+                        return Some(json!({
+                            "kind": "unsupported",
+                        }))
+                }
+            },
+            _ => (),
         }
     }
 
@@ -1852,3 +1914,42 @@ pub fn eval_mir_constant<'tcx>(
         .eval(tcx, ty::TypingEnv::fully_monomorphized(), constant.span)
         .unwrap()
 }
+
+// Turn a place with a `dyn Trait` type into the actual dynamic type.
+//
+// This is based on the internals of
+// `rustc_const_eval::interpret::InterpCx::unpack_dyn_trait`.
+fn unpack_dyn_ty<'tcx>(
+    icx: &InterpCx<'tcx, RenderConstMachine<'tcx>>,
+    mplace: &MPlaceTy<'tcx>,
+    expected_trait: &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>>,
+) -> InterpResult<'tcx, ty::Ty<'tcx>> {
+    assert!(
+        matches!(mplace.layout.ty.kind(), ty::Dynamic(_, _, ty::Dyn)),
+        "`unpack_dyn_ty` only makes sense on `dyn*` types"
+    );
+    let vtable = mplace.meta().unwrap_meta().to_pointer(icx)?;
+    icx.get_ptr_vtable_ty(vtable, Some(expected_trait))
+}
+
+// Turn a place with a `dyn Trait` type into a place with the actual dynamic
+// type.
+//
+// This is based on `rustc_const_eval::interpret::InterpCx::unpack_dyn_trait`.
+fn unpack_dyn_place<'tcx>(
+    icx: &InterpCx<'tcx, RenderConstMachine<'tcx>>,
+    mplace: &MPlaceTy<'tcx>,
+    expected_trait: &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>>,
+) -> InterpResult<'tcx, MPlaceTy<'tcx>> {
+    let ty = unpack_dyn_ty(icx, mplace, expected_trait)?;
+    // This is a kind of transmute, from a place with unsized type and metadata to
+    // a place with sized type and no metadata.
+    let layout = icx.layout_of(ty)?;
+    mplace.offset_with_meta(
+        Size::ZERO,
+        OffsetMode::Wrapping,
+        MemPlaceMeta::None,
+        layout,
+        icx,
+    )
+}

src/schema_ver.rs

@@ -6,4 +6,4 @@
 /// Each version of the schema is assumed to be backwards-incompatible with
 /// previous versions of the schema. As such, any time this version number is
 /// bumped, it should be treated as a major version bump.
-pub const SCHEMA_VER: u64 = 8;
+pub const SCHEMA_VER: u64 = 9;

tests/issues/test0237/README.md

@@ -0,0 +1,3 @@
+A regression test for [issue
+#237](https://github.com/GaloisInc/mir-json/issues/237). This tests
+`mir-json`'s ability to compile constant trait objects.

tests/issues/test0237/test.rs

@@ -0,0 +1,13 @@
+pub trait Trait {
+    fn method(&self) -> u32;
+}
+
+impl Trait for u32 {
+    fn method(&self) -> u32 { *self }
+}
+
+const X: &dyn Trait = &0u32;
+
+pub fn f() -> u32 {
+    X.method()
+}

tests/issues/test0237/test.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+source "$(dirname "$0")/../../common.sh"
+
+expect_no_panic \
+  saw-rustc test.rs \
+    --target "$(rustc --print host-tuple)"