Make TyTyVisitor a pure abstract class

This will help enforce consistency of visitors to fix issues with
TyTy unification rules.

10 files changed, 185 insertions, 70 deletions

diff --git a/gcc/rust/backend/rust-compile-context.h b/gcc/rust/backend/rust-compile-context.h
index d241921..298ff50 100644
--- a/gcc/rust/backend/rust-compile-context.h
+++ b/gcc/rust/backend/rust-compile-context.h
@@ -221,12 +221,18 @@ public:
 
   virtual ~TyTyResolveCompile () {}
 
+  void visit (TyTy::ErrorType &type) override { gcc_unreachable (); }
+
   void visit (TyTy::UnitType &type) override { gcc_unreachable (); }
 
   void visit (TyTy::InferType &type) override { gcc_unreachable (); }
 
   void visit (TyTy::FnType &type) override { gcc_unreachable (); }
 
+  void visit (TyTy::StructFieldType &type) override { gcc_unreachable (); }
+
+  void visit (TyTy::ParamType &type) override { gcc_unreachable (); }
+
   void visit (TyTy::ADTType &type) override
   {
     ::Btype *compiled_type = nullptr;
diff --git a/gcc/rust/backend/rust-compile-tyty.h b/gcc/rust/backend/rust-compile-tyty.h
index 2d4e1f0..137b74b 100644
--- a/gcc/rust/backend/rust-compile-tyty.h
+++ b/gcc/rust/backend/rust-compile-tyty.h
@@ -43,13 +43,19 @@ public:
 
   ~TyTyCompile () {}
 
-  void visit (TyTy::InferType &type) override
-  {
-    // there shouldn't be any of these left
-    gcc_unreachable ();
-  }
+  void visit (TyTy::ErrorType &type) override { gcc_unreachable (); }
+
+  void visit (TyTy::UnitType &type) override { gcc_unreachable (); }
+
+  void visit (TyTy::InferType &type) override { gcc_unreachable (); }
+
+  void visit (TyTy::StructFieldType &type) override { gcc_unreachable (); }
 
-  void visit (TyTy::UnitType &type) override {}
+  void visit (TyTy::ParamType &type) override { gcc_unreachable (); }
+
+  void visit (TyTy::ADTType &type) override { gcc_unreachable (); }
+
+  void visit (TyTy::ArrayType &type) override { gcc_unreachable (); }
 
   void visit (TyTy::FnType &type) override
   {
@@ -82,8 +88,6 @@ public:
 				mappings->lookup_location (type.get_ref ()));
   }
 
-  void visit (TyTy::ParamType &type) override {}
-
   void visit (TyTy::BoolType &type) override
   {
     translated = backend->named_type ("bool", backend->bool_type (),
@@ -205,6 +209,18 @@ public:
 
   ~TyTyExtractParamsFromFnType () {}
 
+  void visit (TyTy::UnitType &type) override { gcc_unreachable (); }
+  void visit (TyTy::InferType &type) override { gcc_unreachable (); }
+  void visit (TyTy::StructFieldType &type) override { gcc_unreachable (); }
+  void visit (TyTy::ADTType &type) override { gcc_unreachable (); }
+  void visit (TyTy::ParamType &type) override { gcc_unreachable (); }
+  void visit (TyTy::ArrayType &type) override { gcc_unreachable (); }
+  void visit (TyTy::BoolType &type) override { gcc_unreachable (); }
+  void visit (TyTy::IntType &type) override { gcc_unreachable (); }
+  void visit (TyTy::UintType &type) override { gcc_unreachable (); }
+  void visit (TyTy::FloatType &type) override { gcc_unreachable (); }
+  void visit (TyTy::ErrorType &type) override { gcc_unreachable (); }
+
   void visit (TyTy::FnType &type) override
   {
     ok = true;
@@ -234,6 +250,18 @@ public:
 
   ~TyTyExtractRetFromFnType () {}
 
+  void visit (TyTy::UnitType &type) override { gcc_unreachable (); }
+  void visit (TyTy::InferType &type) override { gcc_unreachable (); }
+  void visit (TyTy::StructFieldType &type) override { gcc_unreachable (); }
+  void visit (TyTy::ADTType &type) override { gcc_unreachable (); }
+  void visit (TyTy::ParamType &type) override { gcc_unreachable (); }
+  void visit (TyTy::ArrayType &type) override { gcc_unreachable (); }
+  void visit (TyTy::BoolType &type) override { gcc_unreachable (); }
+  void visit (TyTy::IntType &type) override { gcc_unreachable (); }
+  void visit (TyTy::UintType &type) override { gcc_unreachable (); }
+  void visit (TyTy::FloatType &type) override { gcc_unreachable (); }
+  void visit (TyTy::ErrorType &type) override { gcc_unreachable (); }
+
   void visit (TyTy::FnType &type) override
   {
     ok = true;
@@ -261,6 +289,18 @@ public:
 
   ~TyTyCompileParam () {}
 
+  void visit (TyTy::UnitType &type) override { gcc_unreachable (); }
+  void visit (TyTy::InferType &type) override { gcc_unreachable (); }
+  void visit (TyTy::StructFieldType &type) override { gcc_unreachable (); }
+  void visit (TyTy::ADTType &type) override { gcc_unreachable (); }
+  void visit (TyTy::FnType &type) override { gcc_unreachable (); }
+  void visit (TyTy::ArrayType &type) override { gcc_unreachable (); }
+  void visit (TyTy::BoolType &type) override { gcc_unreachable (); }
+  void visit (TyTy::IntType &type) override { gcc_unreachable (); }
+  void visit (TyTy::UintType &type) override { gcc_unreachable (); }
+  void visit (TyTy::FloatType &type) override { gcc_unreachable (); }
+  void visit (TyTy::ErrorType &type) override { gcc_unreachable (); }
+
   void visit (TyTy::ParamType &type) override
   {
     auto btype = TyTyCompile::compile (backend, type.get_base_type ());
diff --git a/gcc/rust/typecheck/rust-hir-type-check-item.h b/gcc/rust/typecheck/rust-hir-type-check-item.h
index adf842c..62320a6 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-item.h
+++ b/gcc/rust/typecheck/rust-hir-type-check-item.h
@@ -43,6 +43,18 @@ public:
     return state;
   }
 
+  void visit (TyTy::UnitType &type) override { gcc_unreachable (); }
+  void visit (TyTy::InferType &type) override { gcc_unreachable (); }
+  void visit (TyTy::StructFieldType &type) override { gcc_unreachable (); }
+  void visit (TyTy::ADTType &type) override { gcc_unreachable (); }
+  void visit (TyTy::ParamType &type) override { gcc_unreachable (); }
+  void visit (TyTy::ArrayType &type) override { gcc_unreachable (); }
+  void visit (TyTy::BoolType &type) override { gcc_unreachable (); }
+  void visit (TyTy::IntType &type) override { gcc_unreachable (); }
+  void visit (TyTy::UintType &type) override { gcc_unreachable (); }
+  void visit (TyTy::FloatType &type) override { gcc_unreachable (); }
+  void visit (TyTy::ErrorType &type) override { gcc_unreachable (); }
+
   void visit (TyTy::FnType &type) override { state = type.return_type (); }
 
 private:
diff --git a/gcc/rust/typecheck/rust-tyctx.cc b/gcc/rust/typecheck/rust-tyctx.cc
index 6eb46ff..cd171d1 100644
--- a/gcc/rust/typecheck/rust-tyctx.cc
+++ b/gcc/rust/typecheck/rust-tyctx.cc
@@ -69,7 +69,10 @@ TypeCheckContext::lookup_type (HirId id, TyTy::TyBase **type)
 {
   auto it = resolved.find (id);
   if (it == resolved.end ())
-    return false;
+    {
+      *type = new TyTy::ErrorType (id);
+      return false;
+    }
 
   *type = it->second;
   return true;
diff --git a/gcc/rust/typecheck/rust-tyty-call.h b/gcc/rust/typecheck/rust-tyty-call.h
index d1341df..c3fcb1a 100644
--- a/gcc/rust/typecheck/rust-tyty-call.h
+++ b/gcc/rust/typecheck/rust-tyty-call.h
@@ -38,6 +38,18 @@ public:
   }
   ~TypeCheckCallExpr () {}
 
+  void visit (UnitType &type) override { gcc_unreachable (); }
+  void visit (InferType &type) override { gcc_unreachable (); }
+  void visit (StructFieldType &type) override { gcc_unreachable (); }
+  void visit (ADTType &type) override { gcc_unreachable (); }
+  void visit (ParamType &type) override { gcc_unreachable (); }
+  void visit (ArrayType &type) override { gcc_unreachable (); }
+  void visit (BoolType &type) override { gcc_unreachable (); }
+  void visit (IntType &type) override { gcc_unreachable (); }
+  void visit (UintType &type) override { gcc_unreachable (); }
+  void visit (FloatType &type) override { gcc_unreachable (); }
+  void visit (ErrorType &type) override { gcc_unreachable (); }
+
   void visit (FnType &type) override;
 
 private:
diff --git a/gcc/rust/typecheck/rust-tyty-resolver.h b/gcc/rust/typecheck/rust-tyty-resolver.h
index e2678c2..3d2196a 100644
--- a/gcc/rust/typecheck/rust-tyty-resolver.h
+++ b/gcc/rust/typecheck/rust-tyty-resolver.h
@@ -151,6 +151,18 @@ public:
 
   virtual ~TyTyExtractorArray () {}
 
+  void visit (TyTy::UnitType &type) override { gcc_unreachable (); }
+  void visit (TyTy::InferType &type) override { gcc_unreachable (); }
+  void visit (TyTy::StructFieldType &type) override { gcc_unreachable (); }
+  void visit (TyTy::ADTType &type) override { gcc_unreachable (); }
+  void visit (TyTy::ParamType &type) override { gcc_unreachable (); }
+  void visit (TyTy::FnType &type) override { gcc_unreachable (); }
+  void visit (TyTy::BoolType &type) override { gcc_unreachable (); }
+  void visit (TyTy::IntType &type) override { gcc_unreachable (); }
+  void visit (TyTy::UintType &type) override { gcc_unreachable (); }
+  void visit (TyTy::FloatType &type) override { gcc_unreachable (); }
+  void visit (TyTy::ErrorType &type) override { gcc_unreachable (); }
+
   void visit (TyTy::ArrayType &type) override { extracted = type.get_type (); }
 
 private:
diff --git a/gcc/rust/typecheck/rust-tyty-rules.h b/gcc/rust/typecheck/rust-tyty-rules.h
index 46ba633..677013f 100644
--- a/gcc/rust/typecheck/rust-tyty-rules.h
+++ b/gcc/rust/typecheck/rust-tyty-rules.h
@@ -113,23 +113,48 @@ public:
     rust_fatal_error (def_locus, "declared here");
   }
 
+  virtual void visit (FloatType &type) override
+  {
+    Location ref_locus = mappings->lookup_location (type.get_ref ());
+    Location def_locus = mappings->lookup_location (base->get_ref ());
+    rust_error_at (ref_locus, "expected [%s] got [%s]",
+		   base->as_string ().c_str (), type.as_string ().c_str ());
+    rust_fatal_error (def_locus, "declared here");
+  }
+
+  virtual void visit (ErrorType &type) override
+  {
+    Location ref_locus = mappings->lookup_location (type.get_ref ());
+    Location def_locus = mappings->lookup_location (base->get_ref ());
+    rust_error_at (ref_locus, "expected [%s] got [%s]",
+		   base->as_string ().c_str (), type.as_string ().c_str ());
+    rust_fatal_error (def_locus, "declared here");
+  }
+
+  virtual void visit (StructFieldType &type) override
+  {
+    Location ref_locus = mappings->lookup_location (type.get_ref ());
+    Location def_locus = mappings->lookup_location (base->get_ref ());
+    rust_error_at (ref_locus, "expected [%s] got [%s]",
+		   base->as_string ().c_str (), type.as_string ().c_str ());
+    rust_fatal_error (def_locus, "declared here");
+  }
+
 protected:
-  BaseRules (TyBase *base) : mappings (Analysis::Mappings::get ()), base (base)
+  BaseRules (TyBase *base)
+    : mappings (Analysis::Mappings::get ()), base (base),
+      resolved (new ErrorType (base->get_ref ()))
   {}
 
   Analysis::Mappings *mappings;
-
-private:
   TyBase *base;
+  TyBase *resolved;
 };
 
 class InferRules : protected BaseRules
 {
 public:
-  InferRules (InferType *base)
-    : BaseRules (base), base (base), resolved (nullptr)
-  {}
-  ~InferRules () {}
+  InferRules (InferType *base) : BaseRules (base), base (base) {}
 
   TyBase *combine (TyBase *other)
   {
@@ -139,36 +164,34 @@ public:
 
   // we are an inference variable so this means we can take the other as the
   // type
-  virtual void visit (UnitType &type) override
+  void visit (UnitType &type) override
   {
     resolved = new UnitType (type.get_ref ());
   }
 
-  virtual void visit (BoolType &type) override
+  void visit (BoolType &type) override
   {
     resolved = new BoolType (type.get_ref ());
   }
 
-  virtual void visit (IntType &type) override
+  void visit (IntType &type) override
   {
     resolved = new IntType (type.get_ref (), type.get_kind ());
   }
 
-  virtual void visit (UintType &type) override
+  void visit (UintType &type) override
   {
     resolved = new UintType (type.get_ref (), type.get_kind ());
   }
 
 private:
   InferType *base;
-  TyBase *resolved;
 };
 
 class StructFieldTypeRules : protected BaseRules
 {
 public:
-  StructFieldTypeRules (StructFieldType *base)
-    : BaseRules (base), base (base), resolved (nullptr)
+  StructFieldTypeRules (StructFieldType *base) : BaseRules (base), base (base)
   {}
 
   TyBase *combine (TyBase *other)
@@ -179,15 +202,12 @@ public:
 
 private:
   StructFieldType *base;
-  TyBase *resolved;
 };
 
 class UnitRules : protected BaseRules
 {
 public:
-  UnitRules (UnitType *base) : BaseRules (base), base (base), resolved (nullptr)
-  {}
-  ~UnitRules () {}
+  UnitRules (UnitType *base) : BaseRules (base), base (base) {}
 
   TyBase *combine (TyBase *other)
   {
@@ -199,14 +219,12 @@ public:
 
 private:
   UnitType *base;
-  TyBase *resolved;
 };
 
 class FnRules : protected BaseRules
 {
 public:
-  FnRules (FnType *base) : BaseRules (base), base (base), resolved (nullptr) {}
-  ~FnRules () {}
+  FnRules (FnType *base) : BaseRules (base), base (base) {}
 
   TyBase *combine (TyBase *other)
   {
@@ -216,16 +234,12 @@ public:
 
 private:
   FnType *base;
-  TyBase *resolved;
 };
 
 class ParamRules : protected BaseRules
 {
 public:
-  ParamRules (ParamType *base)
-    : BaseRules (base), base (base), resolved (nullptr)
-  {}
-  ~ParamRules () {}
+  ParamRules (ParamType *base) : BaseRules (base), base (base) {}
 
   TyBase *combine (TyBase *other)
   {
@@ -235,17 +249,12 @@ public:
 
 private:
   ParamType *base;
-  TyBase *resolved;
 };
 
 class ArrayRules : protected BaseRules
 {
 public:
-  ArrayRules (ArrayType *base)
-    : BaseRules (base), base (base), resolved (nullptr)
-  {}
-
-  ~ArrayRules () {}
+  ArrayRules (ArrayType *base) : BaseRules (base), base (base) {}
 
   TyBase *combine (TyBase *other)
   {
@@ -274,15 +283,12 @@ public:
 
 private:
   ArrayType *base;
-  TyBase *resolved;
 };
 
 class BoolRules : protected BaseRules
 {
 public:
-  BoolRules (BoolType *base) : BaseRules (base), base (base), resolved (nullptr)
-  {}
-  ~BoolRules () {}
+  BoolRules (BoolType *base) : BaseRules (base), base (base) {}
 
   TyBase *combine (TyBase *other)
   {
@@ -297,15 +303,12 @@ public:
 
 private:
   BoolType *base;
-  TyBase *resolved;
 };
 
 class IntRules : protected BaseRules
 {
 public:
-  IntRules (IntType *base) : BaseRules (base), base (base), resolved (nullptr)
-  {}
-  ~IntRules () {}
+  IntRules (IntType *base) : BaseRules (base), base (base) {}
 
   TyBase *combine (TyBase *other)
   {
@@ -321,15 +324,12 @@ public:
 
 private:
   IntType *base;
-  TyBase *resolved;
 };
 
 class UintRules : protected BaseRules
 {
 public:
-  UintRules (UintType *base) : BaseRules (base), base (base), resolved (nullptr)
-  {}
-  ~UintRules () {}
+  UintRules (UintType *base) : BaseRules (base), base (base) {}
 
   TyBase *combine (TyBase *other)
   {
@@ -345,16 +345,12 @@ public:
 
 private:
   UintType *base;
-  TyBase *resolved;
 };
 
 class FloatRules : protected BaseRules
 {
 public:
-  FloatRules (FloatType *base)
-    : BaseRules (base), base (base), resolved (nullptr)
-  {}
-  ~FloatRules () {}
+  FloatRules (FloatType *base) : BaseRules (base), base (base) {}
 
   TyBase *combine (TyBase *other)
   {
@@ -370,7 +366,6 @@ public:
 
 private:
   FloatType *base;
-  TyBase *resolved;
 };
 
 } // namespace TyTy
diff --git a/gcc/rust/typecheck/rust-tyty-visitor.h b/gcc/rust/typecheck/rust-tyty-visitor.h
index 40998ca..def43cd 100644
--- a/gcc/rust/typecheck/rust-tyty-visitor.h
+++ b/gcc/rust/typecheck/rust-tyty-visitor.h
@@ -27,17 +27,18 @@ namespace TyTy {
 class TyVisitor
 {
 public:
-  virtual void visit (UnitType &type) {}
-  virtual void visit (InferType &type) {}
-  virtual void visit (StructFieldType &type) {}
-  virtual void visit (ADTType &type) {}
-  virtual void visit (FnType &type) {}
-  virtual void visit (ParamType &type) {}
-  virtual void visit (ArrayType &type) {}
-  virtual void visit (BoolType &type) {}
-  virtual void visit (IntType &type) {}
-  virtual void visit (UintType &type) {}
-  virtual void visit (FloatType &type) {}
+  virtual void visit (UnitType &type) = 0;
+  virtual void visit (InferType &type) = 0;
+  virtual void visit (StructFieldType &type) = 0;
+  virtual void visit (ADTType &type) = 0;
+  virtual void visit (FnType &type) = 0;
+  virtual void visit (ParamType &type) = 0;
+  virtual void visit (ArrayType &type) = 0;
+  virtual void visit (BoolType &type) = 0;
+  virtual void visit (IntType &type) = 0;
+  virtual void visit (UintType &type) = 0;
+  virtual void visit (FloatType &type) = 0;
+  virtual void visit (ErrorType &type) = 0;
 };
 
 } // namespace TyTy
diff --git a/gcc/rust/typecheck/rust-tyty.cc b/gcc/rust/typecheck/rust-tyty.cc
index 0cefab6..033f839 100644
--- a/gcc/rust/typecheck/rust-tyty.cc
+++ b/gcc/rust/typecheck/rust-tyty.cc
@@ -64,6 +64,25 @@ InferType::combine (TyBase *other)
 }
 
 void
+ErrorType::accept_vis (TyVisitor &vis)
+{
+  vis.visit (*this);
+}
+
+std::string
+ErrorType::as_string () const
+{
+  return "<tyty::error>";
+}
+
+TyBase *
+ErrorType::combine (TyBase *other)
+{
+  // rust_error_at ();
+  return this;
+}
+
+void
 StructFieldType::accept_vis (TyVisitor &vis)
 {
   vis.visit (*this);
diff --git a/gcc/rust/typecheck/rust-tyty.h b/gcc/rust/typecheck/rust-tyty.h
index c7c609e..be7ec0c 100644
--- a/gcc/rust/typecheck/rust-tyty.h
+++ b/gcc/rust/typecheck/rust-tyty.h
@@ -43,6 +43,7 @@ enum TypeKind
   UNIT,
   FIELD,
   // there are more to add...
+  ERROR
 };
 
 class TyVisitor;
@@ -84,6 +85,20 @@ public:
   TyBase *combine (TyBase *other) override;
 };
 
+class ErrorType : public TyBase
+{
+public:
+  ErrorType (HirId ref) : TyBase (ref, TypeKind::ERROR) {}
+
+  void accept_vis (TyVisitor &vis) override;
+
+  bool is_unit () const override { return true; }
+
+  std::string as_string () const override;
+
+  TyBase *combine (TyBase *other) override;
+};
+
 class UnitType : public TyBase
 {
 public: