expand: Add handling for macro expansion in pattern context

gcc/rust/ChangeLog:

	* ast/rust-ast-fragment.cc (Fragment::is_pattern_fragment): New function.
	(Fragment::take_pattern_fragment): Likewise.
	(Fragment::assert_single_fragment): Likewise.
	* ast/rust-ast-fragment.h: Declare them.
	* ast/rust-ast.cc (SingleASTNode::SingleASTNode): Add new constructor for pattern
	single AST nodes.
	(SingleASTNode::operator=): Handle patterns.
	(SingleASTNode::accept_vis): Likewise.
	(SingleASTNode::is_error): Likewise.
	(SingleASTNode::as_string): Likewise.
	* ast/rust-ast.h: Add get_pattern_ptr() functions.
	* ast/rust-expr.h: Likewise.
	* ast/rust-item.h: Likewise.
	* ast/rust-pattern.h: Likewise.
	* ast/rust-stmt.h: Likewise.
	* expand/rust-expand-visitor.cc (derive_item): Use new API enum values.
	(expand_item_attribute): Likewise.
	(expand_stmt_attribute): Likewise.
	(ExpandVisitor::maybe_expand_pattern): New function.
	(ExpandVisitor::expand_closure_params): Handle patterns.
	(ExpandVisitor::visit): Add new visitors for patterns and missed exprs.
	* expand/rust-expand-visitor.h: Declare them.
	* expand/rust-macro-expand.cc (transcribe_pattern): New function.
	(transcribe_context): Call it.
	* expand/rust-macro-expand.h (struct MacroExpander): New Context type.

gcc/testsuite/ChangeLog:

	* rust/compile/issue-3726.rs: New test.
	* rust/compile/issue-3898.rs: New test.

Author: CohenArthur

gcc/rust/ast/rust-ast-fragment.cc

@@ -116,6 +116,12 @@ Fragment::is_type_fragment () const
   return is_single_fragment_of_kind (SingleASTNode::Kind::Type);
 }
 
+bool
+Fragment::is_pattern_fragment () const
+{
+  return is_single_fragment_of_kind (SingleASTNode::Kind::Pattern);
+}
+
 std::unique_ptr<Expr>
 Fragment::take_expression_fragment ()
 {
@@ -130,6 +136,13 @@ Fragment::take_type_fragment ()
   return nodes[0].take_type ();
 }
 
+std::unique_ptr<Pattern>
+Fragment::take_pattern_fragment ()
+{
+  assert_single_fragment (SingleASTNode::Kind::Pattern);
+  return nodes[0].take_pattern ();
+}
+
 void
 Fragment::accept_vis (ASTVisitor &vis)
 {
@@ -159,6 +172,7 @@ Fragment::assert_single_fragment (SingleASTNode::Kind expected) const
     {SingleASTNode::Kind::Expr, "expr"},
     {SingleASTNode::Kind::Stmt, "stmt"},
     {SingleASTNode::Kind::Extern, "extern"},
+    {SingleASTNode::Kind::Pattern, "pattern"},
   };
 
   auto actual = nodes[0].get_kind ();

gcc/rust/ast/rust-ast-fragment.h

@@ -86,9 +86,11 @@ class Fragment
 
   bool is_expression_fragment () const;
   bool is_type_fragment () const;
+  bool is_pattern_fragment () const;
 
   std::unique_ptr<Expr> take_expression_fragment ();
   std::unique_ptr<Type> take_type_fragment ();
+  std::unique_ptr<Pattern> take_pattern_fragment ();
 
   void accept_vis (ASTVisitor &vis);
 

gcc/rust/ast/rust-ast.cc

@@ -71,6 +71,10 @@ SingleASTNode::SingleASTNode (SingleASTNode const &other)
     case Kind::Type:
       type = other.type->clone_type ();
       break;
+
+    case Kind::Pattern:
+      pattern = other.pattern->clone_pattern ();
+      break;
     }
 }
 
@@ -103,6 +107,10 @@ SingleASTNode::operator= (SingleASTNode const &other)
     case Kind::Type:
       type = other.type->clone_type ();
       break;
+
+    case Kind::Pattern:
+      pattern = other.pattern->clone_pattern ();
+      break;
     }
   return *this;
 }
@@ -135,6 +143,10 @@ SingleASTNode::accept_vis (ASTVisitor &vis)
     case Kind::Type:
       type->accept_vis (vis);
       break;
+
+    case Kind::Pattern:
+      pattern->accept_vis (vis);
+      break;
     }
 }
 
@@ -155,6 +167,8 @@ SingleASTNode::is_error ()
       return assoc_item == nullptr;
     case Kind::Type:
       return type == nullptr;
+    case Kind::Pattern:
+      return pattern == nullptr;
     }
 
   rust_unreachable ();
@@ -178,6 +192,8 @@ SingleASTNode::as_string () const
       return "Associated Item: " + assoc_item->as_string ();
     case Kind::Type:
       return "Type: " + type->as_string ();
+    case Kind::Pattern:
+      return "Pattern: " + pattern->as_string ();
     }
 
   rust_unreachable ();

gcc/rust/ast/rust-ast.h

@@ -1965,6 +1965,7 @@ class SingleASTNode : public Visitable
     Extern,
     Assoc,
     Type,
+    Pattern,
   };
 
 private:
@@ -1977,6 +1978,7 @@ class SingleASTNode : public Visitable
   std::unique_ptr<ExternalItem> external_item;
   std::unique_ptr<AssociatedItem> assoc_item;
   std::unique_ptr<Type> type;
+  std::unique_ptr<Pattern> pattern;
 
 public:
   SingleASTNode (std::unique_ptr<Expr> expr)
@@ -2003,6 +2005,10 @@ class SingleASTNode : public Visitable
     : kind (Kind::Type), type (std::move (type))
   {}
 
+  SingleASTNode (std::unique_ptr<Pattern> pattern)
+    : kind (Kind::Pattern), pattern (std::move (pattern))
+  {}
+
   SingleASTNode (SingleASTNode const &other);
 
   SingleASTNode operator= (SingleASTNode const &other);
@@ -2071,6 +2077,12 @@ class SingleASTNode : public Visitable
     return std::move (type);
   }
 
+  std::unique_ptr<Pattern> take_pattern ()
+  {
+    rust_assert (!is_error ());
+    return std::move (pattern);
+  }
+
   void accept_vis (ASTVisitor &vis) override;
 
   bool is_error ();

gcc/rust/ast/rust-expr.h

@@ -2480,6 +2480,12 @@ struct ClosureParam
     return *pattern;
   }
 
+  std::unique_ptr<Pattern> &get_pattern_ptr ()
+  {
+    rust_assert (pattern != nullptr);
+    return pattern;
+  }
+
   Type &get_type ()
   {
     rust_assert (has_type_given ());

gcc/rust/ast/rust-item.h

@@ -631,6 +631,12 @@ class VariadicParam : public Param
     return *param_name;
   }
 
+  std::unique_ptr<Pattern> &get_pattern_ptr ()
+  {
+    rust_assert (param_name != nullptr);
+    return param_name;
+  }
+
   const Pattern &get_pattern () const
   {
     rust_assert (param_name != nullptr);
@@ -714,6 +720,12 @@ class FunctionParam : public Param
     return *param_name;
   }
 
+  std::unique_ptr<Pattern> &get_pattern_ptr ()
+  {
+    rust_assert (param_name != nullptr);
+    return param_name;
+  }
+
   bool has_name () const { return param_name != nullptr; }
 
   // TODO: is this better? Or is a "vis_block" better?

gcc/rust/ast/rust-pattern.h

@@ -1509,6 +1509,12 @@ class GroupedPattern : public Pattern
     return *pattern_in_parens;
   }
 
+  std::unique_ptr<Pattern> &get_pattern_in_parens_ptr ()
+  {
+    rust_assert (pattern_in_parens != nullptr);
+    return pattern_in_parens;
+  }
+
   NodeId get_node_id () const override { return node_id; }
 
   Pattern::Kind get_pattern_kind () override { return Pattern::Kind::Grouped; }

gcc/rust/ast/rust-stmt.h

@@ -201,6 +201,12 @@ class LetStmt : public Stmt
     return *variables_pattern;
   }
 
+  std::unique_ptr<Pattern> &get_pattern_ptr ()
+  {
+    rust_assert (variables_pattern != nullptr);
+    return variables_pattern;
+  }
+
   Type &get_type ()
   {
     rust_assert (has_type ());

gcc/rust/expand/rust-expand-visitor.cc

@@ -18,6 +18,7 @@
 
 #include "rust-expand-visitor.h"
 #include "rust-ast-fragment.h"
+#include "rust-item.h"
 #include "rust-proc-macro.h"
 #include "rust-attributes.h"
 #include "rust-ast.h"
@@ -62,7 +63,7 @@ derive_item (AST::Item &item, AST::SimplePath &to_derive,
 	{
 	  switch (node.get_kind ())
 	    {
-	    case AST::SingleASTNode::ITEM:
+	    case AST::SingleASTNode::Kind::Item:
 	      result.push_back (node.take_item ());
 	      break;
 	    default:
@@ -85,7 +86,7 @@ expand_item_attribute (AST::Item &item, AST::SimplePath &name,
 	{
 	  switch (node.get_kind ())
 	    {
-	    case AST::SingleASTNode::ITEM:
+	    case AST::SingleASTNode::Kind::Item:
 	      result.push_back (node.take_item ());
 	      break;
 	    default:
@@ -114,7 +115,7 @@ expand_stmt_attribute (T &statement, AST::SimplePath &attribute,
 	{
 	  switch (node.get_kind ())
 	    {
-	    case AST::SingleASTNode::STMT:
+	    case AST::SingleASTNode::Kind::Stmt:
 	      result.push_back (node.take_stmt ());
 	      break;
 	    default:
@@ -352,6 +353,19 @@ ExpandVisitor::maybe_expand_type (std::unique_ptr<AST::Type> &type)
   expander.pop_context ();
 }
 
+void
+ExpandVisitor::maybe_expand_pattern (std::unique_ptr<AST::Pattern> &pattern)
+{
+  expander.push_context (MacroExpander::ContextType::PATTERN);
+
+  pattern->accept_vis (*this);
+  auto final_fragment = expander.take_expanded_fragment ();
+  if (final_fragment.should_expand () && final_fragment.is_pattern_fragment ())
+    pattern = final_fragment.take_pattern_fragment ();
+
+  expander.pop_context ();
+}
+
 // FIXME: Can this be refactored into a `scoped` method? Which takes a
 // ContextType as parameter and a lambda? And maybe just an std::vector<T>&?
 void
@@ -424,6 +438,8 @@ ExpandVisitor::expand_closure_params (std::vector<AST::ClosureParam> &params)
 {
   for (auto &param : params)
     {
+      maybe_expand_pattern (param.get_pattern_ptr ());
+
       if (param.has_type_given ())
 	maybe_expand_type (param.get_type_ptr ());
     }
@@ -686,7 +702,7 @@ ExpandVisitor::visit (AST::MatchExpr &expr)
       auto &arm = match_case.get_arm ();
 
       for (auto &pattern : arm.get_patterns ())
-	visit (pattern);
+	maybe_expand_pattern (pattern);
 
       if (arm.has_match_arm_guard ())
 	maybe_expand_expr (arm.get_guard_expr_ptr ());
@@ -695,6 +711,13 @@ ExpandVisitor::visit (AST::MatchExpr &expr)
     }
 }
 
+void
+ExpandVisitor::visit (AST::TupleExpr &expr)
+{
+  for (auto &sub : expr.get_tuple_elems ())
+    maybe_expand_expr (sub);
+}
+
 void
 ExpandVisitor::visit (AST::TypeParam &param)
 {
@@ -970,13 +993,70 @@ ExpandVisitor::visit (AST::StructPatternFieldIdent &field)
 void
 ExpandVisitor::visit (AST::GroupedPattern &pattern)
 {
-  visit (pattern.get_pattern_in_parens ());
+  maybe_expand_pattern (pattern.get_pattern_in_parens_ptr ());
+}
+
+void
+ExpandVisitor::visit (AST::SlicePatternItemsNoRest &items)
+{
+  for (auto &sub : items.get_patterns ())
+    maybe_expand_pattern (sub);
+}
+
+void
+ExpandVisitor::visit (AST::SlicePatternItemsHasRest &items)
+{
+  for (auto &sub : items.get_lower_patterns ())
+    maybe_expand_pattern (sub);
+  for (auto &sub : items.get_upper_patterns ())
+    maybe_expand_pattern (sub);
+}
+
+void
+ExpandVisitor::visit (AST::AltPattern &pattern)
+{
+  for (auto &alt : pattern.get_alts ())
+    maybe_expand_pattern (alt);
+}
+
+void
+ExpandVisitor::visit (AST::TupleStructItemsNoRange &tuple_items)
+{
+  for (auto &sub : tuple_items.get_patterns ())
+    maybe_expand_pattern (sub);
+}
+
+void
+ExpandVisitor::visit (AST::TupleStructItemsRange &tuple_items)
+{
+  for (auto &sub : tuple_items.get_lower_patterns ())
+    maybe_expand_pattern (sub);
+
+  for (auto &sub : tuple_items.get_upper_patterns ())
+    maybe_expand_pattern (sub);
+}
+
+void
+ExpandVisitor::visit (AST::TuplePatternItemsMultiple &tuple_items)
+{
+  for (auto &sub : tuple_items.get_patterns ())
+    maybe_expand_pattern (sub);
+}
+
+void
+ExpandVisitor::visit (AST::TuplePatternItemsRanged &tuple_items)
+{
+  for (auto &sub : tuple_items.get_lower_patterns ())
+    maybe_expand_pattern (sub);
+
+  for (auto &sub : tuple_items.get_upper_patterns ())
+    maybe_expand_pattern (sub);
 }
 
 void
 ExpandVisitor::visit (AST::LetStmt &stmt)
 {
-  visit (stmt.get_pattern ());
+  maybe_expand_pattern (stmt.get_pattern_ptr ());
 
   if (stmt.has_type ())
     maybe_expand_type (stmt.get_type_ptr ());
@@ -1006,9 +1086,17 @@ ExpandVisitor::visit (AST::BareFunctionType &type)
 void
 ExpandVisitor::visit (AST::FunctionParam &param)
 {
+  maybe_expand_pattern (param.get_pattern_ptr ());
   maybe_expand_type (param.get_type_ptr ());
 }
 
+void
+ExpandVisitor::visit (AST::VariadicParam &param)
+{
+  if (param.has_pattern ())
+    maybe_expand_pattern (param.get_pattern_ptr ());
+}
+
 void
 ExpandVisitor::visit (AST::SelfParam &param)
 {