HOTFIX normalise field types before emitting them (#95)

The `Ty`s found in field information can contain `AliasTy` as well as
`ParamTy`, and potentially have unevaluated constants.
Also now panicking if an unevaluated constant is found in array type
metadata.

In the discussion, it was pointed out that the variant fields can be
obtained using `stable_mir` crate (interface) methods only, so I
refactored the code to not use internals where possible.

Related Zulip discussion:[#project-stable-mir > Visiting ADT field
types, problem with unevaluated
constants](https://rust-lang.zulipchat.com/#narrow/channel/320896-project-stable-mir/topic/Visiting.20ADT.20field.20types.2C.20problem.20with.20unevaluated.20constants)

Author: jberthold

src/printer.rs

@@ -22,7 +22,7 @@ extern crate serde;
 extern crate serde_json;
 use rustc_middle as middle;
 use rustc_middle::ty::{
-    EarlyBinder, FnSig, GenericArgs, GenericArgsRef, List, Ty, TyCtxt, TypeFoldable, TypingEnv,
+    EarlyBinder, FnSig, GenericArgs, List, Ty, TyCtxt, TypeFoldable, TypingEnv,
 };
 use rustc_session::config::{OutFileName, OutputType};
 use rustc_smir::rustc_internal::{self, internal};
@@ -557,15 +557,12 @@ impl Visitor for TyCollector<'_> {
             }
             // The visitor won't collect field types for ADTs, therefore doing it explicitly
             TyKind::RigidTy(RigidTy::Adt(adt_def, args)) => {
-                let tcx = self.tcx;
-                let adt = rustc_internal::internal(tcx, adt_def);
-
-                let args: GenericArgsRef = rustc_internal::internal(tcx, args);
-                let fields: Vec<stable_mir::ty::Ty> = adt
-                    .all_fields()
-                    .map(move |field| field.ty(tcx, args))
-                    .map(rustc_internal::stable)
-                    .collect();
+                let fields = adt_def
+                    .variants()
+                    .iter()
+                    .flat_map(|v| v.fields())
+                    .map(|f| f.ty_with_args(&args))
+                    .collect::<Vec<_>>();
 
                 let control = ty.super_visit(self);
                 if matches!(control, ControlFlow::Continue(_)) {
@@ -1055,14 +1052,13 @@ fn mk_type_metadata(
                 .discriminants(tcx)
                 .map(|(_, discr)| discr.val)
                 .collect::<Vec<_>>();
-            let fields = adt_internal
+            let fields = adt_def
                 .variants()
-                .into_iter()
-                .map(|def| {
-                    def.fields
+                .iter()
+                .map(|v| {
+                    v.fields()
                         .iter()
-                        .map(|f| f.ty(tcx, rustc_internal::internal(tcx, &args)))
-                        .map(rustc_internal::stable)
+                        .map(|f| f.ty_with_args(&args))
                         .collect::<Vec<stable_mir::ty::Ty>>()
                 })
                 .collect();
@@ -1078,10 +1074,13 @@ fn mk_type_metadata(
             ))
         }
         T(Adt(adt_def, args)) if t.is_struct() => {
-            let fields = rustc_internal::internal(tcx, adt_def)
-                .all_fields() // is_struct, so only one variant
-                .map(move |f| f.ty(tcx, rustc_internal::internal(tcx, &args)))
-                .map(rustc_internal::stable)
+            let fields = adt_def
+                .variants()
+                .pop() // NB struct, there should be a single variant
+                .unwrap()
+                .fields()
+                .iter()
+                .map(|f| f.ty_with_args(&args))
                 .collect();
             Some((
                 k,
@@ -1104,14 +1103,23 @@ fn mk_type_metadata(
         // encode str together with primitive types
         T(Str) => Some((k, PrimitiveType(Str))),
         // for arrays and slices, record element type and optional size
-        T(Array(elem_type, ty_const)) => Some((
-            k,
-            ArrayType {
-                elem_type,
-                size: Some(ty_const),
-                layout,
-            },
-        )),
+        T(Array(elem_type, ty_const)) => {
+            if matches!(
+                ty_const.kind(),
+                stable_mir::ty::TyConstKind::Unevaluated(_, _)
+            ) {
+                panic!("Unevaluated constant {ty_const:?} in type {k}");
+            }
+            Some((
+                k,
+                ArrayType {
+                    elem_type,
+                    size: Some(ty_const),
+                    layout,
+                },
+            ))
+        }
+
         T(Slice(elem_type)) => Some((
             k,
             ArrayType {

tests/integration/programs/assert_eq.smir.json.expected

@@ -5653,65 +5653,6 @@
         }
       }
     ],
-    [
-      {
-        "RefType": {
-          "layout": {
-            "abi": {
-              "ScalarPair": [
-                {
-                  "Initialized": {
-                    "valid_range": {
-                      "end": 18446744073709551615,
-                      "start": 1
-                    },
-                    "value": {
-                      "Pointer": 0
-                    }
-                  }
-                },
-                {
-                  "Initialized": {
-                    "valid_range": {
-                      "end": 18446744073709551615,
-                      "start": 0
-                    },
-                    "value": {
-                      "Int": {
-                        "length": "I64",
-                        "signed": false
-                      }
-                    }
-                  }
-                }
-              ]
-            },
-            "abi_align": 8,
-            "fields": {
-              "Arbitrary": {
-                "offsets": [
-                  {
-                    "num_bits": 0
-                  },
-                  {
-                    "num_bits": 64
-                  }
-                ]
-              }
-            },
-            "size": {
-              "num_bits": 128
-            },
-            "variants": {
-              "Single": {
-                "index": 0
-              }
-            }
-          },
-          "pointee_type": "elided"
-        }
-      }
-    ],
     [
       {
         "RefType": {