use crate::{
grammar::{
ParseResult,
cpp::{exprs, modules, stats, types},
},
kind::{CppSyntaxKind, CppTokenKind},
parser::{CompleteMarker, CppParser, Marker, MarkerEventContainer, ParseAnchor},
parser_error::CppParseError,
symbols::SymbolKind,
};
use super::{
at_concept, at_requires, expect_contextual_keyword, expect_token,
exprs::parse_expr,
stats::{parse_compound_stat, parse_stats},
types::{
definitely_ends_a_type, is_type_specifier_keyword, parse_decl_specifier_seq,
parse_declarator, parse_declarator_with, parse_name, parse_type_id,
},
};
pub(super) fn parse_template_head(p: &mut CppParser) -> ParseResult {
let previous_depth = p.enter_template_arguments();
let result = parse_template_head_inner(p, previous_depth);
p.leave_template_arguments(previous_depth);
result
}
fn parse_template_head_inner(p: &mut CppParser, outer_depth: Option<usize>) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::TemplateDecl);
expect_token(p, CppTokenKind::TemplateKeyword)?;
if let Err(err) = parse_template_parameter_list(p) {
p.close_marks_above(base);
return Err(err);
}
p.leave_template_arguments(outer_depth);
if at_requires(p)
&& let Err(err) = parse_requires_clause(p)
{
p.close_marks_above(base);
return Err(err);
}
Ok(m.complete(p))
}
fn parse_concept_declaration(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::ConceptDecl);
expect_contextual_keyword(p, "concept")?;
if p.current_token() == CppTokenKind::Identifier {
if let Err(err) = parse_name(p) {
p.close_marks_above(base);
return Err(err);
}
} else {
p.close_marks_above(base);
return Err(CppParseError::syntax_error_from(
&t!("expected a concept name"),
p.current_token_range(),
));
}
let ended = parse_a_definition_per_branch(p, exprs::parse_constraint_expr);
match ended {
Err(err) => {
p.close_marks_above(base);
return Err(err);
}
Ok(ended) if !ended => {
if let Err(err) = expect_semicolon(p) {
p.close_marks_above(base);
return Err(err);
}
}
Ok(_) => {}
}
Ok(m.complete(p))
}
pub(super) fn starts_a_requires_clause(p: &mut CppParser) -> bool {
let checkpoint = p.checkpoint();
let started_at = p.current_token_index();
let parsed = parse_requires_clause(p);
let consumed = parsed.is_ok() && p.current_token_index() > started_at;
p.rollback(checkpoint);
consumed
}
pub fn parse_requires_clause(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::RequiresClause);
expect_contextual_keyword(p, "requires")?;
if let Err(err) = exprs::parse_constraint_expr(p) {
p.close_marks_above(base);
return Err(err);
}
Ok(m.complete(p))
}
pub fn parse_template_parameter_list(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::TemplateParameterList);
expect_token(p, CppTokenKind::Less)?;
if p.current_token() == CppTokenKind::Greater {
p.bump();
return Ok(m.complete(p));
}
loop {
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_template_parameter(p) {
p.close_marks_above(base);
return Err(err);
}
let mut terminator = p.current_token();
while terminator == CppTokenKind::Hash {
if let Err(err) = stats::parse_preprocessor_directive(p) {
p.close_marks_above(base);
return Err(err);
}
terminator = p.current_token();
}
match terminator {
CppTokenKind::Comma => {
p.bump();
continue;
}
CppTokenKind::Greater => {
p.bump();
break;
}
CppTokenKind::Identifier if types::written_like_a_macro(p.current_token_text()) => {
let m = p.mark(CppSyntaxKind::MacroCall);
let name = p.mark(CppSyntaxKind::NameExpr);
p.bump();
name.complete(p);
m.complete(p);
if p.current_token() == CppTokenKind::Greater {
p.bump();
break;
}
continue;
}
_ => {
p.close_marks_above(base);
return Err(CppParseError::syntax_error_from(
&t!("expected `,` or `>` in template parameter list"),
p.current_token_range(),
));
}
}
}
Ok(m.complete(p))
}
fn ends_a_template_parameter_head(kind: CppTokenKind) -> bool {
definitely_ends_a_type(kind) || matches!(kind, CppTokenKind::Ellipsis | CppTokenKind::Greater)
}
fn a_type_parameter_name(p: &CppParser) -> Option<String> {
if !matches!(
p.current_token(),
CppTokenKind::TypenameKeyword | CppTokenKind::ClassKeyword
) {
return None;
}
if p.peek_next_token() == CppTokenKind::Ellipsis {
let name = p.peek_token_text_at(2);
return (!name.is_empty()).then(|| name.to_string());
}
if p.peek_next_token() != CppTokenKind::Identifier {
return None;
}
Some(p.peek_token_text_at(1).to_string())
}
fn parse_template_parameter(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::TemplateParameter);
if let Some(name) = a_type_parameter_name(p) {
p.declare_template_parameter(&name);
}
if p.current_token() == CppTokenKind::TemplateKeyword
&& let Err(err) = parse_template_head(p)
{
p.close_marks_above(base);
return Err(err);
}
if let Some(name) = a_type_parameter_name(p) {
p.declare_template_parameter(&name);
}
if p.current_token() == CppTokenKind::TypenameKeyword
&& p.peek_next_token() == CppTokenKind::Ellipsis
{
let typename_type = p.mark(CppSyntaxKind::TypenameType);
p.bump(); p.bump(); typename_type.complete(p);
if p.current_token() == CppTokenKind::Identifier
&& let Err(err) = parse_name(p)
{
p.close_marks_above(base);
return Err(err);
}
return Ok(m.complete(p));
}
let a_name_precedes_the_parameter = matches!(
p.current_token(),
CppTokenKind::Identifier | CppTokenKind::Scope
);
if let Err(err) = parse_decl_specifier_seq(p) {
p.close_marks_above(base);
return Err(err);
}
let declarator_from = p.current_event_count();
if !ends_a_template_parameter_head(p.current_token())
&& p.current_token() != CppTokenKind::Ellipsis
&& let Err(err) = parse_declarator(p)
{
p.close_marks_above(base);
return Err(err);
}
if a_name_precedes_the_parameter
&& let Some(name) = p.the_name_a_declarator_introduced(declarator_from)
{
p.declare_template_parameter(&name);
}
if p.current_token() == CppTokenKind::Ellipsis {
p.bump();
if p.current_token() == CppTokenKind::Identifier
&& let Err(err) = parse_name(p)
{
p.close_marks_above(base);
return Err(err);
}
}
if p.current_token() == CppTokenKind::Assign {
p.bump();
while p.current_token() == CppTokenKind::Hash {
if let Err(err) = stats::parse_preprocessor_directive(p) {
p.close_marks_above(base);
return Err(err);
}
}
loop {
parse_a_default_value(p, base)?;
if p.current_token() != CppTokenKind::Hash
|| !matches!(p.peek_token_text_at(1), "else" | "elif")
{
break;
}
if let Err(err) = stats::parse_preprocessor_directive(p) {
p.close_marks_above(base);
return Err(err);
}
}
}
Ok(m.complete(p))
}
fn parse_a_default_value(p: &mut CppParser, base: usize) -> ParseResult {
let type_checkpoint = p.checkpoint();
let before = p.current_token_index();
let parsed_a_type = parse_type_id(p).is_ok() && p.current_token_index() > before;
if parsed_a_type && ends_a_template_parameter(p) {
return Ok(CompleteMarker::empty());
}
p.rollback(type_checkpoint);
if let Err(err) = exprs::parse_assignment_expr(p) {
p.close_marks_above(base);
return Err(err);
}
Ok(CompleteMarker::empty())
}
fn ends_a_template_parameter(p: &CppParser) -> bool {
matches!(
p.current_token(),
CppTokenKind::Comma
| CppTokenKind::Greater
| CppTokenKind::RightShift
| CppTokenKind::Hash
| CppTokenKind::Eof
)
}
pub fn parse_declaration(p: &mut CppParser) -> ParseResult {
let outer = p.a_template_id_may_be_the_name();
p.set_a_template_id_may_be_the_name(false);
let parameters_before = p.template_parameter_count();
let result = parse_declaration_here(p);
p.truncate_template_parameters(parameters_before);
p.set_a_template_id_may_be_the_name(outer);
result
}
fn parse_declaration_here(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let checkpoint = p.checkpoint();
match p.current_token() {
CppTokenKind::NamespaceKeyword => return parse_namespace_declaration(p),
CppTokenKind::TypedefKeyword => return parse_typedef_declaration(p),
CppTokenKind::StaticAssertKeyword => return parse_static_assert(p),
CppTokenKind::InlineKeyword if p.peek_next_token() == CppTokenKind::NamespaceKeyword => {
p.bump(); return parse_namespace_declaration(p);
}
CppTokenKind::UsingKeyword => return parse_using_declaration(p),
CppTokenKind::ExternKeyword if starts_a_linkage_specification(p) => {
return parse_linkage_specification(p);
}
CppTokenKind::Tilde => return parse_destructor_declaration(p),
CppTokenKind::Identifier
if p.peek_next_token() == CppTokenKind::Tilde
&& matches!(
p.current_token_text(),
"__thiscall"
| "__cdecl"
| "__stdcall"
| "__fastcall"
| "__vectorcall"
| "__clrcall"
) =>
{
return parse_destructor_declaration(p);
}
CppTokenKind::OperatorKeyword => return parse_conversion_operator_declaration(p),
CppTokenKind::Identifier
if p.is_at_class_member_level()
&& p.current_class_name().is_some_and(|class| class == p.current_token_text())
&& p.peek_next_token() == CppTokenKind::LeftParen
&& !matches!(
p.peek_token_kind_at(2..3).first(),
Some(CppTokenKind::Star | CppTokenKind::Ampersand)
) =>
{
return parse_constructor_declaration(p);
}
CppTokenKind::ExportKeyword => {
if p.peek_token_kind_at(1..2)[0] == CppTokenKind::LeftBrace {
return modules::parse_export_block(p);
}
if matches!(p.peek_token_text_at(1), "module" | "import") {
return modules::parse_exported_declaration(p);
}
match p.peek_token_kind_at(1..2)[0] {
CppTokenKind::UsingKeyword => {
p.bump();
return parse_using_declaration(p);
}
CppTokenKind::NamespaceKeyword => {
p.bump();
return parse_namespace_declaration(p);
}
CppTokenKind::TypedefKeyword => {
p.bump();
return parse_typedef_declaration(p);
}
CppTokenKind::StaticAssertKeyword => {
p.bump();
return parse_static_assert(p);
}
_ => {}
}
}
_ => {}
}
if modules::starts_global_module_fragment(p) {
return modules::parse_global_module_fragment(p);
}
if modules::starts_private_module_fragment(p) {
return modules::parse_private_module_fragment(p);
}
if modules::starts_module_declaration(p) {
return modules::parse_module_declaration(p);
}
if modules::starts_import_declaration(p) {
return modules::parse_import_declaration(p);
}
let m = p.mark(CppSyntaxKind::Declaration);
if p.current_token() == CppTokenKind::ExternKeyword
&& p.peek_next_token() == CppTokenKind::TemplateKeyword
{
p.bump(); p.bump();
p.set_a_template_id_may_be_the_name(true);
}
if p.current_token() == CppTokenKind::TemplateKeyword
&& p.peek_next_token() != CppTokenKind::Less
{
p.bump(); p.set_a_template_id_may_be_the_name(true);
}
if p.current_token() == CppTokenKind::ExportKeyword {
p.bump();
}
let mut seen_a_template_head = false;
loop {
if p.current_token() == CppTokenKind::TemplateKeyword {
p.set_a_template_id_may_be_the_name(true);
if let Err(err) = parse_template_head(p) {
p.rollback(checkpoint);
return Err(err);
}
seen_a_template_head = true;
continue;
}
if seen_a_template_head && p.current_token() == CppTokenKind::Hash {
if let Err(err) = stats::parse_preprocessor_directive(p) {
p.rollback(checkpoint);
return Err(err);
}
continue;
}
if seen_a_template_head && at_requires(p) && starts_a_requires_clause(p) {
if let Err(err) = parse_requires_clause(p) {
p.rollback(checkpoint);
return Err(err);
}
continue;
}
break;
}
if p.current_token() == CppTokenKind::UsingKeyword {
if let Err(err) = parse_using_declaration(p) {
p.rollback(checkpoint);
return Err(err);
}
return Ok(m.complete(p));
}
if seen_a_template_head && at_concept(p) {
if let Err(err) = parse_concept_declaration(p) {
p.rollback(checkpoint);
return Err(err);
}
return Ok(m.complete(p));
}
if p.current_token() == CppTokenKind::TypedefKeyword {
if let Err(err) = parse_typedef_declaration(p) {
p.rollback(checkpoint);
return Err(err);
}
return Ok(m.complete(p));
}
if seen_a_template_head {
loop {
let before = p.current_token_index();
if p.current_token() == CppTokenKind::Hash {
if let Err(err) = stats::parse_preprocessor_directive(p) {
p.rollback(checkpoint);
return Err(err);
}
} else if let Err(err) = types::parse_attribute_specifiers(p) {
p.rollback(checkpoint);
return Err(err);
}
if p.current_token_index() == before {
break;
}
}
}
let specifiers_from = p.current_event_count();
if let Err(err) = parse_decl_specifier_seq(p) {
p.rollback(checkpoint);
return Err(err);
}
if p.current_token() == CppTokenKind::Semicolon {
p.bump();
return Ok(m.complete(p));
}
if p.take_declaration_ended_inside_specifiers() {
return Ok(m.complete(p));
}
if p.current_token() == CppTokenKind::LeftBrace
&& (declaration_opens_a_body(p) || declaration_wrote_a_class_head(p, specifiers_from))
{
if let Err(err) = parse_class_body(p) {
p.close_marks_above(base);
return Err(err);
}
if p.current_token() == CppTokenKind::Semicolon {
p.bump();
} else if a_declaration_cannot_follow(p) {
p.close_marks_above(base);
return Err(CppParseError::syntax_error_from(
&t!("expected `;` after a class definition"),
p.current_token_range(),
));
}
return Ok(m.complete(p));
}
let mut declarators = 0usize;
loop {
if let Err(err) = parse_init_declarator(p) {
if declarators == 0 {
p.rollback(checkpoint);
return Err(err);
}
p.close_marks_above(base);
return Err(err);
}
declarators += 1;
if p.current_token() == CppTokenKind::Comma {
p.bump();
continue;
}
break;
}
if p.current_token() == CppTokenKind::LeftBrace {
if let Err(err) = parse_compound_stat(p) {
p.close_marks_above(base);
return Err(err);
}
return Ok(m.complete(p));
}
if p.current_token() == CppTokenKind::Semicolon
&& declaration_defined_a_class(p, specifiers_from)
{
p.bump();
return Ok(m.complete(p));
}
if p.events_contain_any(specifiers_from, &[CppSyntaxKind::OldStyleParameterList]) {
return Ok(m.complete(p));
}
if let Err(err) = expect_semicolon(p) {
p.end_marks_to(base);
return Err(err);
}
Ok(m.complete(p))
}
fn declaration_defined_a_class(p: &CppParser, specifiers_from: usize) -> bool {
p.events_contain_any(
specifiers_from,
&[CppSyntaxKind::ClassBody, CppSyntaxKind::CompoundStat],
)
}
fn declaration_wrote_a_class_head(p: &CppParser, specifiers_from: usize) -> bool {
p.events_contain_any(
specifiers_from,
&[
CppSyntaxKind::ClassDef,
CppSyntaxKind::StructDef,
CppSyntaxKind::UnionDef,
CppSyntaxKind::EnumDef,
CppSyntaxKind::EnumClassDef,
],
)
}
fn declaration_opens_a_body(p: &CppParser) -> bool {
p.peek_token_kind_at(0..4).iter().any(|kind| {
matches!(
kind,
CppTokenKind::ClassKeyword
| CppTokenKind::StructKeyword
| CppTokenKind::UnionKeyword
| CppTokenKind::EnumKeyword
| CppTokenKind::NamespaceKeyword
)
})
}
pub fn parse_structured_binding(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::StructuredBinding);
expect_token(p, CppTokenKind::LeftBracket)?;
while matches!(
p.current_token(),
CppTokenKind::Identifier | CppTokenKind::Ellipsis
) {
if p.current_token() == CppTokenKind::Ellipsis {
p.bump();
continue;
}
let name = p.mark(CppSyntaxKind::NameExpr);
if let Err(err) = parse_name(p) {
name.undo(p);
p.close_marks_above(base);
return Err(err);
}
name.complete(p);
if p.current_token() != CppTokenKind::Comma {
break;
}
p.bump();
}
if let Err(err) = expect_token(p, CppTokenKind::RightBracket) {
p.close_marks_above(base);
return Err(err);
}
Ok(m.complete(p))
}
pub fn the_declaration_is_a_placeholder(p: &CppParser) -> bool {
let mut index = p.current_token_index();
let mut inside = 0i64;
while index > 0 {
index -= 1;
let kind = p.token_kind_at(index);
if is_declaration_trivia(kind) {
continue;
}
match kind {
CppTokenKind::Ampersand
| CppTokenKind::LogicalAnd
| CppTokenKind::ConstKeyword
| CppTokenKind::VolatileKeyword => {}
CppTokenKind::RightParen => inside += 1,
CppTokenKind::LeftParen if inside > 0 => inside -= 1,
CppTokenKind::AutoKeyword => return true,
_ => return false,
}
}
false
}
pub fn parse_init_declarator(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::InitDeclarator);
let declarator_from = p.current_event_count();
if p.current_token() == CppTokenKind::LeftBracket && the_declaration_is_a_placeholder(p) {
if let Err(err) = parse_structured_binding(p) {
p.close_marks_above(base);
return Err(err);
}
p.set_last_declarator_is_function(false);
return finish_init_declarator(p, m, declarator_from);
}
let at_a_functions_parenthesized_declarator = at_an_operator_led_parenthesized_declarator(p);
if at_a_functions_parenthesized_declarator
|| (p.current_token() == CppTokenKind::LeftParen && !p.has_declaration_type_name())
{
let checkpoint = p.checkpoint();
let paren = p.mark(CppSyntaxKind::Declarator);
while at_a_pointer_operator(p.current_token()) {
p.bump();
}
p.bump();
let named_something = starts_a_declarator(p) && parse_declarator(p).is_ok();
if !named_something {
p.rollback(checkpoint);
} else if p.current_token() == CppTokenKind::RightParen {
p.bump();
paren.complete(p);
p.set_last_declarator_is_function(true);
types::eat_function_qualifiers(p);
if let Err(err) = finish_declarator_suffixes(p, declarator_from) {
p.close_marks_above(base);
return Err(err);
}
return finish_init_declarator(p, m, declarator_from);
} else {
p.rollback(checkpoint);
}
}
if let Err(err) = parse_declarator_with(p, true) {
p.close_marks_above(base);
return Err(err);
}
finish_init_declarator(p, m, declarator_from)
}
fn finish_init_declarator(p: &mut CppParser, m: Marker, declarator_from: usize) -> ParseResult {
let declarator_is_function = p.last_declarator_is_function()
|| p.events_contain_any(
declarator_from,
&[
CppSyntaxKind::ParameterList,
CppSyntaxKind::TrailingReturnType,
],
);
if let Err(err) = types::parse_attribute_specifiers(p) {
m.undo(p);
return Err(err);
}
while eat_a_macro_suffix(p) {}
if an_initializer_needs_a_name(p, declarator_from) {
m.undo(p);
return Err(CppParseError::syntax_error_from(
&t!("expected a declarator name"),
p.current_token_range(),
));
}
loop {
let mut consumed = false;
while declarator_is_function && p.current_token() == CppTokenKind::Hash {
if let Err(err) = stats::parse_preprocessor_directive(p) {
m.undo(p);
return Err(err);
}
consumed = true;
types::eat_function_qualifiers(p);
}
consumed |= eat_a_macro_suffix(p);
if !consumed {
break;
}
}
match p.current_token() {
CppTokenKind::Assign => {
p.bump();
if matches!(
p.current_token(),
CppTokenKind::DefaultKeyword | CppTokenKind::DeleteKeyword
) {
let init = p.mark(CppSyntaxKind::Initializer);
p.bump();
init.complete(p);
return Ok(m.complete(p));
}
let init = p.mark(CppSyntaxKind::Initializer);
while p.current_token() == CppTokenKind::Hash {
if let Err(err) = stats::parse_preprocessor_directive(p) {
init.undo(p);
return Err(err);
}
}
if let Err(err) = parse_initializer_clause(p) {
init.undo(p);
return Err(err);
}
loop {
let mut read_another_branch = false;
while p.current_token() == CppTokenKind::Hash {
let opens_another_branch = matches!(p.peek_token_text_at(1), "else" | "elif");
if let Err(err) = stats::parse_preprocessor_directive(p) {
init.undo(p);
return Err(err);
}
if opens_another_branch {
if let Err(err) = parse_initializer_clause(p) {
init.undo(p);
return Err(err);
}
read_another_branch = true;
}
}
if !read_another_branch {
break;
}
}
init.complete(p);
}
CppTokenKind::LeftBrace
if !declarator_is_function
&& p.events_contain_any(declarator_from, &[CppSyntaxKind::Initializer]) =>
{
m.undo(p);
return Err(CppParseError::syntax_error_from(
&t!("a declarator takes only one initializer"),
p.current_token_range(),
));
}
CppTokenKind::LeftBrace if !declarator_is_function => {
let init = p.mark(CppSyntaxKind::Initializer);
if let Err(err) = parse_braced_initializer(p) {
init.undo(p);
return Err(err);
}
init.complete(p);
}
CppTokenKind::Colon if p.last_declarator_is_function() => {
parse_member_initializer_list(p)?;
parse_further_member_initializer_lists(p)?;
}
CppTokenKind::Identifier
if at_requires(p)
&& (declarator_is_function
|| p.last_consumed_token_kind() == Some(CppTokenKind::RightParen))
&& starts_a_requires_clause(p) =>
{
let constrains_a_function = true;
parse_requires_clause(p)?;
while p.current_token() == CppTokenKind::Hash {
if let Err(err) = stats::parse_preprocessor_directive(p) {
m.undo(p);
return Err(err);
}
}
if constrains_a_function && p.current_token() == CppTokenKind::Colon {
parse_member_initializer_list(p)?;
parse_further_member_initializer_lists(p)?;
}
if p.current_token() == CppTokenKind::Assign
&& matches!(
p.peek_next_token(),
CppTokenKind::DefaultKeyword | CppTokenKind::DeleteKeyword
)
{
p.bump(); let init = p.mark(CppSyntaxKind::Initializer);
p.bump();
init.complete(p);
return Ok(m.complete(p));
}
}
CppTokenKind::Colon if p.is_at_class_member_level() => {
let width = p.mark(CppSyntaxKind::Initializer);
p.bump();
if let Err(err) = exprs::parse_assignment_expr(p) {
width.undo(p);
return Err(err);
}
width.complete(p);
}
_ if declarator_is_function && starts_an_old_style_parameter_list(p) => {
let list = p.mark(CppSyntaxKind::OldStyleParameterList);
loop {
let before = p.current_token_index();
let checkpoint = p.checkpoint();
match parse_declaration(p) {
Ok(_) if p.current_token_index() > before => {}
_ => {
p.rollback(checkpoint);
break;
}
}
if !starts_an_old_style_parameter_list(p) {
break;
}
}
list.complete(p);
}
_ => {}
}
Ok(m.complete(p))
}
fn starts_an_old_style_parameter_list(p: &mut CppParser) -> bool {
if matches!(
p.current_token(),
CppTokenKind::LeftBrace
| CppTokenKind::Semicolon
| CppTokenKind::Eof
| CppTokenKind::None
| CppTokenKind::Hash
) {
return false;
}
types::is_type_specifier_keyword(p.current_token())
|| starts_declaration(p)
|| (p.current_token() == CppTokenKind::Identifier
&& p.is_a_known_type_name(p.current_token_text()))
}
fn at_a_pointer_operator(kind: CppTokenKind) -> bool {
matches!(
kind,
CppTokenKind::Star | CppTokenKind::Ampersand | CppTokenKind::LogicalAnd
)
}
fn at_an_operator_led_parenthesized_declarator(p: &CppParser) -> bool {
let mut index = p.current_token_index();
let mut an_operator_leads = at_a_pointer_operator(p.token_kind_at(index));
if !an_operator_leads {
let before = previous_significant_index(p, index);
an_operator_leads = before.is_some_and(|at| at_a_pointer_operator(p.token_kind_at(at)));
}
while at_a_pointer_operator(p.token_kind_at(index)) {
index = next_significant_index(p, index);
}
if p.token_kind_at(index) != CppTokenKind::LeftParen {
return false;
}
index = next_significant_index(p, index);
let mut decorated = false;
while at_a_pointer_operator(p.token_kind_at(index))
|| matches!(
p.token_kind_at(index),
CppTokenKind::ConstKeyword | CppTokenKind::VolatileKeyword
)
{
decorated = true;
index = next_significant_index(p, index);
}
if p.token_kind_at(index) != CppTokenKind::Identifier {
return false;
}
index = next_significant_index(p, index);
if p.token_kind_at(index) != CppTokenKind::RightParen {
return false;
}
index = next_significant_index(p, index);
if p.token_kind_at(index) != CppTokenKind::LeftParen {
return false;
}
an_operator_leads || !decorated
}
pub(super) fn previous_significant_index(p: &CppParser, index: usize) -> Option<usize> {
let mut at = index;
while at > 0 {
at -= 1;
if !is_declaration_trivia(p.token_kind_at(at)) {
return Some(at);
}
}
None
}
fn finish_declarator_suffixes(p: &mut CppParser, declarator_from: usize) -> ParseResult {
loop {
match p.current_token() {
CppTokenKind::LeftParen => {
parse_function_suffix_or_initializer(p, declarator_from)?;
if p.current_token() == CppTokenKind::LeftParen {
return Ok(CompleteMarker::empty());
}
}
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);
}
_ => return Ok(CompleteMarker::empty()),
}
}
}
fn parse_initializer_clause(p: &mut CppParser) -> ParseResult {
if p.current_token() == CppTokenKind::LeftBrace {
return parse_braced_initializer(p);
}
exprs::parse_assignment_expr(p)
}
pub fn parse_function_suffix_or_initializer(
p: &mut CppParser,
declarator_from: usize,
) -> ParseResult {
let checkpoint = p.checkpoint();
if a_macro_definition_follows(p, declarator_from) {
parse_balanced_token_group(p, CppSyntaxKind::ArgumentList)?;
p.set_last_declarator_is_function(true);
return Ok(CompleteMarker::empty());
}
if !a_name_was_parsed(p, declarator_from) && the_head_of_the_declaration_is_qualified(p) {
let before_the_parameters = p.checkpoint();
if parse_parameter_list(p).is_ok() {
p.set_last_declarator_is_function(true);
types::eat_function_qualifiers(p);
return Ok(CompleteMarker::empty());
}
p.rollback(before_the_parameters);
}
let declarator_is_named = p.has_declaration_type_name();
let a_definition_is_legal_here = !p.is_inside_a_body() || p.is_at_class_member_level();
if a_definition_is_legal_here {
let before_the_function_reading = p.checkpoint();
if parse_parameter_list(p).is_ok() {
let a_trailing_return_type_follows = p.current_token() == CppTokenKind::Arrow;
let qualifiers_after_the_parameter_list = p.current_token_index();
types::eat_function_qualifiers(p);
let qualifiers_follow_the_parameter_list =
p.current_token_index() > qualifiers_after_the_parameter_list;
if a_trailing_return_type_follows
|| qualifiers_follow_the_parameter_list
|| p.current_token() == CppTokenKind::LeftBrace
{
p.set_last_declarator_is_function(true);
return Ok(CompleteMarker::empty());
}
}
p.rollback(before_the_function_reading);
}
if !a_dynamic_exception_specification_follows(p)
&& (p.is_at_file_scope()
&& !a_type_keyword_precedes_the_declarator_name(p)
&& the_arguments_look_like_declarators(p, false)
|| declarator_is_named && the_arguments_look_like_declarators(p, true))
&& let Ok(parsed) = parse_the_initializer(p)
{
return Ok(parsed);
}
if parse_parameter_list(p).is_ok() {
p.set_last_declarator_is_function(true);
types::eat_function_qualifiers(p);
return Ok(CompleteMarker::empty());
}
p.rollback(checkpoint);
if !a_dynamic_exception_specification_follows(p)
&& a_declaration_is_the_better_reading(p, declarator_from)
&& an_argument_list_follows(p)
{
return parse_the_initializer(p);
}
if p.current_token() == CppTokenKind::LeftParen
&& let Ok(parsed) = parse_the_initializer(p)
{
return Ok(parsed);
}
Ok(CompleteMarker::empty())
}
fn a_dynamic_exception_specification_follows(p: &CppParser) -> bool {
let Some(after) = index_after_the_group(p, p.current_token_index()) else {
return false;
};
let throw_at = significant_index_at(p, after);
p.token_kind_at(throw_at) == CppTokenKind::ThrowKeyword
&& p.token_kind_at(significant_index_at(p, throw_at + 1)) == CppTokenKind::LeftParen
}
pub(super) fn a_macro_definition_follows(p: &CppParser, declarator_from: usize) -> bool {
!a_name_was_parsed(p, declarator_from)
&& !the_head_of_the_declaration_is_qualified(p)
&& a_block_follows_the_group(p)
&& (!p.is_inside_a_body()
|| p.declaration_type_name().is_some_and(looks_like_a_macro_name))
}
pub(super) fn looks_like_a_macro_name(name: &str) -> bool {
let mut characters = name.chars();
let Some(first) = characters.next() else {
return false;
};
if !(first.is_ascii_uppercase() || first == '_') {
return false;
}
name.chars().all(|character| {
character.is_ascii_uppercase() || character.is_ascii_digit() || character == '_'
})
}
fn a_block_follows_the_group(p: &CppParser) -> bool {
if p.current_token() != CppTokenKind::LeftParen {
return false;
}
let mut depth = 0isize;
let mut offset = 0usize;
while let Some(kind) = p.peek_token_kind_at(offset..offset + 1).first().copied() {
match kind {
CppTokenKind::LeftParen => depth += 1,
CppTokenKind::RightParen => {
depth -= 1;
if depth == 0 {
return p
.peek_token_kind_at(offset + 1..offset + 2)
.first()
.copied()
== Some(CppTokenKind::LeftBrace);
}
}
CppTokenKind::Semicolon if depth == 0 => return false,
CppTokenKind::Eof | CppTokenKind::None => return false,
_ => {}
}
offset += 1;
}
false
}
pub(super) fn parse_balanced_token_group(p: &mut CppParser, kind: CppSyntaxKind) -> ParseResult {
let base = p.open_marks();
let m = p.mark(kind);
let mut depth = 0isize;
loop {
match p.current_token() {
CppTokenKind::LeftParen => {
depth += 1;
p.bump();
}
CppTokenKind::RightParen => {
depth -= 1;
p.bump();
if depth == 0 {
return Ok(m.complete(p));
}
}
CppTokenKind::Eof | CppTokenKind::None => {
p.close_marks_above(base);
return Err(CppParseError::syntax_error_from(
&t!("unterminated argument list"),
p.current_token_range(),
));
}
_ => p.bump(),
}
}
}
fn parse_the_initializer(p: &mut CppParser) -> ParseResult {
let init = p.mark(CppSyntaxKind::Initializer);
if let Err(err) = parse_expression_list(p, CppTokenKind::RightParen) {
init.undo(p);
return Err(err);
}
init.complete(p);
Ok(CompleteMarker::empty())
}
pub fn a_declaration_is_the_better_reading(p: &CppParser, declarator_from: usize) -> bool {
if declarator_starts_with_a_type_keyword(p) {
return true;
}
if declarator_starts_with_a_known_type_name(p) {
return p.is_inside_a_body() || p.is_at_file_scope();
}
if let Some(name) = p.declaration_type_name()
&& let Some(kind) = p.symbol_kind(name)
{
return match kind {
SymbolKind::Type | SymbolKind::Template => true,
SymbolKind::Function | SymbolKind::Variable | SymbolKind::Namespace => false,
SymbolKind::Macro { .. } => false,
};
}
if a_name_was_parsed(p, declarator_from) && the_arguments_look_like_values(p) {
return true;
}
p.has_declaration_type_name()
&& p.is_at_file_scope()
&& the_arguments_look_like_declarators(p, false)
}
fn a_name_was_parsed(p: &CppParser, declarator_from: usize) -> bool {
p.events_contain_any_between(
declarator_from,
p.current_event_count(),
&[CppSyntaxKind::NameExpr],
)
}
fn an_initializer_needs_a_name(p: &CppParser, declarator_from: usize) -> bool {
matches!(p.current_token(), CppTokenKind::Assign)
&& !a_name_was_parsed(p, declarator_from)
&& !the_declaration_has_a_type(p, declarator_from)
}
fn the_declaration_has_a_type(p: &CppParser, declarator_from: usize) -> bool {
let _ = declarator_from;
if declarator_starts_with_a_type_keyword(p) || declarator_starts_with_a_known_type_name(p) {
return true;
}
if p.has_qualified_declaration_type_name() || the_head_of_the_declaration_is_qualified(p) {
return true;
}
let mut index = p.current_token_index();
let mut inside = 0i64;
while index > 0 {
index -= 1;
let kind = p.token_kind_at(index);
if is_declaration_trivia(kind) {
continue;
}
match kind {
CppTokenKind::RightBracket | CppTokenKind::RightParen => inside += 1,
CppTokenKind::LeftBracket | CppTokenKind::LeftParen if inside > 0 => inside -= 1,
CppTokenKind::Semicolon | CppTokenKind::LeftBrace | CppTokenKind::RightBrace
if inside == 0 =>
{
return false;
}
_ if inside > 0 => {}
_ => return types::is_type_specifier_keyword(kind),
}
}
false
}
fn the_arguments_look_like_values(p: &CppParser) -> bool {
if p.current_token() != CppTokenKind::LeftParen {
return false;
}
let mut index = p.current_token_index() + 1;
let mut depth = 0usize;
let mut at_element_start = true;
while index < p.token_count() {
let kind = p.token_kind_at(index);
if is_declaration_trivia(kind) {
index += 1;
continue;
}
match kind {
CppTokenKind::RightParen if depth == 0 => return false,
CppTokenKind::RightParen | CppTokenKind::RightBracket | CppTokenKind::RightBrace => {
depth = depth.saturating_sub(1);
at_element_start = false;
}
CppTokenKind::LeftParen | CppTokenKind::LeftBracket | CppTokenKind::LeftBrace => {
if at_element_start
&& matches!(kind, CppTokenKind::LeftParen | CppTokenKind::LeftBrace)
{
return true;
}
depth += 1;
at_element_start = false;
}
CppTokenKind::Scope if at_element_start => {}
CppTokenKind::Comma if depth == 0 => at_element_start = true,
CppTokenKind::IntegerLiteral
| CppTokenKind::FloatingLiteral
| CppTokenKind::StringLiteral
| CppTokenKind::CharLiteral
| CppTokenKind::TrueKeyword
| CppTokenKind::FalseKeyword
| CppTokenKind::NullptrKeyword
if at_element_start =>
{
return true;
}
CppTokenKind::Identifier if at_element_start => {
let mut after = next_significant_index(p, index);
while p.token_kind_at(after) == CppTokenKind::Scope {
let segment = next_significant_index(p, after);
if p.token_kind_at(segment) != CppTokenKind::Identifier {
break;
}
after = next_significant_index(p, segment);
}
let follower = p.token_kind_at(after);
let keeps_it_a_declaration = matches!(
follower,
CppTokenKind::Identifier
| CppTokenKind::Scope
| CppTokenKind::Less
| CppTokenKind::Star
| CppTokenKind::Ampersand
| CppTokenKind::LogicalAnd
| CppTokenKind::Comma
| CppTokenKind::RightParen
| CppTokenKind::LeftBracket
| CppTokenKind::Assign
| CppTokenKind::Ellipsis
| CppTokenKind::None
);
if !keeps_it_a_declaration {
return true;
}
at_element_start = false;
}
kind if at_element_start && !can_begin_a_type(kind) => return true,
CppTokenKind::Star | CppTokenKind::Ampersand | CppTokenKind::LogicalAnd
if at_element_start =>
{
return true;
}
CppTokenKind::Semicolon if depth == 0 => return false,
CppTokenKind::Eof | CppTokenKind::None => return false,
_ => at_element_start = false,
}
index += 1;
}
false
}
fn can_begin_a_type(kind: CppTokenKind) -> bool {
is_type_specifier_keyword(kind)
|| matches!(
kind,
CppTokenKind::Identifier
| CppTokenKind::Scope
| CppTokenKind::ConstKeyword
| CppTokenKind::VolatileKeyword
| CppTokenKind::TypenameKeyword
| CppTokenKind::Star
| CppTokenKind::Ampersand
| CppTokenKind::LogicalAnd
| CppTokenKind::Ellipsis
| CppTokenKind::LeftParen
| CppTokenKind::LeftBracket
| CppTokenKind::Less
)
}
pub(super) fn next_significant_index(p: &CppParser, index: usize) -> usize {
significant_index_at(p, index + 1)
}
fn significant_index_at(p: &CppParser, index: usize) -> usize {
let mut index = index;
while index < p.token_count() && is_declaration_trivia(p.token_kind_at(index)) {
index += 1;
}
index
}
fn the_arguments_look_like_declarators(p: &CppParser, known_type_name: bool) -> bool {
if p.current_token() != CppTokenKind::LeftParen {
return false;
}
let mut index = p.current_token_index() + 1;
let mut saw_one = false;
let mut expect_an_element = true;
let mut depth = 0usize;
while index < p.token_count() {
let kind = p.token_kind_at(index);
if is_declaration_trivia(kind) {
index += 1;
continue;
}
match kind {
CppTokenKind::RightParen => return depth == 0 && saw_one && !expect_an_element,
CppTokenKind::LeftParen => {
if !known_type_name || expect_an_element || depth > 0 {
return false;
}
depth += 1;
}
CppTokenKind::Comma if depth == 0 => {
if expect_an_element {
return false;
}
expect_an_element = true;
}
CppTokenKind::Identifier if depth == 0 => {
if !expect_an_element {
return false;
}
if p.peek_token_kind_at(1..2).as_slice() == [CppTokenKind::Scope] {
return false;
}
saw_one = true;
expect_an_element = false;
}
_ if depth > 0 => {}
_ => return false,
}
index += 1;
}
false
}
fn declarator_starts_with_a_known_type_name(p: &CppParser) -> bool {
p.declaration_type_name()
.is_some_and(|name| p.is_a_known_type_name(name))
}
pub fn type_name_at(p: &CppParser, from: ParseAnchor) -> String {
let mut index = p.current_token_index();
loop {
let kind = p.token_kind_at(index);
if !is_declaration_trivia(kind) {
if kind == CppTokenKind::Identifier {
return p.token_text_at(index).to_string();
}
if !matches!(kind, CppTokenKind::Scope) {
return String::new();
}
}
if index == from.token_index() {
return String::new();
}
index -= 1;
}
}
pub fn the_head_of_the_declaration_is_qualified(p: &CppParser) -> bool {
let mut index = p.current_token_index();
while index > 0 {
index -= 1;
let kind = p.token_kind_at(index);
if matches!(
kind,
CppTokenKind::Semicolon | CppTokenKind::LeftBrace | CppTokenKind::RightBrace
) {
return false;
}
if kind == CppTokenKind::Scope {
return true;
}
}
false
}
fn declarator_starts_with_a_type_keyword(p: &CppParser) -> bool {
let mut index = p.current_token_index();
let mut first = None;
let mut angles = 0usize;
while index > 0 {
index -= 1;
let kind = p.token_kind_at(index);
if matches!(
kind,
CppTokenKind::Semicolon
| CppTokenKind::LeftBrace
| CppTokenKind::RightBrace
| CppTokenKind::TemplateKeyword
) {
break;
}
if is_declaration_trivia(kind) {
continue;
}
match kind {
CppTokenKind::Greater => angles += 1,
CppTokenKind::RightShift => angles += 2,
CppTokenKind::Less if angles > 0 => {
angles -= 1;
continue;
}
_ => {}
}
if angles > 0 {
continue;
}
first = Some(kind);
}
first.is_some_and(|kind| {
types::is_type_specifier_keyword(kind)
&& !matches!(
kind,
CppTokenKind::AutoKeyword | CppTokenKind::DecltypeKeyword
)
})
}
fn a_type_keyword_precedes_the_declarator_name(p: &CppParser) -> bool {
let mut index = p.current_token_index();
let mut seen_an_identifier = false;
while index > 0 {
index -= 1;
let kind = p.token_kind_at(index);
if is_declaration_trivia(kind) {
continue;
}
if matches!(
kind,
CppTokenKind::Semicolon | CppTokenKind::LeftBrace | CppTokenKind::RightBrace
) {
return false;
}
match kind {
CppTokenKind::Identifier => seen_an_identifier = true,
CppTokenKind::Scope if seen_an_identifier => seen_an_identifier = false,
_ if seen_an_identifier => {
return types::is_type_specifier_keyword(kind)
&& !matches!(
kind,
CppTokenKind::AutoKeyword | CppTokenKind::DecltypeKeyword
);
}
_ => return false,
}
}
false
}
fn starts_a_declarator(p: &CppParser) -> bool {
matches!(
p.current_token(),
CppTokenKind::Star
| CppTokenKind::Ampersand
| CppTokenKind::LogicalAnd
| CppTokenKind::Identifier
| CppTokenKind::Scope
| CppTokenKind::OperatorKeyword
| CppTokenKind::Tilde
)
}
fn is_declaration_trivia(kind: CppTokenKind) -> bool {
matches!(
kind,
CppTokenKind::Whitespace
| CppTokenKind::Newline
| CppTokenKind::LineContinuation
| CppTokenKind::LineComment
| CppTokenKind::BlockComment
| CppTokenKind::None
)
}
fn a_declaration_cannot_follow(p: &CppParser) -> bool {
use CppTokenKind::*;
matches!(
p.current_token(),
RightBrace | None
| StructKeyword
| ClassKeyword
| UnionKeyword
| EnumKeyword
| TemplateKeyword
| NamespaceKeyword
| UsingKeyword
| TypedefKeyword
| StaticKeyword
| InlineKeyword
| ExternKeyword
| ConstexprKeyword
| ConstevalKeyword
| ConstinitKeyword
| FriendKeyword
| VirtualKeyword
| PublicKeyword
| PrivateKeyword
| ProtectedKeyword
| VoidKeyword
| AutoKeyword
| CharKeyword
| IntKeyword
| FloatKeyword
| DoubleKeyword
)
}
fn an_argument_list_follows(p: &CppParser) -> bool {
p.current_token() == CppTokenKind::LeftParen
&& p.peek_token_kind_at(1..2).as_slice() != [CppTokenKind::RightParen]
}
pub fn parse_for_init_declaration(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::Declaration);
if let Err(err) = parse_decl_specifier_seq(p) {
p.close_marks_above(base);
return Err(err);
}
let declarator_from = p.current_event_count();
if let Err(err) = parse_init_declarator(p) {
p.close_marks_above(base);
return Err(err);
}
while p.current_token() == CppTokenKind::Comma {
p.bump();
if let Err(err) = parse_init_declarator(p) {
p.close_marks_above(base);
return Err(err);
}
}
if !a_name_was_parsed(p, declarator_from) {
p.close_marks_above(base);
return Err(CppParseError::syntax_error_from(
&t!("expected a declaration that names something"),
p.current_token_range(),
));
}
Ok(m.complete(p))
}
pub fn parse_condition_declaration(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::Declaration);
if let Err(err) = parse_decl_specifier_seq(p) {
p.close_marks_above(base);
return Err(err);
}
let declarator_from = p.current_event_count();
if let Err(err) = parse_init_declarator(p) {
p.close_marks_above(base);
return Err(err);
}
let named = a_name_was_parsed(p, declarator_from);
let initialised = p.events_contain_any(declarator_from, &[CppSyntaxKind::Initializer]);
if !named || !initialised {
p.close_marks_above(base);
return Err(CppParseError::syntax_error_from(
&t!("a condition declaration needs one variable with an initializer"),
p.current_token_range(),
));
}
if p.current_token() == CppTokenKind::Comma {
p.close_marks_above(base);
return Err(CppParseError::syntax_error_from(
&t!("a condition declares one variable, not a list"),
p.current_token_range(),
));
}
if p.current_token() != CppTokenKind::RightParen {
p.close_marks_above(base);
return Err(CppParseError::syntax_error_from(
&t!("a condition declaration ends at the `)` that closes the condition"),
p.current_token_range(),
));
}
Ok(m.complete(p))
}
pub fn parse_braced_initializer(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::InitListExpr);
expect_token(p, CppTokenKind::LeftBrace)?;
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 p.current_token() == CppTokenKind::Dot || p.current_token() == CppTokenKind::LeftBracket
{
let designator = p.mark(CppSyntaxKind::DesignatedInitExpr);
loop {
if p.current_token() == CppTokenKind::Dot {
p.bump();
if p.current_token() == CppTokenKind::Identifier {
p.bump();
}
} else if p.current_token() == CppTokenKind::LeftBracket {
p.bump();
let _ = parse_expr(p);
let _ = expect_token(p, CppTokenKind::RightBracket);
} else {
break;
}
}
if p.current_token() == CppTokenKind::Assign {
p.bump();
}
if let Err(err) = parse_initializer_clause(p) {
p.close_marks_above(base);
return Err(err);
}
designator.complete(p);
} else if let Err(err) = parse_initializer_clause(p) {
p.close_marks_above(base);
return Err(err);
}
if p.current_token() == CppTokenKind::Comma {
p.bump();
} else if p.current_token() != CppTokenKind::Hash {
break;
}
}
expect_token(p, CppTokenKind::RightBrace)?;
Ok(m.complete(p))
}
fn parse_member_initializer_list(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
expect_token(p, CppTokenKind::Colon)?;
loop {
let m = p.mark(CppSyntaxKind::MemberInitializer);
if let Err(err) = parse_name(p) {
p.close_marks_above(base);
return Err(err);
}
match p.current_token() {
CppTokenKind::LeftParen => {
if let Err(err) = parse_expression_list(p, CppTokenKind::RightParen) {
p.close_marks_above(base);
return Err(err);
}
}
CppTokenKind::LeftBrace => {
if let Err(err) = parse_braced_initializer(p) {
p.close_marks_above(base);
return Err(err);
}
}
CppTokenKind::Ellipsis => p.bump(),
_ => {}
}
m.complete(p);
if p.current_token() == CppTokenKind::Comma {
p.bump();
continue;
}
break;
}
Ok(CompleteMarker::empty())
}
fn parse_further_member_initializer_lists(p: &mut CppParser) -> ParseResult {
loop {
let mut saw_a_directive = false;
while p.current_token() == CppTokenKind::Hash {
stats::parse_preprocessor_directive(p)?;
saw_a_directive = true;
}
if !saw_a_directive || p.current_token() != CppTokenKind::Colon {
return Ok(CompleteMarker::empty());
}
parse_member_initializer_list(p)?;
}
}
pub fn parse_expression_list(p: &mut CppParser, closing: CppTokenKind) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::ArgumentList);
let opening = if closing == CppTokenKind::RightParen {
CppTokenKind::LeftParen
} else {
CppTokenKind::LeftBracket
};
if let Err(err) = expect_token(p, opening) {
p.close_marks_above(base);
return Err(err);
}
while p.current_token() != closing && !p.is_eof() {
let element = if p.current_token() == CppTokenKind::LeftBrace {
parse_braced_initializer(p)
} else {
exprs::parse_assignment_expr(p)
};
if let Err(err) = element {
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, closing) {
p.close_marks_above(base);
return Err(err);
}
Ok(m.complete(p))
}
pub fn parse_parameter_list(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::ParameterList);
expect_token(p, CppTokenKind::LeftParen)?;
if p.current_token() == CppTokenKind::RightParen {
p.bump();
return Ok(m.complete(p));
}
if p.current_token() == CppTokenKind::Ellipsis {
p.bump();
expect_token(p, CppTokenKind::RightParen)?;
return Ok(m.complete(p));
}
let conditionals_when_the_list_began = p.open_conditionals();
loop {
while p.current_token() == CppTokenKind::Hash {
if let Err(err) = stats::parse_preprocessor_directive(p) {
p.close_marks_above(base);
return Err(err);
}
}
if let Err(err) = parse_one_parameter(p) {
p.close_marks_above(base);
return Err(err);
}
loop {
if p.current_token() != CppTokenKind::Hash {
break;
}
let another_spelling_of_this_parameter =
matches!(p.peek_token_text_at(1), "else" | "elif");
if let Err(err) = stats::parse_preprocessor_directive(p) {
p.close_marks_above(base);
return Err(err);
}
if !another_spelling_of_this_parameter {
continue;
}
if let Err(err) = parse_one_parameter(p) {
p.close_marks_above(base);
return Err(err);
}
}
match p.current_token() {
CppTokenKind::Comma => {
p.bump();
if p.current_token() == CppTokenKind::Ellipsis {
p.bump();
break;
}
continue;
}
_ => break,
}
}
expect_token(p, CppTokenKind::RightParen)?;
let mut read_a_branch_of_the_tail = false;
while p.open_conditionals() > conditionals_when_the_list_began
&& let Some(writes_the_terminator) = 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 {
if let Err(err) = stats::parse_preprocessor_directive(p) {
p.close_marks_above(base);
return Err(err);
}
}
while p.current_token() != CppTokenKind::RightParen && !p.is_eof() {
if let Err(err) = parse_one_parameter(p) {
p.close_marks_above(base);
return Err(err);
}
if p.current_token() != CppTokenKind::Comma {
break;
}
p.bump();
}
if let Err(err) = expect_token(p, CppTokenKind::RightParen) {
p.close_marks_above(base);
return Err(err);
}
}
if read_a_branch_of_the_tail && p.current_token() == CppTokenKind::Semicolon {
p.bump();
}
Ok(m.complete(p))
}
pub(super) fn a_branch_continues_the_tail(p: &CppParser) -> Option<bool> {
let mut index = p.current_token_index();
let mut writes_the_terminator = false;
if p.token_kind_at(index) == CppTokenKind::Semicolon {
writes_the_terminator = true;
index = next_significant_index(p, index);
}
if p.token_kind_at(index) != CppTokenKind::Hash {
return None;
}
let directive = next_significant_index(p, index);
matches!(p.token_text_at(directive), "else" | "elif").then_some(writes_the_terminator)
}
fn parse_one_parameter(p: &mut CppParser) -> ParseResult {
parse_parameter(p)?;
if p.current_token() == CppTokenKind::Ellipsis {
p.bump();
}
Ok(CompleteMarker::empty())
}
fn parse_parameter(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::Parameter);
if p.current_token() == CppTokenKind::ThisKeyword {
let object = p.mark(CppSyntaxKind::ThisExpr);
p.bump(); object.complete(p);
if let Err(err) = types::parse_type_id(p) {
p.close_marks_above(base);
return Err(err);
}
if p.current_token() == CppTokenKind::Identifier
&& let Err(err) = parse_name(p)
{
p.close_marks_above(base);
return Err(err);
}
if p.current_token() == CppTokenKind::Assign {
p.bump();
if let Err(err) = exprs::parse_assignment_expr(p) {
p.close_marks_above(base);
return Err(err);
}
}
return Ok(m.complete(p));
}
if let Err(err) = parse_decl_specifier_seq(p) {
p.close_marks_above(base);
return Err(err);
}
if !definitely_ends_a_type(p.current_token())
&& p.current_token() != CppTokenKind::Comma
&& p.current_token() != CppTokenKind::Ellipsis
&& let Err(err) = parse_declarator(p)
{
p.close_marks_above(base);
return Err(err);
}
if p.current_token() == CppTokenKind::Ellipsis {
p.bump();
if p.current_token() == CppTokenKind::Identifier
&& let Err(err) = parse_name(p)
{
p.close_marks_above(base);
return Err(err);
}
}
if let Err(err) = types::parse_attribute_specifiers(p) {
p.close_marks_above(base);
return Err(err);
}
eat_a_macro_suffix(p);
if p.current_token() == CppTokenKind::Assign {
p.bump();
let init = p.mark(CppSyntaxKind::Initializer);
if let Err(err) = parse_initializer_clause(p) {
init.undo(p);
p.close_marks_above(base);
return Err(err);
}
init.complete(p);
}
Ok(m.complete(p))
}
pub fn parse_class_body(p: &mut CppParser) -> ParseResult {
let _base = p.open_marks();
let m = p.mark(CppSyntaxKind::ClassBody);
expect_token(p, CppTokenKind::LeftBrace)?;
p.enter_type_name_scope();
p.enter_class_body();
let result = parse_class_body_members(p);
p.leave_class_body();
p.leave_type_name_scope();
result?;
Ok(m.complete(p))
}
pub(super) fn eat_a_macro_suffix(p: &mut CppParser) -> bool {
if p.current_token() != CppTokenKind::Identifier {
return false;
}
if matches!(p.current_token_text(), "override" | "final" | "requires") {
return false;
}
let checkpoint = p.checkpoint();
let m = p.mark(CppSyntaxKind::MacroCall);
let name = p.mark(CppSyntaxKind::NameExpr);
p.bump();
name.complete(p);
if p.current_token() == CppTokenKind::LeftParen
&& parse_balanced_token_group(p, CppSyntaxKind::ArgumentList).is_err()
{
p.rollback(checkpoint);
return false;
}
m.complete(p);
true
}
fn parse_class_body_members(p: &mut CppParser) -> ParseResult {
let mut unclosed_braces = 0isize;
while p.current_token() != CppTokenKind::RightBrace || unclosed_braces > 0 {
if p.is_eof() {
break;
}
p.emit_trivia_after_current_token();
if p.is_eof() {
break;
}
if p.current_token() == CppTokenKind::RightBrace {
if unclosed_braces <= 0 {
break;
}
unclosed_braces -= 1;
let error = p.mark(CppSyntaxKind::ErrorNode);
p.bump();
error.complete(p);
continue;
}
let member_base = p.open_marks();
if p.current_token() == CppTokenKind::Hash {
stats::parse_preprocessor_directive(p)?;
continue;
}
if matches!(
p.current_token(),
CppTokenKind::PublicKeyword
| CppTokenKind::PrivateKeyword
| CppTokenKind::ProtectedKeyword
) {
parse_access_specifier(p)?;
continue;
}
if p.current_token() == CppTokenKind::Semicolon {
p.bump();
continue;
}
let before = p.current_token_index();
let before_events = p.current_event_count();
if parse_member(p).is_err() {
unclosed_braces += p.brace_balance_since(before_events).max(0);
p.end_marks_to(member_base);
if p.current_token_index() == before {
if p.current_token() == CppTokenKind::LeftBrace {
unclosed_braces += 1;
}
let error = p.mark(CppSyntaxKind::ErrorNode);
p.bump();
error.complete(p);
}
}
}
if p.current_token() == CppTokenKind::RightBrace {
p.bump();
} else {
p.emit_missing_node();
}
Ok(CompleteMarker::empty())
}
fn access_specifier_kind(kind: CppTokenKind) -> CppSyntaxKind {
match kind {
CppTokenKind::PublicKeyword => CppSyntaxKind::PublicAccess,
CppTokenKind::PrivateKeyword => CppSyntaxKind::PrivateAccess,
_ => CppSyntaxKind::ProtectedAccess,
}
}
fn parse_access_specifier(p: &mut CppParser) -> ParseResult {
let access = p.mark(access_specifier_kind(p.current_token()));
p.consume_current_token();
p.emit_trivia_after_current_token();
p.consume_current_token_if(CppTokenKind::Colon);
access.complete(p);
p.emit_trivia_after_current_token();
Ok(CompleteMarker::empty())
}
fn parse_member(p: &mut CppParser) -> ParseResult {
parse_declaration(p)
}
pub fn expect_semicolon(p: &mut CppParser) -> ParseResult {
if p.take_the_terminator_came_from_a_branch() {
return Ok(CompleteMarker::empty());
}
if p.current_token() == CppTokenKind::Semicolon {
p.consume_current_token();
p.emit_layout_after_current_token();
return Ok(CompleteMarker::empty());
}
p.emit_missing_node();
Err(CppParseError::syntax_error_from(
&t!("expected `;`"),
p.current_token_range(),
))
}
fn a_decltype_here_is_a_type(p: &mut CppParser) -> bool {
let checkpoint = p.checkpoint();
let parsed = types::parse_type_id(p).is_ok();
let followed_by_a_declarator = parsed && starts_a_declarator(p);
p.rollback(checkpoint);
followed_by_a_declarator
}
pub(super) fn kind_after_the_run_of_names(p: &CppParser) -> CppTokenKind {
let mut index = next_significant_index(p, p.current_token_index());
loop {
if p.token_kind_at(index) == CppTokenKind::LeftParen {
let Some(after) = index_after_the_group(p, index) else {
return CppTokenKind::None;
};
index = significant_index_at(p, after);
continue;
}
if p.token_kind_at(index) != CppTokenKind::Identifier {
break;
}
index = next_significant_index(p, index);
}
p.token_kind_at(index)
}
fn index_after_the_group(p: &CppParser, index: usize) -> Option<usize> {
let mut depth = 0isize;
let mut index = index;
while index < p.token_count() {
match p.token_kind_at(index) {
CppTokenKind::LeftParen => depth += 1,
CppTokenKind::RightParen => {
depth -= 1;
if depth == 0 {
return Some(index + 1);
}
}
CppTokenKind::Eof => return None,
_ => {}
}
index += 1;
}
None
}
pub(super) fn can_begin_a_declaration(kind: CppTokenKind) -> bool {
matches!(
kind,
CppTokenKind::TypedefKeyword
| CppTokenKind::UsingKeyword
| CppTokenKind::NamespaceKeyword
| CppTokenKind::TemplateKeyword
| CppTokenKind::ExternKeyword
| CppTokenKind::StaticAssertKeyword
| CppTokenKind::ClassKeyword
| CppTokenKind::StructKeyword
| CppTokenKind::UnionKeyword
| CppTokenKind::EnumKeyword
| CppTokenKind::AlignasKeyword
| CppTokenKind::ConstKeyword
| CppTokenKind::VolatileKeyword
| CppTokenKind::ConstexprKeyword
| CppTokenKind::StaticKeyword
| CppTokenKind::InlineKeyword
| CppTokenKind::VirtualKeyword
| CppTokenKind::ExplicitKeyword
| CppTokenKind::FriendKeyword
| CppTokenKind::MutableKeyword
| CppTokenKind::ThreadLocalKeyword
| CppTokenKind::RegisterKeyword
)
}
pub fn starts_declaration(p: &mut CppParser) -> bool {
match p.current_token() {
CppTokenKind::DecltypeKeyword if a_decltype_here_is_a_type(p) => true,
kind => can_begin_a_declaration(kind),
}
}
fn parse_destructor_declaration(p: &mut CppParser) -> ParseResult {
parse_declaration_starting_at_a_name(p, |p| {
if p.current_token() == CppTokenKind::Identifier {
p.bump();
}
types::parse_declarator(p)
})
}
fn parse_conversion_operator_declaration(p: &mut CppParser) -> ParseResult {
parse_declaration_starting_at_a_name(p, |p| {
let name = p.mark(CppSyntaxKind::Declarator);
if let Err(err) = parse_name(p) {
name.undo(p);
return Err(err);
}
name.complete(p);
types::parse_declarator_function_suffixes(p, p.current_event_count())
})
}
fn parse_constructor_declaration(p: &mut CppParser) -> ParseResult {
parse_declaration_starting_at_a_name(p, |p| {
let name = p.mark(CppSyntaxKind::Declarator);
if let Err(err) = parse_name(p) {
name.undo(p);
return Err(err);
}
let declarator = types::parse_declarator_function_suffixes(p, p.current_event_count());
name.complete(p);
if declarator.is_ok() && p.current_token() == CppTokenKind::Colon {
return parse_member_initializer_list(p).map(|_| CompleteMarker::empty());
}
declarator
})
}
fn parse_declaration_starting_at_a_name(
p: &mut CppParser,
parse_the_name: impl FnOnce(&mut CppParser) -> ParseResult,
) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::Declaration);
let declarator_from = p.current_event_count();
if let Err(err) = parse_the_name(p) {
p.close_marks_above(base);
return Err(err);
}
let declaration = match finish_init_declarator(p, m, declarator_from) {
Ok(declaration) => declaration,
Err(err) => {
p.close_marks_above(base);
return Err(err);
}
};
if p.current_token() == CppTokenKind::LeftBrace {
let wrapped = declaration.precede(p, CppSyntaxKind::Declaration);
if let Err(err) = parse_compound_stat(p) {
p.close_marks_above(base);
return Err(err);
}
return Ok(wrapped.complete(p));
}
if let Err(err) = expect_semicolon(p) {
p.close_marks_above(base);
return Err(err);
}
Ok(declaration)
}
fn a_qualified_name_is_followed_by_an_equals(p: &CppParser) -> bool {
for kind in p.peek_token_kind_at(0..96) {
match kind {
CppTokenKind::Assign => return true,
CppTokenKind::Semicolon
| CppTokenKind::LeftBrace
| CppTokenKind::RightBrace
| CppTokenKind::Eof
| CppTokenKind::None => return false,
_ => {}
}
}
false
}
pub fn parse_using_declaration(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::UsingDecl);
expect_token(p, CppTokenKind::UsingKeyword)?;
if matches!(p.current_token_text(), "namespace") {
let directive = p.mark(CppSyntaxKind::UsingDirective);
p.bump();
parse_name(p)?;
let _ = expect_semicolon(p);
directive.complete(p);
return Ok(m.complete(p));
}
if p.current_token() == CppTokenKind::EnumKeyword {
p.bump();
if let Err(err) = parse_name(p) {
p.close_marks_above(base);
return Err(err);
}
if let Err(err) = expect_semicolon(p) {
p.close_marks_above(base);
return Err(err);
}
return Ok(m.complete(p));
}
if p.current_token() == CppTokenKind::TypenameKeyword {
p.bump();
if let Err(err) = parse_name(p) {
p.close_marks_above(base);
return Err(err);
}
if let Err(err) = expect_semicolon(p) {
p.close_marks_above(base);
return Err(err);
}
return Ok(m.complete(p));
}
let alias_name = if p.current_token() == CppTokenKind::Identifier {
Some(p.current_token_text().to_string())
} else {
None
};
if p.current_token() == CppTokenKind::Identifier
&& p.peek_next_token() == CppTokenKind::Scope
&& !a_qualified_name_is_followed_by_an_equals(p)
{
let name = p.mark(CppSyntaxKind::NameExpr);
p.bump(); let rest = p.mark(CppSyntaxKind::NameExpr);
if let Err(err) = types::parse_name(p) {
rest.undo(p);
name.undo(p);
p.close_marks_above(base);
return Err(err);
}
rest.complete(p);
name.complete(p);
if let Err(err) = expect_semicolon(p) {
p.close_marks_above(base);
return Err(err);
}
return Ok(m.complete(p));
}
if let Err(err) = parse_name(p) {
p.close_marks_above(base);
return Err(err);
}
if let Err(err) = types::parse_attribute_specifiers(p) {
p.close_marks_above(base);
return Err(err);
}
while eat_a_macro_suffix(p) {}
let mut declared = false;
let ended = parse_a_definition_per_branch(p, |p| {
if !declared {
if let Some(name) = &alias_name {
p.declare_type_name(name);
}
declared = true;
}
let before_the_target = p.current_token_index();
parse_type_id(p)?;
let consumed: Vec<CppTokenKind> = (before_the_target..p.current_token_index())
.map(|at| p.token_kind_at(at))
.filter(|kind| !is_declaration_trivia(*kind))
.collect();
let the_target_was_one_name =
matches!(consumed.as_slice(), [CppTokenKind::Identifier]) && !p.has_error();
let a_convention_follows = p.current_token() == CppTokenKind::Identifier
&& p.peek_token_kind_at(1..4).first().is_some_and(|_| {
(1..4).any(|at| {
p.token_kind_at(p.current_token_index() + at) == CppTokenKind::LeftParen
})
});
if (the_target_was_one_name || a_convention_follows)
&& p.current_token() == CppTokenKind::Identifier
{
parse_type_id(p)?;
}
if (p.current_token() == CppTokenKind::LeftBracket
|| p.current_token() == CppTokenKind::LeftParen)
&& let Err(err) = types::parse_declarator_suffixes(p)
{
return Err(err);
}
Ok(CompleteMarker::empty())
});
match ended {
Err(err) => {
p.close_marks_above(base);
return Err(err);
}
Ok(ended) if !ended => {
if let Err(err) = expect_semicolon(p) {
p.close_marks_above(base);
return Err(err);
}
}
Ok(_) => {}
}
Ok(m.complete(p))
}
fn parse_a_definition_per_branch(
p: &mut CppParser,
mut payload: impl FnMut(&mut CppParser) -> ParseResult,
) -> Result<bool, CppParseError> {
let mut ended_with_a_semicolon = false;
loop {
while p.current_token() == CppTokenKind::Hash {
stats::parse_preprocessor_directive(p)?;
}
if p.current_token() != CppTokenKind::Assign {
break;
}
p.bump();
payload(p)?;
if p.current_token() != CppTokenKind::Semicolon {
ended_with_a_semicolon = false;
break;
}
p.bump();
ended_with_a_semicolon = true;
}
Ok(ended_with_a_semicolon)
}
pub fn parse_typedef_declaration(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::TypedefDecl);
expect_token(p, CppTokenKind::TypedefKeyword)?;
if let Err(err) = types::parse_decl_specifier_seq(p) {
p.close_marks_above(base);
return Err(err);
}
loop {
let declarator_from = p.current_event_count();
if let Err(err) = types::parse_declarator(p) {
p.close_marks_above(base);
return Err(err);
}
if let Some(name) = p.the_name_a_declarator_introduced(declarator_from) {
p.declare_type_name(&name);
}
if let Err(err) = types::parse_attribute_specifiers(p) {
p.close_marks_above(base);
return Err(err);
}
if p.current_token() == CppTokenKind::Assign
&& let Err(err) = parse_initializer_clause(p)
{
p.close_marks_above(base);
return Err(err);
}
if p.current_token() != CppTokenKind::Comma {
break;
}
p.bump();
}
if let Err(err) = expect_semicolon(p) {
p.close_marks_above(base);
return Err(err);
}
Ok(m.complete(p))
}
pub fn parse_static_assert(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::DeclStat);
expect_token(p, CppTokenKind::StaticAssertKeyword)?;
if p.current_token() == CppTokenKind::LeftParen {
p.bump();
if let Err(err) = parse_expr(p) {
p.close_marks_above(base);
return Err(err);
}
if p.current_token() == CppTokenKind::Comma {
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);
}
}
if let Err(err) = expect_semicolon(p) {
p.close_marks_above(base);
return Err(err);
}
Ok(m.complete(p))
}
pub fn parse_namespace_declaration(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::NamespaceDecl);
expect_token(p, CppTokenKind::NamespaceKeyword)?;
let _ = types::parse_attribute_specifiers(p);
if p.current_token() == CppTokenKind::Identifier && p.peek_next_token() == CppTokenKind::Assign
{
p.bump();
p.bump();
parse_name(p)?;
let _ = expect_semicolon(p);
return Ok(m.complete(p));
}
if p.current_token() != CppTokenKind::LeftBrace {
if p.current_token() == CppTokenKind::Identifier {
if a_segment_below_is_inline(p) {
parse_a_nested_namespace_name(p);
} else {
parse_name(p)?;
}
}
}
if p.current_token() != CppTokenKind::LeftBrace {
eat_namespace_head_macros(p);
}
if p.current_token() == CppTokenKind::LeftBrace {
if let Err(err) = parse_stats_block(p) {
p.close_marks_above(base);
return Err(err);
}
return Ok(m.complete(p));
}
let _ = expect_semicolon(p);
Ok(m.complete(p))
}
fn a_segment_below_is_inline(p: &CppParser) -> bool {
let mut at = 1usize; while p.peek_token_kind_at(at..at + 1).as_slice() == [CppTokenKind::Scope] {
at += 1;
if p.peek_token_kind_at(at..at + 1).as_slice() == [CppTokenKind::InlineKeyword] {
return true;
}
if p.peek_token_kind_at(at..at + 1).as_slice() != [CppTokenKind::Identifier] {
return false;
}
at += 1;
}
false
}
fn parse_a_nested_namespace_name(p: &mut CppParser) {
let name = p.mark(CppSyntaxKind::NameExpr);
loop {
if p.current_token() == CppTokenKind::InlineKeyword {
p.bump();
}
if p.current_token() != CppTokenKind::Identifier {
break;
}
p.bump();
if p.current_token() != CppTokenKind::Scope {
break;
}
p.bump();
}
name.complete(p);
}
fn eat_namespace_head_macros(p: &mut CppParser) -> bool {
let checkpoint = p.checkpoint();
let mut ate_anything = false;
while p.current_token() == CppTokenKind::Identifier {
p.bump();
ate_anything = true;
if p.current_token() == CppTokenKind::LeftParen {
if parse_balanced_token_group(p, CppSyntaxKind::ArgumentList).is_err() {
p.rollback(checkpoint);
return false;
}
}
}
if !ate_anything || p.current_token() != CppTokenKind::LeftBrace {
p.rollback(checkpoint);
return false;
}
true
}
fn parse_stats_block(p: &mut CppParser) -> ParseResult {
let _base = p.open_marks();
let m = p.mark(CppSyntaxKind::CompoundStat);
expect_token(p, CppTokenKind::LeftBrace)?;
parse_stats(p);
if p.current_token() == CppTokenKind::RightBrace {
p.bump();
} else {
p.emit_missing_node();
}
Ok(m.complete(p))
}
pub fn parse_linkage_block(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::CompoundStat);
expect_token(p, CppTokenKind::LeftBrace)?;
p.enter_block_body();
let mut unclosed_braces = 0isize;
while p.current_token() != CppTokenKind::RightBrace || unclosed_braces > 0 {
if p.is_eof() {
break;
}
if p.current_token() == CppTokenKind::RightBrace {
if unclosed_braces <= 0 {
break;
}
unclosed_braces -= 1;
let error = p.mark(CppSyntaxKind::ErrorNode);
p.bump();
error.complete(p);
continue;
}
if p.current_token() == CppTokenKind::Hash {
let directive_base = p.open_marks();
if let Err(err) = stats::parse_preprocessor_directive(p) {
p.end_marks_to(directive_base);
p.push_error(err);
}
continue;
}
let member_base = p.open_marks();
let before = p.current_token_index();
let before_events = p.current_event_count();
if parse_declaration(p).is_err() {
unclosed_braces += p.brace_balance_since(before_events).max(0);
p.end_marks_to(member_base);
if p.current_token_index() == before {
if p.current_token() == CppTokenKind::LeftBrace {
unclosed_braces += 1;
}
let error = p.mark(CppSyntaxKind::ErrorNode);
p.bump();
error.complete(p);
}
}
}
p.leave_block_body();
if p.current_token() == CppTokenKind::RightBrace {
p.bump();
} else {
p.emit_missing_node();
}
let _ = base;
Ok(m.complete(p))
}
pub fn starts_a_linkage_specification(p: &CppParser) -> bool {
p.current_token() == CppTokenKind::ExternKeyword
&& matches!(
p.peek_token_kind_at(1..2).first(),
Some(&CppTokenKind::StringLiteral)
)
}
fn parse_linkage_specification(p: &mut CppParser) -> ParseResult {
let base = p.open_marks();
let m = p.mark(CppSyntaxKind::Declaration);
let specifiers = p.mark(CppSyntaxKind::DeclSpecifierSeq);
let linkage = p.mark(CppSyntaxKind::ExternSpec);
p.bump(); p.bump(); linkage.complete(p);
specifiers.complete(p);
if p.current_token() == CppTokenKind::LeftBrace {
if let Err(err) = parse_linkage_block(p) {
p.close_marks_above(base);
return Err(err);
}
return Ok(m.complete(p));
}
if let Err(err) = parse_declaration(p) {
p.close_marks_above(base);
return Err(err);
}
Ok(m.complete(p))
}