Add boiler plate for TyTy::ClosureType

gcc/rust/backend/rust-compile-context.h

@@ -661,6 +661,8 @@ class TyTyResolveCompile : public TyTy::TyVisitor
     ctx->insert_compiled_type (type.get_ty_ref (), named_struct, &type);
   }
 
+  void visit (TyTy::ClosureType &type) override { gcc_unreachable (); }
+
 private:
   TyTyResolveCompile (Context *ctx, bool trait_object_mode)
     : ctx (ctx), trait_object_mode (trait_object_mode), translated (nullptr)

gcc/rust/backend/rust-compile-tyty.h

@@ -239,6 +239,8 @@ class TyTyCompile : public TyTy::TyVisitor
 
   void visit (TyTy::DynamicObjectType &) override { gcc_unreachable (); }
 
+  void visit (TyTy::ClosureType &) override { gcc_unreachable (); }
+
 private:
   TyTyCompile (::Backend *backend)
     : backend (backend), translated (nullptr),

gcc/rust/typecheck/rust-hir-const-fold.h

@@ -193,6 +193,8 @@ class ConstFoldType : public TyTy::TyVisitor
 
   void visit (TyTy::DynamicObjectType &) override { gcc_unreachable (); }
 
+  void visit (TyTy::ClosureType &) override { gcc_unreachable (); }
+
 private:
   ConstFoldType (::Backend *backend)
     : backend (backend), translated (backend->error_type ())

gcc/rust/typecheck/rust-substitution-mapper.h

@@ -138,6 +138,7 @@ class SubstMapper : public TyTy::TyVisitor
   void visit (TyTy::StrType &) override { gcc_unreachable (); }
   void visit (TyTy::NeverType &) override { gcc_unreachable (); }
   void visit (TyTy::DynamicObjectType &) override { gcc_unreachable (); }
+  void visit (TyTy::ClosureType &) override { gcc_unreachable (); }
 
 private:
   SubstMapper (HirId ref, HIR::GenericArgs *generics, Location locus)
@@ -217,6 +218,11 @@ class SubstMapperInternal : public TyTy::TyVisitor
     resolved = type.handle_substitions (mappings);
   }
 
+  void visit (TyTy::ClosureType &type) override
+  {
+    resolved = type.handle_substitions (mappings);
+  }
+
   // nothing to do for these
   void visit (TyTy::InferType &) override { gcc_unreachable (); }
   void visit (TyTy::FnPtr &) override { gcc_unreachable (); }
@@ -271,6 +277,14 @@ class SubstMapperFromExisting : public TyTy::TyVisitor
     resolved = to_sub->handle_substitions (type.get_substitution_arguments ());
   }
 
+  void visit (TyTy::ClosureType &type) override
+  {
+    rust_assert (type.was_substituted ());
+
+    TyTy::ClosureType *to_sub = static_cast<TyTy::ClosureType *> (receiver);
+    resolved = to_sub->handle_substitions (type.get_substitution_arguments ());
+  }
+
   void visit (TyTy::InferType &) override { gcc_unreachable (); }
   void visit (TyTy::TupleType &) override { gcc_unreachable (); }
   void visit (TyTy::FnPtr &) override { gcc_unreachable (); }
@@ -323,6 +337,11 @@ class GetUsedSubstArgs : public TyTy::TyVisitor
     args = type.get_substitution_arguments ();
   }
 
+  void visit (TyTy::ClosureType &type) override
+  {
+    args = type.get_substitution_arguments ();
+  }
+
   void visit (TyTy::InferType &) override {}
   void visit (TyTy::TupleType &) override {}
   void visit (TyTy::FnPtr &) override {}

gcc/rust/typecheck/rust-tyty-call.h

@@ -65,6 +65,7 @@ class TypeCheckCallExpr : private TyVisitor
   // call fns
   void visit (FnType &type) override;
   void visit (FnPtr &type) override;
+  void visit (ClosureType &type) override { gcc_unreachable (); }
 
 private:
   TypeCheckCallExpr (HIR::CallExpr &c, Resolver::TypeCheckContext *context)
@@ -116,6 +117,7 @@ class TypeCheckMethodCallExpr : private TyVisitor
 
   // call fns
   void visit (FnType &type) override;
+  void visit (ClosureType &type) override { gcc_unreachable (); }
 
 private:
   TypeCheckMethodCallExpr (HIR::MethodCallExpr &c,

gcc/rust/typecheck/rust-tyty-cast.h

@@ -329,6 +329,17 @@ class BaseCastRules : public TyVisitor
 		   type.as_string ().c_str ());
   }
 
+  virtual void visit (ClosureType &type) override
+  {
+    Location ref_locus = mappings->lookup_location (type.get_ref ());
+    Location base_locus = mappings->lookup_location (get_base ()->get_ref ());
+    RichLocation r (ref_locus);
+    r.add_range (base_locus);
+    rust_error_at (r, "invalid cast [%s] to [%s]",
+		   get_base ()->as_string ().c_str (),
+		   type.as_string ().c_str ());
+  }
+
 protected:
   BaseCastRules (BaseType *base)
     : mappings (Analysis::Mappings::get ()),
@@ -590,6 +601,19 @@ class InferCastRules : public BaseCastRules
     BaseCastRules::visit (type);
   }
 
+  void visit (ClosureType &type) override
+  {
+    bool is_valid
+      = (base->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL);
+    if (is_valid)
+      {
+	resolved = type.clone ();
+	return;
+      }
+
+    BaseCastRules::visit (type);
+  }
+
 private:
   BaseType *get_base () override { return base; }
 
@@ -749,6 +773,21 @@ class FnptrCastRules : public BaseCastRules
   FnPtr *base;
 };
 
+class ClosureCastRules : public BaseCastRules
+{
+  using Rust::TyTy::BaseCastRules::visit;
+
+public:
+  ClosureCastRules (ClosureType *base) : BaseCastRules (base), base (base) {}
+
+  // TODO
+
+private:
+  BaseType *get_base () override { return base; }
+
+  ClosureType *base;
+};
+
 class ArrayCastRules : public BaseCastRules
 {
   using Rust::TyTy::BaseCastRules::visit;

gcc/rust/typecheck/rust-tyty-cmp.h

@@ -391,6 +391,22 @@ class BaseCmp : public TyConstVisitor
       }
   }
 
+  virtual void visit (const ClosureType &type) override
+  {
+    ok = false;
+    if (emit_error_flag)
+      {
+	Location ref_locus = mappings->lookup_location (type.get_ref ());
+	Location base_locus
+	  = mappings->lookup_location (get_base ()->get_ref ());
+	RichLocation r (ref_locus);
+	r.add_range (base_locus);
+	rust_error_at (r, "expected [%s] got [%s]",
+		       get_base ()->as_string ().c_str (),
+		       type.as_string ().c_str ());
+      }
+  }
+
 protected:
   BaseCmp (const BaseType *base, bool emit_errors)
     : mappings (Analysis::Mappings::get ()),
@@ -651,6 +667,19 @@ class InferCmp : public BaseCmp
     BaseCmp::visit (type);
   }
 
+  void visit (const ClosureType &type) override
+  {
+    bool is_valid
+      = (base->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL);
+    if (is_valid)
+      {
+	ok = true;
+	return;
+      }
+
+    BaseCmp::visit (type);
+  }
+
 private:
   const BaseType *get_base () const override { return base; }
   const InferType *base;
@@ -792,6 +821,20 @@ class FnptrCmp : public BaseCmp
   const FnPtr *base;
 };
 
+class ClosureCmp : public BaseCmp
+{
+  using Rust::TyTy::BaseCmp::visit;
+
+public:
+  ClosureCmp (const ClosureType *base, bool emit_errors)
+    : BaseCmp (base, emit_errors), base (base)
+  {}
+
+private:
+  const BaseType *get_base () const override { return base; }
+  const ClosureType *base;
+};
+
 class ArrayCmp : public BaseCmp
 {
   using Rust::TyTy::BaseCmp::visit;

gcc/rust/typecheck/rust-tyty-coercion.h

@@ -343,6 +343,17 @@ class BaseCoercionRules : public TyVisitor
 		   type.as_string ().c_str ());
   }
 
+  virtual void visit (ClosureType &type) override
+  {
+    Location ref_locus = mappings->lookup_location (type.get_ref ());
+    Location base_locus = mappings->lookup_location (get_base ()->get_ref ());
+    RichLocation r (ref_locus);
+    r.add_range (base_locus);
+    rust_error_at (r, "expected [%s] got [%s]",
+		   get_base ()->as_string ().c_str (),
+		   type.as_string ().c_str ());
+  }
+
 protected:
   BaseCoercionRules (BaseType *base)
     : mappings (Analysis::Mappings::get ()),
@@ -605,6 +616,19 @@ class InferCoercionRules : public BaseCoercionRules
     BaseCoercionRules::visit (type);
   }
 
+  void visit (ClosureType &type) override
+  {
+    bool is_valid
+      = (base->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL);
+    if (is_valid)
+      {
+	resolved = type.clone ();
+	return;
+      }
+
+    BaseCoercionRules::visit (type);
+  }
+
 private:
   BaseType *get_base () override { return base; }
 
@@ -764,6 +788,23 @@ class FnptrCoercionRules : public BaseCoercionRules
   FnPtr *base;
 };
 
+class ClosureCoercionRules : public BaseCoercionRules
+{
+  using Rust::TyTy::BaseCoercionRules::visit;
+
+public:
+  ClosureCoercionRules (ClosureType *base)
+    : BaseCoercionRules (base), base (base)
+  {}
+
+  // TODO
+
+private:
+  BaseType *get_base () override { return base; }
+
+  ClosureType *base;
+};
+
 class ArrayCoercionRules : public BaseCoercionRules
 {
   using Rust::TyTy::BaseCoercionRules::visit;

gcc/rust/typecheck/rust-tyty-rules.h

@@ -364,6 +364,17 @@ class BaseRules : public TyVisitor
 		   type.as_string ().c_str ());
   }
 
+  virtual void visit (ClosureType &type) override
+  {
+    Location ref_locus = mappings->lookup_location (type.get_ref ());
+    Location base_locus = mappings->lookup_location (get_base ()->get_ref ());
+    RichLocation r (ref_locus);
+    r.add_range (base_locus);
+    rust_error_at (r, "expected [%s] got [%s]",
+		   get_base ()->as_string ().c_str (),
+		   type.as_string ().c_str ());
+  }
+
 protected:
   BaseRules (BaseType *base)
     : mappings (Analysis::Mappings::get ()),
@@ -625,6 +636,19 @@ class InferRules : public BaseRules
     BaseRules::visit (type);
   }
 
+  void visit (ClosureType &type) override
+  {
+    bool is_valid
+      = (base->get_infer_kind () == TyTy::InferType::InferTypeKind::GENERAL);
+    if (is_valid)
+      {
+	resolved = type.clone ();
+	return;
+      }
+
+    BaseRules::visit (type);
+  }
+
 private:
   BaseType *get_base () override { return base; }
 
@@ -784,6 +808,21 @@ class FnptrRules : public BaseRules
   FnPtr *base;
 };
 
+class ClosureRules : public BaseRules
+{
+  using Rust::TyTy::BaseRules::visit;
+
+public:
+  ClosureRules (ClosureType *base) : BaseRules (base), base (base) {}
+
+  // TODO
+
+private:
+  BaseType *get_base () override { return base; }
+
+  ClosureType *base;
+};
+
 class ArrayRules : public BaseRules
 {
   using Rust::TyTy::BaseRules::visit;

gcc/rust/typecheck/rust-tyty-visitor.h

@@ -49,6 +49,7 @@ class TyVisitor
   virtual void visit (PlaceholderType &type) = 0;
   virtual void visit (ProjectionType &type) = 0;
   virtual void visit (DynamicObjectType &type) = 0;
+  virtual void visit (ClosureType &type) = 0;
 };
 
 class TyConstVisitor
@@ -76,6 +77,7 @@ class TyConstVisitor
   virtual void visit (const PlaceholderType &type) = 0;
   virtual void visit (const ProjectionType &type) = 0;
   virtual void visit (const DynamicObjectType &type) = 0;
+  virtual void visit (const ClosureType &type) = 0;
 };
 
 } // namespace TyTy