Add assert macro handler

Assert macro handler was missing, insert a basic handler that desugars to
a condition and a call to panic.

gcc/rust/ChangeLog:

	* expand/rust-macro-builtins-log-debug.cc (MacroBuiltin::assert_handler):
	Add basic assert builtin macro handler.

gcc/testsuite/ChangeLog:

	* rust/compile/assert_missing_panic.rs: New test.

Signed-off-by: Pierre-Emmanuel Patry <pierre-emmanuel.patry@embecosm.com>

Author: P-E-P

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

@@ -19,6 +19,9 @@
 #include "rust-ast-fragment.h"
 #include "rust-macro-builtins.h"
 #include "rust-macro-builtins-helpers.h"
+#include "rust-ast-builder.h"
+#include "optional.h"
+#include "rust-ast-collector.h"
 
 namespace Rust {
 tl::optional<AST::Fragment>
@@ -27,6 +30,79 @@ MacroBuiltin::assert_handler (location_t invoc_locus,
 			      AST::InvocKind semicolon)
 {
   rust_debug ("assert!() called");
+  auto tt = invoc.get_delim_tok_tree ();
+  MacroInvocLexer lex (tt.to_token_stream ());
+  Parser<MacroInvocLexer> parser (lex);
+
+  auto last_token_id = macro_end_token (tt, parser);
+  bool has_error = false;
+
+  auto expanded_expr = try_expand_many_expr (parser, last_token_id,
+					     invoc.get_expander (), has_error);
+  if (expanded_expr.size () < 1)
+    {
+      rust_error_at (invoc_locus,
+		     "macro requires a boolean expression as an argument");
+      return AST::Fragment::create_error ();
+    }
+  auto expr_to_assert = std::move (expanded_expr[0]);
+  expanded_expr.erase (expanded_expr.begin ());
+
+  if (expanded_expr.size () > 1)
+    {
+      rust_sorry_at (
+	invoc_locus,
+	"The second form of assert with a message is not supported yet");
+
+      return AST::Fragment::create_error ();
+    }
+
+  auto pending_invocations = check_for_eager_invocations (expanded_expr);
+  if (!pending_invocations.empty ())
+    return make_eager_builtin_invocation (BuiltinMacro::Assert, invoc_locus,
+					  invoc.get_delim_tok_tree (),
+					  std::move (pending_invocations));
+
+  if (expr_to_assert->get_expr_kind () != AST::Expr::Kind::MacroInvocation)
+    {
+      AST::Builder b (invoc_locus);
+
+      std::vector<std::unique_ptr<AST::TokenTree>> panic_tree;
+      const_TokenPtr open = Token::make (TokenId::LEFT_PAREN, invoc_locus);
+      panic_tree.push_back (std::make_unique<AST::Token> (std::move (open)));
+
+      const_TokenPtr close = Token::make (TokenId::RIGHT_PAREN, invoc_locus);
+      panic_tree.push_back (std::make_unique<AST::Token> (std::move (close)));
+
+      auto panic = AST::MacroInvocation::Regular (
+	AST::MacroInvocData (AST::SimplePath (Identifier ("panic")),
+			     AST::DelimTokenTree (AST::DelimType::PARENS,
+						  std::move (panic_tree),
+						  invoc_locus)),
+	{} /* outer attributes */, invoc_locus, true /* semicoloned */);
+      auto stmt = b.statementify (std::move (panic));
+      std::vector<std::unique_ptr<AST::Stmt>> stmts;
+      stmts.push_back (std::move (stmt));
+      auto block = b.block (std::move (stmts));
+      auto negated_condition = std::unique_ptr<AST::NegationExpr> (
+	new AST::NegationExpr (std::move (expr_to_assert),
+			       AST::NegationExpr::ExprType::NOT, {},
+			       invoc_locus));
+
+      auto if_expr = std::make_unique<AST::IfExpr> (
+	std::move (negated_condition) /* condition*/, std::move (block),
+	std::vector<AST::Attribute>{}, invoc_locus);
+
+      auto node = AST::SingleASTNode (std::move (if_expr));
+
+      AST::TokenCollector collector;
+      collector.visit (node);
+      std::vector<std::unique_ptr<AST::Token>> tokens;
+      for (auto &&token : collector.collect_tokens ())
+	tokens.push_back (std::make_unique<AST::Token> (token));
+
+      return AST::Fragment ({node}, std::move (tokens));
+    }
 
   return AST::Fragment::create_error ();
 }

gcc/testsuite/rust/compile/assert_missing_panic.rs

@@ -0,0 +1,12 @@
+#![feature(rustc_attrs)]
+#![feature(no_core)]
+#![no_core]
+
+#[macro_export]
+#[rustc_builtin_macro]
+macro_rules! assert {
+    ($($arg:tt)*) => {};
+}
+
+const _: () = assert!(true);
+// { dg-error "could not resolve macro invocation .panic." "" { target *-*-* } .-1 }