Prevent multiple resolution insertion

gcc/rust/ChangeLog:

	* expand/rust-derive-clone.cc
	(DeriveClone::clone_impl): Avoid using the same node id multiple
	times.
	(DeriveClone::clone_enum_identifier): Likewise.
	(DeriveClone::clone_enum_tuple): Likewise.
	* expand/rust-derive-copy.cc
	(DeriveCopy::copy_impl): Likewise.
	* resolve/rust-ast-resolve-item.cc
	(flatten_list): Likewise.
	* resolve/rust-ast-resolve-path.cc
	(ResolvePath::resolve_path): Prevent reinsertion of resolutions.
	* resolve/rust-ast-resolve-type.cc
	(ResolveRelativeTypePath::go): Likewise.
	* typecheck/rust-hir-type-check-expr.cc
	(TypeCheckExpr::resolve_fn_trait_call): Likewise.
	* resolve/rust-name-resolver.cc
	(Resolver::insert_resolved_name): Catch multiple resolution
	insertions.
	(Resolver::insert_resolved_type): Likewise.

gcc/testsuite/ChangeLog:

	* rust/compile/nr2/exclude: Remove entries.

Signed-off-by: Owen Avery <powerboat9.gamer@gmail.com>

diff --git a/gcc/rust/expand/rust-derive-clone.cc b/gcc/rust/expand/rust-derive-clone.cc
index 3c4c8894631221b518377890e4d5f661d5f7152e..00abb593c17ee207a1804fcde5cd73bf6e036917 100644 (file)
--- a/gcc/rust/expand/rust-derive-clone.cc
+++ b/gcc/rust/expand/rust-derive-clone.cc
@@ -91,14 +91,17 @@ DeriveClone::clone_impl (
   std::unique_ptr<AssociatedItem> &&clone_fn, std::string name,
   const std::vector<std::unique_ptr<GenericParam>> &type_generics)
 {
-  auto clone = builder.type_path (LangItem::Kind::CLONE);
+  // we should have two of these, so we don't run into issues with
+  // two paths sharing a node id
+  auto clone_bound = builder.type_path (LangItem::Kind::CLONE);
+  auto clone_trait_path = builder.type_path (LangItem::Kind::CLONE);
 
   auto trait_items = vec (std::move (clone_fn));
 
-  auto generics
-    = setup_impl_generics (name, type_generics, builder.trait_bound (clone));
+  auto generics = setup_impl_generics (name, type_generics,
+                                      builder.trait_bound (clone_bound));
 
-  return builder.trait_impl (clone, std::move (generics.self_type),
+  return builder.trait_impl (clone_trait_path, std::move (generics.self_type),
                             std::move (trait_items),
                             std::move (generics.impl));
 }
@@ -173,9 +176,14 @@ DeriveClone::clone_enum_identifier (PathInExpression variant_path,
                                    const std::unique_ptr<EnumItem> &variant)
 {
   auto pattern = std::unique_ptr<Pattern> (new ReferencePattern (
-    std::unique_ptr<Pattern> (new PathInExpression (variant_path)), false,
-    false, loc));
-  auto expr = std::unique_ptr<Expr> (new PathInExpression (variant_path));
+    std::unique_ptr<Pattern> (new PathInExpression (
+      variant_path.get_segments (), {}, variant_path.get_locus (),
+      variant_path.opening_scope_resolution ())),
+    false, false, loc));
+  auto expr = std::unique_ptr<Expr> (
+    new PathInExpression (variant_path.get_segments (), {},
+                         variant_path.get_locus (),
+                         variant_path.opening_scope_resolution ()));
 
   return builder.match_case (std::move (pattern), std::move (expr));
 }
@@ -206,14 +214,19 @@ DeriveClone::clone_enum_tuple (PathInExpression variant_path,
   auto pattern_items = std::unique_ptr<TupleStructItems> (
     new TupleStructItemsNoRange (std::move (patterns)));
 
-  auto pattern = std::unique_ptr<Pattern> (
-    new ReferencePattern (std::unique_ptr<Pattern> (new TupleStructPattern (
-                           variant_path, std::move (pattern_items))),
-                         false, false, loc));
-
-  auto expr
-    = builder.call (std::unique_ptr<Expr> (new PathInExpression (variant_path)),
-                   std::move (cloned_patterns));
+  auto pattern = std::unique_ptr<Pattern> (new ReferencePattern (
+    std::unique_ptr<Pattern> (new TupleStructPattern (
+      PathInExpression (variant_path.get_segments (), {},
+                       variant_path.get_locus (),
+                       variant_path.opening_scope_resolution ()),
+      std::move (pattern_items))),
+    false, false, loc));
+
+  auto expr = builder.call (std::unique_ptr<Expr> (new PathInExpression (
+                             variant_path.get_segments (), {},
+                             variant_path.get_locus (),
+                             variant_path.opening_scope_resolution ())),
+                           std::move (cloned_patterns));
 
   return builder.match_case (std::move (pattern), std::move (expr));
 }

diff --git a/gcc/rust/expand/rust-derive-copy.cc b/gcc/rust/expand/rust-derive-copy.cc
index 0c173f969876b7dae8ea60949e7bf719778a3c8e..025d179148319fffbaaa2cdad5b0876fe5c2fb9a 100644 (file)
--- a/gcc/rust/expand/rust-derive-copy.cc
+++ b/gcc/rust/expand/rust-derive-copy.cc
@@ -42,13 +42,16 @@ DeriveCopy::copy_impl (
   std::string name,
   const std::vector<std::unique_ptr<GenericParam>> &type_generics)
 {
-  auto copy = builder.type_path (LangItem::Kind::COPY);
+  // we should have two of these, so we don't run into issues with
+  // two paths sharing a node id
+  auto copy_bound = builder.type_path (LangItem::Kind::COPY);
+  auto copy_trait_path = builder.type_path (LangItem::Kind::COPY);
 
-  auto generics
-    = setup_impl_generics (name, type_generics, builder.trait_bound (copy));
+  auto generics = setup_impl_generics (name, type_generics,
+                                      builder.trait_bound (copy_bound));
 
-  return builder.trait_impl (copy, std::move (generics.self_type), {},
-                            std::move (generics.impl));
+  return builder.trait_impl (copy_trait_path, std::move (generics.self_type),
+                            {}, std::move (generics.impl));
 }
 
 void

diff --git a/gcc/rust/resolve/rust-ast-resolve-item.cc b/gcc/rust/resolve/rust-ast-resolve-item.cc
index c96da3da3f13a5537a9572738ea12030ecf2544f..89cf0f3c07e3bf7690f7f7e39037b2415244fb6b 100644 (file)
--- a/gcc/rust/resolve/rust-ast-resolve-item.cc
+++ b/gcc/rust/resolve/rust-ast-resolve-item.cc
@@ -903,7 +903,18 @@ flatten_list (const AST::UseTreeList &list, std::vector<Import> &imports)
 
       for (auto import = imports.begin () + start_idx; import != imports.end ();
           import++)
-       import->add_prefix (prefix);
+       {
+         // avoid duplicate node ids
+         auto prefix_copy
+           = AST::SimplePath ({}, prefix.has_opening_scope_resolution (),
+                              prefix.get_locus ());
+         for (auto &seg : prefix.get_segments ())
+           prefix_copy.get_segments ().push_back (
+             AST::SimplePathSegment (seg.get_segment_name (),
+                                     seg.get_locus ()));
+
+         import->add_prefix (std::move (prefix_copy));
+       }
     }
 }
 

diff --git a/gcc/rust/resolve/rust-ast-resolve-path.cc b/gcc/rust/resolve/rust-ast-resolve-path.cc
index 656b7e64bb73eadc6f19a97745f4c6232ab0990c..b2b10719e19086978bcb224bf11178fb82751774 100644 (file)
--- a/gcc/rust/resolve/rust-ast-resolve-path.cc
+++ b/gcc/rust/resolve/rust-ast-resolve-path.cc
@@ -80,8 +80,16 @@ ResolvePath::resolve_path (AST::PathInExpression &expr)
          // what is the current crate scope node id?
          module_scope_id = crate_scope_id;
          previous_resolved_node_id = module_scope_id;
-         resolver->insert_resolved_name (segment.get_node_id (),
-                                         module_scope_id);
+
+         NodeId existing = UNKNOWN_NODEID;
+         bool ok = resolver->lookup_resolved_name (segment.get_node_id (),
+                                                   &existing);
+
+         if (ok)
+           rust_assert (existing == module_scope_id);
+         else
+           resolver->insert_resolved_name (segment.get_node_id (),
+                                           module_scope_id);
          continue;
        }
       else if (segment.is_super_path_seg ())
@@ -95,8 +103,16 @@ ResolvePath::resolve_path (AST::PathInExpression &expr)
 
          module_scope_id = resolver->peek_parent_module_scope ();
          previous_resolved_node_id = module_scope_id;
-         resolver->insert_resolved_name (segment.get_node_id (),
-                                         module_scope_id);
+
+         NodeId existing = UNKNOWN_NODEID;
+         bool ok = resolver->lookup_resolved_name (segment.get_node_id (),
+                                                   &existing);
+
+         if (ok)
+           rust_assert (existing == module_scope_id);
+         else
+           resolver->insert_resolved_name (segment.get_node_id (),
+                                           module_scope_id);
          continue;
        }
 
@@ -140,23 +156,45 @@ ResolvePath::resolve_path (AST::PathInExpression &expr)
                                      ident_seg.as_string ());
          if (resolver->get_name_scope ().lookup (path, &resolved_node))
            {
-             resolver->insert_resolved_name (segment.get_node_id (),
-                                             resolved_node);
+             NodeId existing = UNKNOWN_NODEID;
+             bool ok = resolver->lookup_resolved_name (segment.get_node_id (),
+                                                       &existing);
+
+             if (ok)
+               rust_assert (existing == resolved_node);
+             else
+               resolver->insert_resolved_name (segment.get_node_id (),
+                                               resolved_node);
              resolved_node_id = resolved_node;
            }
          // check the type scope
          else if (resolver->get_type_scope ().lookup (path, &resolved_node))
            {
-             resolver->insert_resolved_type (segment.get_node_id (),
-                                             resolved_node);
+             NodeId existing = UNKNOWN_NODEID;
+             bool ok = resolver->lookup_resolved_type (segment.get_node_id (),
+                                                       &existing);
+
+             if (ok)
+               rust_assert (existing == resolved_node);
+             else
+               resolver->insert_resolved_type (segment.get_node_id (),
+                                               resolved_node);
              resolved_node_id = resolved_node;
            }
          else if (segment.is_lower_self_seg ())
            {
              module_scope_id = crate_scope_id;
              previous_resolved_node_id = module_scope_id;
-             resolver->insert_resolved_name (segment.get_node_id (),
-                                             module_scope_id);
+
+             NodeId existing = UNKNOWN_NODEID;
+             bool ok = resolver->lookup_resolved_name (segment.get_node_id (),
+                                                       &existing);
+
+             if (ok)
+               rust_assert (existing == module_scope_id);
+             else
+               resolver->insert_resolved_name (segment.get_node_id (),
+                                               module_scope_id);
              continue;
            }
          else
@@ -179,15 +217,33 @@ ResolvePath::resolve_path (AST::PathInExpression &expr)
                    resolved_node))
                {
                  resolved_node_id = resolved_node;
-                 resolver->insert_resolved_name (segment.get_node_id (),
-                                                 resolved_node);
+
+                 NodeId existing = UNKNOWN_NODEID;
+                 bool ok
+                   = resolver->lookup_resolved_name (segment.get_node_id (),
+                                                     &existing);
+
+                 if (ok)
+                   rust_assert (existing == resolved_node);
+                 else
+                   resolver->insert_resolved_name (segment.get_node_id (),
+                                                   resolved_node);
                }
              else if (resolver->get_type_scope ().decl_was_declared_here (
                         resolved_node))
                {
                  resolved_node_id = resolved_node;
-                 resolver->insert_resolved_type (segment.get_node_id (),
-                                                 resolved_node);
+
+                 NodeId existing = UNKNOWN_NODEID;
+                 bool ok
+                   = resolver->lookup_resolved_type (segment.get_node_id (),
+                                                     &existing);
+
+                 if (ok)
+                   rust_assert (existing == resolved_node);
+                 else
+                   resolver->insert_resolved_type (segment.get_node_id (),
+                                                   resolved_node);
                }
              else
                {
@@ -224,15 +280,29 @@ ResolvePath::resolve_path (AST::PathInExpression &expr)
       // name scope first
       if (resolver->get_name_scope ().decl_was_declared_here (resolved_node_id))
        {
-         resolver->insert_resolved_name (expr.get_node_id (),
-                                         resolved_node_id);
+         NodeId existing = UNKNOWN_NODEID;
+         bool ok
+           = resolver->lookup_resolved_name (expr.get_node_id (), &existing);
+
+         if (ok)
+           rust_assert (existing == resolved_node_id);
+         else
+           resolver->insert_resolved_name (expr.get_node_id (),
+                                           resolved_node_id);
        }
       // check the type scope
       else if (resolver->get_type_scope ().decl_was_declared_here (
                 resolved_node_id))
        {
-         resolver->insert_resolved_type (expr.get_node_id (),
-                                         resolved_node_id);
+         NodeId existing = UNKNOWN_NODEID;
+         bool ok
+           = resolver->lookup_resolved_type (expr.get_node_id (), &existing);
+
+         if (ok)
+           rust_assert (existing == resolved_node_id);
+         else
+           resolver->insert_resolved_type (expr.get_node_id (),
+                                           resolved_node_id);
        }
       else
        {
@@ -284,8 +354,16 @@ ResolvePath::resolve_path (AST::SimplePath &expr)
          // what is the current crate scope node id?
          module_scope_id = crate_scope_id;
          previous_resolved_node_id = module_scope_id;
-         resolver->insert_resolved_name (segment.get_node_id (),
-                                         module_scope_id);
+
+         NodeId existing = UNKNOWN_NODEID;
+         bool ok = resolver->lookup_resolved_name (segment.get_node_id (),
+                                                   &existing);
+
+         if (ok)
+           rust_assert (existing == module_scope_id);
+         else
+           resolver->insert_resolved_name (segment.get_node_id (),
+                                           module_scope_id);
          resolved_node_id = module_scope_id;
 
          continue;
@@ -301,8 +379,16 @@ ResolvePath::resolve_path (AST::SimplePath &expr)
 
          module_scope_id = resolver->peek_parent_module_scope ();
          previous_resolved_node_id = module_scope_id;
-         resolver->insert_resolved_name (segment.get_node_id (),
-                                         module_scope_id);
+
+         NodeId existing = UNKNOWN_NODEID;
+         bool ok = resolver->lookup_resolved_name (segment.get_node_id (),
+                                                   &existing);
+
+         if (ok)
+           rust_assert (existing == module_scope_id);
+         else
+           resolver->insert_resolved_name (segment.get_node_id (),
+                                           module_scope_id);
          resolved_node_id = module_scope_id;
 
          continue;
@@ -318,15 +404,31 @@ ResolvePath::resolve_path (AST::SimplePath &expr)
                resolved_node))
            {
              resolved_node_id = resolved_node;
-             resolver->insert_resolved_name (segment.get_node_id (),
-                                             resolved_node);
+
+             NodeId existing = UNKNOWN_NODEID;
+             bool ok = resolver->lookup_resolved_name (segment.get_node_id (),
+                                                       &existing);
+
+             if (ok)
+               rust_assert (existing == resolved_node);
+             else
+               resolver->insert_resolved_name (segment.get_node_id (),
+                                               resolved_node);
            }
          else if (resolver->get_type_scope ().decl_was_declared_here (
                     resolved_node))
            {
              resolved_node_id = resolved_node;
-             resolver->insert_resolved_type (segment.get_node_id (),
-                                             resolved_node);
+
+             NodeId existing = UNKNOWN_NODEID;
+             bool ok = resolver->lookup_resolved_type (segment.get_node_id (),
+                                                       &existing);
+
+             if (ok)
+               rust_assert (existing == resolved_node);
+             else
+               resolver->insert_resolved_type (segment.get_node_id (),
+                                               resolved_node);
            }
          else
            {
@@ -347,15 +449,31 @@ ResolvePath::resolve_path (AST::SimplePath &expr)
          if (resolver->get_name_scope ().lookup (path, &resolved_node))
            {
              resolved_node_id = resolved_node;
-             resolver->insert_resolved_name (segment.get_node_id (),
-                                             resolved_node);
+
+             NodeId existing = UNKNOWN_NODEID;
+             bool ok = resolver->lookup_resolved_name (segment.get_node_id (),
+                                                       &existing);
+
+             if (ok)
+               rust_assert (existing == resolved_node);
+             else
+               resolver->insert_resolved_name (segment.get_node_id (),
+                                               resolved_node);
            }
          // check the type scope
          else if (resolver->get_type_scope ().lookup (path, &resolved_node))
            {
              resolved_node_id = resolved_node;
-             resolver->insert_resolved_type (segment.get_node_id (),
-                                             resolved_node);
+
+             NodeId existing = UNKNOWN_NODEID;
+             bool ok = resolver->lookup_resolved_type (segment.get_node_id (),
+                                                       &existing);
+
+             if (ok)
+               rust_assert (existing == resolved_node);
+             else
+               resolver->insert_resolved_type (segment.get_node_id (),
+                                               resolved_node);
            }
        }
 
@@ -398,15 +516,29 @@ ResolvePath::resolve_path (AST::SimplePath &expr)
       // name scope first
       if (resolver->get_name_scope ().decl_was_declared_here (resolved_node_id))
        {
-         resolver->insert_resolved_name (expr.get_node_id (),
-                                         resolved_node_id);
+         NodeId existing = UNKNOWN_NODEID;
+         bool ok
+           = resolver->lookup_resolved_name (expr.get_node_id (), &existing);
+
+         if (ok)
+           rust_assert (existing == resolved_node_id);
+         else
+           resolver->insert_resolved_name (expr.get_node_id (),
+                                           resolved_node_id);
        }
       // check the type scope
       else if (resolver->get_type_scope ().decl_was_declared_here (
                 resolved_node_id))
        {
-         resolver->insert_resolved_type (expr.get_node_id (),
-                                         resolved_node_id);
+         NodeId existing = UNKNOWN_NODEID;
+         bool ok
+           = resolver->lookup_resolved_type (expr.get_node_id (), &existing);
+
+         if (ok)
+           rust_assert (existing == resolved_node_id);
+         else
+           resolver->insert_resolved_type (expr.get_node_id (),
+                                           resolved_node_id);
        }
       else
        {

diff --git a/gcc/rust/resolve/rust-ast-resolve-type.cc b/gcc/rust/resolve/rust-ast-resolve-type.cc
index 243291751290e91259b6233fc8833c95781028fd..c1c40227b4f3fd6d7a7c2eed54080083b93b4fd8 100644 (file)
--- a/gcc/rust/resolve/rust-ast-resolve-type.cc
+++ b/gcc/rust/resolve/rust-ast-resolve-type.cc
@@ -249,14 +249,28 @@ ResolveRelativeTypePath::go (AST::TypePath &path, NodeId &resolved_node_id)
            = CanonicalPath::new_seg (segment->get_node_id (), ident_string);
          if (resolver->get_type_scope ().lookup (path, &resolved_node))
            {
-             resolver->insert_resolved_type (segment->get_node_id (),
-                                             resolved_node);
+             NodeId existing = UNKNOWN_NODEID;
+             bool ok = resolver->lookup_resolved_type (segment->get_node_id (),
+                                                       &existing);
+
+             if (ok)
+               rust_assert (existing == resolved_node);
+             else
+               resolver->insert_resolved_type (segment->get_node_id (),
+                                               resolved_node);
              resolved_node_id = resolved_node;
            }
          else if (resolver->get_name_scope ().lookup (path, &resolved_node))
            {
-             resolver->insert_resolved_name (segment->get_node_id (),
-                                             resolved_node);
+             NodeId existing = UNKNOWN_NODEID;
+             bool ok = resolver->lookup_resolved_name (segment->get_node_id (),
+                                                       &existing);
+
+             if (ok)
+               rust_assert (existing == resolved_node);
+             else
+               resolver->insert_resolved_name (segment->get_node_id (),
+                                               resolved_node);
              resolved_node_id = resolved_node;
            }
          else if (!segment->is_lang_item () && segment->is_lower_self_seg ())
@@ -264,8 +278,16 @@ ResolveRelativeTypePath::go (AST::TypePath &path, NodeId &resolved_node_id)
              // what is the current crate scope node id?
              module_scope_id = crate_scope_id;
              previous_resolved_node_id = module_scope_id;
-             resolver->insert_resolved_name (segment->get_node_id (),
-                                             module_scope_id);
+
+             NodeId existing = UNKNOWN_NODEID;
+             bool ok = resolver->lookup_resolved_name (segment->get_node_id (),
+                                                       &existing);
+
+             if (ok)
+               rust_assert (existing == module_scope_id);
+             else
+               resolver->insert_resolved_name (segment->get_node_id (),
+                                               module_scope_id);
 
              continue;
            }
@@ -283,15 +305,33 @@ ResolveRelativeTypePath::go (AST::TypePath &path, NodeId &resolved_node_id)
                    resolved_node))
                {
                  resolved_node_id = resolved_node;
-                 resolver->insert_resolved_name (segment->get_node_id (),
-                                                 resolved_node);
+
+                 NodeId existing = UNKNOWN_NODEID;
+                 bool ok
+                   = resolver->lookup_resolved_name (segment->get_node_id (),
+                                                     &existing);
+
+                 if (ok)
+                   rust_assert (existing == resolved_node);
+                 else
+                   resolver->insert_resolved_name (segment->get_node_id (),
+                                                   resolved_node);
                }
              else if (resolver->get_type_scope ().decl_was_declared_here (
                         resolved_node))
                {
                  resolved_node_id = resolved_node;
-                 resolver->insert_resolved_type (segment->get_node_id (),
-                                                 resolved_node);
+
+                 NodeId existing = UNKNOWN_NODEID;
+                 bool ok
+                   = resolver->lookup_resolved_type (segment->get_node_id (),
+                                                     &existing);
+
+                 if (ok)
+                   rust_assert (existing == resolved_node);
+                 else
+                   resolver->insert_resolved_type (segment->get_node_id (),
+                                                   resolved_node);
                }
              else
                {
@@ -327,15 +367,29 @@ ResolveRelativeTypePath::go (AST::TypePath &path, NodeId &resolved_node_id)
       // name scope first
       if (resolver->get_name_scope ().decl_was_declared_here (resolved_node_id))
        {
-         resolver->insert_resolved_name (path.get_node_id (),
-                                         resolved_node_id);
+         NodeId existing = UNKNOWN_NODEID;
+         bool ok
+           = resolver->lookup_resolved_name (path.get_node_id (), &existing);
+
+         if (ok)
+           rust_assert (existing == resolved_node_id);
+         else
+           resolver->insert_resolved_name (path.get_node_id (),
+                                           resolved_node_id);
        }
       // check the type scope
       else if (resolver->get_type_scope ().decl_was_declared_here (
                 resolved_node_id))
        {
-         resolver->insert_resolved_type (path.get_node_id (),
-                                         resolved_node_id);
+         NodeId existing = UNKNOWN_NODEID;
+         bool ok
+           = resolver->lookup_resolved_type (path.get_node_id (), &existing);
+
+         if (ok)
+           rust_assert (existing == resolved_node_id);
+         else
+           resolver->insert_resolved_type (path.get_node_id (),
+                                           resolved_node_id);
        }
       else
        {

diff --git a/gcc/rust/resolve/rust-name-resolver.cc b/gcc/rust/resolve/rust-name-resolver.cc
index 31da593b86c8807559a2bf241ca1657e57310a52..6f2101dcd860e4d8443ec739ba435c9b18bc4eb0 100644 (file)
--- a/gcc/rust/resolve/rust-name-resolver.cc
+++ b/gcc/rust/resolve/rust-name-resolver.cc
@@ -472,6 +472,8 @@ void
 Resolver::insert_resolved_name (NodeId refId, NodeId defId)
 {
   rust_assert (!flag_name_resolution_2_0);
+  rust_assert (resolved_names.find (refId) == resolved_names.end ());
+
   resolved_names[refId] = defId;
   get_name_scope ().append_reference_for_def (refId, defId);
   insert_captured_item (defId);
@@ -492,9 +494,8 @@ Resolver::lookup_resolved_name (NodeId refId, NodeId *defId)
 void
 Resolver::insert_resolved_type (NodeId refId, NodeId defId)
 {
-  // auto it = resolved_types.find (refId);
-  // rust_assert (it == resolved_types.end ());
   rust_assert (!flag_name_resolution_2_0);
+  rust_assert (resolved_types.find (refId) == resolved_types.end ());
 
   resolved_types[refId] = defId;
   get_type_scope ().append_reference_for_def (refId, defId);

diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.cc b/gcc/rust/typecheck/rust-hir-type-check-expr.cc
index 8d000113c082aa31c72227626e5723f3680ffaae..09f078a6001d79917e34bce0f9ad9452521ddab2 100644 (file)
--- a/gcc/rust/typecheck/rust-hir-type-check-expr.cc
+++ b/gcc/rust/typecheck/rust-hir-type-check-expr.cc
@@ -2124,13 +2124,26 @@ TypeCheckExpr::resolve_fn_trait_call (HIR::CallExpr &expr,
       auto &nr_ctx = const_cast<Resolver2_0::NameResolutionContext &> (
        Resolver2_0::ImmutableNameResolutionContext::get ().resolver ());
 
-      nr_ctx.map_usage (Resolver2_0::Usage (expr.get_mappings ().get_nodeid ()),
-                       Resolver2_0::Definition (resolved_node_id));
+      auto existing = nr_ctx.lookup (expr.get_mappings ().get_nodeid ());
+      if (existing)
+       rust_assert (*existing == resolved_node_id);
+      else
+       nr_ctx.map_usage (Resolver2_0::Usage (
+                           expr.get_mappings ().get_nodeid ()),
+                         Resolver2_0::Definition (resolved_node_id));
     }
   else
     {
-      resolver->insert_resolved_name (expr.get_mappings ().get_nodeid (),
-                                     resolved_node_id);
+      NodeId existing = UNKNOWN_NODEID;
+      bool ok
+       = resolver->lookup_resolved_name (expr.get_mappings ().get_nodeid (),
+                                         &existing);
+
+      if (ok)
+       rust_assert (existing == resolved_node_id);
+      else
+       resolver->insert_resolved_name (expr.get_mappings ().get_nodeid (),
+                                       resolved_node_id);
     }
 
   // return the result of the function back

diff --git a/gcc/testsuite/rust/compile/nr2/exclude b/gcc/testsuite/rust/compile/nr2/exclude
index a2a833f90738710ab12a02fd6ed354d5ba76cd09..0252028fb8f7161703b98a7d6e6cd12308907ff7 100644 (file)
--- a/gcc/testsuite/rust/compile/nr2/exclude
+++ b/gcc/testsuite/rust/compile/nr2/exclude
@@ -5,7 +5,6 @@ const_generics_3.rs
 const_generics_4.rs
 feature_rust_attri0.rs
 generics9.rs
-issue-1483.rs
 issue-1901.rs
 issue-1981.rs
 issue-2043.rs
@@ -34,14 +33,9 @@ undeclared_label.rs
 use_1.rs
 while_break_expr.rs
 issue-3139-2.rs
-issue-2953-2.rs
 issue-2905-2.rs
 issue-266.rs
-derive_clone_enum1.rs
-derive_clone_enum2.rs
 derive_clone_enum3.rs
-issue-3139-1.rs
-issue-3139-3.rs
 derive-debug1.rs
 derive-default1.rs
 issue-3402-1.rs