Merge branch 'master' into module_path

Author: Harishankar14

gcc/rust/ast/rust-ast-collector.cc

@@ -2449,7 +2449,11 @@ TokenCollector::visit (Trait &trait)
     push (Rust::Token::make (TRAIT, trait.get_locus ()));
     push (Rust::Token::make_identifier (UNDEF_LOCATION, std::move (id)));
 
-    visit (trait.get_generic_params ());
+    if (trait.has_generics ())
+      visit (trait.get_generic_params ());
+    if (!trait.get_type_param_bounds ().empty ())
+      push (Rust::Token::make ((COLON), trait.get_locus ()));
+    visit_items_joined_by_separator (trait.get_type_param_bounds (), PLUS);
 
     visit_items_as_block (trait.get_trait_items (), {});
   });

gcc/rust/ast/rust-ast.cc

@@ -235,6 +235,14 @@ Crate::as_string () const
   return str + "\n";
 }
 
+void
+Crate::inject_extern_crate (std::string name)
+{
+  items.push_back (std::make_unique<AST::ExternCrate> (
+    AST::ExternCrate (name, AST::Visibility::create_public (UNKNOWN_LOCATION),
+		      {}, UNKNOWN_LOCATION)));
+}
+
 std::string
 Attribute::as_string () const
 {

gcc/rust/ast/rust-ast.h

@@ -2116,6 +2116,8 @@ struct Crate : public GlobContainer
     // TODO: is this the best way to do this?
   }
 
+  void inject_extern_crate (std::string name);
+
   NodeId get_node_id () const { return node_id; }
   const std::vector<Attribute> &get_inner_attrs () const { return inner_attrs; }
   std::vector<Attribute> &get_inner_attrs () { return inner_attrs; }

gcc/rust/expand/rust-macro-expand.cc

@@ -112,9 +112,13 @@ MacroExpander::expand_decl_macro (location_t invoc_locus,
 
   if (matched_rule == nullptr)
     {
-      rich_location r (line_table, invoc_locus);
-      r.add_range (rules_def.get_locus ());
-      rust_error_at (r, "Failed to match any rule within macro");
+      if (!had_duplicate_error)
+	{
+	  rich_location r (line_table, invoc_locus);
+	  r.add_range (rules_def.get_locus ());
+	  rust_error_at (r, "Failed to match any rule within macro");
+	}
+      had_duplicate_error = false;
       return AST::Fragment::create_error ();
     }
 
@@ -535,6 +539,8 @@ MacroExpander::match_matcher (Parser<MacroInvocLexer> &parser,
 
   const MacroInvocLexer &source = parser.get_token_source ();
 
+  std::unordered_map<std::string, location_t> duplicate_check;
+
   for (auto &match : matcher.get_matches ())
     {
       size_t offs_begin = source.get_offs ();
@@ -548,6 +554,21 @@ MacroExpander::match_matcher (Parser<MacroInvocLexer> &parser,
 	    if (!match_fragment (parser, *fragment))
 	      return false;
 
+	    auto duplicate_result = duplicate_check.insert (
+	      std::make_pair (fragment->get_ident ().as_string (),
+			      fragment->get_ident ().get_locus ()));
+
+	    if (!duplicate_result.second)
+	      {
+		// TODO: add range labels?
+		rich_location r (line_table,
+				 fragment->get_ident ().get_locus ());
+		r.add_range (duplicate_result.first->second);
+		rust_error_at (r, "duplicate matcher binding");
+		had_duplicate_error = true;
+		return false;
+	      }
+
 	    // matched fragment get the offset in the token stream
 	    size_t offs_end = source.get_offs ();
 	    sub_stack.insert_metavar (

gcc/rust/expand/rust-macro-expand.h

@@ -300,7 +300,8 @@ struct MacroExpander
     : cfg (cfg), crate (crate), session (session),
       sub_stack (SubstitutionScope ()),
       expanded_fragment (AST::Fragment::create_error ()),
-      has_changed_flag (false), resolver (Resolver::Resolver::get ()),
+      has_changed_flag (false), had_duplicate_error (false),
+      resolver (Resolver::Resolver::get ()),
       mappings (Analysis::Mappings::get ())
   {}
 
@@ -512,6 +513,9 @@ struct MacroExpander
   tl::optional<AST::MacroRulesDefinition &> last_def;
   tl::optional<AST::MacroInvocation &> last_invoc;
 
+  // used to avoid emitting excess errors
+  bool had_duplicate_error;
+
 public:
   Resolver::Resolver *resolver;
   Analysis::Mappings &mappings;

gcc/rust/resolve/rust-forever-stack.hxx

@@ -311,20 +311,25 @@ ForeverStack<N>::get (Node &start, const Identifier &name)
 
     auto candidate = current.rib.get (name.as_string ());
 
-    return candidate.map_or (
-      [&resolved_definition] (Rib::Definition found) {
-	if (found.is_variant ())
+    if (candidate)
+      {
+	if (candidate->is_variant ())
 	  return KeepGoing::Yes;
 	// for most namespaces, we do not need to care about various ribs -
 	// they are available from all contexts if defined in the current
 	// scope, or an outermore one. so if we do have a candidate, we can
 	// return it directly and stop iterating
-	resolved_definition = found;
+	resolved_definition = *candidate;
 
 	return KeepGoing::No;
-      },
-      // if there was no candidate, we keep iterating
-      KeepGoing::Yes);
+      }
+    else
+      {
+	if (current.rib.kind == Rib::Kind::Module)
+	  return KeepGoing::No;
+	else
+	  return KeepGoing::Yes;
+      }
   });
 
   return resolved_definition;

gcc/rust/rust-session-manager.cc

@@ -162,6 +162,16 @@ validate_crate_name (const std::string &crate_name, Error &error)
   return true;
 }
 
+static bool
+has_attribute (AST::Crate crate, std::string attribute)
+{
+  auto &crate_attrs = crate.get_inner_attrs ();
+  auto has_attr = [&attribute] (AST::Attribute &attr) {
+    return attr.as_string () == attribute;
+  };
+  return std::any_of (crate_attrs.begin (), crate_attrs.end (), has_attr);
+}
+
 void
 Session::init ()
 {
@@ -658,6 +668,11 @@ Session::compile_crate (const char *filename)
 
   Analysis::AttributeChecker ().go (parsed_crate);
 
+  if (!has_attribute (parsed_crate, std::string (Values::Attributes::NO_CORE)))
+    {
+      parsed_crate.inject_extern_crate ("core");
+    }
+
   if (last_step == CompileOptions::CompileStep::Expansion)
     return;
 

gcc/rust/util/rust-attribute-values.h

@@ -37,6 +37,7 @@ class Attributes
   static constexpr auto &MUST_USE = "must_use";
   static constexpr auto &LANG = "lang";
   static constexpr auto &LINK_NAME = "link_name";
+  static constexpr auto &NO_CORE = "no_core";
   static constexpr auto &LINK_SECTION = "link_section";
   static constexpr auto &NO_MANGLE = "no_mangle";
   static constexpr auto &EXPORT_NAME = "export_name";

gcc/testsuite/rust/borrowck/position_dependant_outlives.rs

@@ -1,4 +1,7 @@
 // { dg-additional-options "-frust-compile-until=compilation -frust-borrowcheck" }
+#![feature(no_core)]
+#![no_core]
+
 
 pub fn position_dependent_outlives<'a>(x: &'a mut i32, cond: bool) -> &'a mut i32 {
     let y = &mut *x;

gcc/testsuite/rust/borrowck/reference.rs

@@ -1,5 +1,8 @@
 // { dg-additional-options "-frust-compile-until=compilation -frust-borrowcheck -fdiagnostics-show-caret -fdiagnostics-show-line-numbers" }
 // { dg-enable-nn-line-numbers "" }
+#![feature(no_core)]
+#![no_core]
+
 
 #![feature(lang_items)]
 #[lang = "sized"]