gccrs: Parse statement macros as statements.

gcc/rust/ChangeLog:

	* ast/rust-ast.h (Expr::to_stmt): Remove method.
	* ast/rust-macro.h (MacroInvocation::to_stmt): Remove override.
	* ast/rust-stmt.h: Remove use of Expr::to_stmt.
	* expand/rust-macro-expand.h (struct MacroExpander):
	Add EXPR/STMT and remove BLOCK from ContextType.
	* expand/rust-expand-visitor.cc (ExpandVisitor::maybe_expand_expr): Use EXPR context.
	(ExpandVisitor::expand_inner_stmts): Use STMT context.
	(ExpandVisitor::visitor): Remove use of BLOCK context.
	* expand/rust-macro-expand.cc (transcribe_on_delimiter): Remove function.
	(transcribe_context): Use EXPR/STMT contexts.
	(MacroExpander::parse_proc_macro_output): Use EXPR/STMT contexts.
	* parse/rust-parse-impl.h (Parser::parse_stmt):
	Delegate macro parsing to parse_expr_stmt, check for ! after macro_rules.
	(Parser::parse_expr_stmt):
	Parse macro statements/expression statements starting with a macro.
	(Parser::parse_match_expr): Don't modify flag unnecessarily.
	(Parser::parse_stmt_or_expr):
	Parse macro statements/expression statements starting with a macro.
	(Parser::parse_path_based_stmt_or_expr): Remove method.
	(Parser::parse_macro_invocation_maybe_semi): Remove method.
	(Parser::parse_expr): Move code into left_denotations.
	(Parser::left_denotations): New method.
	(Parser::null_denotation): Split out methods for cases with and without paths.
	(Parser::null_denotation_path): New method.
	(Parser::null_denotation_not_path): New method.
	(Parser::parse_macro_invocation_partial): Don't check for semicolon here.
	* parse/rust-parse.h: Update declarations.

gcc/testsuite/ChangeLog:

	* rust/compile/braced_macro_arm.rs: New test.
	* rust/compile/braced_macro_statements1.rs: New test.
	* rust/compile/braced_macro_statements2.rs: New test.
	* rust/compile/braced_macro_statements3.rs: New test.
	* rust/compile/issue-2225.rs: Update test.

Signed-off-by: Matthew Jasper <[email protected]>

Author: matthewjasper

gcc/rust/ast/rust-ast.h

@@ -988,8 +988,6 @@ class Expr : public Node
 
   virtual std::vector<Attribute> &get_outer_attrs () = 0;
 
-  virtual Expr *to_stmt () const { return clone_expr_impl (); }
-
   // TODO: think of less hacky way to implement this kind of thing
   // Sets outer attributes.
   virtual void set_outer_attrs (std::vector<Attribute>) = 0;

gcc/rust/ast/rust-macro.h

@@ -811,15 +811,6 @@ class MacroInvocation : public TypeNoBounds,
   {
     return clone_macro_invocation_impl ();
   }
-
-  Expr *to_stmt () const override
-
-  {
-    auto new_impl = clone_macro_invocation_impl ();
-    new_impl->is_semi_coloned = true;
-
-    return new_impl;
-  }
 };
 
 // more generic meta item path-only form

gcc/rust/ast/rust-stmt.h

@@ -201,8 +201,9 @@ class ExprStmt : public Stmt
 
   std::vector<LetStmt *> locals;
 
-  ExprStmt (std::unique_ptr<Expr> expr, Location locus, bool semicolon_followed)
-    : expr (expr->to_stmt ()), locus (locus),
+  ExprStmt (std::unique_ptr<Expr> &&expr, Location locus,
+	    bool semicolon_followed)
+    : expr (std::move (expr)), locus (locus),
       semicolon_followed (semicolon_followed)
   {}
 

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

@@ -232,7 +232,7 @@ void
 ExpandVisitor::expand_inner_stmts (
   std::vector<std::unique_ptr<AST::Stmt>> &stmts)
 {
-  expander.push_context (MacroExpander::ContextType::BLOCK);
+  expander.push_context (MacroExpander::ContextType::STMT);
 
   for (auto it = stmts.begin (); it != stmts.end (); it++)
     {
@@ -272,10 +272,9 @@ ExpandVisitor::expand_inner_stmts (
 void
 ExpandVisitor::maybe_expand_expr (std::unique_ptr<AST::Expr> &expr)
 {
-  // FIXME: ARTHUR: Why isn't there a ContextType::EXPR? We can only
-  // reach `parse_expr` once in MacroExpander::transcribe_rule(), but it
-  // would make things clearer wouldn't it?
+  expander.push_context (MacroExpander::ContextType::EXPR);
   expr->accept_vis (*this);
+  expander.pop_context ();
 
   auto final_fragment = expander.take_expanded_fragment ();
   if (final_fragment.should_expand ()
@@ -732,12 +731,8 @@ ExpandVisitor::visit (AST::BlockExpr &expr)
 {
   expand_inner_stmts (expr.get_statements ());
 
-  expander.push_context (MacroExpander::ContextType::BLOCK);
-
   if (expr.has_tail_expr ())
     maybe_expand_expr (expr.get_tail_expr ());
-
-  expander.pop_context ();
 }
 
 void
@@ -1438,7 +1433,7 @@ ExpandVisitor::visit (AST::LetStmt &stmt)
 void
 ExpandVisitor::visit (AST::ExprStmt &stmt)
 {
-  visit (stmt.get_expr ());
+  maybe_expand_expr (stmt.get_expr ());
 }
 
 void

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

@@ -894,16 +894,6 @@ transcribe_type (Parser<MacroInvocLexer> &parser)
   return AST::Fragment ({std::move (type)}, lexer.get_token_slice (start, end));
 }
 
-static AST::Fragment
-transcribe_on_delimiter (Parser<MacroInvocLexer> &parser, bool semicolon,
-			 AST::DelimType delimiter, TokenId last_token_id)
-{
-  if (semicolon || delimiter == AST::DelimType::CURLY)
-    return transcribe_many_stmts (parser, last_token_id);
-  else
-    return transcribe_expression (parser);
-} // namespace Rust
-
 static AST::Fragment
 transcribe_context (MacroExpander::ContextType ctx,
 		    Parser<MacroInvocLexer> &parser, bool semicolon,
@@ -945,9 +935,12 @@ transcribe_context (MacroExpander::ContextType ctx,
     case MacroExpander::ContextType::TYPE:
       return transcribe_type (parser);
       break;
+    case MacroExpander::ContextType::STMT:
+      return transcribe_many_stmts (parser, last_token_id, semicolon);
+    case MacroExpander::ContextType::EXPR:
+      return transcribe_expression (parser);
     default:
-      return transcribe_on_delimiter (parser, semicolon, delimiter,
-				      last_token_id);
+      gcc_unreachable ();
     }
 }
 
@@ -1111,7 +1104,7 @@ MacroExpander::parse_proc_macro_output (ProcMacro::TokenStream ts)
 	  nodes.push_back ({std::move (result)});
 	}
       break;
-    case ContextType::BLOCK:
+    case ContextType::STMT:
       while (lex.peek_token ()->get_id () != END_OF_FILE)
 	{
 	  auto result = parser.parse_stmt ();
@@ -1125,6 +1118,7 @@ MacroExpander::parse_proc_macro_output (ProcMacro::TokenStream ts)
     case ContextType::TRAIT_IMPL:
     case ContextType::EXTERN:
     case ContextType::TYPE:
+    case ContextType::EXPR:
     default:
       gcc_unreachable ();
     }

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

@@ -221,7 +221,8 @@ struct MacroExpander
   enum class ContextType
   {
     ITEM,
-    BLOCK,
+    STMT,
+    EXPR,
     EXTERN,
     TYPE,
     TRAIT,