use super::*;
pub(super) fn parse_macro(
ctx: &ParserCtx<'_>,
at_idx: usize,
diagnostics: &mut Vec<ParseDiagnostic>,
flags: ExprFlags,
) -> ExprParse {
let mut events = vec![Event::Start(SyntaxKind::MACRO_CALL)];
events.push(Event::Start(SyntaxKind::MACRO_NAME));
events.push(Event::Tok(at_idx)); let name_end = parse_macro_name_body(ctx, &mut events, at_idx + 1, diagnostics);
finish(&mut events, SyntaxKind::MACRO_NAME);
let end = parse_macro_args(ctx, &mut events, name_end, diagnostics, flags, at_idx);
finish(&mut events, SyntaxKind::MACRO_CALL);
ExprParse {
start: at_idx,
end,
events,
}
}
pub(super) fn parse_qualified_macro(
ctx: &ParserCtx<'_>,
lhs: ExprParse,
dot_idx: usize,
diagnostics: &mut Vec<ParseDiagnostic>,
flags: ExprFlags,
) -> ExprParse {
let mut events = vec![Event::Start(SyntaxKind::MACRO_CALL)];
events.push(Event::Start(SyntaxKind::MACRO_NAME));
events.extend(lhs.events);
push_range(&mut events, lhs.end, dot_idx);
events.push(Event::Tok(dot_idx)); let at_idx = ctx.skip_trivia(dot_idx + 1);
push_range(&mut events, dot_idx + 1, at_idx);
events.push(Event::Tok(at_idx)); if ctx.token(at_idx + 1).map(|t| t.kind) == Some(TokKind::Ident)
&& ctx.token(at_idx + 2).map(|t| t.kind) == Some(TokKind::Dot)
&& ctx.token(at_idx + 3).map(|t| t.kind) == Some(TokKind::Ident)
{
let at_start = ctx.tokens()[at_idx].start;
push_diagnostic(
diagnostics,
DiagnosticKind::MacroSigilTrailing,
"misplaced macro sigil",
at_start,
at_start,
);
}
let name_end = parse_macro_name_body(ctx, &mut events, at_idx + 1, diagnostics);
finish(&mut events, SyntaxKind::MACRO_NAME);
let end = parse_macro_args(ctx, &mut events, name_end, diagnostics, flags, lhs.start);
finish(&mut events, SyntaxKind::MACRO_CALL);
ExprParse {
start: lhs.start,
end,
events,
}
}
pub(crate) fn is_var_identifier_start(ctx: &ParserCtx<'_>, i: usize) -> bool {
ctx.token(i)
.is_some_and(|t| t.kind == TokKind::StringPrefix && t.text == "var")
&& matches!(
ctx.token(i + 1),
Some(t) if t.kind == TokKind::StringDelimOpen && t.text.len() == 1
)
}
pub(crate) fn push_var_macro_name(
ctx: &ParserCtx<'_>,
events: &mut Vec<Event>,
i: usize,
diagnostics: &mut Vec<ParseDiagnostic>,
) -> Option<usize> {
if is_var_identifier_start(ctx, i) {
let lit = parse_string_literal(ctx, i, diagnostics);
let end = lit.end;
events.extend(lit.events);
Some(end)
} else {
None
}
}
fn parse_macro_name_body(
ctx: &ParserCtx<'_>,
events: &mut Vec<Event>,
start: usize,
diagnostics: &mut Vec<ParseDiagnostic>,
) -> usize {
if let Some(end) = push_var_macro_name(ctx, events, start, diagnostics) {
return end;
}
match ctx.token(start).map(|t| t.kind) {
Some(TokKind::Dot) => {
events.push(Event::Tok(start));
start + 1
}
Some(TokKind::Ident) => {
events.push(Event::Tok(start));
let mut i = start + 1;
let mut saw_dollar_final = false;
let mut saw_inner_at = false;
while ctx.token(i).map(|t| t.kind) == Some(TokKind::Dot) {
match ctx.token(i + 1).map(|t| t.kind) {
Some(TokKind::Ident) => {
events.push(Event::Tok(i)); events.push(Event::Tok(i + 1)); i += 2;
saw_dollar_final = false;
}
Some(TokKind::Dollar)
if ctx.token(i + 2).map(|t| t.kind) == Some(TokKind::Ident) =>
{
events.push(Event::Tok(i)); events.push(Event::Tok(i + 1)); events.push(Event::Tok(i + 2)); i += 3;
saw_dollar_final = true;
}
Some(TokKind::At)
if ctx.token(i + 2).map(|t| t.kind) == Some(TokKind::Ident) =>
{
events.push(Event::Tok(i)); events.push(Event::Tok(i + 1)); events.push(Event::Tok(i + 2)); i += 3;
saw_dollar_final = false;
saw_inner_at = true;
}
_ => break,
}
}
if saw_dollar_final || saw_inner_at {
let at_start = ctx.tokens()[start - 1].start;
push_diagnostic(
diagnostics,
DiagnosticKind::MacroSigilLeading,
"invalid qualified macro name",
at_start,
at_start,
);
}
i
}
Some(TokKind::LParen) => {
let inner = ctx.skip_ws(start + 1);
if ctx.token(inner).map(|t| t.kind) == Some(TokKind::Ident) {
let after = ctx.skip_ws(inner + 1);
if ctx.token(after).map(|t| t.kind) == Some(TokKind::RParen) {
push_range(events, start, after + 1);
return after + 1;
}
}
start
}
Some(TokKind::LBracket | TokKind::LBrace) => {
if let Some(expr) = parse_prefix(ctx, start, diagnostics, ExprFlags::default()) {
let name_start = ctx.tokens()[start].start;
let end = expr.end;
events.extend(expr.events);
push_diagnostic(
diagnostics,
DiagnosticKind::InvalidMacroName,
"invalid macro name",
name_start,
name_start,
);
end
} else {
start
}
}
Some(k) if is_macro_name_token(k) => {
events.push(Event::Tok(start));
start + 1
}
_ => start,
}
}
fn is_macro_name_token(kind: TokKind) -> bool {
!matches!(kind, TokKind::Dot | TokKind::Colon)
&& (is_op_name(kind)
|| is_value_operator(kind)
|| kind == TokKind::Dollar
|| kind.is_keyword())
}
fn parse_macro_args(
ctx: &ParserCtx<'_>,
events: &mut Vec<Event>,
name_end: usize,
diagnostics: &mut Vec<ParseDiagnostic>,
flags: ExprFlags,
macro_start: usize,
) -> usize {
let inside_brackets = flags.inside_brackets;
let generator_for_ends = flags.generator_for_ends;
let macro_newlines = ctx.options.syntax_edition >= crate::parser::SyntaxEdition::Julia114
&& flags.paren_content_start == Some(macro_start);
if ctx.token(name_end).map(|t| t.kind) == Some(TokKind::LParen) {
let (list_events, end) = parse_arg_list(
ctx,
name_end,
TokKind::RParen,
SyntaxKind::ARG_LIST,
false,
true,
diagnostics,
);
events.extend(list_events);
return end;
}
if matches!(
ctx.token(name_end).map(|t| t.kind),
Some(TokKind::LBracket | TokKind::LBrace)
) {
let arg_flags = ExprFlags {
inside_brackets,
..ExprFlags::default()
};
if let Some(arg) = parse_prefix(ctx, name_end, diagnostics, arg_flags) {
events.extend(arg.events);
return arg.end;
}
}
let mut pos = name_end;
let mut n_args = 0;
loop {
let mut next = ctx.skip_ws_and_block_comments(pos);
if macro_newlines
&& matches!(
ctx.token(next).map(|t| t.kind),
Some(TokKind::Newline | TokKind::Comment)
)
{
let after = ctx.skip_trivia(next);
if ctx.token(after).is_none_or(|t| {
t.kind == TokKind::ForKw
|| is_operator(t.kind)
|| is_quotable_operator(t.kind)
|| is_value_operator(t.kind)
|| is_unary_prefix_op(t.kind, t.text)
|| t.kind == TokKind::DotDotDot
|| word_operator(ctx, after, false).is_some()
}) {
break;
}
next = after;
}
match ctx.token(next).map(|t| t.kind) {
None
| Some(
TokKind::Newline
| TokKind::Comment
| TokKind::Comma
| TokKind::RParen
| TokKind::RBracket
| TokKind::RBrace
| TokKind::Semicolon,
) => break,
Some(TokKind::ForKw) if generator_for_ends => break,
Some(TokKind::Dot)
if ctx
.token(ctx.skip_ws_and_block_comments(next + 1))
.is_some_and(|t| t.kind == TokKind::LParen) =>
{
break;
}
_ => {
let arg_flags = ExprFlags {
inside_brackets,
array_mode: true,
generator_for_ends,
stmt_comma: true,
..ExprFlags::default()
};
match parse_expr_in(ctx.tokens(), next, 0, diagnostics, arg_flags) {
Some(arg) => {
push_range(events, pos, next);
events.extend(arg.events);
pos = arg.end;
n_args += 1;
}
None => break,
}
}
}
}
if n_args == 1 && macro_leaf_is_doc(ctx, name_end) {
let nl = ctx.skip_ws(pos);
if ctx.token(nl).map(|t| t.kind) == Some(TokKind::Newline) {
let after = ctx.skip_ws(nl + 1);
let extend = !matches!(
ctx.token(after).map(|t| t.kind),
None | Some(
TokKind::Newline
| TokKind::Comma
| TokKind::Semicolon
| TokKind::RParen
| TokKind::RBracket
| TokKind::RBrace
| TokKind::EndKw
| TokKind::ElseKw
| TokKind::ElseifKw
| TokKind::CatchKw
| TokKind::FinallyKw
)
);
if extend {
push_range(events, pos, after);
let arg_flags = ExprFlags {
inside_brackets,
array_mode: true,
generator_for_ends,
stmt_comma: true,
..ExprFlags::default()
};
if let Some(arg) = parse_expr_in(ctx.tokens(), after, 0, diagnostics, arg_flags) {
events.extend(arg.events);
pos = arg.end;
}
}
}
}
pos
}
fn macro_leaf_is_doc(ctx: &ParserCtx<'_>, name_end: usize) -> bool {
name_end > 0
&& ctx
.token(name_end - 1)
.is_some_and(|t| t.kind == TokKind::Ident && t.text == "doc")
}