use std::collections::HashSet;
use cpp_parser::{CppParser, CppSyntaxKind, CppTokenKind, ParserConfig};
#[derive(Debug, Default, Clone)]
pub struct Roles {
pub template_angle: HashSet<usize>,
pub declarator_mark: HashSet<usize>,
pub block_brace: HashSet<usize>,
pub init_brace: HashSet<usize>,
pub brace_kind: std::collections::HashMap<usize, BraceKind>,
pub namespace_names: std::collections::HashMap<usize, String>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BraceKind {
Function,
Class,
Struct,
Union,
Enum,
Namespace,
Control,
Try,
Catch,
Lambda,
ExternBlock,
CaseLabel,
}
impl Roles {
pub fn is_template_angle(&self, offset: usize) -> bool {
self.template_angle.contains(&offset)
}
pub fn is_declarator(&self, offset: usize) -> bool {
self.declarator_mark.contains(&offset)
}
}
pub fn of(source: &str) -> Roles {
let mut roles = Roles::default();
let tree = CppParser::parse(source, ParserConfig::default());
let root = tree.get_red_root();
for node in root.descendants() {
let kind = CppSyntaxKind::from(node.kind());
match kind {
CppSyntaxKind::TemplateArgumentList | CppSyntaxKind::TemplateParameterList => {
for token in node
.descendants_with_tokens()
.filter_map(|it| it.into_token())
{
let token_kind = CppTokenKind::from(token.kind());
if matches!(token_kind, CppTokenKind::Less | CppTokenKind::Greater) {
roles.template_angle.insert(token_range_start(&token));
}
}
}
CppSyntaxKind::PointerType
| CppSyntaxKind::ReferenceType
| CppSyntaxKind::RValueReferenceType => {
let in_a_condition = node
.ancestors()
.take_while(|ancestor| {
CppSyntaxKind::from(ancestor.kind()) != CppSyntaxKind::CompoundStat
})
.any(|ancestor| {
matches!(
CppSyntaxKind::from(ancestor.kind()),
CppSyntaxKind::IfStat
| CppSyntaxKind::WhileStat
| CppSyntaxKind::ForStat
| CppSyntaxKind::SwitchStat
| CppSyntaxKind::DoStat
)
});
if in_a_condition {
continue;
}
for token in node
.descendants_with_tokens()
.filter_map(|it| it.into_token())
{
if matches!(
CppTokenKind::from(token.kind()),
CppTokenKind::Star | CppTokenKind::Ampersand | CppTokenKind::LogicalAnd
) {
roles.declarator_mark.insert(token_range_start(&token));
}
}
}
CppSyntaxKind::CompoundStat
| CppSyntaxKind::ClassBody
| CppSyntaxKind::EnumDef
| CppSyntaxKind::NamespaceDecl => {
if let Some(brace) = first_brace(&node) {
roles.block_brace.insert(brace);
if let Some(name) = namespace_name(&node) {
roles.namespace_names.insert(brace, name);
}
}
}
CppSyntaxKind::InitListExpr => {
if let Some(brace) = first_brace(&node) {
roles.init_brace.insert(brace);
}
}
_ => {}
}
}
for element in root.descendants_with_tokens() {
let Some(token) = element.into_token() else {
continue;
};
if CppTokenKind::from(token.kind()) != CppTokenKind::LeftBrace {
continue;
}
let brace = token_range_start(&token);
let previous = previous_non_trivia(&token);
let introduced = matches!(
previous,
Some(
CppTokenKind::Assign
| CppTokenKind::ReturnKeyword
| CppTokenKind::Comma
| CppTokenKind::LeftParen
| CppTokenKind::LeftBracket
)
);
let named_an_initializer = roles.init_brace.contains(&brace)
&& !matches!(
previous,
Some(CppTokenKind::RightParen | CppTokenKind::RightBracket)
);
if introduced || named_an_initializer {
continue;
}
if token.parent().is_none() {
continue;
}
let brace_kind = opens_a_case_body(&token)
.then_some(BraceKind::CaseLabel)
.or_else(|| control_keyword_before(&token))
.or_else(|| body_kind_of(&token))
.or(match previous {
Some(CppTokenKind::RightParen) => Some(BraceKind::Function),
Some(CppTokenKind::RightBracket) => Some(BraceKind::Lambda),
_ => None,
});
if let Some(brace_kind) = brace_kind {
roles.brace_kind.insert(brace, brace_kind);
}
}
roles
}
fn body_kind_of(open: &cpp_parser::CppSyntaxToken) -> Option<BraceKind> {
let this_brace = token_range_start(open);
let parent = open.parent()?;
let mut compounds = 0usize;
for ancestor in parent.ancestors() {
match CppSyntaxKind::from(ancestor.kind()) {
CppSyntaxKind::CompoundStat => compounds += 1,
CppSyntaxKind::FunctionDef => {
return Some(if compounds <= 1 {
BraceKind::Function
} else {
BraceKind::Control
});
}
CppSyntaxKind::LambdaExpr => return Some(BraceKind::Lambda),
CppSyntaxKind::IfStat
| CppSyntaxKind::ForStat
| CppSyntaxKind::WhileStat
| CppSyntaxKind::DoStat
| CppSyntaxKind::SwitchStat => return Some(BraceKind::Control),
CppSyntaxKind::TryStat => return Some(BraceKind::Try),
CppSyntaxKind::CatchStat | CppSyntaxKind::CatchHandler => {
return Some(BraceKind::Catch);
}
CppSyntaxKind::ExternSpec => {
return Some(if first_brace(&ancestor) == Some(this_brace) {
BraceKind::ExternBlock
} else {
BraceKind::Function
});
}
CppSyntaxKind::NamespaceDecl => {
return Some(if first_brace(&ancestor) == Some(this_brace) {
BraceKind::Namespace
} else {
BraceKind::Function
});
}
CppSyntaxKind::ClassBody => {
if first_brace(&ancestor) != Some(this_brace) {
return Some(if compounds == 1 {
BraceKind::Function
} else {
BraceKind::Control
});
}
return match ancestor
.parent()
.map(|parent| CppSyntaxKind::from(parent.kind()))
{
Some(CppSyntaxKind::ClassDef) => Some(BraceKind::Class),
Some(CppSyntaxKind::StructDef) => Some(BraceKind::Struct),
Some(CppSyntaxKind::UnionDef) => Some(BraceKind::Union),
Some(CppSyntaxKind::EnumDef) => Some(BraceKind::Enum),
_ => None,
};
}
_ => {}
}
}
None
}
fn control_keyword_before(open: &cpp_parser::CppSyntaxToken) -> Option<BraceKind> {
let mut previous = open.prev_token();
let mut seen = Vec::new();
while let Some(token) = previous {
let kind = CppTokenKind::from(token.kind());
if cpp_parser::is_trivia(kind) {
previous = token.prev_token();
continue;
}
if seen.is_empty() {
match kind {
CppTokenKind::RightParen => {}
CppTokenKind::ElseKeyword | CppTokenKind::DoKeyword => {
return Some(BraceKind::Control);
}
CppTokenKind::TryKeyword => return Some(BraceKind::Try),
_ => return None,
}
}
match kind {
CppTokenKind::RightParen => seen.push(CppTokenKind::RightParen),
CppTokenKind::LeftParen => {
seen.pop();
if seen.is_empty() {
let mut before = token.prev_token();
while let Some(token) = before {
let kind = CppTokenKind::from(token.kind());
if cpp_parser::is_trivia(kind) {
before = token.prev_token();
continue;
}
return match kind {
CppTokenKind::IfKeyword
| CppTokenKind::ForKeyword
| CppTokenKind::WhileKeyword
| CppTokenKind::SwitchKeyword => Some(BraceKind::Control),
CppTokenKind::CatchKeyword => Some(BraceKind::Catch),
_ => None,
};
}
return None;
}
}
_ => {}
}
previous = token.prev_token();
}
None
}
fn is_a_comment(kind: CppTokenKind) -> bool {
matches!(
kind,
CppTokenKind::LineComment
| CppTokenKind::BlockComment
| CppTokenKind::DocText
| CppTokenKind::DocCommandName
| CppTokenKind::DocTrivia
)
}
fn opens_a_case_body(open: &cpp_parser::CppSyntaxToken) -> bool {
let mut previous = open.prev_token();
while let Some(token) = previous {
let kind = CppTokenKind::from(token.kind());
if cpp_parser::is_trivia(kind) || is_a_comment(kind) {
previous = token.prev_token();
continue;
}
if kind != CppTokenKind::Colon {
if std::env::var_os("CPPLS_TRACE_CASE").is_some() {
eprintln!("[case] -> false (saw {kind:?})");
}
return false;
}
let mut label = token.prev_token();
while let Some(token) = label {
match CppTokenKind::from(token.kind()) {
CppTokenKind::CaseKeyword | CppTokenKind::DefaultKeyword => {
if std::env::var_os("CPPLS_TRACE_CASE").is_some() {
eprintln!("[case] -> true (label found)");
}
return true;
}
CppTokenKind::Semicolon
| CppTokenKind::LeftBrace
| CppTokenKind::RightBrace
| CppTokenKind::Colon => return false,
_ => {}
}
label = token.prev_token();
}
return false;
}
false
}
fn namespace_name(node: &cpp_parser::CppSyntaxNode) -> Option<String> {
let mut after_the_keyword = false;
for element in node.descendants_with_tokens() {
let Some(token) = element.into_token() else {
continue;
};
let kind = CppTokenKind::from(token.kind());
if kind == CppTokenKind::NamespaceKeyword {
after_the_keyword = true;
continue;
}
if !after_the_keyword || cpp_parser::is_trivia(kind) {
continue;
}
return match kind {
CppTokenKind::Identifier => Some(token.text().to_string()),
CppTokenKind::LeftBrace => None,
_ => None,
};
}
None
}
fn previous_non_trivia(token: &cpp_parser::CppSyntaxToken) -> Option<CppTokenKind> {
let mut previous = token.prev_token();
while let Some(token) = previous {
let kind = CppTokenKind::from(token.kind());
if !cpp_parser::is_trivia(kind) {
return Some(kind);
}
previous = token.prev_token();
}
None
}
fn token_range_start(token: &cpp_parser::CppSyntaxToken) -> usize {
u32::from(token.text_range().start()) as usize
}
fn first_brace(node: &cpp_parser::CppSyntaxNode) -> Option<usize> {
node.descendants_with_tokens()
.filter_map(|it| it.into_token())
.find(|token| CppTokenKind::from(token.kind()) == CppTokenKind::LeftBrace)
.map(|token| token_range_start(&token))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_template_argument_list_marks_its_angles() {
let roles = of("std::vector<int> v;\n");
let less = "std::vector".len();
assert!(roles.is_template_angle(less), "the `<` of `vector<int>`");
}
#[test]
fn a_comparison_is_not_a_template_angle() {
let roles = of("int a = b < c;\n");
let less = "int a = b ".len();
assert!(!roles.is_template_angle(less));
}
#[test]
fn a_lambda_body_inside_a_call_is_a_lambda_brace() {
let source = "void f() {\n g([this](int a) {\n h(a);\n });\n}\n";
let roles = of(source);
let lambda_brace = source
.find("int a) {")
.expect("the lambda is in the fixture")
+ 7;
assert_eq!(
roles.brace_kind.get(&lambda_brace),
Some(&BraceKind::Lambda)
);
}
#[test]
fn a_range_for_body_is_a_control_brace() {
let source = "void f() {\n for (auto &a : v) {\n g();\n }\n}\n";
let roles = of(source);
let function_brace = source.find("() {").expect("the function is in the fixture") + 3;
let for_brace = source.find("v) {").expect("the loop is in the fixture") + 3;
assert_eq!(
roles.brace_kind.get(&function_brace),
Some(&BraceKind::Function)
);
assert_eq!(roles.brace_kind.get(&for_brace), Some(&BraceKind::Control));
}
#[test]
fn a_class_method_body_is_a_function_brace() {
let source = "class C {\n void m() {\n g();\n }\n};\n";
let roles = of(source);
let method_brace = source.find("() {").expect("the method is in the fixture") + 3;
eprintln!(
"kind at method brace: {:?}",
roles.brace_kind.get(&method_brace)
);
eprintln!("all: {:?}", roles.brace_kind);
assert_eq!(
roles.brace_kind.get(&method_brace),
Some(&BraceKind::Function)
);
}
#[test]
fn a_namespace_brace_knows_its_name() {
let source = "namespace ns {\nint x;\n}\n";
let roles = of(source);
let brace = source.find('{').expect("the body is in the fixture");
assert_eq!(roles.brace_kind.get(&brace), Some(&BraceKind::Namespace));
assert_eq!(roles.namespace_names.get(&brace), Some(&"ns".to_string()));
}
#[test]
fn a_constructor_body_is_a_function_brace() {
let source = "A::A(int x) : x_(x) {\n}\n";
let roles = of(source);
let brace = source.find('{').expect("the body is in the fixture");
assert_eq!(roles.brace_kind.get(&brace), Some(&BraceKind::Function));
}
#[test]
fn a_declarator_star_is_marked_and_a_product_is_not() {
let roles = of("int *p = a * b;\n");
let declarator = "int ".len();
let product = "int *p = a ".len();
assert!(roles.is_declarator(declarator));
assert!(!roles.is_declarator(product));
}
#[test]
fn a_function_body_brace_is_a_block_and_a_braced_init_is_not() {
let roles = of("void f() {}\nint x = {1};\n");
assert!(roles.block_brace.contains(&"void f() ".len()));
assert!(roles.init_brace.contains(&"void f() {}\nint x = ".len()));
}
}