use crate::{
grammar::{
ParseResult,
cpp::{decls, stats, types},
},
kind::{CppSyntaxKind, CppTokenKind},
parser::{CppParser, MarkerEventContainer},
parser_error::CppParseError,
symbols::SymbolKind,
};
use super::{at_requires, expect_token};
fn get_operator_precedence(p: &CppParser, token: CppTokenKind) -> Option<u8> {
if matches!(token, CppTokenKind::Greater | CppTokenKind::RightShift)
&& p.at_the_end_of_a_launch_configuration()
{
return None;
}
let token = the_alternative_operator(p, token).unwrap_or(token);
if matches!(token, CppTokenKind::Greater | CppTokenKind::RightShift)
&& !p.greater_than_is_an_operator()
{
return None;
}
match token {
CppTokenKind::Assign
| CppTokenKind::PlusAssign
| CppTokenKind::MinusAssign
| CppTokenKind::StarAssign
| CppTokenKind::SlashAssign
| CppTokenKind::PercentAssign
| CppTokenKind::AmpersandAssign
| CppTokenKind::PipeAssign
| CppTokenKind::CaretAssign
| CppTokenKind::LeftShiftAssign
| CppTokenKind::RightShiftAssign => Some(1),
CppTokenKind::LogicalOr => Some(4),
CppTokenKind::LogicalAnd => Some(5),
CppTokenKind::Pipe => Some(6),
CppTokenKind::Caret => Some(7),
CppTokenKind::Ampersand => Some(8),
CppTokenKind::Equal | CppTokenKind::NotEqual => Some(9),
CppTokenKind::Less
| CppTokenKind::LessEqual
| CppTokenKind::Greater
| CppTokenKind::GreaterEqual
| CppTokenKind::Spaceship => Some(10),
CppTokenKind::LeftShift | CppTokenKind::RightShift => Some(11),
CppTokenKind::Plus | CppTokenKind::Minus => Some(12),
CppTokenKind::Star | CppTokenKind::Slash | CppTokenKind::Percent => Some(13),
CppTokenKind::DotStar | CppTokenKind::ArrowStar => Some(14),
_ => None,
}
}
fn the_alternative_operator(p: &CppParser, token: CppTokenKind) -> Option<CppTokenKind> {
if token != CppTokenKind::Identifier {
return None;
}
Some(match p.current_token_text() {
"and" => CppTokenKind::LogicalAnd,
"or" => CppTokenKind::LogicalOr,
"not" => CppTokenKind::LogicalNot,
"bitand" => CppTokenKind::Ampersand,
"bitor" => CppTokenKind::Pipe,
"xor" => CppTokenKind::Caret,
"compl" => CppTokenKind::Tilde,
"not_eq" => CppTokenKind::NotEqual,
"and_eq" => CppTokenKind::AmpersandAssign,
"or_eq" => CppTokenKind::PipeAssign,
"xor_eq" => CppTokenKind::CaretAssign,
_ => return None,
})
}
fn throw_has_no_operand(p: &CppParser) -> bool {
matches!(
p.current_token(),
CppTokenKind::Semicolon
| CppTokenKind::RightParen
| CppTokenKind::RightBracket
| CppTokenKind::RightBrace
| CppTokenKind::Comma
| CppTokenKind::Colon
| CppTokenKind::Eof
| CppTokenKind::None
)
}
fn is_fold_operator(p: &CppParser, token: CppTokenKind) -> bool {
matches!(get_operator_precedence(p, token), Some(precedence) if precedence > 1)
}
fn is_right_associative(token: CppTokenKind) -> bool {
is_assignment_operator(token)
}
fn is_assignment_operator(token: CppTokenKind) -> bool {
matches!(
token,
CppTokenKind::Assign
| CppTokenKind::PlusAssign
| CppTokenKind::MinusAssign
| CppTokenKind::StarAssign
| CppTokenKind::SlashAssign
| CppTokenKind::PercentAssign
| CppTokenKind::AmpersandAssign
| CppTokenKind::PipeAssign
| CppTokenKind::CaretAssign
| CppTokenKind::LeftShiftAssign
| CppTokenKind::RightShiftAssign
)
}
pub fn parse_expr(p: &mut CppParser) -> ParseResult {
parse_expr_up_to(p, Level::Full, true)
}
pub fn parse_assignment_expr(p: &mut CppParser) -> ParseResult {
parse_expr_up_to(p, Level::Assignment, true)
}
pub fn parse_argument(p: &mut CppParser) -> ParseResult {
if p.current_token() == CppTokenKind::LeftBrace {
return decls::parse_braced_initializer(p);
}
parse_assignment_expr(p)
}
pub fn parse_call_arguments(p: &mut CppParser) -> ParseResult {
expect_token(p, CppTokenKind::LeftParen)?;
if p.current_token() != CppTokenKind::RightParen {
parse_argument(p)?;
while p.current_token() == CppTokenKind::Comma {
p.bump(); parse_argument(p)?;
}
}
expect_token(p, CppTokenKind::RightParen)?;
Ok(crate::parser::CompleteMarker::empty())
}
pub fn parse_constraint_expr(p: &mut CppParser) -> ParseResult {
let previous = p.enter_constraint();
let result = parse_binary_expr_with_precedence(p, 4);
p.leave_constraint(previous);
result
}
fn parse_requirement_expression(p: &mut CppParser) -> ParseResult {
let previous = p.enter_constraint();
let result = parse_expr(p);
p.leave_constraint(previous);
result
}
pub fn parse_expr_without_pack_expansion(p: &mut CppParser) -> ParseResult {
parse_expr_up_to(p, Level::Full, false)
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum Level {
Full,
Assignment,
}
fn parse_expr_up_to(p: &mut CppParser, level: Level, pack_expansion: bool) -> ParseResult {
let mut expr = parse_ternary_expr(p)?;
if level == Level::Full {
while p.current_token() == CppTokenKind::Comma {
let m = expr.precede(p, CppSyntaxKind::BinaryExpr);
p.bump(); parse_ternary_expr(p)?;
expr = m.complete(p);
}
}
if pack_expansion && p.current_token() == CppTokenKind::Ellipsis {
let expansion = expr.precede(p, CppSyntaxKind::PackExpansionExpr);
p.bump(); return Ok(expansion.complete(p));
}
Ok(expr)
}
fn parse_ternary_expr(p: &mut CppParser) -> ParseResult {
let mut expr = parse_binary_expr_with_precedence(p, 0)?;
if p.current_token() == CppTokenKind::Question {
let conditionals_when_the_conditional_began = p.open_conditionals();
let m = expr.precede(p, CppSyntaxKind::TernaryExpr);
p.bump();
if p.current_token() != CppTokenKind::Colon {
parse_expr(p)?; }
while p.current_token() == CppTokenKind::Hash {
stats::parse_preprocessor_directive(p)?;
}
expect_token(p, CppTokenKind::Colon)?;
parse_ternary_expr(p)?;
let mut read_a_branch_of_the_tail = false;
while p.open_conditionals() > conditionals_when_the_conditional_began
&& let Some(writes_the_terminator) = decls::a_branch_continues_the_tail(p)
{
if writes_the_terminator {
p.bump(); p.note_the_terminator_came_from_a_branch();
read_a_branch_of_the_tail = true;
}
while p.current_token() == CppTokenKind::Hash {
stats::parse_preprocessor_directive(p)?;
}
expect_token(p, CppTokenKind::Colon)?;
parse_ternary_expr(p)?;
}
if read_a_branch_of_the_tail && p.current_token() == CppTokenKind::Semicolon {
p.bump();
}
expr = m.complete(p);
}
Ok(expr)
}
fn parse_binary_expr_with_precedence(p: &mut CppParser, min_prec: u8) -> ParseResult {
let mut left = parse_unary_expr(p, true)?;
if is_fold_operator(p, p.current_token())
&& p.peek_next_token() == CppTokenKind::Ellipsis
&& let Some(prec) = get_operator_precedence(p, p.joined_operator_at_the_cursor().0)
&& prec >= min_prec
{
let operator = p.current_token();
let m = left.precede(p, CppSyntaxKind::BinaryExpr);
p.bump(); let fold = p.mark(CppSyntaxKind::FoldExpr);
p.bump(); fold.complete(p);
if is_fold_operator(p, p.current_token())
&& p.current_token() == operator
&& let Some(prec) = get_operator_precedence(p, p.joined_operator_at_the_cursor().0)
&& prec >= min_prec
{
p.bump(); parse_binary_expr_with_precedence(p, prec + 1)?;
return Ok(m.complete(p));
}
return Ok(m.complete(p));
}
loop {
if p.current_token() == CppTokenKind::Hash {
let checkpoint = p.checkpoint();
let mut opens_another_branch = false;
while p.current_token() == CppTokenKind::Hash {
if matches!(p.peek_token_text_at(1), "else" | "elif") {
opens_another_branch = true;
}
stats::parse_preprocessor_directive(p)?;
}
let an_operator_follows =
get_operator_precedence(p, p.joined_operator_at_the_cursor().0)
.is_some_and(|prec| prec >= min_prec);
if !an_operator_follows {
if opens_another_branch {
p.rollback(checkpoint);
}
break;
}
}
let Some(prec) = get_operator_precedence(p, p.joined_operator_at_the_cursor().0) else {
break;
};
if prec < min_prec {
break;
}
let (operator, spans) = p.joined_operator_at_the_cursor();
let m = left.precede(p, CppSyntaxKind::BinaryExpr);
for _ in 0..spans {
p.bump(); }
if is_assignment_operator(operator) && p.current_token() == CppTokenKind::LeftBrace {
decls::parse_braced_initializer(p)?;
left = m.complete(p);
continue;
}
let next_min_prec = if is_right_associative(operator) {
prec
} else {
prec + 1
};
parse_binary_expr_with_precedence(p, next_min_prec)?;
left = m.complete(p);
}
Ok(left)
}
fn parse_unary_expr(p: &mut CppParser, fold_operand: bool) -> ParseResult {
let token = the_alternative_operator(p, p.current_token()).unwrap_or(p.current_token());
match token {
CppTokenKind::LogicalNot
| CppTokenKind::Tilde
| CppTokenKind::Plus
| CppTokenKind::Minus
| CppTokenKind::PlusPlus
| CppTokenKind::MinusMinus
| CppTokenKind::Star
| CppTokenKind::Ampersand => {
let m = p.mark(CppSyntaxKind::UnaryExpr);
p.bump(); parse_unary_expr(p, fold_operand)?; Ok(m.complete(p))
}
CppTokenKind::CoAwaitKeyword => {
let m = p.mark(CppSyntaxKind::UnaryExpr);
p.bump(); parse_unary_expr(p, fold_operand)?; Ok(m.complete(p))
}
CppTokenKind::ThrowKeyword => {
let m = p.mark(CppSyntaxKind::ThrowExpr);
p.bump();
if !throw_has_no_operand(p) {
parse_unary_expr(p, fold_operand)?;
}
Ok(m.complete(p))
}
CppTokenKind::Identifier if at_requires(p) && starts_a_requires_expression(p) => {
parse_requires_expression(p)
}
CppTokenKind::NoexceptKeyword if p.peek_next_token() == CppTokenKind::LeftParen => {
let m = p.mark(CppSyntaxKind::UnaryExpr);
p.bump(); parse_unary_expr(p, fold_operand)?; Ok(m.complete(p))
}
CppTokenKind::SizeofKeyword | CppTokenKind::AlignofKeyword => {
let m = p.mark(CppSyntaxKind::UnaryExpr);
p.bump();
let counts_a_pack = p.current_token() == CppTokenKind::Ellipsis;
if counts_a_pack {
p.bump(); }
if p.current_token() == CppTokenKind::LeftParen {
p.bump(); parse_type_id_or_expression(p)?;
expect_token(p, CppTokenKind::RightParen)?;
} else if !counts_a_pack {
parse_unary_expr(p, fold_operand)?;
}
Ok(m.complete(p))
}
CppTokenKind::TypeidKeyword => {
let m = p.mark(CppSyntaxKind::UnaryExpr);
p.bump(); expect_token(p, CppTokenKind::LeftParen)?;
parse_type_id_or_expression(p)?;
expect_token(p, CppTokenKind::RightParen)?;
let completed = m.complete(p);
parse_postfix_suffixes(p, completed)
}
CppTokenKind::NewKeyword => parse_new_expr(p),
CppTokenKind::Scope if p.peek_next_token() == CppTokenKind::NewKeyword => parse_new_expr(p),
CppTokenKind::Scope if p.peek_next_token() == CppTokenKind::DeleteKeyword => {
parse_delete_expr(p, fold_operand)
}
CppTokenKind::DeleteKeyword => parse_delete_expr(p, fold_operand),
_ if types::at_an_implementation_keyword(p) => {
types::parse_an_implementation_keyword(p);
parse_unary_expr(p, fold_operand)
}
_ => parse_postfix_expr(p, fold_operand),
}
}
pub fn parse_type_id_or_expression(p: &mut CppParser) -> ParseResult {
let checkpoint = p.checkpoint();
let before = p.current_token_index();
if types::parse_type_id(p).is_ok()
&& p.current_token_index() > before
&& p.current_token() == CppTokenKind::RightParen
{
return Ok(crate::parser::CompleteMarker::empty());
}
p.rollback(checkpoint);
parse_expr(p)
}
fn is_a_type_in_parentheses(p: &CppParser) -> bool {
if p.current_token() != CppTokenKind::LeftParen {
return false;
}
for kind in p.peek_token_kind_at(1..64) {
match kind {
CppTokenKind::RightParen | CppTokenKind::LeftParen => break,
CppTokenKind::TemplateKeyword => return false,
_ => {}
}
}
if closes_with_a_pointer_operator(p) {
return true;
}
if an_operand_is_decisive(p) && an_operand_follows_the_parentheses(p) {
return true;
}
match p.peek_token_kind_at(1..2).first() {
Some(&kind) if types::is_type_specifier_keyword(kind) => true,
Some(&CppTokenKind::Identifier) => {
let name = p.peek_token_text_at(1);
p.is_a_known_type_name(name)
|| p.symbol_kind(name)
.is_some_and(|kind| matches!(kind, SymbolKind::Type | SymbolKind::Template))
}
_ => false,
}
}
fn cannot_follow_an_expression(p: &CppParser) -> bool {
matches!(
p.current_token(),
CppTokenKind::StructKeyword
| CppTokenKind::ClassKeyword
| CppTokenKind::UnionKeyword
| CppTokenKind::EnumKeyword
| CppTokenKind::NamespaceKeyword
| CppTokenKind::TemplateKeyword
| CppTokenKind::TypedefKeyword
| CppTokenKind::UsingKeyword
| CppTokenKind::ExternKeyword
| CppTokenKind::StaticAssertKeyword
| CppTokenKind::StaticKeyword
| CppTokenKind::FriendKeyword
| CppTokenKind::InlineKeyword
| CppTokenKind::VirtualKeyword
| CppTokenKind::ExplicitKeyword
| CppTokenKind::ReturnKeyword
| CppTokenKind::IfKeyword
| CppTokenKind::ForKeyword
| CppTokenKind::WhileKeyword
| CppTokenKind::PublicKeyword
| CppTokenKind::PrivateKeyword
| CppTokenKind::ProtectedKeyword
)
}
fn read_a_template_id_here(p: &mut CppParser) -> bool {
let before_the_arguments = p.checkpoint();
let read = types::parse_template_argument_list(p);
let an_operand_ends_the_constraint = an_operand_is_decisive(p) && starts_an_operand(p, 0);
if read.is_err()
|| an_operand_ends_the_constraint
|| (an_operand_is_decisive(p) && cannot_follow_an_expression(p))
{
p.rollback(before_the_arguments);
return false;
}
true
}
fn an_operand_is_decisive(p: &CppParser) -> bool {
!p.is_in_a_constraint() || p.is_open(CppSyntaxKind::ParenExpr)
}
fn macro_name_before(p: &CppParser) -> Option<String> {
let mut index = p.current_token_index();
while index > 0 {
index -= 1;
let text = p.token_text_at(index);
if !text.trim().is_empty() {
return Some(text.to_string());
}
}
None
}
fn a_template_id_here_is_called(p: &CppParser) -> bool {
let window = p.peek_token_kind_at(1..TEMPLATE_ARGUMENT_WINDOW);
let mut depth = 0usize;
for (index, kind) in window.iter().enumerate() {
match kind {
CppTokenKind::Less => depth += 1,
CppTokenKind::Greater => {
if depth == 0 {
return false;
}
depth -= 1;
if depth == 0 {
return window.get(index + 1) == Some(&CppTokenKind::LeftParen);
}
}
CppTokenKind::Semicolon | CppTokenKind::LeftBrace | CppTokenKind::RightBrace => {
return false;
}
CppTokenKind::LeftParen if depth == 0 => return false,
_ => {}
}
}
false
}
const TEMPLATE_ARGUMENT_WINDOW: usize = 8;
fn an_operand_follows_the_parentheses(p: &CppParser) -> bool {
let mut depth = 0isize;
let mut after_the_group = None;
for (index, kind) in p.peek_token_kind_at(1..128).iter().enumerate() {
match kind {
CppTokenKind::LeftParen => depth += 1,
CppTokenKind::RightParen => {
depth -= 1;
if depth < 0 {
after_the_group = Some(index + 2);
break;
}
}
CppTokenKind::Eof | CppTokenKind::None => return false,
_ => {}
}
}
let Some(mut offset) = after_the_group else {
return false;
};
while p.peek_token_kind_at(offset..offset + 1).first() == Some(&CppTokenKind::LeftParen) {
let mut inner = 0isize;
let mut closed = false;
for (index, kind) in p.peek_token_kind_at(offset..128).iter().enumerate() {
match kind {
CppTokenKind::LeftParen => inner += 1,
CppTokenKind::RightParen => {
inner -= 1;
if inner == 0 {
offset += index + 1;
closed = true;
break;
}
}
CppTokenKind::Eof | CppTokenKind::None => return false,
_ => {}
}
}
if !closed {
return false;
}
}
starts_an_operand(p, offset) || a_braced_initialiser_follows(p, offset)
}
fn a_braced_initialiser_follows(p: &CppParser, offset: usize) -> bool {
p.peek_token_kind_at(offset..offset + 1).first() == Some(&CppTokenKind::LeftBrace)
}
fn starts_an_operand(p: &CppParser, offset: usize) -> bool {
matches!(
p.peek_token_kind_at(offset..offset + 1).first(),
Some(
CppTokenKind::Identifier
| CppTokenKind::IntegerLiteral
| CppTokenKind::FloatingLiteral
| CppTokenKind::StringLiteral
| CppTokenKind::CharLiteral
| CppTokenKind::UserDefinedLiteral
| CppTokenKind::TrueKeyword
| CppTokenKind::FalseKeyword
| CppTokenKind::NullptrKeyword
| CppTokenKind::ThisKeyword
| CppTokenKind::LogicalNot
| CppTokenKind::Tilde
| CppTokenKind::SizeofKeyword
| CppTokenKind::AlignofKeyword
| CppTokenKind::TypeidKeyword
| CppTokenKind::NewKeyword
| CppTokenKind::DeleteKeyword
| CppTokenKind::ThrowKeyword
| CppTokenKind::CoAwaitKeyword
| CppTokenKind::NoexceptKeyword
)
)
}
fn closes_with_a_pointer_operator(p: &CppParser) -> bool {
let mut contents = Vec::new();
for kind in p.peek_token_kind_at(1..64) {
match kind {
CppTokenKind::RightParen => break,
CppTokenKind::LeftParen => return false,
other => contents.push(other),
}
}
let mut last = contents.len();
while last > 0
&& matches!(
contents[last - 1],
CppTokenKind::ConstKeyword | CppTokenKind::VolatileKeyword
)
{
last -= 1;
}
last > 0
&& matches!(
contents[last - 1],
CppTokenKind::Star | CppTokenKind::Ampersand | CppTokenKind::LogicalAnd
)
}
fn parse_new_expr(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::NewExpr);
if p.current_token() == CppTokenKind::Scope {
p.bump(); }
p.bump();
if let Err(err) = parse_new_type_and_initializer(p) {
p.close_marks_above(base);
return Err(err);
}
if let Err(err) = parse_new_declarator_suffixes(p) {
p.close_marks_above(base);
return Err(err);
}
if let Err(err) = parse_new_initializer(p) {
p.close_marks_above(base);
return Err(err);
}
let allocation = m.complete(p);
parse_postfix_suffixes(p, allocation)
}
fn parse_new_type_and_initializer(p: &mut CppParser) -> ParseResult {
if p.current_token() == CppTokenKind::LeftParen {
let checkpoint = p.checkpoint();
if placement_arguments_at(p) {
let placement = p.mark(CppSyntaxKind::ArgumentList);
decls::parse_expression_list(p, CppTokenKind::RightParen)?;
placement.complete(p);
return parse_a_type_here(p);
}
if parse_a_type_here(p).is_ok() {
return Ok(crate::parser::CompleteMarker::empty());
}
p.rollback(checkpoint);
let placement = p.mark(CppSyntaxKind::ArgumentList);
decls::parse_expression_list(p, CppTokenKind::RightParen)?;
placement.complete(p);
}
parse_a_type_here(p)
}
fn parse_a_type_here(p: &mut CppParser) -> ParseResult {
let before = p.current_token_index();
types::parse_type_id_for_an_allocation(p)?;
if p.current_token_index() == before {
return Err(CppParseError::syntax_error_from(
&t!("expected a type to allocate"),
p.current_token_range(),
));
}
Ok(crate::parser::CompleteMarker::empty())
}
fn placement_arguments_at(p: &CppParser) -> bool {
if p.current_token() != CppTokenKind::LeftParen {
return false;
}
let scan = p.peek_token_kind_at(1..64);
let mut depth = 0isize;
for (position, kind) in scan.iter().enumerate() {
match kind {
CppTokenKind::LeftParen if at_element_start(&scan, position) => return true,
CppTokenKind::LeftParen | CppTokenKind::LeftBracket | CppTokenKind::LeftBrace => {
depth += 1
}
CppTokenKind::RightParen | CppTokenKind::RightBracket | CppTokenKind::RightBrace => {
if depth == 0 {
return false;
}
depth -= 1;
}
CppTokenKind::Comma if depth == 0 => return true,
CppTokenKind::IntegerLiteral
| CppTokenKind::FloatingLiteral
| CppTokenKind::StringLiteral
| CppTokenKind::CharLiteral
| CppTokenKind::UserDefinedLiteral
| CppTokenKind::TrueKeyword
| CppTokenKind::FalseKeyword
| CppTokenKind::NullptrKeyword
if at_element_start(&scan, position) =>
{
return true;
}
CppTokenKind::Eof | CppTokenKind::None => return false,
_ => {}
}
}
false
}
fn at_element_start(scan: &[CppTokenKind], position: usize) -> bool {
position == 0 || scan.get(position - 1) == Some(&CppTokenKind::Comma)
}
fn parse_new_declarator_suffixes(p: &mut CppParser) -> ParseResult {
while p.current_token() == CppTokenKind::LeftBracket {
let array = p.mark(CppSyntaxKind::ArrayType);
p.bump();
if p.current_token() != CppTokenKind::RightBracket
&& !p.is_eof()
&& let Err(err) = parse_expr(p)
{
array.undo(p);
return Err(err);
}
if let Err(err) = expect_token(p, CppTokenKind::RightBracket) {
array.undo(p);
return Err(err);
}
array.complete(p);
}
Ok(crate::parser::CompleteMarker::empty())
}
fn parse_new_initializer(p: &mut CppParser) -> ParseResult {
match p.current_token() {
CppTokenKind::LeftParen => {
let init = p.mark(CppSyntaxKind::Initializer);
if let Err(err) = decls::parse_expression_list(p, CppTokenKind::RightParen) {
init.undo(p);
return Err(err);
}
init.complete(p);
}
CppTokenKind::LeftBrace => {
let init = p.mark(CppSyntaxKind::Initializer);
if let Err(err) = decls::parse_braced_initializer(p) {
init.undo(p);
return Err(err);
}
init.complete(p);
}
_ => {}
}
Ok(crate::parser::CompleteMarker::empty())
}
fn parse_postfix_expr(p: &mut CppParser, fold_operand: bool) -> ParseResult {
let expr = parse_primary_expr(p, fold_operand)?;
parse_postfix_suffixes(p, expr)
}
fn parse_postfix_suffixes(
p: &mut CppParser,
mut expr: crate::parser::CompleteMarker,
) -> ParseResult {
loop {
match p.current_token() {
CppTokenKind::LeftParen => {
let m = expr.precede(p, CppSyntaxKind::CallExpr);
let before_the_arguments = p.checkpoint();
if parse_call_arguments(p).is_err() {
p.rollback(before_the_arguments);
decls::parse_balanced_token_group(p, CppSyntaxKind::ArgumentList)?;
}
expr = m.complete(p);
}
CppTokenKind::LeftBracket
if p.is_in_a_constraint()
&& p.peek_next_token() == CppTokenKind::LeftBracket
&& p.peek_token_kind_at(1..3).last() == Some(&CppTokenKind::Identifier) =>
{
break;
}
CppTokenKind::LeftBracket => {
let m = expr.precede(p, CppSyntaxKind::IndexExpr);
p.bump(); parse_expr(p)?;
expect_token(p, CppTokenKind::RightBracket)?;
expr = m.complete(p);
}
CppTokenKind::Dot | CppTokenKind::Arrow => {
let m = expr.precede(p, CppSyntaxKind::IndexExpr);
let operator_range = p.current_token_range();
p.bump();
let same_line = p.lines_between(
operator_range.end_offset(),
p.current_token_range().start_offset,
) == 0;
if same_line
&& p.current_token() == CppTokenKind::TemplateKeyword
&& matches!(
p.peek_next_token(),
CppTokenKind::Identifier | CppTokenKind::OperatorKeyword
)
{
p.bump(); }
while same_line && p.current_token() == CppTokenKind::Identifier {
if p.peek_next_token() == CppTokenKind::Less {
let before_the_qualifier = p.checkpoint();
p.bump();
if types::parse_template_argument_list(p).is_err()
|| p.current_token() != CppTokenKind::Scope
{
p.rollback(before_the_qualifier);
break;
}
} else if p.peek_next_token() == CppTokenKind::Scope {
p.bump(); } else {
break;
}
p.bump(); if p.current_token() == CppTokenKind::TemplateKeyword
&& matches!(
p.peek_next_token(),
CppTokenKind::Identifier | CppTokenKind::OperatorKeyword
)
{
p.bump(); }
}
if same_line && p.current_token() == CppTokenKind::Identifier {
p.bump();
if types::could_start_template_arguments(p) {
let before_the_arguments = p.checkpoint();
let read = types::parse_template_argument_list(p);
if read.is_err() || starts_an_operand(p, 0) {
p.rollback(before_the_arguments);
}
}
} else if same_line && p.current_token() == CppTokenKind::OperatorKeyword {
types::parse_operator_name_here(p)?;
if types::could_start_template_arguments(p) {
let before_the_arguments = p.checkpoint();
let read = types::parse_template_argument_list(p);
if read.is_err() || starts_an_operand(p, 0) {
p.rollback(before_the_arguments);
}
}
} else if same_line && p.current_token() == CppTokenKind::Tilde {
p.bump(); if p.current_token() == CppTokenKind::Identifier
|| p.current_token() == CppTokenKind::Scope
|| starter_of_a_builtin_type(p.current_token())
{
let name = p.mark(CppSyntaxKind::NameExpr);
if p.current_token() == CppTokenKind::Scope {
p.bump();
}
if starter_of_a_builtin_type(p.current_token()) {
p.bump();
name.complete(p);
continue;
}
while same_line && p.current_token() == CppTokenKind::Identifier {
p.bump();
if types::could_start_template_arguments(p) {
let before_the_arguments = p.checkpoint();
let read = types::parse_template_argument_list(p);
if read.is_err() || starts_an_operand(p, 0) {
p.rollback(before_the_arguments);
}
}
if p.current_token() == CppTokenKind::Scope {
p.bump();
continue;
}
break;
}
name.complete(p);
}
} else {
p.emit_missing_node();
p.push_error(CppParseError::syntax_error_from(
&t!("expected identifier after member access operator"),
p.current_token_range(),
));
expr = m.complete(p);
break;
}
expr = m.complete(p);
}
CppTokenKind::PlusPlus | CppTokenKind::MinusMinus => {
let m = expr.precede(p, CppSyntaxKind::UnaryExpr);
p.bump(); expr = m.complete(p);
}
CppTokenKind::LeftBrace
if !p.is_in_a_constraint()
|| p.is_open(CppSyntaxKind::Requirement)
|| p.is_open(CppSyntaxKind::ParenExpr) =>
{
let marks_before = p.open_marks();
let m = expr.precede(p, CppSyntaxKind::InitListExpr);
if let Err(err) = decls::parse_braced_initializer(p) {
p.close_marks_above(marks_before);
return Err(err);
}
expr = m.complete(p);
}
CppTokenKind::LeftShift if p.cuda() && p.peek_next_token() == CppTokenKind::Less => {
let m = expr.precede(p, CppSyntaxKind::CudaLaunchExpr);
p.bump(); expect_token(p, CppTokenKind::Less)?; let configuration = p.mark(CppSyntaxKind::ArgumentList);
loop {
parse_assignment_expr(p)?;
if p.current_token() != CppTokenKind::Comma {
break;
}
p.bump();
}
configuration.complete(p);
if p.at_the_end_of_a_launch_configuration() {
p.bump();
p.bump();
p.bump();
} else {
expect_token(p, CppTokenKind::Greater)?;
}
if p.current_token() == CppTokenKind::LeftParen {
let before_the_arguments = p.checkpoint();
if parse_call_arguments(p).is_err() {
p.rollback(before_the_arguments);
decls::parse_balanced_token_group(p, CppSyntaxKind::ArgumentList)?;
}
}
expr = m.complete(p);
}
_ => break,
}
}
Ok(expr)
}
fn a_decltype_that_begins_a_qualified_name(p: &CppParser) -> bool {
if p.current_token() != CppTokenKind::DecltypeKeyword {
return false;
}
if p.peek_next_token() != CppTokenKind::LeftParen {
return false;
}
let mut index = decls::next_significant_index(p, p.current_token_index());
let mut depth = 0isize;
while index < p.token_count() {
match p.token_kind_at(index) {
CppTokenKind::LeftParen => depth += 1,
CppTokenKind::RightParen => {
depth -= 1;
if depth == 0 {
let after = decls::next_significant_index(p, index);
return p.token_kind_at(after) == CppTokenKind::Scope;
}
}
CppTokenKind::Eof | CppTokenKind::None => return false,
_ => {}
}
index += 1;
}
false
}
fn parse_delete_expr(p: &mut CppParser, fold_operand: bool) -> ParseResult {
let m = p.mark(CppSyntaxKind::UnaryExpr);
if p.current_token() == CppTokenKind::Scope {
p.bump(); }
expect_token(p, CppTokenKind::DeleteKeyword)?;
if p.current_token() == CppTokenKind::LeftBracket {
p.bump();
expect_token(p, CppTokenKind::RightBracket)?;
}
parse_unary_expr(p, fold_operand)?;
Ok(m.complete(p))
}
fn parse_primary_expr(p: &mut CppParser, fold_operand: bool) -> ParseResult {
match p.current_token() {
CppTokenKind::IntegerLiteral
| CppTokenKind::FloatingLiteral
| CppTokenKind::StringLiteral
| CppTokenKind::CharLiteral
| CppTokenKind::TrueKeyword
| CppTokenKind::FalseKeyword
| CppTokenKind::NullptrKeyword
| CppTokenKind::UserDefinedLiteral => {
let m = p.mark(CppSyntaxKind::LiteralExpr);
let is_a_string = p.current_token() == CppTokenKind::StringLiteral;
p.bump();
while is_a_string
&& matches!(
p.current_token(),
CppTokenKind::StringLiteral
| CppTokenKind::Identifier
| CppTokenKind::Hash
)
{
if p.current_token() == CppTokenKind::Hash {
stats::parse_preprocessor_directive(p)?;
} else {
p.bump();
}
}
Ok(m.complete(p))
}
kind if types::is_type_specifier_keyword(kind)
&& matches!(
p.peek_next_token(),
CppTokenKind::LeftParen | CppTokenKind::LeftBrace
)
&& !a_decltype_that_begins_a_qualified_name(p) =>
{
let m = p.mark(CppSyntaxKind::CastExpr);
let the_type = p.mark(CppSyntaxKind::BuiltinType);
p.bump();
the_type.complete(p);
if let Err(err) = parse_functional_payload(p) {
m.undo(p);
return Err(err);
}
Ok(m.complete(p))
}
CppTokenKind::TypenameKeyword
if matches!(
p.peek_token_kind_at(1..2).first(),
Some(&CppTokenKind::Identifier)
) =>
{
let m = p.mark(CppSyntaxKind::CastExpr);
p.bump();
let the_type = p.mark(CppSyntaxKind::TypenameType);
if let Err(err) = types::parse_name(p) {
the_type.undo(p);
m.undo(p);
return Err(err);
}
the_type.complete(p);
if let Err(err) = parse_functional_payload(p) {
m.undo(p);
return Err(err);
}
Ok(m.complete(p))
}
CppTokenKind::StaticCastKeyword
| CppTokenKind::DynamicCastKeyword
| CppTokenKind::ConstCastKeyword
| CppTokenKind::ReinterpretCastKeyword => {
let m = p.mark(CppSyntaxKind::CastExpr);
p.bump();
let parsed = expect_token(p, CppTokenKind::Less)
.and_then(|_| types::parse_type_id(p))
.and_then(|_| expect_token(p, CppTokenKind::Greater))
.and_then(|_| expect_token(p, CppTokenKind::LeftParen))
.and_then(|_| {
if p.current_token() == CppTokenKind::RightParen {
Ok(())
} else {
parse_expr(p).map(|_| ())
}
})
.and_then(|_| expect_token(p, CppTokenKind::RightParen));
match parsed {
Ok(()) => Ok(m.complete(p)),
Err(err) => {
m.undo(p);
Err(err)
}
}
}
CppTokenKind::LogicalAnd
if p.peek_next_token() == CppTokenKind::Identifier
&& p.language()
.support(crate::features::Feature::LabelsAsValues) =>
{
let m = p.mark(CppSyntaxKind::UnaryExpr);
p.bump(); p.bump(); Ok(m.complete(p))
}
CppTokenKind::Identifier
if p.current_token_text() == "_Generic"
&& p.peek_next_token() == CppTokenKind::LeftParen
&& p.language()
.support(crate::features::Feature::GenericSelection) =>
{
parse_generic_selection(p)
}
CppTokenKind::Identifier
| CppTokenKind::Scope
| CppTokenKind::OperatorKeyword
| CppTokenKind::DecltypeKeyword
if !is_expression_keyword(p)
&& (p.current_token() != CppTokenKind::DecltypeKeyword
|| a_decltype_that_begins_a_qualified_name(p)) =>
{
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::IdentifierExpr);
if p.current_token() == CppTokenKind::Scope {
p.bump();
}
loop {
if p.current_token() == CppTokenKind::TemplateKeyword {
p.bump();
if !matches!(
p.current_token(),
CppTokenKind::Identifier
| CppTokenKind::OperatorKeyword
| CppTokenKind::Tilde
) {
p.close_marks_above(base);
return Err(CppParseError::syntax_error_from(
&t!("expected a name after `template`"),
p.current_token_range(),
));
}
}
match p.current_token() {
CppTokenKind::Identifier => p.bump(),
CppTokenKind::DecltypeKeyword if p.peek_next_token() == CppTokenKind::LeftParen => {
p.bump(); p.bump(); let payload = if p.current_token() == CppTokenKind::AutoKeyword {
types::parse_type_id(p).map(|_| ())
} else {
parse_expr(p).map(|_| ())
};
if let Err(err) =
payload.and_then(|()| expect_token(p, CppTokenKind::RightParen))
{
p.close_marks_above(base);
return Err(err);
}
}
CppTokenKind::Tilde => {
p.bump();
if p.current_token() == CppTokenKind::Identifier {
p.bump();
}
break;
}
CppTokenKind::OperatorKeyword => {
types::parse_operator_name_here(p)?;
break;
}
_ => {
p.close_marks_above(base);
return Err(CppParseError::syntax_error_from(
&t!("expected a name after `::`"),
p.current_token_range(),
));
}
}
if p.current_token() == CppTokenKind::Less
&& types::could_start_template_arguments(p)
&& !read_a_template_id_here(p) {
break;
}
if p.current_token() == CppTokenKind::Scope {
p.bump();
continue;
}
let mut taken = 0usize;
while an_operand_is_decisive(p)
&& p.current_token() == CppTokenKind::Identifier
&& match p.peek_token_kind_at(1..3).as_slice() {
[CppTokenKind::LeftParen, ..] => true,
[CppTokenKind::RightParen, CppTokenKind::LeftParen] => {
p.is_open(CppSyntaxKind::ParenExpr)
}
[CppTokenKind::Less, ..] => {
let the_prefix_is_a_macro = macro_name_before(p)
.map(|name| {
p.is_a_macro(&name) == Some(true) || types::written_like_a_macro(&name)
})
.unwrap_or(taken > 0);
the_prefix_is_a_macro && a_template_id_here_is_called(p)
}
_ => false,
}
{
p.bump();
taken += 1;
}
if p.current_token() == CppTokenKind::Less
&& types::could_start_template_arguments(p)
{
read_a_template_id_here(p);
}
break;
}
Ok(m.complete(p))
}
CppTokenKind::LeftParen if is_a_type_in_parentheses(p) => {
let checkpoint = p.checkpoint();
let m = p.mark(CppSyntaxKind::CastExpr);
p.bump();
let parsed = types::parse_type_id(p)
.and_then(|_| expect_token(p, CppTokenKind::RightParen))
.and_then(|_| {
if p.current_token() == CppTokenKind::LeftBrace {
decls::parse_braced_initializer(p)
} else {
parse_unary_expr(p, false)
}
});
match parsed {
Ok(_) => Ok(m.complete(p)),
Err(_) => {
p.rollback(checkpoint);
parse_parenthesized_expression(p)
}
}
}
CppTokenKind::LeftParen => parse_parenthesized_expression(p),
CppTokenKind::LeftBracket if starts_a_lambda(p) => parse_lambda(p),
CppTokenKind::Caret => parse_block_literal(p),
CppTokenKind::ThisKeyword => {
let m = p.mark(CppSyntaxKind::ThisExpr);
p.bump();
Ok(m.complete(p))
}
CppTokenKind::Ellipsis if fold_operand => {
let m = p.mark(CppSyntaxKind::FoldExpr);
p.bump();
Ok(m.complete(p))
}
CppTokenKind::Identifier
if p.current_token_text() == "_Generic"
&& p.peek_next_token() == CppTokenKind::LeftParen
&& p.language()
.support(crate::features::Feature::GenericSelection) =>
{
parse_generic_selection(p)
}
_ => Err(CppParseError::syntax_error_from(
&t!("expected primary expression"),
p.current_token_range(),
)),
}
}
fn parse_generic_selection(p: &mut CppParser) -> ParseResult {
let m = p.mark(CppSyntaxKind::GenericSelectionExpr);
p.bump(); expect_token(p, CppTokenKind::LeftParen)?;
parse_assignment_expr(p)?;
while p.current_token() == CppTokenKind::Comma {
p.bump();
if p.current_token() == CppTokenKind::DefaultKeyword {
p.bump();
} else {
types::parse_type_id(p)?;
}
expect_token(p, CppTokenKind::Colon)?;
parse_assignment_expr(p)?;
}
if let Err(err) = expect_token(p, CppTokenKind::RightParen) {
p.push_error(err);
}
Ok(m.complete(p))
}
fn parse_functional_payload(p: &mut CppParser) -> ParseResult {
if p.current_token() == CppTokenKind::LeftBrace {
return decls::parse_braced_initializer(p);
}
let m = p.mark(CppSyntaxKind::ParenExpr);
expect_token(p, CppTokenKind::LeftParen)?;
if p.current_token() != CppTokenKind::RightParen
&& let Err(err) = parse_expr_up_to(p, Level::Full, true)
{
m.undo(p);
return Err(err);
}
if let Err(err) = expect_token(p, CppTokenKind::RightParen) {
m.undo(p);
return Err(err);
}
Ok(m.complete(p))
}
fn parse_parenthesized_expression(p: &mut CppParser) -> ParseResult {
let m = p.mark(CppSyntaxKind::ParenExpr);
expect_token(p, CppTokenKind::LeftParen)?;
if p.current_token() == CppTokenKind::LeftBrace {
if let Err(err) = crate::grammar::cpp::stats::parse_compound_stat(p) {
m.undo(p);
return Err(err);
}
if let Err(err) = expect_token(p, CppTokenKind::RightParen) {
m.undo(p);
return Err(err);
}
return Ok(m.complete(p));
}
if let Err(err) = parse_expr_up_to(p, Level::Full, true) {
m.undo(p);
return Err(err);
}
if let Err(err) = expect_token(p, CppTokenKind::RightParen) {
m.undo(p);
return Err(err);
}
Ok(m.complete(p))
}
fn parse_block_literal(p: &mut CppParser) -> ParseResult {
let m = p.mark(CppSyntaxKind::LambdaExpr);
p.bump();
if p.current_token() == CppTokenKind::LeftParen
&& let Err(err) = crate::grammar::cpp::decls::parse_parameter_list(p)
{
m.undo(p);
return Err(err);
}
while p.current_token() == CppTokenKind::Hash {
if let Err(err) = crate::grammar::cpp::stats::parse_preprocessor_directive(p) {
m.undo(p);
return Err(err);
}
}
if let Err(err) = crate::grammar::cpp::stats::parse_compound_stat(p) {
m.undo(p);
return Err(err);
}
Ok(m.complete(p))
}
fn is_expression_keyword(p: &CppParser) -> bool {
matches!(
p.current_token(),
CppTokenKind::NullptrKeyword
| CppTokenKind::SizeofKeyword
| CppTokenKind::AlignofKeyword
| CppTokenKind::TypeidKeyword
| CppTokenKind::NewKeyword
| CppTokenKind::DeleteKeyword
| CppTokenKind::ThrowKeyword
| CppTokenKind::CoAwaitKeyword
)
}
fn starts_a_requires_expression(p: &CppParser) -> bool {
match p.peek_token_kind_at(1..2).first() {
Some(&CppTokenKind::LeftBrace) => true,
Some(&CppTokenKind::LeftParen) => {
let mut depth = 0isize;
let mut offset = 1usize;
for kind in p.peek_token_kind_at(1..128) {
offset += 1;
match kind {
CppTokenKind::LeftParen => depth += 1,
CppTokenKind::RightParen => {
depth -= 1;
if depth == 0 {
return p.peek_token_kind_at(offset..offset + 1).as_slice()
== [CppTokenKind::LeftBrace];
}
}
_ => {}
}
}
false
}
_ => false,
}
}
pub(super) fn starter_of_a_builtin_type(kind: CppTokenKind) -> bool {
matches!(
kind,
CppTokenKind::BoolLiteral
| CppTokenKind::CharKeyword
| CppTokenKind::ShortKeyword
| CppTokenKind::IntKeyword
| CppTokenKind::LongKeyword
| CppTokenKind::SignedKeyword
| CppTokenKind::UnsignedKeyword
| CppTokenKind::FloatKeyword
| CppTokenKind::DoubleKeyword
| CppTokenKind::VoidKeyword
| CppTokenKind::DecltypeKeyword
)
}
fn parse_requires_expression(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::RequiresExpr);
p.bump();
if p.current_token() == CppTokenKind::LeftParen
&& let Err(err) = decls::parse_parameter_list(p)
{
p.close_marks_above(base);
return Err(err);
}
if p.current_token() != CppTokenKind::LeftBrace {
p.close_marks_above(base);
return Err(CppParseError::syntax_error_from(
&t!("expected `{` after `requires`"),
p.current_token_range(),
));
}
p.bump();
while p.current_token() != CppTokenKind::RightBrace && !p.is_eof() {
if p.current_token() == CppTokenKind::Hash {
if let Err(err) = stats::parse_preprocessor_directive(p) {
p.close_marks_above(base);
return Err(err);
}
continue;
}
if let Err(err) = parse_requirement(p) {
p.close_marks_above(base);
return Err(err);
}
if p.current_token() == CppTokenKind::Semicolon {
p.bump();
continue;
}
break;
}
if p.current_token() != CppTokenKind::RightBrace {
p.close_marks_above(base);
return Err(CppParseError::syntax_error_from(
&t!("expected `}`"),
p.current_token_range(),
));
}
p.bump();
Ok(m.complete(p))
}
fn parse_requirement(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::Requirement);
match p.current_token() {
CppTokenKind::Identifier if at_requires(p) && decls::starts_a_requires_clause(p) => {
if let Err(err) = decls::parse_requires_clause(p) {
p.close_marks_above(base);
return Err(err);
}
}
CppTokenKind::TypenameKeyword => {
if let Err(err) = types::parse_type_id(p) {
p.close_marks_above(base);
return Err(err);
}
}
CppTokenKind::LeftBrace => {
p.bump(); if let Err(err) = parse_requirement_expression(p) {
p.close_marks_above(base);
return Err(err);
}
if let Err(err) = expect_token(p, CppTokenKind::RightBrace) {
p.close_marks_above(base);
return Err(err);
}
if p.current_token() == CppTokenKind::NoexceptKeyword {
let specification = p.mark(CppSyntaxKind::NoexceptSpec);
p.bump();
if p.current_token() == CppTokenKind::LeftParen {
p.bump();
if let Err(err) = parse_expr(p) {
p.close_marks_above(base);
return Err(err);
}
if let Err(err) = expect_token(p, CppTokenKind::RightParen) {
p.close_marks_above(base);
return Err(err);
}
}
specification.complete(p);
}
if p.current_token() == CppTokenKind::Arrow {
let trailing = p.mark(CppSyntaxKind::TrailingReturnType);
p.bump(); if let Err(err) = types::parse_type_id(p) {
trailing.undo(p);
p.close_marks_above(base);
return Err(err);
}
trailing.complete(p);
}
}
_ => {
if let Err(err) = parse_expr(p) {
p.close_marks_above(base);
return Err(err);
}
}
}
Ok(m.complete(p))
}
fn starts_a_lambda(p: &CppParser) -> bool {
use CppTokenKind::{
Ampersand, Arrow, Assign, Caret, CharLiteral, Colon, Comma, Dot, Ellipsis, Equal,
FalseKeyword, FloatingLiteral, Greater, GreaterEqual, Identifier, IntegerLiteral,
LeftBrace, LeftBracket, LeftParen, LeftShift, Less, LessEqual, LogicalAnd, LogicalNot,
LogicalOr, Minus, MinusMinus, MutableKeyword, NoexceptKeyword, NotEqual, NullptrKeyword,
Percent, Pipe, Plus, PlusPlus, Question, RightBracket, RightParen, RightShift, Scope,
Slash, Star, StringLiteral, ThisKeyword, Tilde, TrueKeyword,
};
let mut next_after_the_list = None;
for (offset, kind) in p.peek_token_kind_at(1..64).into_iter().enumerate() {
match kind {
Identifier
| Comma
| Ampersand
| Assign
| Ellipsis
| ThisKeyword
| Star
| Scope
| IntegerLiteral
| FloatingLiteral
| StringLiteral
| CharLiteral
| TrueKeyword
| FalseKeyword
| NullptrKeyword
| LeftParen
| RightParen
| LeftBracket
| Plus
| Minus
| Slash
| Percent
| Caret
| Pipe
| Tilde
| LogicalNot
| LogicalAnd
| LogicalOr
| Equal
| NotEqual
| Less
| Greater
| LessEqual
| GreaterEqual
| LeftShift
| RightShift
| PlusPlus
| MinusMinus
| Arrow
| Dot
| Question
| Colon => {}
RightBracket => {
next_after_the_list = p.peek_token_kind_at(offset + 2..offset + 3).first().copied();
break;
}
_ => return false,
}
}
matches!(
next_after_the_list,
Some(LeftParen)
| Some(LeftBrace)
| Some(MutableKeyword)
| Some(NoexceptKeyword)
| Some(Arrow)
| Some(Less)
)
}
fn parse_lambda(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::LambdaExpr);
if let Err(err) = parse_capture_list(p) {
p.close_marks_above(base);
return Err(err);
}
if matches!(
p.current_token(),
CppTokenKind::Less | CppTokenKind::TemplateKeyword
) {
if p.current_token() == CppTokenKind::TemplateKeyword {
p.bump();
}
if let Err(err) = decls::parse_template_parameter_list(p) {
p.close_marks_above(base);
return Err(err);
}
}
if p.current_token() == CppTokenKind::LeftParen
&& let Err(err) = decls::parse_parameter_list(p)
{
p.close_marks_above(base);
return Err(err);
}
types::eat_function_qualifiers(p);
if let Err(err) = stats::parse_compound_stat(p) {
p.close_marks_above(base);
return Err(err);
}
Ok(m.complete(p))
}
fn parse_capture_list(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::LambdaCaptureList);
if let Err(err) = expect_token(p, CppTokenKind::LeftBracket) {
p.close_marks_above(base);
return Err(err);
}
while p.current_token() != CppTokenKind::RightBracket && !p.is_eof() {
if let Err(err) = parse_capture(p) {
p.close_marks_above(base);
return Err(err);
}
if p.current_token() == CppTokenKind::Comma {
p.bump();
continue;
}
break;
}
if let Err(err) = expect_token(p, CppTokenKind::RightBracket) {
p.close_marks_above(base);
return Err(err);
}
Ok(m.complete(p))
}
fn parse_capture(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::LambdaCapture);
if matches!(
p.current_token(),
CppTokenKind::Ampersand | CppTokenKind::Star
) {
p.bump();
}
if p.current_token() == CppTokenKind::Ellipsis {
p.bump();
}
if matches!(
p.current_token(),
CppTokenKind::ThisKeyword
| CppTokenKind::Ellipsis
| CppTokenKind::Assign
| CppTokenKind::Identifier
) {
p.bump();
}
if p.current_token() == CppTokenKind::Ellipsis {
p.bump();
}
if p.current_token() == CppTokenKind::Assign {
p.bump();
if let Err(err) = parse_assignment_expr(p) {
p.close_marks_above(base);
return Err(err);
}
}
Ok(m.complete(p))
}