gccrs: Refactor substitution param mapping to be more abstract

This is an initial patch required to refactor our generics code to be
simpler and more abstract so we return the HIR::GenericParam in ParamMappings
instead of assuming its a TypeParam so we can slowly introduce ConstGenericParam
into this same flow.

gcc/rust/ChangeLog:

	* typecheck/rust-hir-type-check-base.cc: check for type param
	* typecheck/rust-tyty-subst.cc (SubstitutionParamMapping::SubstitutionParamMapping):
	return HIR::GenericParam base class
	(SubstitutionParamMapping::get_generic_param): likewise
	(SubstitutionParamMapping::get_type_representation): new helper
	(SubstitutionParamMapping::param_has_default_ty): check for param type
	(SubstitutionParamMapping::get_default_ty): likewise
	* typecheck/rust-tyty-subst.h: get the locus from the subst HIR::GenericParam now
	* typecheck/rust-tyty-variance-analysis.cc (GenericTyPerCrateCtx::debug_print_solutions):
	likwise
	(GenericTyVisitorCtx::process_type): likewise

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

diff --git a/gcc/rust/typecheck/rust-hir-type-check-base.cc b/gcc/rust/typecheck/rust-hir-type-check-base.cc
index c1f15afae61e3c38ad9039e292510a466c7aaf4e..acc331620ba53f2660d74f0b67ed6736f35ccb28 100644 (file)
--- a/gcc/rust/typecheck/rust-hir-type-check-base.cc
+++ b/gcc/rust/typecheck/rust-hir-type-check-base.cc
@@ -512,9 +512,13 @@ TypeCheckBase::resolve_generic_params (
   // now walk them to setup any specified type param bounds
   for (auto &subst : substitutions)
     {
+      auto &generic = subst.get_generic_param ();
+      if (generic.get_kind () != HIR::GenericParam::GenericKind::TYPE)
+       continue;
+
+      auto &type_param = static_cast<HIR::TypeParam &> (generic);
       auto pty = subst.get_param_ty ();
-      TypeResolveGenericParam::ApplyAnyTraitBounds (subst.get_generic_param (),
-                                                   pty);
+      TypeResolveGenericParam::ApplyAnyTraitBounds (type_param, pty);
     }
 }
 

diff --git a/gcc/rust/typecheck/rust-tyty-subst.cc b/gcc/rust/typecheck/rust-tyty-subst.cc
index 2d5e87e5addad7ca9ee559c58f829bb9e4044dbb..13aca42182f21e8a0d42dcd2a257239b92162bef 100644 (file)
--- a/gcc/rust/typecheck/rust-tyty-subst.cc
+++ b/gcc/rust/typecheck/rust-tyty-subst.cc
@@ -28,7 +28,7 @@
 namespace Rust {
 namespace TyTy {
 
-SubstitutionParamMapping::SubstitutionParamMapping (HIR::TypeParam &generic,
+SubstitutionParamMapping::SubstitutionParamMapping (HIR::GenericParam &generic,
                                                    ParamType *param)
   : generic (generic), param (param)
 {}
@@ -66,13 +66,13 @@ SubstitutionParamMapping::get_param_ty () const
   return param;
 }
 
-HIR::TypeParam &
+HIR::GenericParam &
 SubstitutionParamMapping::get_generic_param ()
 {
   return generic;
 }
 
-const HIR::TypeParam &
+const HIR::GenericParam &
 SubstitutionParamMapping::get_generic_param () const
 {
   return generic;
@@ -84,6 +84,14 @@ SubstitutionParamMapping::needs_substitution () const
   return !(get_param_ty ()->is_concrete ());
 }
 
+Identifier
+SubstitutionParamMapping::get_type_representation () const
+{
+  rust_assert (generic.get_kind () == HIR::GenericParam::GenericKind::TYPE);
+  const auto &type_param = static_cast<const HIR::TypeParam &> (generic);
+  return type_param.get_type_representation ();
+}
+
 location_t
 SubstitutionParamMapping::get_param_locus () const
 {
@@ -93,13 +101,20 @@ SubstitutionParamMapping::get_param_locus () const
 bool
 SubstitutionParamMapping::param_has_default_ty () const
 {
-  return generic.has_type ();
+  if (generic.get_kind () != HIR::GenericParam::GenericKind::TYPE)
+    return false;
+
+  const auto &type_param = static_cast<const HIR::TypeParam &> (generic);
+  return type_param.has_type ();
 }
 
 BaseType *
 SubstitutionParamMapping::get_default_ty () const
 {
-  TyVar var (generic.get_type_mappings ().get_hirid ());
+  rust_assert (generic.get_kind () == HIR::GenericParam::GenericKind::TYPE);
+
+  const auto &type_param = static_cast<const HIR::TypeParam &> (generic);
+  TyVar var (type_param.get_type_mappings ().get_hirid ());
   return var.get_tyty ();
 }
 
@@ -675,7 +690,11 @@ SubstitutionRef::get_mappings_from_generic_args (
     {
       rich_location r (line_table, args.get_locus ());
       if (!substitutions.empty ())
-       r.add_range (substitutions.front ().get_param_locus ());
+       {
+         const auto &subst = substitutions.front ();
+         const auto &generic = subst.get_generic_param ();
+         r.add_range (generic.get_locus ());
+       }
 
       rust_error_at (
        r,
@@ -688,7 +707,12 @@ SubstitutionRef::get_mappings_from_generic_args (
   if (args.get_type_args ().size () + offs < min_required_substitutions ())
     {
       rich_location r (line_table, args.get_locus ());
-      r.add_range (substitutions.front ().get_param_locus ());
+      if (!substitutions.empty ())
+       {
+         const auto &subst = substitutions.front ();
+         const auto &generic = subst.get_generic_param ();
+         r.add_range (generic.get_locus ());
+       }
 
       rust_error_at (
        r, ErrorCode::E0107,
@@ -708,15 +732,20 @@ SubstitutionRef::get_mappings_from_generic_args (
        }
 
       const auto &param_mapping = substitutions.at (offs);
-      const auto &type_param = param_mapping.get_generic_param ();
-      if (type_param.from_impl_trait ())
+      const auto &generic = param_mapping.get_generic_param ();
+      if (generic.get_kind () == HIR::GenericParam::GenericKind::TYPE)
        {
-         rich_location r (line_table, arg->get_locus ());
-         r.add_fixit_remove (arg->get_locus ());
-         rust_error_at (r, ErrorCode::E0632,
-                        "cannot provide explicit generic arguments when "
-                        "%<impl Trait%> is used in argument position");
-         return SubstitutionArgumentMappings::error ();
+         const auto &type_param
+           = static_cast<const HIR::TypeParam &> (generic);
+         if (type_param.from_impl_trait ())
+           {
+             rich_location r (line_table, arg->get_locus ());
+             r.add_fixit_remove (arg->get_locus ());
+             rust_error_at (r, ErrorCode::E0632,
+                            "cannot provide explicit generic arguments when "
+                            "%<impl Trait%> is used in argument position");
+             return SubstitutionArgumentMappings::error ();
+           }
        }
 
       SubstitutionArg subst_arg (&param_mapping, resolved);

diff --git a/gcc/rust/typecheck/rust-tyty-subst.h b/gcc/rust/typecheck/rust-tyty-subst.h
index 141db3d448b76f4314113c420ef64c558d74d733..f78242499eaf1b87f2356d2287169002045403b7 100644 (file)
--- a/gcc/rust/typecheck/rust-tyty-subst.h
+++ b/gcc/rust/typecheck/rust-tyty-subst.h
@@ -24,6 +24,7 @@
 #include "rust-hir-full-decls.h"
 #include "rust-tyty-bounds.h"
 #include "rust-tyty-region.h"
+#include "rust-ast.h"
 #include "optional.h"
 
 namespace Rust {
@@ -44,7 +45,7 @@ class SubstitutionArgumentMappings;
 class SubstitutionParamMapping
 {
 public:
-  SubstitutionParamMapping (HIR::TypeParam &generic, ParamType *param);
+  SubstitutionParamMapping (HIR::GenericParam &generic, ParamType *param);
 
   SubstitutionParamMapping (const SubstitutionParamMapping &other);
 
@@ -56,11 +57,12 @@ public:
   SubstitutionParamMapping clone () const;
 
   ParamType *get_param_ty ();
-
   const ParamType *get_param_ty () const;
 
-  HIR::TypeParam &get_generic_param ();
-  const HIR::TypeParam &get_generic_param () const;
+  HIR::GenericParam &get_generic_param ();
+  const HIR::GenericParam &get_generic_param () const;
+
+  Identifier get_type_representation () const;
 
   // this is used for the backend to override the HirId ref of the param to
   // what the concrete type is for the rest of the context
@@ -77,7 +79,7 @@ public:
   bool need_substitution () const;
 
 private:
-  HIR::TypeParam &generic;
+  HIR::GenericParam &generic;
   ParamType *param;
 };
 

diff --git a/gcc/rust/typecheck/rust-tyty-variance-analysis.cc b/gcc/rust/typecheck/rust-tyty-variance-analysis.cc
index 38f9d526e045a26c5110a5f4ddfd7d2064a94025..7971ccfd02e93e04aeffb70e7fcedd7712709b8b 100644 (file)
--- a/gcc/rust/typecheck/rust-tyty-variance-analysis.cc
+++ b/gcc/rust/typecheck/rust-tyty-variance-analysis.cc
@@ -199,9 +199,7 @@ GenericTyPerCrateCtx::debug_print_solutions ()
            {
              if (i > solution_index)
                result += ", ";
-             result += param.get_generic_param ()
-                         .get_type_representation ()
-                         .as_string ();
+             result += param.get_type_representation ().as_string ();
              result += "=";
              result += solutions[i].as_string ();
              i++;
@@ -239,8 +237,7 @@ GenericTyVisitorCtx::process_type (ADTType &ty)
   first_type = first_lifetime + ty.get_used_arguments ().get_regions ().size ();
 
   for (auto &param : ty.get_substs ())
-    param_names.push_back (
-      param.get_generic_param ().get_type_representation ().as_string ());
+    param_names.push_back (param.get_type_representation ().as_string ());
 
   for (const auto &variant : ty.get_variants ())
     {