17 files changed, 472 insertions, 239 deletions

diff --git a/gcc/rust/backend/rust-compile-base.cc b/gcc/rust/backend/rust-compile-base.cc
index bcc7fc4..12b9561 100644
--- a/gcc/rust/backend/rust-compile-base.cc
+++ b/gcc/rust/backend/rust-compile-base.cc
@@ -549,7 +549,7 @@ HIRCompileBase::mark_addressable (tree exp, location_t locus)
 }
 
 tree
-HIRCompileBase::address_expression (tree expr, location_t location)
+HIRCompileBase::address_expression (tree expr, location_t location, tree ptrty)
 {
   if (expr == error_mark_node)
     return error_mark_node;
@@ -557,7 +557,22 @@ HIRCompileBase::address_expression (tree expr, location_t location)
   if (!mark_addressable (expr, location))
     return error_mark_node;
 
-  return build_fold_addr_expr_loc (location, expr);
+  if (ptrty == NULL || ptrty == error_mark_node)
+    ptrty = build_pointer_type (TREE_TYPE (expr));
+
+  return build_fold_addr_expr_with_type_loc (location, expr, ptrty);
+}
+
+tree
+HIRCompileBase::compile_constant_expr (
+  Context *ctx, HirId coercion_id, TyTy::BaseType *resolved_type,
+  TyTy::BaseType *expected_type, const Resolver::CanonicalPath &canonical_path,
+  HIR::Expr &const_value_expr, location_t locus, location_t expr_locus)
+{
+  HIRCompileBase c (ctx);
+  return c.compile_constant_item (coercion_id, resolved_type, expected_type,
+				  canonical_path, const_value_expr, locus,
+				  expr_locus);
 }
 
 tree
@@ -651,7 +666,8 @@ get_abi (const AST::AttrVec &outer_attrs,
 
 tree
 HIRCompileBase::compile_function (
-  const std::string &fn_name, HIR::SelfParam &self_param,
+  bool is_root_item, const std::string &fn_name,
+  tl::optional<HIR::SelfParam> &self_param,
   std::vector<HIR::FunctionParam> &function_params,
   const HIR::FunctionQualifiers &qualifiers, HIR::Visibility &visibility,
   AST::AttrVec &outer_attrs, location_t locus, HIR::BlockExpr *function_body,
@@ -662,7 +678,7 @@ HIRCompileBase::compile_function (
     = canonical_path.get () + fntype->subst_as_string ();
 
   // we don't mangle the main fn since we haven't implemented the main shim
-  bool is_main_fn = fn_name.compare ("main") == 0;
+  bool is_main_fn = fn_name.compare ("main") == 0 && is_root_item;
   if (is_main_fn)
     {
       rust_assert (!main_identifier_node);
@@ -698,24 +714,24 @@ HIRCompileBase::compile_function (
   // setup the params
   TyTy::BaseType *tyret = fntype->get_return_type ();
   std::vector<Bvariable *> param_vars;
-  if (!self_param.is_error ())
+  if (self_param)
     {
       rust_assert (fntype->is_method ());
       TyTy::BaseType *self_tyty_lookup = fntype->get_self_type ();
 
       tree self_type = TyTyResolveCompile::compile (ctx, self_tyty_lookup);
       Bvariable *compiled_self_param
-	= CompileSelfParam::compile (ctx, fndecl, self_param, self_type,
-				     self_param.get_locus ());
+	= CompileSelfParam::compile (ctx, fndecl, self_param.value (),
+				     self_type, self_param->get_locus ());
 
       param_vars.push_back (compiled_self_param);
-      ctx->insert_var_decl (self_param.get_mappings ().get_hirid (),
+      ctx->insert_var_decl (self_param->get_mappings ().get_hirid (),
 			    compiled_self_param);
     }
 
   // offset from + 1 for the TyTy::FnType being used when this is a method to
   // skip over Self on the FnType
-  bool is_method = !self_param.is_error ();
+  bool is_method = self_param.has_value ();
   size_t i = is_method ? 1 : 0;
   for (auto &referenced_param : function_params)
     {
@@ -1011,7 +1027,7 @@ HIRCompileBase::resolve_method_address (TyTy::FnType *fntype,
 tree
 HIRCompileBase::unit_expression (location_t locus)
 {
-  tree unit_type = TyTyResolveCompile::get_unit_type ();
+  tree unit_type = TyTyResolveCompile::get_unit_type (ctx);
   return Backend::constructor_expression (unit_type, false, {}, -1, locus);
 }
 
diff --git a/gcc/rust/backend/rust-compile-base.h b/gcc/rust/backend/rust-compile-base.h
index 9328a7f..6814abc 100644
--- a/gcc/rust/backend/rust-compile-base.h
+++ b/gcc/rust/backend/rust-compile-base.h
@@ -29,7 +29,14 @@ class HIRCompileBase
 public:
   virtual ~HIRCompileBase () {}
 
-  static tree address_expression (tree expr, location_t locus);
+  static tree address_expression (tree expr, location_t locus,
+				  tree ptrty = NULL_TREE);
+
+  static tree compile_constant_expr (
+    Context *ctx, HirId coercion_id, TyTy::BaseType *resolved_type,
+    TyTy::BaseType *expected_type,
+    const Resolver::CanonicalPath &canonical_path, HIR::Expr &const_value_expr,
+    location_t locus, location_t expr_locus);
 
 protected:
   HIRCompileBase (Context *ctx) : ctx (ctx) {}
@@ -96,7 +103,8 @@ protected:
 			      HIR::Expr &const_value_expr, location_t locus,
 			      location_t expr_locus);
 
-  tree compile_function (const std::string &fn_name, HIR::SelfParam &self_param,
+  tree compile_function (bool is_root_item, const std::string &fn_name,
+			 tl::optional<HIR::SelfParam> &self_param,
 			 std::vector<HIR::FunctionParam> &function_params,
 			 const HIR::FunctionQualifiers &qualifiers,
 			 HIR::Visibility &visibility, AST::AttrVec &outer_attrs,
@@ -104,7 +112,7 @@ protected:
 			 const Resolver::CanonicalPath &canonical_path,
 			 TyTy::FnType *fntype);
 
-  static tree unit_expression (location_t locus);
+  tree unit_expression (location_t locus);
 
   void setup_fndecl (tree fndecl, bool is_main_entry_point, bool is_generic_fn,
 		     HIR::Visibility &visibility,
diff --git a/gcc/rust/backend/rust-compile-context.h b/gcc/rust/backend/rust-compile-context.h
index a446388..ce81a1d 100644
--- a/gcc/rust/backend/rust-compile-context.h
+++ b/gcc/rust/backend/rust-compile-context.h
@@ -72,7 +72,10 @@ public:
       return it->second;
 
     compiled_type_map.insert ({h, type});
-    push_type (type);
+
+    if (TYPE_NAME (type) != NULL)
+      push_type (type);
+
     return type;
   }
 
diff --git a/gcc/rust/backend/rust-compile-expr.cc b/gcc/rust/backend/rust-compile-expr.cc
index 353a498..37856a7 100644
--- a/gcc/rust/backend/rust-compile-expr.cc
+++ b/gcc/rust/backend/rust-compile-expr.cc
@@ -31,6 +31,7 @@
 #include "convert.h"
 #include "print-tree.h"
 #include "rust-system.h"
+#include "rust-tyty.h"
 
 namespace Rust {
 namespace Compile {
@@ -158,27 +159,28 @@ CompileExpr::visit (HIR::ArithmeticOrLogicalExpr &expr)
       return;
     }
 
-  if (ctx->in_fn () && !ctx->const_context_p ())
-    {
-      auto receiver_tmp = NULL_TREE;
-      auto receiver
-	= Backend::temporary_variable (ctx->peek_fn ().fndecl, NULL_TREE,
-				       TREE_TYPE (lhs), lhs, true,
-				       expr.get_locus (), &receiver_tmp);
-      auto check
-	= Backend::arithmetic_or_logical_expression_checked (op, lhs, rhs,
-							     expr.get_locus (),
-							     receiver);
-
-      ctx->add_statement (check);
-      translated = receiver->get_tree (expr.get_locus ());
-    }
-  else
+  bool can_generate_overflow_checks
+    = (ctx->in_fn () && !ctx->const_context_p ()) && flag_overflow_checks;
+  if (!can_generate_overflow_checks)
     {
       translated
 	= Backend::arithmetic_or_logical_expression (op, lhs, rhs,
 						     expr.get_locus ());
+      return;
     }
+
+  auto receiver_tmp = NULL_TREE;
+  auto receiver
+    = Backend::temporary_variable (ctx->peek_fn ().fndecl, NULL_TREE,
+				   TREE_TYPE (lhs), lhs, true,
+				   expr.get_locus (), &receiver_tmp);
+  auto check
+    = Backend::arithmetic_or_logical_expression_checked (op, lhs, rhs,
+							 expr.get_locus (),
+							 receiver);
+
+  ctx->add_statement (check);
+  translated = receiver->get_tree (expr.get_locus ());
 }
 
 void
@@ -903,7 +905,8 @@ CompileExpr::visit (HIR::BorrowExpr &expr)
 				       &tyty))
     return;
 
-  translated = address_expression (main_expr, expr.get_locus ());
+  tree expected_type = TyTyResolveCompile::compile (ctx, tyty);
+  translated = address_expression (main_expr, expr.get_locus (), expected_type);
 }
 
 void
@@ -1035,11 +1038,6 @@ check_match_scrutinee (HIR::MatchExpr &expr, Context *ctx)
     }
 
   TyTy::TypeKind scrutinee_kind = scrutinee_expr_tyty->get_kind ();
-  rust_assert ((TyTy::is_primitive_type_kind (scrutinee_kind)
-		&& scrutinee_kind != TyTy::TypeKind::NEVER)
-	       || scrutinee_kind == TyTy::TypeKind::ADT
-	       || scrutinee_kind == TyTy::TypeKind::TUPLE
-	       || scrutinee_kind == TyTy::TypeKind::REF);
 
   if (scrutinee_kind == TyTy::TypeKind::FLOAT)
     {
@@ -1397,8 +1395,8 @@ CompileExpr::visit (HIR::MethodCallExpr &expr)
   TyTy::FnType *fntype = static_cast<TyTy::FnType *> (lookup_fntype);
 
   TyTy::BaseType *receiver = nullptr;
-  ok = ctx->get_tyctx ()->lookup_receiver (expr.get_mappings ().get_hirid (),
-					   &receiver);
+  ok = ctx->get_tyctx ()->lookup_type (
+    expr.get_receiver ().get_mappings ().get_hirid (), &receiver);
   rust_assert (ok);
 
   bool is_dyn_dispatch
@@ -1535,8 +1533,8 @@ CompileExpr::resolve_operator_overload (
 
   TyTy::BaseType *receiver = nullptr;
   bool ok
-    = ctx->get_tyctx ()->lookup_receiver (expr.get_mappings ().get_hirid (),
-					  &receiver);
+    = ctx->get_tyctx ()->lookup_type (lhs_expr.get_mappings ().get_hirid (),
+				      &receiver);
   rust_assert (ok);
 
   bool is_generic_receiver = receiver->get_kind () == TyTy::TypeKind::PARAM;
@@ -1905,6 +1903,14 @@ CompileExpr::array_value_expr (location_t expr_locus,
   for (auto &elem : elems.get_values ())
     {
       tree translated_expr = CompileExpr::Compile (*elem, ctx);
+      if (translated_expr == error_mark_node)
+	{
+	  rich_location r (line_table, expr_locus);
+	  r.add_fixit_replace (elem->get_locus (), "not a value");
+	  rust_error_at (r, ErrorCode::E0423, "expected value");
+	  return error_mark_node;
+	}
+
       constructor.push_back (translated_expr);
       indexes.push_back (i++);
     }
@@ -2006,6 +2012,9 @@ HIRCompileBase::resolve_adjustements (
   tree e = expression;
   for (auto &adjustment : adjustments)
     {
+      if (e == error_mark_node)
+	return error_mark_node;
+
       switch (adjustment.get_type ())
 	{
 	case Resolver::Adjustment::AdjustmentType::ERROR:
@@ -2456,7 +2465,7 @@ CompileExpr::generate_closure_function (HIR::ClosureExpr &expr,
       auto body_mappings = function_body.get_mappings ();
       if (flag_name_resolution_2_0)
 	{
-	  auto nr_ctx
+	  auto &nr_ctx
 	    = Resolver2_0::ImmutableNameResolutionContext::get ().resolver ();
 
 	  auto candidate = nr_ctx.values.to_rib (body_mappings.get_nodeid ());
diff --git a/gcc/rust/backend/rust-compile-extern.h b/gcc/rust/backend/rust-compile-extern.h
index bacd1c0..d6aa589 100644
--- a/gcc/rust/backend/rust-compile-extern.h
+++ b/gcc/rust/backend/rust-compile-extern.h
@@ -34,16 +34,10 @@ class CompileExternItem : public HIRCompileBase,
 public:
   static tree compile (HIR::ExternalItem *item, Context *ctx,
 		       TyTy::BaseType *concrete = nullptr,
-		       bool is_query_mode = false,
 		       location_t ref_locus = UNDEF_LOCATION)
   {
     CompileExternItem compiler (ctx, concrete, ref_locus);
     item->accept_vis (compiler);
-
-    if (is_query_mode && compiler.reference == error_mark_node)
-      rust_internal_error_at (ref_locus, "failed to compile extern item: %s",
-			      item->as_string ().c_str ());
-
     return compiler.reference;
   }
 
diff --git a/gcc/rust/backend/rust-compile-implitem.cc b/gcc/rust/backend/rust-compile-implitem.cc
index 71b3e8d..1230c85 100644
--- a/gcc/rust/backend/rust-compile-implitem.cc
+++ b/gcc/rust/backend/rust-compile-implitem.cc
@@ -117,7 +117,7 @@ CompileTraitItem::visit (HIR::TraitItemFunc &func)
   auto vis = HIR::Visibility (HIR::Visibility::VisType::PUBLIC);
   HIR::TraitFunctionDecl &function = func.get_decl ();
   tree fndecl
-    = compile_function (function.get_function_name ().as_string (),
+    = compile_function (false, function.get_function_name ().as_string (),
 			function.get_self (), function.get_function_params (),
 			function.get_qualifiers (), vis,
 			func.get_outer_attrs (), func.get_locus (),
diff --git a/gcc/rust/backend/rust-compile-implitem.h b/gcc/rust/backend/rust-compile-implitem.h
index d2ef989..2d18dbf 100644
--- a/gcc/rust/backend/rust-compile-implitem.h
+++ b/gcc/rust/backend/rust-compile-implitem.h
@@ -30,16 +30,10 @@ class CompileInherentImplItem : public CompileItem
 public:
   static tree Compile (HIR::ImplItem *item, Context *ctx,
 		       TyTy::BaseType *concrete = nullptr,
-		       bool is_query_mode = false,
 		       location_t ref_locus = UNDEF_LOCATION)
   {
     CompileInherentImplItem compiler (ctx, concrete, ref_locus);
     item->accept_vis (compiler);
-
-    if (is_query_mode && compiler.reference == error_mark_node)
-      rust_internal_error_at (ref_locus, "failed to compile impl item: %s",
-			      item->as_string ().c_str ());
-
     return compiler.reference;
   }
 
diff --git a/gcc/rust/backend/rust-compile-intrinsic.cc b/gcc/rust/backend/rust-compile-intrinsic.cc
index 0f05458..4888e23 100644
--- a/gcc/rust/backend/rust-compile-intrinsic.cc
+++ b/gcc/rust/backend/rust-compile-intrinsic.cc
@@ -17,7 +17,6 @@
 #include "rust-compile-intrinsic.h"
 #include "rust-compile-context.h"
 #include "rust-compile-type.h"
-#include "rust-compile-expr.h"
 #include "rust-compile-fnparam.h"
 #include "rust-builtins.h"
 #include "rust-diagnostics.h"
@@ -27,14 +26,10 @@
 #include "rust-tree.h"
 #include "tree-core.h"
 #include "rust-gcc.h"
-#include "print-tree.h"
 #include "fold-const.h"
 #include "langhooks.h"
-#include "rust-gcc.h"
 #include "rust-constexpr.h"
 
-#include "print-tree.h"
-
 // declaration taken from "stringpool.h"
 // the get_identifier macro causes compilation issues
 extern tree
@@ -93,6 +88,10 @@ static tree
 move_val_init_handler (Context *ctx, TyTy::FnType *fntype);
 static tree
 assume_handler (Context *ctx, TyTy::FnType *fntype);
+static tree
+discriminant_value_handler (Context *ctx, TyTy::FnType *fntype);
+static tree
+variant_count_handler (Context *ctx, TyTy::FnType *fntype);
 
 enum class Prefetch
 {
@@ -217,45 +216,46 @@ sorry_handler (Context *ctx, TyTy::FnType *fntype)
 
 static const std::map<std::string,
 		      std::function<tree (Context *, TyTy::FnType *)>>
-  generic_intrinsics = {
-    {"offset", offset_handler},
-    {"size_of", sizeof_handler},
-    {"transmute", transmute_handler},
-    {"rotate_left", rotate_left_handler},
-    {"rotate_right", rotate_right_handler},
-    {"wrapping_add", wrapping_op_handler (PLUS_EXPR)},
-    {"wrapping_sub", wrapping_op_handler (MINUS_EXPR)},
-    {"wrapping_mul", wrapping_op_handler (MULT_EXPR)},
-    {"add_with_overflow", op_with_overflow (PLUS_EXPR)},
-    {"sub_with_overflow", op_with_overflow (MINUS_EXPR)},
-    {"mul_with_overflow", op_with_overflow (MULT_EXPR)},
-    {"copy", copy_handler (true)},
-    {"copy_nonoverlapping", copy_handler (false)},
-    {"prefetch_read_data", prefetch_read_data},
-    {"prefetch_write_data", prefetch_write_data},
-    {"atomic_store_seqcst", atomic_store_handler (__ATOMIC_SEQ_CST)},
-    {"atomic_store_release", atomic_store_handler (__ATOMIC_RELEASE)},
-    {"atomic_store_relaxed", atomic_store_handler (__ATOMIC_RELAXED)},
-    {"atomic_store_unordered", atomic_store_handler (__ATOMIC_RELAXED)},
-    {"atomic_load_seqcst", atomic_load_handler (__ATOMIC_SEQ_CST)},
-    {"atomic_load_acquire", atomic_load_handler (__ATOMIC_ACQUIRE)},
-    {"atomic_load_relaxed", atomic_load_handler (__ATOMIC_RELAXED)},
-    {"atomic_load_unordered", atomic_load_handler (__ATOMIC_RELAXED)},
-    {"unchecked_add", unchecked_op_handler (PLUS_EXPR)},
-    {"unchecked_sub", unchecked_op_handler (MINUS_EXPR)},
-    {"unchecked_mul", unchecked_op_handler (MULT_EXPR)},
-    {"unchecked_div", unchecked_op_handler (TRUNC_DIV_EXPR)},
-    {"unchecked_rem", unchecked_op_handler (TRUNC_MOD_EXPR)},
-    {"unchecked_shl", unchecked_op_handler (LSHIFT_EXPR)},
-    {"unchecked_shr", unchecked_op_handler (RSHIFT_EXPR)},
-    {"uninit", uninit_handler},
-    {"move_val_init", move_val_init_handler},
-    {"likely", expect_handler (true)},
-    {"unlikely", expect_handler (false)},
-    {"assume", assume_handler},
-    {"try", try_handler (false)},
-    {"catch_unwind", try_handler (true)},
-};
+  generic_intrinsics
+  = {{"offset", offset_handler},
+     {"size_of", sizeof_handler},
+     {"transmute", transmute_handler},
+     {"rotate_left", rotate_left_handler},
+     {"rotate_right", rotate_right_handler},
+     {"wrapping_add", wrapping_op_handler (PLUS_EXPR)},
+     {"wrapping_sub", wrapping_op_handler (MINUS_EXPR)},
+     {"wrapping_mul", wrapping_op_handler (MULT_EXPR)},
+     {"add_with_overflow", op_with_overflow (PLUS_EXPR)},
+     {"sub_with_overflow", op_with_overflow (MINUS_EXPR)},
+     {"mul_with_overflow", op_with_overflow (MULT_EXPR)},
+     {"copy", copy_handler (true)},
+     {"copy_nonoverlapping", copy_handler (false)},
+     {"prefetch_read_data", prefetch_read_data},
+     {"prefetch_write_data", prefetch_write_data},
+     {"atomic_store_seqcst", atomic_store_handler (__ATOMIC_SEQ_CST)},
+     {"atomic_store_release", atomic_store_handler (__ATOMIC_RELEASE)},
+     {"atomic_store_relaxed", atomic_store_handler (__ATOMIC_RELAXED)},
+     {"atomic_store_unordered", atomic_store_handler (__ATOMIC_RELAXED)},
+     {"atomic_load_seqcst", atomic_load_handler (__ATOMIC_SEQ_CST)},
+     {"atomic_load_acquire", atomic_load_handler (__ATOMIC_ACQUIRE)},
+     {"atomic_load_relaxed", atomic_load_handler (__ATOMIC_RELAXED)},
+     {"atomic_load_unordered", atomic_load_handler (__ATOMIC_RELAXED)},
+     {"unchecked_add", unchecked_op_handler (PLUS_EXPR)},
+     {"unchecked_sub", unchecked_op_handler (MINUS_EXPR)},
+     {"unchecked_mul", unchecked_op_handler (MULT_EXPR)},
+     {"unchecked_div", unchecked_op_handler (TRUNC_DIV_EXPR)},
+     {"unchecked_rem", unchecked_op_handler (TRUNC_MOD_EXPR)},
+     {"unchecked_shl", unchecked_op_handler (LSHIFT_EXPR)},
+     {"unchecked_shr", unchecked_op_handler (RSHIFT_EXPR)},
+     {"uninit", uninit_handler},
+     {"move_val_init", move_val_init_handler},
+     {"likely", expect_handler (true)},
+     {"unlikely", expect_handler (false)},
+     {"assume", assume_handler},
+     {"try", try_handler (false)},
+     {"catch_unwind", try_handler (true)},
+     {"discriminant_value", discriminant_value_handler},
+     {"variant_count", variant_count_handler}};
 
 Intrinsics::Intrinsics (Context *ctx) : ctx (ctx) {}
 
@@ -1273,7 +1273,7 @@ assume_handler (Context *ctx, TyTy::FnType *fntype)
   TREE_SIDE_EFFECTS (assume_expr) = 1;
 
   ctx->add_statement (assume_expr);
-  // BUILTIN size_of FN BODY END
+  // BUILTIN assume FN BODY END
 
   finalize_intrinsic_block (ctx, fndecl);
 
@@ -1322,7 +1322,7 @@ try_handler_inner (Context *ctx, TyTy::FnType *fntype, bool is_new_api)
 
   if (is_new_api)
     {
-      auto ret_type = TyTyResolveCompile::get_unit_type ();
+      auto ret_type = TyTyResolveCompile::get_unit_type (ctx);
       auto ret_expr = Backend::constructor_expression (ret_type, false, {}, -1,
 						       UNDEF_LOCATION);
       normal_return_stmt
@@ -1375,5 +1375,120 @@ try_handler_inner (Context *ctx, TyTy::FnType *fntype, bool is_new_api)
   return fndecl;
 }
 
+static tree
+discriminant_value_handler (Context *ctx, TyTy::FnType *fntype)
+{
+  rust_assert (fntype->get_params ().size () == 1);
+  rust_assert (fntype->get_return_type ()->is<TyTy::PlaceholderType> ());
+  rust_assert (fntype->has_substitutions ());
+  rust_assert (fntype->get_num_type_params () == 1);
+  auto &mapping = fntype->get_substs ().at (0);
+  auto param_ty = mapping.get_param_ty ();
+  rust_assert (param_ty->can_resolve ());
+  auto resolved = param_ty->resolve ();
+  auto p = static_cast<TyTy::PlaceholderType *> (fntype->get_return_type ());
+
+  TyTy::BaseType *return_type = nullptr;
+  bool ok = ctx->get_tyctx ()->lookup_builtin ("isize", &return_type);
+  rust_assert (ok);
+
+  bool is_adt = resolved->is<TyTy::ADTType> ();
+  bool is_enum = false;
+  if (is_adt)
+    {
+      const auto &adt = *static_cast<TyTy::ADTType *> (resolved);
+      return_type = adt.get_repr_options ().repr;
+      rust_assert (return_type != nullptr);
+      is_enum = adt.is_enum ();
+    }
+
+  p->set_associated_type (return_type->get_ref ());
+
+  tree lookup = NULL_TREE;
+  if (check_for_cached_intrinsic (ctx, fntype, &lookup))
+    return lookup;
+
+  auto fndecl = compile_intrinsic_function (ctx, fntype);
+
+  std::vector<Bvariable *> param_vars;
+  compile_fn_params (ctx, fntype, fndecl, &param_vars);
+
+  if (!Backend::function_set_parameters (fndecl, param_vars))
+    return error_mark_node;
+
+  enter_intrinsic_block (ctx, fndecl);
+
+  // BUILTIN disriminant_value FN BODY BEGIN
+
+  tree result = integer_zero_node;
+  if (is_enum)
+    {
+      tree val = Backend::var_expression (param_vars[0], UNDEF_LOCATION);
+      tree deref = build_fold_indirect_ref_loc (UNKNOWN_LOCATION, val);
+      result = Backend::struct_field_expression (deref, 0, UNKNOWN_LOCATION);
+    }
+
+  auto return_statement
+    = Backend::return_statement (fndecl, result, BUILTINS_LOCATION);
+  ctx->add_statement (return_statement);
+
+  // BUILTIN disriminant_value FN BODY END
+
+  finalize_intrinsic_block (ctx, fndecl);
+
+  return fndecl;
+}
+
+static tree
+variant_count_handler (Context *ctx, TyTy::FnType *fntype)
+{
+  rust_assert (fntype->get_num_type_params () == 1);
+  auto &mapping = fntype->get_substs ().at (0);
+  auto param_ty = mapping.get_param_ty ();
+  rust_assert (param_ty->can_resolve ());
+  auto resolved = param_ty->resolve ();
+
+  size_t variant_count = 0;
+  bool is_adt = resolved->is<TyTy::ADTType> ();
+  if (is_adt)
+    {
+      const auto &adt = *static_cast<TyTy::ADTType *> (resolved);
+      variant_count = adt.number_of_variants ();
+    }
+
+  tree lookup = NULL_TREE;
+  if (check_for_cached_intrinsic (ctx, fntype, &lookup))
+    return lookup;
+
+  auto fndecl = compile_intrinsic_function (ctx, fntype);
+
+  std::vector<Bvariable *> param_vars;
+  compile_fn_params (ctx, fntype, fndecl, &param_vars);
+
+  if (!Backend::function_set_parameters (fndecl, param_vars))
+    return error_mark_node;
+
+  enter_intrinsic_block (ctx, fndecl);
+
+  // BUILTIN disriminant_value FN BODY BEGIN
+  tree result_decl = DECL_RESULT (fndecl);
+  tree type = TREE_TYPE (result_decl);
+
+  mpz_t ival;
+  mpz_init_set_ui (ival, variant_count);
+  tree result = wide_int_to_tree (type, wi::from_mpz (type, ival, true));
+  mpz_clear (ival);
+
+  auto return_statement
+    = Backend::return_statement (fndecl, result, BUILTINS_LOCATION);
+  ctx->add_statement (return_statement);
+
+  // BUILTIN disriminant_value FN BODY END
+
+  finalize_intrinsic_block (ctx, fndecl);
+
+  return fndecl;
+}
+
 } // namespace Compile
 } // namespace Rust
diff --git a/gcc/rust/backend/rust-compile-item.cc b/gcc/rust/backend/rust-compile-item.cc
index 52cd59f..9666990 100644
--- a/gcc/rust/backend/rust-compile-item.cc
+++ b/gcc/rust/backend/rust-compile-item.cc
@@ -19,6 +19,8 @@
 #include "rust-compile-item.h"
 #include "rust-compile-implitem.h"
 #include "rust-compile-extern.h"
+#include "rust-substitution-mapper.h"
+#include "rust-type-util.h"
 #include "rust-immutable-name-resolution-context.h"
 
 namespace Rust {
@@ -52,7 +54,7 @@ CompileItem::visit (HIR::StaticItem &var)
 
   if (flag_name_resolution_2_0)
     {
-      auto nr_ctx
+      auto &nr_ctx
 	= Resolver2_0::ImmutableNameResolutionContext::get ().resolver ();
 
       canonical_path
@@ -119,7 +121,7 @@ CompileItem::visit (HIR::ConstantItem &constant)
 
   if (flag_name_resolution_2_0)
     {
-      auto nr_ctx
+      auto &nr_ctx
 	= Resolver2_0::ImmutableNameResolutionContext::get ().resolver ();
 
       canonical_path
@@ -165,12 +167,33 @@ CompileItem::visit (HIR::Function &function)
       // is given
       if (concrete == nullptr)
 	return;
-      else
+
+      rust_assert (concrete->get_kind () == TyTy::TypeKind::FNDEF);
+      TyTy::FnType *concrete_fnty = static_cast<TyTy::FnType *> (concrete);
+      bool is_trait_item_concrete
+	= ctx->get_mappings ()
+	    .lookup_trait_item_defid (concrete_fnty->get_id ())
+	    .has_value ();
+      if (!is_trait_item_concrete)
 	{
 	  rust_assert (concrete->get_kind () == TyTy::TypeKind::FNDEF);
 	  fntype = static_cast<TyTy::FnType *> (concrete);
-	  fntype->monomorphize ();
 	}
+      else
+	{
+	  TyTy::BaseType *infer
+	    = Resolver::SubstMapper::InferSubst (fntype, function.get_locus ());
+	  TyTy::BaseType *resolved
+	    = Resolver::unify_site (function.get_mappings ().get_hirid (),
+				    TyTy::TyWithLocation (infer),
+				    TyTy::TyWithLocation (concrete),
+				    function.get_locus ());
+
+	  rust_assert (resolved->is<TyTy::FnType> ());
+	  fntype = resolved->as<TyTy::FnType> ();
+	}
+
+      fntype->monomorphize ();
     }
   else
     {
@@ -192,7 +215,7 @@ CompileItem::visit (HIR::Function &function)
 
   if (flag_name_resolution_2_0)
     {
-      auto nr_ctx
+      auto &nr_ctx
 	= Resolver2_0::ImmutableNameResolutionContext::get ().resolver ();
 
       auto path = nr_ctx.values.to_canonical_path (
@@ -229,8 +252,12 @@ CompileItem::visit (HIR::Function &function)
   if (function.get_qualifiers ().is_const ())
     ctx->push_const_context ();
 
+  auto lookup_root_item = ctx->get_mappings ().lookup_hir_item (
+    function.get_mappings ().get_hirid ());
+  bool is_root_item = lookup_root_item.has_value ();
   tree fndecl
-    = compile_function (function.get_function_name ().as_string (),
+    = compile_function (is_root_item,
+			function.get_function_name ().as_string (),
 			function.get_self_param (),
 			function.get_function_params (),
 			function.get_qualifiers (), function.get_visibility (),
diff --git a/gcc/rust/backend/rust-compile-item.h b/gcc/rust/backend/rust-compile-item.h
index efc65fe..d9d946d 100644
--- a/gcc/rust/backend/rust-compile-item.h
+++ b/gcc/rust/backend/rust-compile-item.h
@@ -31,16 +31,10 @@ protected:
 public:
   static tree compile (HIR::Item *item, Context *ctx,
 		       TyTy::BaseType *concrete = nullptr,
-		       bool is_query_mode = false,
 		       location_t ref_locus = UNDEF_LOCATION)
   {
     CompileItem compiler (ctx, concrete, ref_locus);
     item->accept_vis (compiler);
-
-    if (is_query_mode && compiler.reference == error_mark_node)
-      rust_internal_error_at (ref_locus, "failed to compile item: %s",
-			      item->as_string ().c_str ());
-
     return compiler.reference;
   }
 
diff --git a/gcc/rust/backend/rust-compile-pattern.cc b/gcc/rust/backend/rust-compile-pattern.cc
index 4e352fd..e83717b 100644
--- a/gcc/rust/backend/rust-compile-pattern.cc
+++ b/gcc/rust/backend/rust-compile-pattern.cc
@@ -481,8 +481,7 @@ CompilePatternBindings::visit (HIR::TupleStructPattern &pattern)
 						      tuple_field_index++,
 						      pattern->get_locus ());
 
-		ctx->insert_pattern_binding (
-		  pattern->get_mappings ().get_hirid (), binding);
+		CompilePatternBindings::Compile (*pattern, binding, ctx);
 	      }
 	  }
 	else
@@ -497,8 +496,7 @@ CompilePatternBindings::visit (HIR::TupleStructPattern &pattern)
 						      tuple_field_index++,
 						      pattern->get_locus ());
 
-		ctx->insert_pattern_binding (
-		  pattern->get_mappings ().get_hirid (), binding);
+		CompilePatternBindings::Compile (*pattern, binding, ctx);
 	      }
 	  }
       }
@@ -607,8 +605,16 @@ CompilePatternBindings::visit (HIR::ReferencePattern &pattern)
 void
 CompilePatternBindings::visit (HIR::IdentifierPattern &pattern)
 {
-  ctx->insert_pattern_binding (pattern.get_mappings ().get_hirid (),
-			       match_scrutinee_expr);
+  if (!pattern.get_is_ref ())
+    {
+      ctx->insert_pattern_binding (pattern.get_mappings ().get_hirid (),
+				   match_scrutinee_expr);
+      return;
+    }
+
+  tree ref = address_expression (match_scrutinee_expr,
+				 EXPR_LOCATION (match_scrutinee_expr));
+  ctx->insert_pattern_binding (pattern.get_mappings ().get_hirid (), ref);
 }
 
 void
diff --git a/gcc/rust/backend/rust-compile-resolve-path.cc b/gcc/rust/backend/rust-compile-resolve-path.cc
index 69599cc..81d2dbb 100644
--- a/gcc/rust/backend/rust-compile-resolve-path.cc
+++ b/gcc/rust/backend/rust-compile-resolve-path.cc
@@ -32,18 +32,41 @@
 namespace Rust {
 namespace Compile {
 
-void
-ResolvePathRef::visit (HIR::QualifiedPathInExpression &expr)
+tree
+ResolvePathRef::Compile (HIR::QualifiedPathInExpression &expr, Context *ctx)
 {
-  resolved = resolve (expr.get_final_segment ().get_segment (),
-		      expr.get_mappings (), expr.get_locus (), true);
+  ResolvePathRef resolver (ctx);
+  return resolver.resolve_path_like (expr);
 }
 
-void
-ResolvePathRef::visit (HIR::PathInExpression &expr)
+tree
+ResolvePathRef::Compile (HIR::PathInExpression &expr, Context *ctx)
 {
-  resolved = resolve (expr.get_final_segment ().get_segment (),
-		      expr.get_mappings (), expr.get_locus (), false);
+  ResolvePathRef resolver (ctx);
+  return resolver.resolve_path_like (expr);
+}
+
+ResolvePathRef::ResolvePathRef (Context *ctx) : HIRCompileBase (ctx) {}
+
+template <typename T>
+tree
+ResolvePathRef::resolve_path_like (T &expr)
+{
+  if (expr.is_lang_item ())
+    {
+      auto lang_item
+	= Analysis::Mappings::get ().get_lang_item_node (expr.get_lang_item ());
+
+      // FIXME: Is that correct? :/
+      auto final_segment
+	= HIR::PathIdentSegment (LangItem::ToString (expr.get_lang_item ()));
+
+      return resolve_with_node_id (final_segment, expr.get_mappings (),
+				   expr.get_locus (), true, lang_item);
+    }
+
+  return resolve (expr.get_final_segment ().get_segment (),
+		  expr.get_mappings (), expr.get_locus (), true);
 }
 
 tree
@@ -82,7 +105,9 @@ ResolvePathRef::attempt_constructor_expression_lookup (
 
   // make the ctor for the union
   HIR::Expr &discrim_expr = variant->get_discriminant ();
+  ctx->push_const_context ();
   tree discrim_expr_node = CompileExpr::Compile (discrim_expr, ctx);
+  ctx->pop_const_context ();
   tree folded_discrim_expr = fold_expr (discrim_expr_node);
   tree qualifier = folded_discrim_expr;
 
@@ -92,42 +117,17 @@ ResolvePathRef::attempt_constructor_expression_lookup (
 }
 
 tree
-ResolvePathRef::resolve (const HIR::PathIdentSegment &final_segment,
-			 const Analysis::NodeMapping &mappings,
-			 location_t expr_locus, bool is_qualified_path)
+ResolvePathRef::resolve_with_node_id (
+  const HIR::PathIdentSegment &final_segment,
+  const Analysis::NodeMapping &mappings, location_t expr_locus,
+  bool is_qualified_path, NodeId resolved_node_id)
 {
   TyTy::BaseType *lookup = nullptr;
   bool ok = ctx->get_tyctx ()->lookup_type (mappings.get_hirid (), &lookup);
   rust_assert (ok);
 
-  // need to look up the reference for this identifier
-
-  // this can fail because it might be a Constructor for something
-  // in that case the caller should attempt ResolvePathType::Compile
-  NodeId ref_node_id = UNKNOWN_NODEID;
-  if (flag_name_resolution_2_0)
-    {
-      auto nr_ctx
-	= Resolver2_0::ImmutableNameResolutionContext::get ().resolver ();
-
-      auto resolved = nr_ctx.lookup (mappings.get_nodeid ());
-
-      if (!resolved)
-	return attempt_constructor_expression_lookup (lookup, ctx, mappings,
-						      expr_locus);
-
-      ref_node_id = *resolved;
-    }
-  else
-    {
-      if (!ctx->get_resolver ()->lookup_resolved_name (mappings.get_nodeid (),
-						       &ref_node_id))
-	return attempt_constructor_expression_lookup (lookup, ctx, mappings,
-						      expr_locus);
-    }
-
   tl::optional<HirId> hid
-    = ctx->get_mappings ().lookup_node_to_hir (ref_node_id);
+    = ctx->get_mappings ().lookup_node_to_hir (resolved_node_id);
   if (!hid.has_value ())
     {
       rust_error_at (expr_locus, "reverse call path lookup failure");
@@ -186,6 +186,11 @@ ResolvePathRef::resolve (const HIR::PathIdentSegment &final_segment,
 	}
     }
 
+  // Handle unit struct
+  if (lookup->get_kind () == TyTy::TypeKind::ADT)
+    return attempt_constructor_expression_lookup (lookup, ctx, mappings,
+						  expr_locus);
+
   // let the query system figure it out
   tree resolved_item = query_compile (ref, lookup, final_segment, mappings,
 				      expr_locus, is_qualified_path);
@@ -193,10 +198,50 @@ ResolvePathRef::resolve (const HIR::PathIdentSegment &final_segment,
     {
       TREE_USED (resolved_item) = 1;
     }
+
   return resolved_item;
 }
 
 tree
+ResolvePathRef::resolve (const HIR::PathIdentSegment &final_segment,
+			 const Analysis::NodeMapping &mappings,
+			 location_t expr_locus, bool is_qualified_path)
+{
+  TyTy::BaseType *lookup = nullptr;
+  bool ok = ctx->get_tyctx ()->lookup_type (mappings.get_hirid (), &lookup);
+  rust_assert (ok);
+
+  // need to look up the reference for this identifier
+
+  // this can fail because it might be a Constructor for something
+  // in that case the caller should attempt ResolvePathType::Compile
+  NodeId ref_node_id = UNKNOWN_NODEID;
+  if (flag_name_resolution_2_0)
+    {
+      auto &nr_ctx
+	= Resolver2_0::ImmutableNameResolutionContext::get ().resolver ();
+
+      auto resolved = nr_ctx.lookup (mappings.get_nodeid ());
+
+      if (!resolved)
+	return attempt_constructor_expression_lookup (lookup, ctx, mappings,
+						      expr_locus);
+
+      ref_node_id = *resolved;
+    }
+  else
+    {
+      if (!ctx->get_resolver ()->lookup_resolved_name (mappings.get_nodeid (),
+						       &ref_node_id))
+	return attempt_constructor_expression_lookup (lookup, ctx, mappings,
+						      expr_locus);
+    }
+
+  return resolve_with_node_id (final_segment, mappings, expr_locus,
+			       is_qualified_path, ref_node_id);
+}
+
+tree
 HIRCompileBase::query_compile (HirId ref, TyTy::BaseType *lookup,
 			       const HIR::PathIdentSegment &final_segment,
 			       const Analysis::NodeMapping &mappings,
@@ -206,11 +251,9 @@ HIRCompileBase::query_compile (HirId ref, TyTy::BaseType *lookup,
   if (auto resolved_item = ctx->get_mappings ().lookup_hir_item (ref))
     {
       if (!lookup->has_substitutions_defined ())
-	return CompileItem::compile (*resolved_item, ctx, nullptr, true,
-				     expr_locus);
+	return CompileItem::compile (*resolved_item, ctx, nullptr, expr_locus);
       else
-	return CompileItem::compile (*resolved_item, ctx, lookup, true,
-				     expr_locus);
+	return CompileItem::compile (*resolved_item, ctx, lookup, expr_locus);
     }
   else if (auto hir_extern_item
 	   = ctx->get_mappings ().lookup_hir_extern_item (ref))
@@ -218,10 +261,10 @@ HIRCompileBase::query_compile (HirId ref, TyTy::BaseType *lookup,
       HIR::ExternalItem *resolved_extern_item = hir_extern_item->first;
       if (!lookup->has_substitutions_defined ())
 	return CompileExternItem::compile (resolved_extern_item, ctx, nullptr,
-					   true, expr_locus);
+					   expr_locus);
       else
 	return CompileExternItem::compile (resolved_extern_item, ctx, lookup,
-					   true, expr_locus);
+					   expr_locus);
     }
   else
     {
@@ -243,17 +286,14 @@ HIRCompileBase::query_compile (HirId ref, TyTy::BaseType *lookup,
 	{
 	  if (!lookup->has_substitutions_defined ())
 	    return CompileInherentImplItem::Compile (resolved_item->first, ctx,
-						     nullptr, true, expr_locus);
+						     nullptr, expr_locus);
 	  else
 	    return CompileInherentImplItem::Compile (resolved_item->first, ctx,
-						     lookup, true, expr_locus);
+						     lookup, expr_locus);
 	}
-      else
+      else if (auto trait_item
+	       = ctx->get_mappings ().lookup_hir_trait_item (ref))
 	{
-	  // it might be resolved to a trait item
-	  tl::optional<HIR::TraitItem *> trait_item
-	    = ctx->get_mappings ().lookup_hir_trait_item (ref);
-
 	  HIR::Trait *trait = ctx->get_mappings ().lookup_trait_item_mapping (
 	    trait_item.value ()->get_mappings ().get_hirid ());
 
@@ -263,16 +303,41 @@ HIRCompileBase::query_compile (HirId ref, TyTy::BaseType *lookup,
 	    trait->get_mappings ().get_defid (), &trait_ref);
 	  rust_assert (ok);
 
-	  TyTy::BaseType *receiver = nullptr;
-	  ok = ctx->get_tyctx ()->lookup_receiver (mappings.get_hirid (),
-						   &receiver);
-	  rust_assert (ok);
-	  receiver = receiver->destructure ();
+	  if (trait_item.value ()->get_item_kind ()
+	      == HIR::TraitItem::TraitItemKind::CONST)
+	    {
+	      auto &c
+		= *static_cast<HIR::TraitItemConst *> (trait_item.value ());
+	      if (!c.has_expr ())
+		{
+		  rich_location r (line_table, expr_locus);
+		  r.add_range (trait->get_locus ());
+		  r.add_range (c.get_locus ());
+		  rust_error_at (r, "no default expression on trait constant");
+		  return error_mark_node;
+		}
+
+	      return CompileExpr::Compile (c.get_expr (), ctx);
+	    }
+
+	  if (trait_item.value ()->get_item_kind ()
+	      != HIR::TraitItem::TraitItemKind::FUNC)
+	    return error_mark_node;
 
 	  // the type resolver can only resolve type bounds to their trait
 	  // item so its up to us to figure out if this path should resolve
 	  // to an trait-impl-block-item or if it can be defaulted to the
 	  // trait-impl-item's definition
+	  //
+	  // because we know this is resolved to a trait item we can actually
+	  // just grab the Self type parameter here for the receiver to match
+	  // the appropriate impl block
+
+	  rust_assert (lookup->is<TyTy::FnType> ());
+	  auto fn = lookup->as<TyTy::FnType> ();
+	  rust_assert (fn->get_num_type_params () > 0);
+	  auto &self = fn->get_substs ().at (0);
+	  auto receiver = self.get_param_ty ();
 	  auto candidates
 	    = Resolver::PathProbeImplTrait::Probe (receiver, final_segment,
 						   trait_ref);
@@ -307,11 +372,10 @@ HIRCompileBase::query_compile (HirId ref, TyTy::BaseType *lookup,
 
 	      if (!lookup->has_substitutions_defined ())
 		return CompileInherentImplItem::Compile (impl_item, ctx,
-							 nullptr, true,
-							 expr_locus);
+							 nullptr, expr_locus);
 	      else
 		return CompileInherentImplItem::Compile (impl_item, ctx, lookup,
-							 true, expr_locus);
+							 expr_locus);
 	    }
 	}
     }
diff --git a/gcc/rust/backend/rust-compile-resolve-path.h b/gcc/rust/backend/rust-compile-resolve-path.h
index 7654fd9..79bfb86 100644
--- a/gcc/rust/backend/rust-compile-resolve-path.h
+++ b/gcc/rust/backend/rust-compile-resolve-path.h
@@ -20,53 +20,39 @@
 #define RUST_COMPILE_RESOLVE_PATH
 
 #include "rust-compile-base.h"
-#include "rust-hir-visitor.h"
 
 namespace Rust {
 namespace Compile {
 
-class ResolvePathRef : public HIRCompileBase, public HIR::HIRPatternVisitor
+class ResolvePathRef : public HIRCompileBase
 {
 public:
-  static tree Compile (HIR::QualifiedPathInExpression &expr, Context *ctx)
-  {
-    ResolvePathRef resolver (ctx);
-    expr.accept_vis (resolver);
-    return resolver.resolved;
-  }
-
-  static tree Compile (HIR::PathInExpression &expr, Context *ctx)
-  {
-    ResolvePathRef resolver (ctx);
-    expr.accept_vis (resolver);
-    return resolver.resolved;
-  }
-
-  void visit (HIR::PathInExpression &expr) override;
-  void visit (HIR::QualifiedPathInExpression &expr) override;
-
-  // Empty visit for unused Pattern HIR nodes.
-  void visit (HIR::IdentifierPattern &) override {}
-  void visit (HIR::LiteralPattern &) override {}
-  void visit (HIR::RangePattern &) override {}
-  void visit (HIR::ReferencePattern &) override {}
-  void visit (HIR::SlicePattern &) override {}
-  void visit (HIR::AltPattern &) override {}
-  void visit (HIR::StructPattern &) override {}
-  void visit (HIR::TuplePattern &) override {}
-  void visit (HIR::TupleStructPattern &) override {}
-  void visit (HIR::WildcardPattern &) override {}
-
-  ResolvePathRef (Context *ctx)
-    : HIRCompileBase (ctx), resolved (error_mark_node)
-  {}
-
+  static tree Compile (HIR::QualifiedPathInExpression &expr, Context *ctx);
+
+  static tree Compile (HIR::PathInExpression &expr, Context *ctx);
+
+  ResolvePathRef (Context *ctx);
+
+  /**
+   * Generic visitor for both PathInExpression and QualifiedPathInExpression
+   */
+  template <typename T> tree resolve_path_like (T &expr);
+
+  /**
+   * Inner implementation of `resolve` - resolution with an already known NodeId
+   */
+  tree resolve_with_node_id (const HIR::PathIdentSegment &final_segment,
+			     const Analysis::NodeMapping &mappings,
+			     location_t locus, bool is_qualified_path,
+			     NodeId resolved_node_id);
+  /**
+   * Resolve a mappings' NodeId and call into `resolve_with_node_id` which
+   * performs the rest of the path resolution
+   */
   tree resolve (const HIR::PathIdentSegment &final_segment,
 		const Analysis::NodeMapping &mappings, location_t locus,
 		bool is_qualified_path);
 
-  tree resolved;
-
 private:
   tree
   attempt_constructor_expression_lookup (TyTy::BaseType *lookup, Context *ctx,
diff --git a/gcc/rust/backend/rust-compile-type.cc b/gcc/rust/backend/rust-compile-type.cc
index 85e7865..83e5756 100644
--- a/gcc/rust/backend/rust-compile-type.cc
+++ b/gcc/rust/backend/rust-compile-type.cc
@@ -55,7 +55,7 @@ TyTyResolveCompile::compile (Context *ctx, const TyTy::BaseType *ty,
 // see: gcc/c/c-decl.cc:8230-8241
 // https://github.com/Rust-GCC/gccrs/blob/0024bc2f028369b871a65ceb11b2fddfb0f9c3aa/gcc/c/c-decl.c#L8229-L8241
 tree
-TyTyResolveCompile::get_implicit_enumeral_node_type ()
+TyTyResolveCompile::get_implicit_enumeral_node_type (TyTy::BaseType *repr)
 {
   // static tree enum_node = NULL_TREE;
   // if (enum_node == NULL_TREE)
@@ -77,25 +77,26 @@ TyTyResolveCompile::get_implicit_enumeral_node_type ()
   //   }
   // return enum_node;
 
-  static tree enum_node = NULL_TREE;
-  if (enum_node == NULL_TREE)
-    {
-      // equivalent to isize
-      enum_node = Backend::named_type (
-	"enumeral", Backend::integer_type (false, Backend::get_pointer_size ()),
-	BUILTINS_LOCATION);
-    }
-  return enum_node;
+  return compile (ctx, repr);
 }
 
 tree
-TyTyResolveCompile::get_unit_type ()
+TyTyResolveCompile::get_unit_type (Context *ctx)
 {
   static tree unit_type;
   if (unit_type == nullptr)
     {
+      auto cn = ctx->get_mappings ().get_current_crate ();
+      auto &c = ctx->get_mappings ().get_ast_crate (cn);
+      location_t locus = BUILTINS_LOCATION;
+      if (c.items.size () > 0)
+	{
+	  auto &item = c.items[0];
+	  locus = item->get_locus ();
+	}
+
       auto unit_type_node = Backend::struct_type ({});
-      unit_type = Backend::named_type ("()", unit_type_node, BUILTINS_LOCATION);
+      unit_type = Backend::named_type ("()", unit_type_node, locus);
     }
   return unit_type;
 }
@@ -384,8 +385,8 @@ TyTyResolveCompile::visit (const TyTy::ADTType &type)
 	= Backend::named_type ("payload", variants_union, locus);
 
       // create the overall struct
-      tree enumeral_type
-	= TyTyResolveCompile::get_implicit_enumeral_node_type ();
+      tree enumeral_type = TyTyResolveCompile::get_implicit_enumeral_node_type (
+	type.get_repr_options ().repr);
       Backend::typed_identifier discrim (RUST_ENUM_DISR_FIELD_NAME,
 					 enumeral_type, locus);
       Backend::typed_identifier variants_union_field ("payload",
@@ -429,7 +430,7 @@ TyTyResolveCompile::visit (const TyTy::TupleType &type)
 {
   if (type.num_fields () == 0)
     {
-      translated = get_unit_type ();
+      translated = get_unit_type (ctx);
       return;
     }
 
@@ -464,12 +465,24 @@ TyTyResolveCompile::visit (const TyTy::ArrayType &type)
     = TyTyResolveCompile::compile (ctx, type.get_element_type ());
 
   ctx->push_const_context ();
-  tree capacity_expr = CompileExpr::Compile (type.get_capacity_expr (), ctx);
+
+  HIR::Expr &hir_capacity_expr = type.get_capacity_expr ();
+  TyTy::BaseType *capacity_expr_ty = nullptr;
+  bool ok = ctx->get_tyctx ()->lookup_type (
+    hir_capacity_expr.get_mappings ().get_hirid (), &capacity_expr_ty);
+  rust_assert (ok);
+  tree capacity_expr = HIRCompileBase::compile_constant_expr (
+    ctx, hir_capacity_expr.get_mappings ().get_hirid (), capacity_expr_ty,
+    capacity_expr_ty, Resolver::CanonicalPath::create_empty (),
+    hir_capacity_expr, type.get_locus (), hir_capacity_expr.get_locus ());
+
   ctx->pop_const_context ();
 
   tree folded_capacity_expr = fold_expr (capacity_expr);
 
   translated = Backend::array_type (element_type, folded_capacity_expr);
+  if (translated != error_mark_node)
+    translated = ctx->insert_compiled_type (translated);
 }
 
 void
@@ -722,7 +735,7 @@ TyTyResolveCompile::visit (const TyTy::StrType &type)
 void
 TyTyResolveCompile::visit (const TyTy::NeverType &)
 {
-  translated = get_unit_type ();
+  translated = get_unit_type (ctx);
 }
 
 void
@@ -739,6 +752,12 @@ TyTyResolveCompile::visit (const TyTy::DynamicObjectType &type)
 				    type.get_ident ().locus);
 }
 
+void
+TyTyResolveCompile::visit (const TyTy::OpaqueType &type)
+{
+  translated = error_mark_node;
+}
+
 tree
 TyTyResolveCompile::create_dyn_obj_record (const TyTy::DynamicObjectType &type)
 {
diff --git a/gcc/rust/backend/rust-compile-type.h b/gcc/rust/backend/rust-compile-type.h
index e01ca43..7ebc4a6 100644
--- a/gcc/rust/backend/rust-compile-type.h
+++ b/gcc/rust/backend/rust-compile-type.h
@@ -30,9 +30,7 @@ public:
   static tree compile (Context *ctx, const TyTy::BaseType *ty,
 		       bool trait_object_mode = false);
 
-  static tree get_implicit_enumeral_node_type ();
-
-  static tree get_unit_type ();
+  static tree get_unit_type (Context *ctx);
 
   void visit (const TyTy::InferType &) override;
   void visit (const TyTy::ADTType &) override;
@@ -58,6 +56,7 @@ public:
   void visit (const TyTy::ProjectionType &) override;
   void visit (const TyTy::DynamicObjectType &) override;
   void visit (const TyTy::ClosureType &) override;
+  void visit (const TyTy::OpaqueType &) override;
 
 public:
   static hashval_t type_hasher (tree type);
@@ -66,6 +65,7 @@ protected:
   tree create_slice_type_record (const TyTy::SliceType &type);
   tree create_str_type_record (const TyTy::StrType &type);
   tree create_dyn_obj_record (const TyTy::DynamicObjectType &type);
+  tree get_implicit_enumeral_node_type (TyTy::BaseType *repr);
 
 private:
   TyTyResolveCompile (Context *ctx, bool trait_object_mode);
diff --git a/gcc/rust/backend/rust-compile.cc b/gcc/rust/backend/rust-compile.cc
index 7b00066..dbd8515 100644
--- a/gcc/rust/backend/rust-compile.cc
+++ b/gcc/rust/backend/rust-compile.cc
@@ -338,7 +338,7 @@ HIRCompileBase::compute_address_for_trait_item (
 	}
 
       return CompileInherentImplItem::Compile (associated_function, ctx,
-					       lookup_fntype, true, locus);
+					       lookup_fntype, locus);
     }
 
   // we can only compile trait-items with a body
diff --git a/gcc/rust/backend/rust-constexpr.cc b/gcc/rust/backend/rust-constexpr.cc
index 2f2bbbd..dc2d6b1 100644
--- a/gcc/rust/backend/rust-constexpr.cc
+++ b/gcc/rust/backend/rust-constexpr.cc
@@ -2697,10 +2697,8 @@ eval_store_expression (const constexpr_ctx *ctx, tree t, bool lval,
 	      }
 	    if (TREE_CODE (probe) == ARRAY_REF)
 	      {
-		// TODO
-		rust_unreachable ();
-		// elt = eval_and_check_array_index (ctx, probe, false,
-		// 				  non_constant_p, overflow_p);
+		elt = eval_and_check_array_index (ctx, probe, false,
+						  non_constant_p, overflow_p);
 		if (*non_constant_p)
 		  return t;
 	      }