gccrs: Refactor the ParamType to a BaseGeneric base-type

In order to support const generics we need to abstract away some of the specific
ParamType to a BaseGeneric type so we can easily reuse our existing substitution
bits for const generics which will mean creating a TyTy::ConstType to wrap up
the gcc tree but also represent a const inference and the const decl.

gcc/rust/ChangeLog:

	* backend/rust-compile-intrinsic.cc (sizeof_handler): refactor types
	(op_with_overflow_inner): likewise
	(uninit_handler): likewise
	(move_val_init_handler): likewise
	* backend/rust-compile-resolve-path.cc (HIRCompileBase::query_compile): likewise
	* typecheck/rust-hir-trait-resolve.cc: likewise
	* typecheck/rust-hir-type-check-base.cc: likewise
	* typecheck/rust-hir-type-check-item.cc: likewise
	* typecheck/rust-tyty-bounds.cc (TypeBoundPredicate::is_equal): likewise
	* typecheck/rust-tyty-subst.cc (SubstitutionParamMapping::get_param_ty): likewise
	(SubstitutionArg::get_param_mapping): likewise
	(SubstitutionRef::prepare_higher_ranked_bounds): likewise
	(SubstitutionRef::monomorphize): likewise
	* typecheck/rust-tyty-subst.h (class BaseGeneric): new generic base
	* typecheck/rust-tyty.cc (VariantDef::clone): likewise
	(VariantDef::monomorphized_clone): refactor
	(ADTType::is_equal): likewise
	(FnType::is_equal): likewise
	(ParamType::ParamType): likewise
	* typecheck/rust-tyty.h (class ParamType): likewise
	(class BaseGeneric): new base class impl

Signed-off-by: Philip Herron <herron.philip@googlemail.com>

diff --git a/gcc/rust/backend/rust-compile-intrinsic.cc b/gcc/rust/backend/rust-compile-intrinsic.cc
index 7627620c4713f36ab658899aa78bba9deaf318eb..450a86979208b448164ea3ec8197402e8462cad7 100644 (file)
--- a/gcc/rust/backend/rust-compile-intrinsic.cc
+++ b/gcc/rust/backend/rust-compile-intrinsic.cc
@@ -437,8 +437,8 @@ sizeof_handler (Context *ctx, TyTy::FnType *fntype)
   // get the template parameter type tree fn size_of<T>();
   rust_assert (fntype->get_num_substitutions () == 1);
   auto &param_mapping = fntype->get_substs ().at (0);
-  const TyTy::ParamType *param_tyty = param_mapping.get_param_ty ();
-  TyTy::BaseType *resolved_tyty = param_tyty->resolve ();
+  const auto param_tyty = param_mapping.get_param_ty ();
+  auto resolved_tyty = param_tyty->resolve ();
   tree template_parameter_type
     = TyTyResolveCompile::compile (ctx, resolved_tyty);
 
@@ -643,8 +643,8 @@ op_with_overflow_inner (Context *ctx, TyTy::FnType *fntype, tree_code op)
 
   rust_assert (fntype->get_num_substitutions () == 1);
   auto &param_mapping = fntype->get_substs ().at (0);
-  const TyTy::ParamType *param_tyty = param_mapping.get_param_ty ();
-  TyTy::BaseType *resolved_tyty = param_tyty->resolve ();
+  const auto param_tyty = param_mapping.get_param_ty ();
+  auto resolved_tyty = param_tyty->resolve ();
   tree template_parameter_type
     = TyTyResolveCompile::compile (ctx, resolved_tyty);
 
@@ -1079,8 +1079,8 @@ uninit_handler (Context *ctx, TyTy::FnType *fntype)
   // get the template parameter type tree fn uninit<T>();
   rust_assert (fntype->get_num_substitutions () == 1);
   auto &param_mapping = fntype->get_substs ().at (0);
-  const TyTy::ParamType *param_tyty = param_mapping.get_param_ty ();
-  TyTy::BaseType *resolved_tyty = param_tyty->resolve ();
+  const auto param_tyty = param_mapping.get_param_ty ();
+  auto resolved_tyty = param_tyty->resolve ();
   tree template_parameter_type
     = TyTyResolveCompile::compile (ctx, resolved_tyty);
 
@@ -1144,8 +1144,8 @@ move_val_init_handler (Context *ctx, TyTy::FnType *fntype)
   // get the template parameter type tree fn size_of<T>();
   rust_assert (fntype->get_num_substitutions () == 1);
   auto &param_mapping = fntype->get_substs ().at (0);
-  const TyTy::ParamType *param_tyty = param_mapping.get_param_ty ();
-  TyTy::BaseType *resolved_tyty = param_tyty->resolve ();
+  auto param_tyty = param_mapping.get_param_ty ();
+  auto resolved_tyty = param_tyty->resolve ();
   tree template_parameter_type
     = TyTyResolveCompile::compile (ctx, resolved_tyty);
 

diff --git a/gcc/rust/backend/rust-compile-resolve-path.cc b/gcc/rust/backend/rust-compile-resolve-path.cc
index be2af64fc38a60e36de3955167585ee873910db2..f3b9dc28db21247ae7a29164dcc7c464db5328de 100644 (file)
--- a/gcc/rust/backend/rust-compile-resolve-path.cc
+++ b/gcc/rust/backend/rust-compile-resolve-path.cc
@@ -330,7 +330,7 @@ HIRCompileBase::query_compile (HirId ref, TyTy::BaseType *lookup,
          auto fn = lookup->as<TyTy::FnType> ();
          rust_assert (fn->get_num_type_params () > 0);
          TyTy::SubstitutionParamMapping &self = fn->get_substs ().at (0);
-         TyTy::ParamType *receiver = self.get_param_ty ();
+         TyTy::BaseGeneric *receiver = self.get_param_ty ();
          TyTy::BaseType *r = receiver;
          if (!receiver->can_resolve ())
            {

diff --git a/gcc/rust/typecheck/rust-hir-trait-resolve.cc b/gcc/rust/typecheck/rust-hir-trait-resolve.cc
index e2e9dbf83b030e511cea791402aa2a4553600fd7..0fd0147b45f33f13fb9411c61174f0abd4a90d54 100644 (file)
--- a/gcc/rust/typecheck/rust-hir-trait-resolve.cc
+++ b/gcc/rust/typecheck/rust-hir-trait-resolve.cc
@@ -584,8 +584,8 @@ AssociatedImplTrait::setup_associated_types (
        }
       else
        {
-         TyTy::ParamType *param = p.get_param_ty ();
-         TyTy::BaseType *resolved = param->destructure ();
+         auto param = p.get_param_ty ();
+         auto resolved = param->destructure ();
          subst_args.push_back (TyTy::SubstitutionArg (&p, resolved));
          param_mappings[param->get_symbol ()] = resolved->get_ref ();
        }
@@ -613,8 +613,8 @@ AssociatedImplTrait::setup_associated_types (
       if (i == 0)
        continue;
 
-      const TyTy::ParamType *p = arg.get_param_ty ();
-      TyTy::BaseType *r = p->resolve ();
+      const auto p = arg.get_param_ty ();
+      auto r = p->resolve ();
       if (!r->is_concrete ())
        {
          r = SubstMapperInternal::Resolve (r, infer_arguments);
@@ -630,8 +630,8 @@ AssociatedImplTrait::setup_associated_types (
       if (i == 0)
        continue;
 
-      const TyTy::ParamType *p = arg.get_param_ty ();
-      TyTy::BaseType *r = p->resolve ();
+      const auto p = arg.get_param_ty ();
+      auto r = p->resolve ();
       if (!r->is_concrete ())
        {
          r = SubstMapperInternal::Resolve (r, infer_arguments);

diff --git a/gcc/rust/typecheck/rust-hir-type-check-base.cc b/gcc/rust/typecheck/rust-hir-type-check-base.cc
index acc331620ba53f2660d74f0b67ed6736f35ccb28..cbb85bd4f4f30ae8689b122386a46404f94c9b0b 100644 (file)
--- a/gcc/rust/typecheck/rust-hir-type-check-base.cc
+++ b/gcc/rust/typecheck/rust-hir-type-check-base.cc
@@ -23,6 +23,7 @@
 #include "rust-hir-trait-resolve.h"
 #include "rust-type-util.h"
 #include "rust-attribute-values.h"
+#include "rust-tyty.h"
 
 namespace Rust {
 namespace Resolver {
@@ -486,6 +487,10 @@ TypeCheckBase::resolve_generic_params (
 
            context->insert_type (generic_param->get_mappings (),
                                  specified_type);
+
+           // TODO for const generics
+           // TyTy::SubstitutionParamMapping p (*generic_param, param_type);
+           // substitutions.push_back (p);
          }
          break;
 
@@ -501,8 +506,7 @@ TypeCheckBase::resolve_generic_params (
              *generic_param, false /*resolve_trait_bounds*/);
            context->insert_type (generic_param->get_mappings (), param_type);
 
-           auto &param = static_cast<HIR::TypeParam &> (*generic_param);
-           TyTy::SubstitutionParamMapping p (param, param_type);
+           TyTy::SubstitutionParamMapping p (*generic_param, param_type);
            substitutions.push_back (p);
          }
          break;
@@ -517,7 +521,10 @@ TypeCheckBase::resolve_generic_params (
        continue;
 
       auto &type_param = static_cast<HIR::TypeParam &> (generic);
-      auto pty = subst.get_param_ty ();
+      auto bpty = subst.get_param_ty ();
+      rust_assert (bpty->get_kind () == TyTy::TypeKind::PARAM);
+      auto pty = static_cast<TyTy::ParamType *> (bpty);
+
       TypeResolveGenericParam::ApplyAnyTraitBounds (type_param, pty);
     }
 }

diff --git a/gcc/rust/typecheck/rust-hir-type-check-item.cc b/gcc/rust/typecheck/rust-hir-type-check-item.cc
index e86525a68e55d07659d73439e4f83027714e3147..f104a1a56e81f1c0809da702ce32ec5f5e6d7132 100644 (file)
--- a/gcc/rust/typecheck/rust-hir-type-check-item.cc
+++ b/gcc/rust/typecheck/rust-hir-type-check-item.cc
@@ -118,8 +118,8 @@ TypeCheckItem::ResolveImplBlockSelfWithInference (
        }
       else
        {
-         TyTy::ParamType *param = p.get_param_ty ();
-         TyTy::BaseType *resolved = param->destructure ();
+         auto param = p.get_param_ty ();
+         auto resolved = param->destructure ();
          args.push_back (TyTy::SubstitutionArg (&p, resolved));
        }
     }

diff --git a/gcc/rust/typecheck/rust-tyty-bounds.cc b/gcc/rust/typecheck/rust-tyty-bounds.cc
index c34d3628895ade7d5cda0eb40f9c83b730272a00..3ae4effa6af40c3889e550bb439e95a5e6cfcc8b 100644 (file)
--- a/gcc/rust/typecheck/rust-tyty-bounds.cc
+++ b/gcc/rust/typecheck/rust-tyty-bounds.cc
@@ -721,7 +721,7 @@ TypeBoundPredicate::handle_substitions (
       if (sub.get_param_ty () == nullptr)
        continue;
 
-      ParamType *p = sub.get_param_ty ();
+      auto p = sub.get_param_ty ();
       BaseType *r = p->resolve ();
       BaseType *s = Resolver::SubstMapperInternal::Resolve (r, subst_mappings);
 
@@ -851,8 +851,8 @@ TypeBoundPredicate::is_equal (const TypeBoundPredicate &other) const
       const SubstitutionParamMapping &a = substitutions.at (i);
       const SubstitutionParamMapping &b = other.substitutions.at (i);
 
-      const ParamType *ap = a.get_param_ty ();
-      const ParamType *bp = b.get_param_ty ();
+      const auto ap = a.get_param_ty ();
+      const auto bp = b.get_param_ty ();
 
       const BaseType *apd = ap->destructure ();
       const BaseType *bpd = bp->destructure ();

diff --git a/gcc/rust/typecheck/rust-tyty-subst.cc b/gcc/rust/typecheck/rust-tyty-subst.cc
index 13aca42182f21e8a0d42dcd2a257239b92162bef..01899d83435fcea18572507f2aa967855774cbec 100644 (file)
--- a/gcc/rust/typecheck/rust-tyty-subst.cc
+++ b/gcc/rust/typecheck/rust-tyty-subst.cc
@@ -54,13 +54,13 @@ SubstitutionParamMapping::clone () const
                                   static_cast<ParamType *> (param->clone ()));
 }
 
-ParamType *
+BaseGeneric *
 SubstitutionParamMapping::get_param_ty ()
 {
   return param;
 }
 
-const ParamType *
+const BaseGeneric *
 SubstitutionParamMapping::get_param_ty () const
 {
   return param;
@@ -229,7 +229,7 @@ SubstitutionArg::get_param_mapping () const
   return param;
 }
 
-const ParamType *
+const BaseGeneric *
 SubstitutionArg::get_param_ty () const
 {
   return original_param;
@@ -334,11 +334,11 @@ SubstitutionArgumentMappings::is_error () const
 
 bool
 SubstitutionArgumentMappings::get_argument_for_symbol (
-  const ParamType *param_to_find, SubstitutionArg *argument) const
+  const BaseGeneric *param_to_find, SubstitutionArg *argument) const
 {
   for (const auto &mapping : mappings)
     {
-      const ParamType *p = mapping.get_param_ty ();
+      const auto *p = mapping.get_param_ty ();
       if (p->get_symbol () == param_to_find->get_symbol ())
        {
          *argument = mapping;
@@ -951,7 +951,7 @@ SubstitutionRef::prepare_higher_ranked_bounds ()
 {
   for (const auto &subst : get_substs ())
     {
-      const TyTy::ParamType *pty = subst.get_param_ty ();
+      const auto pty = subst.get_param_ty ();
       for (const auto &bound : pty->get_specified_bounds ())
        {
          const auto ref = bound.get ();
@@ -965,8 +965,7 @@ SubstitutionRef::monomorphize ()
 {
   for (const auto &subst : get_substs ())
     {
-      const TyTy::ParamType *pty = subst.get_param_ty ();
-
+      const auto pty = subst.get_param_ty ();
       if (!pty->can_resolve ())
        continue;
 

diff --git a/gcc/rust/typecheck/rust-tyty-subst.h b/gcc/rust/typecheck/rust-tyty-subst.h
index f78242499eaf1b87f2356d2287169002045403b7..0ac3ea73807daed4b7681bfe44d001b0a5eb1ea7 100644 (file)
--- a/gcc/rust/typecheck/rust-tyty-subst.h
+++ b/gcc/rust/typecheck/rust-tyty-subst.h
@@ -31,6 +31,7 @@ namespace Rust {
 namespace TyTy {
 
 class ParamType;
+class BaseGeneric;
 
 struct RegionConstraints
 {
@@ -56,8 +57,8 @@ public:
 
   SubstitutionParamMapping clone () const;
 
-  ParamType *get_param_ty ();
-  const ParamType *get_param_ty () const;
+  BaseGeneric *get_param_ty ();
+  const BaseGeneric *get_param_ty () const;
 
   HIR::GenericParam &get_generic_param ();
   const HIR::GenericParam &get_generic_param () const;
@@ -156,7 +157,7 @@ public:
 
   const SubstitutionParamMapping *get_param_mapping () const;
 
-  const ParamType *get_param_ty () const;
+  const BaseGeneric *get_param_ty () const;
 
   static SubstitutionArg error ();
 
@@ -168,7 +169,7 @@ public:
 
 private:
   const SubstitutionParamMapping *param;
-  const ParamType *original_param;
+  const BaseGeneric *original_param;
   BaseType *argument;
 };
 
@@ -208,7 +209,7 @@ public:
 
   bool is_error () const;
 
-  bool get_argument_for_symbol (const ParamType *param_to_find,
+  bool get_argument_for_symbol (const BaseGeneric *param_to_find,
                                SubstitutionArg *argument) const;
 
   /** Return type parameter index for symbol */

diff --git a/gcc/rust/typecheck/rust-tyty.cc b/gcc/rust/typecheck/rust-tyty.cc
index 4b4117bdb8dd6d8d034a8ee0b70c502e9830f6fd..64207e9d7ea7ea1fb949df35a6e07f2c761fc63b 100644 (file)
--- a/gcc/rust/typecheck/rust-tyty.cc
+++ b/gcc/rust/typecheck/rust-tyty.cc
@@ -1690,7 +1690,7 @@ VariantDef::clone () const
 
   auto &&discriminant_opt = has_discriminant ()
                              ? tl::optional<std::unique_ptr<HIR::Expr>> (
-                               get_discriminant ().clone_expr ())
+                                 get_discriminant ().clone_expr ())
                              : tl::nullopt;
 
   return new VariantDef (id, defid, identifier, ident, type,
@@ -1706,7 +1706,7 @@ VariantDef::monomorphized_clone () const
 
   auto discriminant_opt = has_discriminant ()
                            ? tl::optional<std::unique_ptr<HIR::Expr>> (
-                             get_discriminant ().clone_expr ())
+                               get_discriminant ().clone_expr ())
                            : tl::nullopt;
 
   return new VariantDef (id, defid, identifier, ident, type,
@@ -1818,8 +1818,8 @@ ADTType::is_equal (const BaseType &other) const
          const SubstitutionParamMapping &a = substitutions.at (i);
          const SubstitutionParamMapping &b = other2->substitutions.at (i);
 
-         const ParamType *aa = a.get_param_ty ();
-         const ParamType *bb = b.get_param_ty ();
+         const auto &aa = a.get_param_ty ();
+         const auto &bb = b.get_param_ty ();
          if (!aa->is_equal (*bb))
            return false;
        }
@@ -2145,8 +2145,8 @@ FnType::is_equal (const BaseType &other) const
          const SubstitutionParamMapping &a = get_substs ().at (i);
          const SubstitutionParamMapping &b = ofn.get_substs ().at (i);
 
-         const ParamType *pa = a.get_param_ty ();
-         const ParamType *pb = b.get_param_ty ();
+         const auto *pa = a.get_param_ty ();
+         const auto *pb = b.get_param_ty ();
          if (!pa->is_equal (*pb))
            return false;
        }
@@ -3409,10 +3409,10 @@ ParamType::ParamType (std::string symbol, location_t locus, HirId ref,
                      HIR::GenericParam &param,
                      std::vector<TypeBoundPredicate> specified_bounds,
                      std::set<HirId> refs)
-  : BaseType (ref, ref, KIND,
-             {Resolver::CanonicalPath::new_seg (UNKNOWN_NODEID, symbol),
-              locus},
-             specified_bounds, refs),
+  : BaseGeneric (ref, ref, KIND,
+                {Resolver::CanonicalPath::new_seg (UNKNOWN_NODEID, symbol),
+                 locus},
+                specified_bounds, refs),
     is_trait_self (false), symbol (symbol), param (param)
 {}
 
@@ -3420,10 +3420,10 @@ ParamType::ParamType (bool is_trait_self, std::string symbol, location_t locus,
                      HirId ref, HirId ty_ref, HIR::GenericParam &param,
                      std::vector<TypeBoundPredicate> specified_bounds,
                      std::set<HirId> refs)
-  : BaseType (ref, ty_ref, KIND,
-             {Resolver::CanonicalPath::new_seg (UNKNOWN_NODEID, symbol),
-              locus},
-             specified_bounds, refs),
+  : BaseGeneric (ref, ty_ref, KIND,
+                {Resolver::CanonicalPath::new_seg (UNKNOWN_NODEID, symbol),
+                 locus},
+                specified_bounds, refs),
     is_trait_self (is_trait_self), symbol (symbol), param (param)
 {}
 

diff --git a/gcc/rust/typecheck/rust-tyty.h b/gcc/rust/typecheck/rust-tyty.h
index 13e9184f29d79d23c8b64f0c5ba38f7318fbda13..381bbeb835d753bbba4446fe5eecb2e0a082b800 100644 (file)
--- a/gcc/rust/typecheck/rust-tyty.h
+++ b/gcc/rust/typecheck/rust-tyty.h
@@ -365,7 +365,26 @@ public:
   std::string get_name () const override final;
 };
 
-class ParamType : public BaseType
+class BaseGeneric : public BaseType
+{
+public:
+  virtual std::string get_symbol () const = 0;
+
+  virtual HIR::GenericParam &get_generic_param () = 0;
+
+  virtual bool can_resolve () const = 0;
+
+  virtual BaseType *resolve () const = 0;
+
+protected:
+  BaseGeneric (HirId ref, HirId ty_ref, TypeKind kind, RustIdent ident,
+              std::vector<TypeBoundPredicate> specified_bounds,
+              std::set<HirId> refs = std::set<HirId> ())
+    : BaseType (ref, ty_ref, kind, ident, specified_bounds, refs)
+  {}
+};
+
+class ParamType : public BaseGeneric
 {
 public:
   static constexpr auto KIND = TypeKind::PARAM;
@@ -389,13 +408,13 @@ public:
 
   BaseType *clone () const final override;
 
-  std::string get_symbol () const;
+  std::string get_symbol () const override final;
 
-  HIR::GenericParam &get_generic_param ();
+  HIR::GenericParam &get_generic_param () override final;
 
-  bool can_resolve () const;
+  bool can_resolve () const override final;
 
-  BaseType *resolve () const;
+  BaseType *resolve () const override final;
 
   std::string get_name () const override final;
 
@@ -523,7 +542,7 @@ public:
 
   TypeBoundPredicate (const TypeBoundPredicate &other);
 
-  virtual ~TypeBoundPredicate (){};
+  virtual ~TypeBoundPredicate () {};
 
   TypeBoundPredicate &operator= (const TypeBoundPredicate &other);