stash

gcc/rust/ast/rust-item.h

@@ -2081,6 +2081,8 @@ class EnumItemDiscriminant : public EnumItem
 
   void accept_vis (ASTVisitor &vis) override;
 
+  bool has_expr () { return expression != nullptr; }
+
   // TODO: is this better? Or is a "vis_block" better?
   std::unique_ptr<Expr> &get_expr ()
   {
@@ -3434,6 +3436,8 @@ class NamedFunctionParam
    * '_'). */
   bool has_name () const { return name != "_" && name != ""; }
 
+  bool has_type () const { return param_type != nullptr; }
+
   bool has_outer_attrs () const { return !outer_attrs.empty (); }
 
   // Returns whether the named function parameter is in an error state.

gcc/rust/ast/rust-macro.h

@@ -579,6 +579,11 @@ class MacroRulesDefinition : public VisItem
 
   MacroKind get_kind () const { return kind; }
 
+  std::unique_ptr<MacroRulesDefinition> clone_macro_rules_def () const
+  {
+    return std::unique_ptr<MacroRulesDefinition> (clone_item_impl ());
+  }
+
 protected:
   /* Use covariance to implement clone function as returning this object rather
    * than base */

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

@@ -108,6 +108,8 @@ std::unordered_map<std::string, AST::MacroTranscriberFunc>
     {"test_case", MacroBuiltin::sorry},
     {"global_allocator", MacroBuiltin::sorry},
     {"cfg_accessible", MacroBuiltin::sorry},
+    {"rustc_const_stable", MacroBuiltin::sorry},
+    {"rustc_const_unstable", MacroBuiltin::sorry},
     /* Derive builtins do not need a real transcriber, but still need one. It
        should however never be called since builtin derive macros get expanded
        differently, and benefit from knowing on what kind of items they are

gcc/rust/hir/rust-ast-lower-pattern.cc

@@ -70,30 +70,39 @@ ASTLoweringPattern::visit (AST::TupleStructPattern &pattern)
     = ASTLowerPathInExpression::translate (&pattern.get_path ());
 
   TupleStructItems *lowered = nullptr;
-  auto &items = pattern.get_items ();
-  switch (items->get_item_type ())
+
+  if (pattern.has_items ())
     {
-      case AST::TupleStructItems::RANGE: {
-	// TODO
-	rust_unreachable ();
-      }
-      break;
+      auto &items = pattern.get_items ();
+      switch (items->get_item_type ())
+	{
+	  case AST::TupleStructItems::RANGE: {
+	    // TODO
+	    rust_unreachable ();
+	  }
+	  break;
 
-      case AST::TupleStructItems::NO_RANGE: {
-	AST::TupleStructItemsNoRange &items_no_range
-	  = static_cast<AST::TupleStructItemsNoRange &> (*items.get ());
+	  case AST::TupleStructItems::NO_RANGE: {
+	    AST::TupleStructItemsNoRange &items_no_range
+	      = static_cast<AST::TupleStructItemsNoRange &> (*items.get ());
 
-	std::vector<std::unique_ptr<HIR::Pattern>> patterns;
-	for (auto &inner_pattern : items_no_range.get_patterns ())
-	  {
-	    HIR::Pattern *p
-	      = ASTLoweringPattern::translate (inner_pattern.get ());
-	    patterns.push_back (std::unique_ptr<HIR::Pattern> (p));
-	  }
+	    std::vector<std::unique_ptr<HIR::Pattern>> patterns;
+	    for (auto &inner_pattern : items_no_range.get_patterns ())
+	      {
+		HIR::Pattern *p
+		  = ASTLoweringPattern::translate (inner_pattern.get ());
+		patterns.push_back (std::unique_ptr<HIR::Pattern> (p));
+	      }
 
-	lowered = new HIR::TupleStructItemsNoRange (std::move (patterns));
-      }
-      break;
+	    lowered = new HIR::TupleStructItemsNoRange (std::move (patterns));
+	  }
+	  break;
+	}
+    }
+  else
+    {
+      std::vector<std::unique_ptr<HIR::Pattern>> patterns;
+      lowered = new HIR::TupleStructItemsNoRange (std::move (patterns));
     }
 
   auto crate_num = mappings->get_current_crate ();

gcc/rust/parse/rust-parse-impl.h

@@ -10635,8 +10635,12 @@ Parser<ManagedTokenSource>::parse_pattern_no_alt ()
 	      if (lexer.peek_token ()->get_id () == RIGHT_PAREN)
 		{
 		  lexer.skip_token ();
+		  std::unique_ptr<AST::TupleStructItems> items (
+		    new AST::TupleStructItemsNoRange (
+		      std::vector<std::unique_ptr<AST::Pattern>> ()));
 		  return std::unique_ptr<AST::TupleStructPattern> (
-		    new AST::TupleStructPattern (std::move (path), nullptr));
+		    new AST::TupleStructPattern (std::move (path),
+						 std::move (items)));
 		}
 
 	      // parse items

gcc/rust/resolve/rust-ast-resolve-pattern.cc

@@ -91,6 +91,9 @@ PatternDeclaration::visit (AST::TupleStructPattern &pattern)
 {
   ResolvePath::go (&pattern.get_path ());
 
+  if (!pattern.has_items ())
+    return;
+
   std::unique_ptr<AST::TupleStructItems> &items = pattern.get_items ();
   switch (items->get_item_type ())
     {