Canonicalize types based on hashing than HirIds and TyTy equality

When we compile types for GCC we need to make sure we canonicalize them,
this means that for any user defined type such as Structs or Tuples we want
all expressions or declarations to use the same tree. Even if we have
duplicate tree's we can end up confusing the middle-end and lose out on
optimizations as we will be using view_convert_exprs to maintain the
consistancy which will marshall between the objects unnessecarily.

The old method for doing this kept mappings of HirIds which was fine for
simple cases but when generics are involved new Id's are generated so this
meant we ended up having a vector of pairs {TyTy::BaseType, tree} and we
did a liner search to find the relevant TyTy::BaseType that we equaled to.

This was not only slow but did not handle the cases for generic associated
types or nested generics. So we needed a more general faster implementation
therefore hashing. This patch takes the gcc/tree.h type_hash_canon code
and adds in hashing for RECORD and UNION types. This means we will generate
a duplicate type then hash it and look for an existing type.

This patch will also allow us to fix how we implement monomorphization of
functions by nesting the hashes behind DefId's.

12 files changed, 291 insertions, 402 deletions

diff --git a/gcc/rust/Make-lang.in b/gcc/rust/Make-lang.in
index 11994740..5d97a16 100644
--- a/gcc/rust/Make-lang.in
+++ b/gcc/rust/Make-lang.in
@@ -130,6 +130,7 @@ GRS_OBJS = \
     rust/rust-constexpr.o \
     rust/rust-compile-base.o \
     rust/rust-tree.o \
+    rust/rust-compile-context.o \
     $(END)
 # removed object files from here
 
diff --git a/gcc/rust/backend/rust-compile-block.h b/gcc/rust/backend/rust-compile-block.h
index 4a3c6f5..0595ee9 100644
--- a/gcc/rust/backend/rust-compile-block.h
+++ b/gcc/rust/backend/rust-compile-block.h
@@ -20,7 +20,6 @@
 #define RUST_COMPILE_BLOCK
 
 #include "rust-compile-base.h"
-#include "rust-compile-tyty.h"
 
 namespace Rust {
 namespace Compile {
diff --git a/gcc/rust/backend/rust-compile-context.cc b/gcc/rust/backend/rust-compile-context.cc
new file mode 100644
index 0000000..463ac27
--- /dev/null
+++ b/gcc/rust/backend/rust-compile-context.cc
@@ -0,0 +1,139 @@
+// Copyright (C) 2020-2022 Free Software Foundation, Inc.
+
+// This file is part of GCC.
+
+// GCC is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation; either version 3, or (at your option) any later
+// version.
+
+// GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+// for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with GCC; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include "rust-compile-context.h"
+#include "rust-compile-type.h"
+
+namespace Rust {
+namespace Compile {
+
+Context::Context (::Backend *backend)
+  : backend (backend), resolver (Resolver::Resolver::get ()),
+    tyctx (Resolver::TypeCheckContext::get ()),
+    mappings (Analysis::Mappings::get ()), mangler (Mangler ())
+{
+  setup_builtins ();
+}
+
+void
+Context::setup_builtins ()
+{
+  auto builtins = resolver->get_builtin_types ();
+  for (auto it = builtins.begin (); it != builtins.end (); it++)
+    {
+      HirId ref;
+      bool ok = tyctx->lookup_type_by_node_id ((*it)->get_node_id (), &ref);
+      rust_assert (ok);
+
+      TyTy::BaseType *lookup;
+      ok = tyctx->lookup_type (ref, &lookup);
+      rust_assert (ok);
+
+      TyTyResolveCompile::compile (this, lookup);
+    }
+}
+
+hashval_t
+Context::type_hasher (tree type)
+{
+  inchash::hash hstate;
+
+  hstate.add_int (TREE_CODE (type));
+
+  if (TYPE_NAME (type))
+    {
+      hashval_t record_name_hash
+	= IDENTIFIER_HASH_VALUE (DECL_NAME (TYPE_NAME (type)));
+      hstate.add_object (record_name_hash);
+    }
+
+  if (TREE_TYPE (type))
+    hstate.add_object (TYPE_HASH (TREE_TYPE (type)));
+
+  for (tree t = TYPE_ATTRIBUTES (type); t; t = TREE_CHAIN (t))
+    /* Just the identifier is adequate to distinguish.  */
+    hstate.add_object (IDENTIFIER_HASH_VALUE (TREE_PURPOSE (t)));
+
+  switch (TREE_CODE (type))
+    {
+    case METHOD_TYPE:
+      hstate.add_object (TYPE_HASH (TYPE_METHOD_BASETYPE (type)));
+      /* FALLTHROUGH. */
+    case FUNCTION_TYPE:
+      for (tree t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
+	if (TREE_VALUE (t) != error_mark_node)
+	  hstate.add_object (TYPE_HASH (TREE_VALUE (t)));
+      break;
+
+    case OFFSET_TYPE:
+      hstate.add_object (TYPE_HASH (TYPE_OFFSET_BASETYPE (type)));
+      break;
+
+      case ARRAY_TYPE: {
+	if (TYPE_DOMAIN (type))
+	  hstate.add_object (TYPE_HASH (TYPE_DOMAIN (type)));
+	if (!AGGREGATE_TYPE_P (TREE_TYPE (type)))
+	  {
+	    unsigned typeless = TYPE_TYPELESS_STORAGE (type);
+	    hstate.add_object (typeless);
+	  }
+      }
+      break;
+
+      case INTEGER_TYPE: {
+	tree t = TYPE_MAX_VALUE (type);
+	if (!t)
+	  t = TYPE_MIN_VALUE (type);
+	for (int i = 0; i < TREE_INT_CST_NUNITS (t); i++)
+	  hstate.add_object (TREE_INT_CST_ELT (t, i));
+	break;
+      }
+
+    case REAL_TYPE:
+      case FIXED_POINT_TYPE: {
+	unsigned prec = TYPE_PRECISION (type);
+	hstate.add_object (prec);
+	break;
+      }
+
+    case VECTOR_TYPE:
+      hstate.add_poly_int (TYPE_VECTOR_SUBPARTS (type));
+      break;
+
+    case RECORD_TYPE:
+    case UNION_TYPE:
+      case QUAL_UNION_TYPE: {
+	for (tree t = TYPE_FIELDS (type); t; t = TREE_CHAIN (t))
+	  {
+	    hashval_t name_hash = IDENTIFIER_HASH_VALUE (DECL_NAME (t));
+	    hashval_t type_hash = type_hasher (TREE_TYPE (t));
+	    hstate.add_object (name_hash);
+	    hstate.add_object (type_hash);
+	  }
+      }
+      break;
+
+    default:
+      break;
+    }
+
+  return hstate.end ();
+}
+
+} // namespace Compile
+} // namespace Rust
diff --git a/gcc/rust/backend/rust-compile-context.h b/gcc/rust/backend/rust-compile-context.h
index d17034b..8378554 100644
--- a/gcc/rust/backend/rust-compile-context.h
+++ b/gcc/rust/backend/rust-compile-context.h
@@ -24,7 +24,6 @@
 #include "rust-name-resolver.h"
 #include "rust-hir-type-check.h"
 #include "rust-backend.h"
-#include "rust-compile-tyty.h"
 #include "rust-hir-full.h"
 #include "rust-mangle.h"
 #include "rust-tree.h"
@@ -41,50 +40,14 @@ struct fncontext
 class Context
 {
 public:
-  Context (::Backend *backend)
-    : backend (backend), resolver (Resolver::Resolver::get ()),
-      tyctx (Resolver::TypeCheckContext::get ()),
-      mappings (Analysis::Mappings::get ()), mangler (Mangler ())
-  {
-    // insert the builtins
-    auto builtins = resolver->get_builtin_types ();
-    for (auto it = builtins.begin (); it != builtins.end (); it++)
-      {
-	HirId ref;
-	bool ok = tyctx->lookup_type_by_node_id ((*it)->get_node_id (), &ref);
-	rust_assert (ok);
-
-	TyTy::BaseType *lookup;
-	ok = tyctx->lookup_type (ref, &lookup);
-	rust_assert (ok);
+  Context (::Backend *backend);
 
-	tree compiled = TyTyCompile::compile (backend, lookup);
-	compiled_type_map.insert (std::pair<HirId, tree> (ref, compiled));
-	builtin_range.insert (ref);
-      }
-  }
+  void setup_builtins ();
 
-  bool lookup_compiled_types (HirId id, tree *type,
-			      const TyTy::BaseType *ref = nullptr)
+  bool lookup_compiled_types (tree t, tree *type)
   {
-    if (ref != nullptr)
-      {
-	for (auto it = mono.begin (); it != mono.end (); it++)
-	  {
-	    std::pair<HirId, tree> &val = it->second;
-	    const TyTy::BaseType *r = it->first;
-
-	    if (ref->is_equal (*r))
-	      {
-		*type = val.second;
-
-		return true;
-	      }
-	  }
-	return false;
-      }
-
-    auto it = compiled_type_map.find (id);
+    hashval_t h = type_hasher (t);
+    auto it = compiled_type_map.find (h);
     if (it == compiled_type_map.end ())
       return false;
 
@@ -92,16 +55,16 @@ public:
     return true;
   }
 
-  void insert_compiled_type (HirId id, tree type,
-			     const TyTy::BaseType *ref = nullptr)
+  tree insert_compiled_type (tree type)
   {
-    rust_assert (builtin_range.find (id) == builtin_range.end ());
-    compiled_type_map.insert (std::pair<HirId, tree> (id, type));
-    if (ref != nullptr)
-      {
-	std::pair<HirId, tree> elem (id, type);
-	mono[ref] = std::move (elem);
-      }
+    hashval_t h = type_hasher (type);
+    auto it = compiled_type_map.find (h);
+    if (it != compiled_type_map.end ())
+      return it->second;
+
+    compiled_type_map.insert ({h, type});
+    push_type (type);
+    return type;
   }
 
   ::Backend *get_backend () { return backend; }
@@ -328,18 +291,19 @@ public:
   std::vector<tree> &get_const_decls () { return const_decls; }
   std::vector<tree> &get_func_decls () { return func_decls; }
 
+  static hashval_t type_hasher (tree type);
+
 private:
   ::Backend *backend;
   Resolver::Resolver *resolver;
   Resolver::TypeCheckContext *tyctx;
   Analysis::Mappings *mappings;
-  std::set<HirId> builtin_range;
   Mangler mangler;
 
   // state
   std::vector<fncontext> fn_stack;
   std::map<HirId, ::Bvariable *> compiled_var_decls;
-  std::map<HirId, tree> compiled_type_map;
+  std::map<hashval_t, tree> compiled_type_map;
   std::map<HirId, tree> compiled_fn_map;
   std::map<HirId, tree> compiled_consts;
   std::map<HirId, tree> compiled_labels;
@@ -347,7 +311,6 @@ private:
   std::vector<tree> scope_stack;
   std::vector<::Bvariable *> loop_value_stack;
   std::vector<tree> loop_begin_labels;
-  std::map<const TyTy::BaseType *, std::pair<HirId, tree>> mono;
   std::map<DefId, std::vector<std::pair<const TyTy::BaseType *, tree>>>
     mono_fns;
   std::map<HirId, tree> implicit_pattern_bindings;
diff --git a/gcc/rust/backend/rust-compile-expr.h b/gcc/rust/backend/rust-compile-expr.h
index b05b129..655ffbb 100644
--- a/gcc/rust/backend/rust-compile-expr.h
+++ b/gcc/rust/backend/rust-compile-expr.h
@@ -20,7 +20,6 @@
 #define RUST_COMPILE_EXPR
 
 #include "rust-compile-base.h"
-#include "rust-compile-tyty.h"
 #include "rust-compile-resolve-path.h"
 #include "rust-compile-block.h"
 #include "rust-compile-struct-field-expr.h"
diff --git a/gcc/rust/backend/rust-compile-resolve-path.h b/gcc/rust/backend/rust-compile-resolve-path.h
index 37dec0b..f0360bd 100644
--- a/gcc/rust/backend/rust-compile-resolve-path.h
+++ b/gcc/rust/backend/rust-compile-resolve-path.h
@@ -20,7 +20,6 @@
 #define RUST_COMPILE_RESOLVE_PATH
 
 #include "rust-compile-base.h"
-#include "rust-compile-tyty.h"
 
 namespace Rust {
 namespace Compile {
diff --git a/gcc/rust/backend/rust-compile-stmt.h b/gcc/rust/backend/rust-compile-stmt.h
index ad34253..5f17777 100644
--- a/gcc/rust/backend/rust-compile-stmt.h
+++ b/gcc/rust/backend/rust-compile-stmt.h
@@ -20,7 +20,6 @@
 #define RUST_COMPILE_STMT
 
 #include "rust-compile-base.h"
-#include "rust-compile-tyty.h"
 #include "rust-compile-expr.h"
 
 namespace Rust {
diff --git a/gcc/rust/backend/rust-compile-struct-field-expr.h b/gcc/rust/backend/rust-compile-struct-field-expr.h
index c5e986e..6968c06 100644
--- a/gcc/rust/backend/rust-compile-struct-field-expr.h
+++ b/gcc/rust/backend/rust-compile-struct-field-expr.h
@@ -20,7 +20,6 @@
 #define RUST_COMPILE_STRUCT_FIELD_EXPR
 
 #include "rust-compile-base.h"
-#include "rust-compile-tyty.h"
 
 namespace Rust {
 namespace Compile {
diff --git a/gcc/rust/backend/rust-compile-type.cc b/gcc/rust/backend/rust-compile-type.cc
index 03c2ca4..3874027 100644
--- a/gcc/rust/backend/rust-compile-type.cc
+++ b/gcc/rust/backend/rust-compile-type.cc
@@ -21,11 +21,27 @@
 #include "rust-constexpr.h"
 
 #include "tree.h"
-#include "print-tree.h"
 
 namespace Rust {
 namespace Compile {
 
+tree
+TyTyResolveCompile::compile (Context *ctx, const TyTy::BaseType *ty,
+			     bool trait_object_mode)
+{
+  TyTyResolveCompile compiler (ctx, trait_object_mode);
+  ty->accept_vis (compiler);
+
+  if (compiler.translated != error_mark_node
+      && TYPE_NAME (compiler.translated) != NULL)
+    {
+      // canonicalize the type
+      compiler.translated = ctx->insert_compiled_type (compiler.translated);
+    }
+
+  return compiler.translated;
+}
+
 static const std::string RUST_ENUM_DISR_FIELD_NAME = "RUST$ENUM$DISR";
 
 // see: gcc/c/c-decl.cc:8230-8241
@@ -96,6 +112,7 @@ TyTyResolveCompile::visit (const TyTy::PlaceholderType &type)
 void
 TyTyResolveCompile::visit (const TyTy::ParamType &param)
 {
+  // FIXME make this reuse the same machinery from constexpr code
   recursion_count++;
   rust_assert (recursion_count < kDefaultRecusionLimit);
 
@@ -163,9 +180,6 @@ TyTyResolveCompile::visit (const TyTy::FnPtr &type)
 void
 TyTyResolveCompile::visit (const TyTy::ADTType &type)
 {
-  if (ctx->lookup_compiled_types (type.get_ty_ref (), &translated, &type))
-    return;
-
   tree type_record = error_mark_node;
   if (!type.is_enum ())
     {
@@ -302,14 +316,8 @@ TyTyResolveCompile::visit (const TyTy::ADTType &type)
 
   std::string named_struct_str
     = type.get_ident ().path.get () + type.subst_as_string ();
-  tree named_struct
-    = ctx->get_backend ()->named_type (named_struct_str, type_record,
-				       type.get_ident ().locus);
-
-  ctx->push_type (named_struct);
-  translated = named_struct;
-
-  ctx->insert_compiled_type (type.get_ty_ref (), named_struct, &type);
+  translated = ctx->get_backend ()->named_type (named_struct_str, type_record,
+						type.get_ident ().locus);
 }
 
 void
@@ -321,10 +329,6 @@ TyTyResolveCompile::visit (const TyTy::TupleType &type)
       return;
     }
 
-  bool ok = ctx->lookup_compiled_types (type.get_ty_ref (), &translated, &type);
-  if (ok)
-    return;
-
   // create implicit struct
   std::vector<Backend::typed_identifier> fields;
   for (size_t i = 0; i < type.num_fields (); i++)
@@ -345,13 +349,9 @@ TyTyResolveCompile::visit (const TyTy::TupleType &type)
     }
 
   tree struct_type_record = ctx->get_backend ()->struct_type (fields);
-  tree named_struct
+  translated
     = ctx->get_backend ()->named_type (type.as_string (), struct_type_record,
 				       type.get_ident ().locus);
-
-  ctx->push_type (named_struct);
-  ctx->insert_compiled_type (type.get_ty_ref (), named_struct, &type);
-  translated = named_struct;
 }
 
 void
@@ -369,9 +369,6 @@ TyTyResolveCompile::visit (const TyTy::ArrayType &type)
 void
 TyTyResolveCompile::visit (const TyTy::SliceType &type)
 {
-  if (ctx->lookup_compiled_types (type.get_ty_ref (), &translated, &type))
-    return;
-
   std::vector<Backend::typed_identifier> fields;
 
   tree element_type
@@ -393,77 +390,141 @@ TyTyResolveCompile::visit (const TyTy::SliceType &type)
 
   std::string named_struct_str
     = std::string ("[") + type.get_element_type ()->get_name () + "]";
-  tree named_struct
-    = ctx->get_backend ()->named_type (named_struct_str, type_record,
-				       type.get_ident ().locus);
-
-  ctx->push_type (named_struct);
-  translated = named_struct;
-
-  ctx->insert_compiled_type (type.get_ty_ref (), named_struct, &type);
+  translated = ctx->get_backend ()->named_type (named_struct_str, type_record,
+						type.get_ident ().locus);
 }
 
 void
 TyTyResolveCompile::visit (const TyTy::BoolType &type)
 {
-  tree compiled_type = nullptr;
-  bool ok = ctx->lookup_compiled_types (type.get_ty_ref (), &compiled_type);
-  rust_assert (ok);
-  translated = compiled_type;
+  translated
+    = ctx->get_backend ()->named_type ("bool",
+				       ctx->get_backend ()->bool_type (),
+				       Linemap::predeclared_location ());
 }
 
 void
 TyTyResolveCompile::visit (const TyTy::IntType &type)
 {
-  tree compiled_type = nullptr;
-  bool ok = ctx->lookup_compiled_types (type.get_ty_ref (), &compiled_type);
-  rust_assert (ok);
-  translated = compiled_type;
+  switch (type.get_int_kind ())
+    {
+    case TyTy::IntType::I8:
+      translated = ctx->get_backend ()->named_type (
+	"i8", ctx->get_backend ()->integer_type (false, 8),
+	Linemap::predeclared_location ());
+      return;
+
+    case TyTy::IntType::I16:
+      translated = ctx->get_backend ()->named_type (
+	"i16", ctx->get_backend ()->integer_type (false, 16),
+	Linemap::predeclared_location ());
+      return;
+
+    case TyTy::IntType::I32:
+      translated = ctx->get_backend ()->named_type (
+	"i32", ctx->get_backend ()->integer_type (false, 32),
+	Linemap::predeclared_location ());
+      return;
+
+    case TyTy::IntType::I64:
+      translated = ctx->get_backend ()->named_type (
+	"i64", ctx->get_backend ()->integer_type (false, 64),
+	Linemap::predeclared_location ());
+      return;
+
+    case TyTy::IntType::I128:
+      translated = ctx->get_backend ()->named_type (
+	"i128", ctx->get_backend ()->integer_type (false, 128),
+	Linemap::predeclared_location ());
+      return;
+    }
 }
 
 void
 TyTyResolveCompile::visit (const TyTy::UintType &type)
 {
-  tree compiled_type = nullptr;
-  bool ok = ctx->lookup_compiled_types (type.get_ty_ref (), &compiled_type);
-  rust_assert (ok);
-  translated = compiled_type;
+  switch (type.get_uint_kind ())
+    {
+    case TyTy::UintType::U8:
+      translated = ctx->get_backend ()->named_type (
+	"u8", ctx->get_backend ()->integer_type (true, 8),
+	Linemap::predeclared_location ());
+      return;
+
+    case TyTy::UintType::U16:
+      translated = ctx->get_backend ()->named_type (
+	"u16", ctx->get_backend ()->integer_type (true, 16),
+	Linemap::predeclared_location ());
+      return;
+
+    case TyTy::UintType::U32:
+      translated = ctx->get_backend ()->named_type (
+	"u32", ctx->get_backend ()->integer_type (true, 32),
+	Linemap::predeclared_location ());
+      return;
+
+    case TyTy::UintType::U64:
+      translated = ctx->get_backend ()->named_type (
+	"u64", ctx->get_backend ()->integer_type (true, 64),
+	Linemap::predeclared_location ());
+      return;
+
+    case TyTy::UintType::U128:
+      translated = ctx->get_backend ()->named_type (
+	"u128", ctx->get_backend ()->integer_type (true, 128),
+	Linemap::predeclared_location ());
+      return;
+    }
 }
 
 void
 TyTyResolveCompile::visit (const TyTy::FloatType &type)
 {
-  tree compiled_type = nullptr;
-  bool ok = ctx->lookup_compiled_types (type.get_ty_ref (), &compiled_type);
-  rust_assert (ok);
-  translated = compiled_type;
+  switch (type.get_float_kind ())
+    {
+    case TyTy::FloatType::F32:
+      translated
+	= ctx->get_backend ()->named_type ("f32",
+					   ctx->get_backend ()->float_type (32),
+					   Linemap::predeclared_location ());
+      return;
+
+    case TyTy::FloatType::F64:
+      translated
+	= ctx->get_backend ()->named_type ("f64",
+					   ctx->get_backend ()->float_type (64),
+					   Linemap::predeclared_location ());
+      return;
+    }
 }
 
 void
 TyTyResolveCompile::visit (const TyTy::USizeType &type)
 {
-  tree compiled_type = nullptr;
-  bool ok = ctx->lookup_compiled_types (type.get_ty_ref (), &compiled_type);
-  rust_assert (ok);
-  translated = compiled_type;
+  translated = ctx->get_backend ()->named_type (
+    "usize",
+    ctx->get_backend ()->integer_type (
+      true, ctx->get_backend ()->get_pointer_size ()),
+    Linemap::predeclared_location ());
 }
 
 void
 TyTyResolveCompile::visit (const TyTy::ISizeType &type)
 {
-  tree compiled_type = nullptr;
-  bool ok = ctx->lookup_compiled_types (type.get_ty_ref (), &compiled_type);
-  rust_assert (ok);
-  translated = compiled_type;
+  translated = ctx->get_backend ()->named_type (
+    "isize",
+    ctx->get_backend ()->integer_type (
+      false, ctx->get_backend ()->get_pointer_size ()),
+    Linemap::predeclared_location ());
 }
 
 void
 TyTyResolveCompile::visit (const TyTy::CharType &type)
 {
-  tree compiled_type = nullptr;
-  bool ok = ctx->lookup_compiled_types (type.get_ty_ref (), &compiled_type);
-  rust_assert (ok);
-  translated = compiled_type;
+  translated
+    = ctx->get_backend ()->named_type ("char",
+				       ctx->get_backend ()->wchar_type (),
+				       Linemap::predeclared_location ());
 }
 
 void
@@ -501,10 +562,10 @@ TyTyResolveCompile::visit (const TyTy::PointerType &type)
 void
 TyTyResolveCompile::visit (const TyTy::StrType &type)
 {
-  tree compiled_type = nullptr;
-  bool ok = ctx->lookup_compiled_types (type.get_ty_ref (), &compiled_type);
-  rust_assert (ok);
-  translated = compiled_type;
+  tree raw_str = ctx->get_backend ()->raw_str_type ();
+  translated
+    = ctx->get_backend ()->named_type ("str", raw_str,
+				       Linemap::predeclared_location ());
 }
 
 void
@@ -523,9 +584,6 @@ TyTyResolveCompile::visit (const TyTy::DynamicObjectType &type)
       return;
     }
 
-  if (ctx->lookup_compiled_types (type.get_ty_ref (), &translated, &type))
-    return;
-
   // create implicit struct
   auto items = type.get_object_items ();
   std::vector<Backend::typed_identifier> fields;
@@ -547,14 +605,8 @@ TyTyResolveCompile::visit (const TyTy::DynamicObjectType &type)
   fields.push_back (std::move (vtf));
 
   tree type_record = ctx->get_backend ()->struct_type (fields);
-  tree named_struct
-    = ctx->get_backend ()->named_type (type.get_name (), type_record,
-				       type.get_ident ().locus);
-
-  ctx->push_type (named_struct);
-  translated = named_struct;
-
-  ctx->insert_compiled_type (type.get_ty_ref (), named_struct, &type);
+  translated = ctx->get_backend ()->named_type (type.get_name (), type_record,
+						type.get_ident ().locus);
 }
 
 } // namespace Compile
diff --git a/gcc/rust/backend/rust-compile-type.h b/gcc/rust/backend/rust-compile-type.h
index 4f9c403..3e1f903 100644
--- a/gcc/rust/backend/rust-compile-type.h
+++ b/gcc/rust/backend/rust-compile-type.h
@@ -28,12 +28,7 @@ class TyTyResolveCompile : public TyTy::TyConstVisitor
 {
 public:
   static tree compile (Context *ctx, const TyTy::BaseType *ty,
-		       bool trait_object_mode = false)
-  {
-    TyTyResolveCompile compiler (ctx, trait_object_mode);
-    ty->accept_vis (compiler);
-    return compiler.translated;
-  }
+		       bool trait_object_mode = false);
 
   static tree get_implicit_enumeral_node_type (Context *ctx);
 
@@ -62,6 +57,9 @@ public:
   void visit (const TyTy::DynamicObjectType &) override;
   void visit (const TyTy::ClosureType &) override;
 
+public:
+  static hashval_t type_hasher (tree type);
+
 private:
   TyTyResolveCompile (Context *ctx, bool trait_object_mode)
     : ctx (ctx), trait_object_mode (trait_object_mode),
@@ -72,8 +70,8 @@ private:
   bool trait_object_mode;
   tree translated;
 
+  // FIXME this needs to be derived from the gcc config option
   size_t recursion_count;
-
   static const size_t kDefaultRecusionLimit = 5;
 };
 
diff --git a/gcc/rust/backend/rust-compile-tyty.h b/gcc/rust/backend/rust-compile-tyty.h
deleted file mode 100644
index 52ad2f9..0000000
--- a/gcc/rust/backend/rust-compile-tyty.h
+++ /dev/null
@@ -1,260 +0,0 @@
-// Copyright (C) 2020-2022 Free Software Foundation, Inc.
-
-// This file is part of GCC.
-
-// GCC is free software; you can redistribute it and/or modify it under
-// the terms of the GNU General Public License as published by the Free
-// Software Foundation; either version 3, or (at your option) any later
-// version.
-
-// GCC is distributed in the hope that it will be useful, but WITHOUT ANY
-// WARRANTY; without even the implied warranty of MERCHANTABILITY or
-// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-// for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with GCC; see the file COPYING3.  If not see
-// <http://www.gnu.org/licenses/>.
-
-#ifndef RUST_COMPILE_TYTY
-#define RUST_COMPILE_TYTY
-
-#include "rust-system.h"
-#include "rust-location.h"
-#include "rust-diagnostics.h"
-#include "rust-backend.h"
-#include "rust-tyty.h"
-#include "rust-tyty-visitor.h"
-#include "rust-hir-map.h"
-#include "rust-hir-full.h"
-
-namespace Rust {
-namespace Compile {
-
-class TyTyCompile : public TyTy::TyVisitor
-{
-public:
-  static tree compile (::Backend *backend, TyTy::BaseType *ty)
-  {
-    TyTyCompile compiler (backend);
-    ty->accept_vis (compiler);
-    rust_assert (compiler.translated != nullptr);
-    return compiler.translated;
-  }
-
-  void visit (TyTy::ErrorType &) override { gcc_unreachable (); }
-
-  void visit (TyTy::InferType &) override { gcc_unreachable (); }
-
-  void visit (TyTy::ADTType &) override { gcc_unreachable (); }
-
-  void visit (TyTy::PlaceholderType &) override { gcc_unreachable (); }
-
-  void visit (TyTy::ProjectionType &) override { gcc_unreachable (); }
-
-  void visit (TyTy::TupleType &type) override
-  {
-    // this interface is only for unit-type the -type interface takes into
-    // account the context
-    rust_assert (type.num_fields () == 0);
-    translated = backend->unit_type ();
-  }
-
-  void visit (TyTy::ArrayType &) override { gcc_unreachable (); }
-
-  void visit (TyTy::SliceType &) override { gcc_unreachable (); }
-
-  void visit (TyTy::ReferenceType &) override { gcc_unreachable (); }
-
-  void visit (TyTy::PointerType &) override { gcc_unreachable (); }
-
-  void visit (TyTy::ParamType &) override { gcc_unreachable (); }
-
-  void visit (TyTy::FnPtr &) override { gcc_unreachable (); }
-
-  void visit (TyTy::FnType &type) override
-  {
-    Backend::typed_identifier receiver;
-    std::vector<Backend::typed_identifier> parameters;
-    std::vector<Backend::typed_identifier> results;
-
-    if (!type.get_return_type ()->is_unit ())
-      {
-	auto hir_type = type.get_return_type ();
-	auto ret = TyTyCompile::compile (backend, hir_type);
-	results.push_back (Backend::typed_identifier (
-	  "_", ret, mappings->lookup_location (hir_type->get_ref ())));
-      }
-
-    for (auto &params : type.get_params ())
-      {
-	auto param_pattern = params.first;
-	auto param_tyty = params.second;
-	auto compiled_param_type = TyTyCompile::compile (backend, param_tyty);
-
-	auto compiled_param = Backend::typed_identifier (
-	  param_pattern->as_string (), compiled_param_type,
-	  mappings->lookup_location (param_tyty->get_ref ()));
-
-	parameters.push_back (compiled_param);
-      }
-
-    if (!type.is_varadic ())
-      translated
-	= backend->function_type (receiver, parameters, results, NULL,
-				  mappings->lookup_location (type.get_ref ()));
-    else
-      translated
-	= backend->function_type_varadic (receiver, parameters, results, NULL,
-					  mappings->lookup_location (
-					    type.get_ref ()));
-  }
-
-  void visit (TyTy::BoolType &) override
-  {
-    translated = backend->named_type ("bool", backend->bool_type (),
-				      Linemap::predeclared_location ());
-  }
-
-  void visit (TyTy::IntType &type) override
-  {
-    switch (type.get_int_kind ())
-      {
-      case TyTy::IntType::I8:
-	translated
-	  = backend->named_type ("i8", backend->integer_type (false, 8),
-				 Linemap::predeclared_location ());
-	return;
-
-      case TyTy::IntType::I16:
-	translated
-	  = backend->named_type ("i16", backend->integer_type (false, 16),
-				 Linemap::predeclared_location ());
-	return;
-
-      case TyTy::IntType::I32:
-	translated
-	  = backend->named_type ("i32", backend->integer_type (false, 32),
-				 Linemap::predeclared_location ());
-	return;
-
-      case TyTy::IntType::I64:
-	translated
-	  = backend->named_type ("i64", backend->integer_type (false, 64),
-				 Linemap::predeclared_location ());
-	return;
-
-      case TyTy::IntType::I128:
-	translated
-	  = backend->named_type ("i128", backend->integer_type (false, 128),
-				 Linemap::predeclared_location ());
-	return;
-      }
-    gcc_unreachable ();
-  }
-
-  void visit (TyTy::UintType &type) override
-  {
-    switch (type.get_uint_kind ())
-      {
-      case TyTy::UintType::U8:
-	translated = backend->named_type ("u8", backend->integer_type (true, 8),
-					  Linemap::predeclared_location ());
-	return;
-
-      case TyTy::UintType::U16:
-	translated
-	  = backend->named_type ("u16", backend->integer_type (true, 16),
-				 Linemap::predeclared_location ());
-	return;
-
-      case TyTy::UintType::U32:
-	translated
-	  = backend->named_type ("u32", backend->integer_type (true, 32),
-				 Linemap::predeclared_location ());
-	return;
-
-      case TyTy::UintType::U64:
-	translated
-	  = backend->named_type ("u64", backend->integer_type (true, 64),
-				 Linemap::predeclared_location ());
-	return;
-
-      case TyTy::UintType::U128:
-	translated
-	  = backend->named_type ("u128", backend->integer_type (true, 128),
-				 Linemap::predeclared_location ());
-	return;
-      }
-    gcc_unreachable ();
-  }
-
-  void visit (TyTy::FloatType &type) override
-  {
-    switch (type.get_float_kind ())
-      {
-      case TyTy::FloatType::F32:
-	translated = backend->named_type ("f32", backend->float_type (32),
-					  Linemap::predeclared_location ());
-	return;
-
-      case TyTy::FloatType::F64:
-	translated = backend->named_type ("f64", backend->float_type (64),
-					  Linemap::predeclared_location ());
-	return;
-      }
-
-    gcc_unreachable ();
-  }
-
-  void visit (TyTy::USizeType &) override
-  {
-    translated = backend->named_type (
-      "usize", backend->integer_type (true, backend->get_pointer_size ()),
-      Linemap::predeclared_location ());
-  }
-
-  void visit (TyTy::ISizeType &) override
-  {
-    translated = backend->named_type (
-      "isize", backend->integer_type (false, backend->get_pointer_size ()),
-      Linemap::predeclared_location ());
-  }
-
-  void visit (TyTy::CharType &) override
-  {
-    translated = backend->named_type ("char", backend->wchar_type (),
-				      Linemap::predeclared_location ());
-  }
-
-  void visit (TyTy::StrType &) override
-  {
-    tree raw_str = backend->raw_str_type ();
-    translated
-      = backend->named_type ("str", raw_str, Linemap::predeclared_location ());
-  }
-
-  void visit (TyTy::NeverType &) override
-  {
-    translated = backend->unit_type ();
-  }
-
-  void visit (TyTy::DynamicObjectType &) override { gcc_unreachable (); }
-
-  void visit (TyTy::ClosureType &) override { gcc_unreachable (); }
-
-private:
-  TyTyCompile (::Backend *backend)
-    : backend (backend), translated (nullptr),
-      mappings (Analysis::Mappings::get ())
-  {}
-
-  ::Backend *backend;
-  tree translated;
-  Analysis::Mappings *mappings;
-};
-
-} // namespace Compile
-} // namespace Rust
-
-#endif // RUST_COMPILE_TYTY
diff --git a/gcc/rust/backend/rust-mangle.h b/gcc/rust/backend/rust-mangle.h
index 03e1dc6..6d5a64f 100644
--- a/gcc/rust/backend/rust-mangle.h
+++ b/gcc/rust/backend/rust-mangle.h
@@ -17,7 +17,8 @@
 #ifndef RUST_MANGLE_H
 #define RUST_MANGLE_H
 
-#include "rust-compile-tyty.h"
+#include "rust-system.h"
+#include "rust-tyty.h"
 
 namespace Rust {
 namespace Compile {