1 use errors::{Applicability, DiagnosticBuilder};
3 use syntax::ast::{self, *};
4 use syntax::source_map::Spanned;
5 use syntax::ext::base::*;
6 use syntax::ext::build::AstBuilder;
7 use syntax::parse::token;
8 use syntax::parse::parser::Parser;
9 use syntax::print::pprust;
11 use syntax::symbol::Symbol;
12 use syntax::tokenstream::{TokenStream, TokenTree};
13 use syntax_pos::{Span, DUMMY_SP};
15 pub fn expand_assert<'cx>(
16 cx: &'cx mut ExtCtxt<'_>,
19 ) -> Box<dyn MacResult + 'cx> {
20 let Assert { cond_expr, custom_message } = match parse_assert(cx, sp, tts) {
24 return DummyResult::expr(sp);
28 let sp = sp.apply_mark(cx.current_expansion.mark);
29 let panic_call = Mac_ {
30 path: Path::from_ident(Ident::new(Symbol::intern("panic"), sp)),
31 tts: custom_message.unwrap_or_else(|| {
32 TokenStream::from(TokenTree::Token(
35 token::Lit::Str_(Name::intern(&format!(
36 "assertion failed: {}",
37 pprust::expr_to_string(&cond_expr).escape_debug()
43 delim: MacDelimiter::Parenthesis,
45 let if_expr = cx.expr_if(
47 cx.expr(sp, ExprKind::Unary(UnOp::Not, cond_expr)),
50 ExprKind::Mac(Spanned {
57 MacEager::expr(if_expr)
61 cond_expr: P<ast::Expr>,
62 custom_message: Option<TokenStream>,
69 ) -> Result<Assert, DiagnosticBuilder<'a>> {
70 let mut parser = cx.new_parser_from_tts(tts);
72 if parser.token == token::Eof {
73 let mut err = cx.struct_span_err(sp, "macro requires a boolean expression as an argument");
74 err.span_label(sp, "boolean expression required");
78 let cond_expr = parser.parse_expr()?;
80 // Some crates use the `assert!` macro in the following form (note extra semicolon):
86 // Warn about semicolon and suggest removing it. Eventually, this should be turned into an
88 if parser.token == token::Semi {
89 let mut err = cx.struct_span_warn(sp, "macro requires an expression as an argument");
92 "try removing semicolon",
94 Applicability::MaybeIncorrect
96 err.note("this is going to be an error in the future");
102 // Some crates use the `assert!` macro in the following form (note missing comma before
105 // assert!(true "error message");
107 // Parse this as an actual message, and suggest inserting a comma. Eventually, this should be
108 // turned into an error.
109 let custom_message = if let token::Literal(token::Lit::Str_(_), _) = parser.token {
110 let mut err = cx.struct_span_warn(parser.span, "unexpected string literal");
111 let comma_span = cx.source_map().next_point(parser.prev_span);
112 err.span_suggestion_short(
114 "try adding a comma",
116 Applicability::MaybeIncorrect
118 err.note("this is going to be an error in the future");
121 parse_custom_message(&mut parser)
122 } else if parser.eat(&token::Comma) {
123 parse_custom_message(&mut parser)
128 if parser.token != token::Eof {
129 parser.expect_one_of(&[], &[])?;
133 Ok(Assert { cond_expr, custom_message })
136 fn parse_custom_message<'a>(parser: &mut Parser<'a>) -> Option<TokenStream> {
137 let ts = parser.parse_tokens();