use cpp_parser::{CppAstNode, CppSyntaxKind, CppSyntaxNode, SourceRange};
use crate::sema::symbol::{
Binding, BindingKind, Known, Name, Scope, ScopeId, ScopeTree, UnknownReason,
};
pub fn name_node_at(root: &CppSyntaxNode, offset: usize) -> Option<CppSyntaxNode> {
let mut found = None;
let mut node = root.clone();
loop {
if !contains(&node, offset) {
return found;
}
if is_a_name_node(&node) {
found = Some(node.clone());
}
let next = node
.children_with_tokens()
.find(|element| contains_element(element, offset));
match next {
Some(element) => match element.into_node() {
Some(child) => node = child,
None => return found,
},
None => return found,
}
}
}
fn is_a_name_node(node: &CppSyntaxNode) -> bool {
matches!(
CppSyntaxKind::from(node.kind()),
CppSyntaxKind::NameExpr | CppSyntaxKind::IdentifierExpr | CppSyntaxKind::IndexExpr
)
}
pub fn identifier_written_at(name: &CppSyntaxNode, offset: usize) -> Option<String> {
let token = identifier_token_at(name, offset)?;
Some(token.text().to_string())
}
fn identifier_token_at(name: &CppSyntaxNode, offset: usize) -> Option<cpp_parser::CppSyntaxToken> {
name.children_with_tokens()
.filter_map(|child| child.into_token())
.find(|token| {
cpp_parser::CppTokenKind::from(token.kind()) == cpp_parser::CppTokenKind::Identifier
&& contains_token(token, offset)
})
}
pub fn name_at(root: &CppSyntaxNode, offset: usize) -> Option<(String, SourceRange)> {
let node = name_node_at(root, offset)?;
let token = identifier_token_at(&node, offset)?;
Some((
token.text().to_string(),
cpp_parser::source_range(token.text_range()),
))
}
pub fn header_name_at(root: &CppSyntaxNode, offset: usize) -> Option<(String, SourceRange)> {
let token = header_name_token_at(root, offset)?;
let text = token.text();
let range = cpp_parser::source_range(token.text_range());
let spelling = text
.strip_prefix('<')
.and_then(|rest| rest.strip_suffix('>'))
.or_else(|| {
text.strip_prefix('"')
.and_then(|rest| rest.strip_suffix('"'))
})
.unwrap_or(text);
Some((spelling.to_string(), range))
}
fn header_name_token_at(root: &CppSyntaxNode, offset: usize) -> Option<cpp_parser::CppSyntaxToken> {
root.descendants_with_tokens()
.filter_map(|element| element.into_token())
.find(|token| {
cpp_parser::CppTokenKind::from(token.kind()) == cpp_parser::CppTokenKind::HeaderName
&& contains_token(token, offset)
})
}
pub fn header_name_in(root: &CppSyntaxNode, directive: SourceRange) -> Option<SourceRange> {
let token = root
.descendants_with_tokens()
.filter_map(|element| element.into_token())
.find(|token| {
cpp_parser::CppTokenKind::from(token.kind()) == cpp_parser::CppTokenKind::HeaderName
&& directive.start_offset <= usize::from(token.text_range().start())
&& usize::from(token.text_range().end()) <= directive.end_offset()
})?;
let range = cpp_parser::source_range(token.text_range());
let text = token.text();
let inside = text.len().saturating_sub(2);
if inside == 0 || !(text.starts_with('<') || text.starts_with('"')) {
return Some(range);
}
Some(SourceRange::new(range.start_offset + 1, inside))
}
pub fn operator_in(root: &CppSyntaxNode, position: usize) -> Option<cpp_parser::CppSyntaxToken> {
let token = cpp_parser::token_at(root, position)?;
if matches!(token.text(), "." | "->") {
return Some(token);
}
let before = position.checked_sub(1)?;
let token = cpp_parser::token_at(root, before)?;
matches!(token.text(), "." | "->").then_some(token)
}
pub fn name_ending_before_an_operator(
root: &CppSyntaxNode,
offset: usize,
) -> Option<CppSyntaxNode> {
let mut at = offset;
while at > 0 {
at -= 1;
if let Some(node) = name_node_at(root, at)
&& usize::from(node.text_range().end()) <= offset
&& is_a_spelling(&node)
{
return Some(node);
}
let token = cpp_parser::token_at(root, at)?;
if cpp_parser::CppTokenKind::from(token.kind()) == cpp_parser::CppTokenKind::ThisKeyword {
return token
.parent_ancestors()
.find(|node| {
cpp_parser::CppSyntaxKind::from(node.kind())
== cpp_parser::CppSyntaxKind::ThisExpr
})
.or_else(|| token.parent_ancestors().next());
}
if matches!(token.text(), "." | "->") {
continue;
}
if !cpp_parser::is_trivia(cpp_parser::CppTokenKind::from(token.kind())) {
return None;
}
}
None
}
fn is_a_spelling(node: &CppSyntaxNode) -> bool {
let text = node.text().to_string();
let trimmed = text.trim();
!trimmed.is_empty()
&& trimmed.chars().all(|character| {
character.is_alphanumeric() || matches!(character, '_' | ':' | '~' | ' ' | '\t')
})
&& trimmed
.chars()
.next_back()
.is_some_and(|last| last.is_alphanumeric() || last == '_')
}
pub fn name_at_including_directives(
root: &CppSyntaxNode,
offset: usize,
) -> Option<(String, SourceRange)> {
if let Some(found) = name_at(root, offset) {
return Some(found);
}
let token = root
.descendants_with_tokens()
.filter_map(|element| element.into_token())
.find(|token| contains_token(token, offset))?;
(cpp_parser::CppTokenKind::from(token.kind()) == cpp_parser::CppTokenKind::Identifier).then(
|| {
(
token.text().to_string(),
cpp_parser::source_range(token.text_range()),
)
},
)
}
pub fn qualified_name_at(root: &CppSyntaxNode, offset: usize) -> Option<(String, SourceRange)> {
let node = name_node_at(root, offset)?;
let token = identifier_token_at(&node, offset)?;
let mut written = String::new();
let mut global = false;
for element in node.children_with_tokens() {
let Some(child) = element.into_token() else {
continue;
};
match cpp_parser::CppTokenKind::from(child.kind()) {
cpp_parser::CppTokenKind::Identifier => {
if !written.is_empty() {
written.push_str("::");
}
written.push_str(child.text());
if contains_token(&child, offset) {
return Some((
spell(global, &written),
cpp_parser::source_range(token.text_range()),
));
}
}
cpp_parser::CppTokenKind::Scope if written.is_empty() => global = true,
_ => {}
}
}
Some((
spell(global, token.text()),
cpp_parser::source_range(token.text_range()),
))
}
fn spell(global: bool, written: &str) -> String {
if global {
format!("::{written}")
} else {
written.to_string()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NamePosition {
pub scope: String,
pub written: String,
pub range: SourceRange,
}
pub fn name_position_at(root: &CppSyntaxNode, offset: usize) -> Option<NamePosition> {
let Some(node) = name_node_around(root, offset) else {
if member_access_at(root, offset).is_some() {
return None;
}
if let Some(token) = cpp_parser::token_at(root, offset)
&& inside_a_comment_or_a_literal(&token)
{
return None;
}
let word = cpp_parser::token_at(root, offset)
.filter(|token| {
cpp_parser::CppTokenKind::from(token.kind()) == cpp_parser::CppTokenKind::Identifier
})
.or_else(|| {
cpp_parser::token_at(root, offset.saturating_sub(1)).filter(|token| {
cpp_parser::CppTokenKind::from(token.kind())
== cpp_parser::CppTokenKind::Identifier
})
});
if let Some(token) = word {
let range = cpp_parser::source_range(token.text_range());
let written = token
.text()
.chars()
.take(offset.saturating_sub(range.start_offset))
.collect();
return Some(NamePosition {
scope: String::new(),
written,
range,
});
}
return Some(NamePosition {
scope: String::new(),
written: String::new(),
range: SourceRange::new(offset, 0),
});
};
let mut segments: Vec<String> = Vec::new();
let mut written = String::new();
let mut global = false;
let mut range = None;
let mut last_was_a_scope = false;
for token in node
.children_with_tokens()
.filter_map(|child| child.into_token())
{
let token_range = cpp_parser::source_range(token.text_range());
if cpp_parser::is_trivia(cpp_parser::CppTokenKind::from(token.kind())) {
continue;
}
let kind = cpp_parser::CppTokenKind::from(token.kind());
let previous_was_a_scope = last_was_a_scope;
last_was_a_scope = kind == cpp_parser::CppTokenKind::Scope;
if token_range.start_offset >= offset {
if token_range.start_offset == offset && kind == cpp_parser::CppTokenKind::Identifier {
range = Some(token_range);
if !previous_was_a_scope {
segments.clear();
written = token
.text()
.chars()
.take(offset.saturating_sub(token_range.start_offset))
.collect();
global = false;
}
}
break;
}
match kind {
cpp_parser::CppTokenKind::Semicolon
| cpp_parser::CppTokenKind::LeftBrace
| cpp_parser::CppTokenKind::RightBrace
| cpp_parser::CppTokenKind::LeftParen
| cpp_parser::CppTokenKind::RightParen
| cpp_parser::CppTokenKind::LeftBracket
| cpp_parser::CppTokenKind::RightBracket
| cpp_parser::CppTokenKind::Comma
| cpp_parser::CppTokenKind::Assign => {
segments.clear();
written.clear();
global = false;
range = None;
}
cpp_parser::CppTokenKind::Identifier => {
if token_range.end_offset() <= offset {
written.push_str(token.text());
range = Some(token_range);
continue;
}
written.push_str(&token.text()[..offset - token_range.start_offset]);
range = Some(token_range);
break;
}
cpp_parser::CppTokenKind::Scope => {
if written.is_empty() && segments.is_empty() {
global = true;
} else {
segments.push(std::mem::take(&mut written));
}
range = None;
}
_ => break,
}
}
Some(NamePosition {
scope: spell(global, &segments.join("::")),
written,
range: range.unwrap_or(SourceRange {
start_offset: offset,
length: 0,
}),
})
}
fn inside_a_comment_or_a_literal(token: &cpp_parser::CppSyntaxToken) -> bool {
if matches!(
cpp_parser::CppTokenKind::from(token.kind()),
cpp_parser::CppTokenKind::LineComment
| cpp_parser::CppTokenKind::BlockComment
| cpp_parser::CppTokenKind::StringLiteral
| cpp_parser::CppTokenKind::CharLiteral
) {
return true;
}
token.parent_ancestors().any(|node| {
cpp_parser::CppSyntaxKind::from(node.kind()) == cpp_parser::CppSyntaxKind::DocComment
})
}
fn name_node_around(root: &CppSyntaxNode, offset: usize) -> Option<CppSyntaxNode> {
let mut found = None;
let mut node = root.clone();
let tracing = crate::probes::coordinates();
loop {
let range = node.text_range();
if !(usize::from(range.start()) <= offset && offset <= usize::from(range.end())) {
if tracing {
eprintln!(
" name_node_around({offset}): leaving {:?} {}..{} (does not contain)",
CppSyntaxKind::from(node.kind()),
usize::from(range.start()),
usize::from(range.end())
);
}
return found;
}
if cpp_parser::CppNameExpr::can_cast(node.kind().into()) {
found = Some(node.clone());
}
let next = node.children_with_tokens().find_map(|element| {
(contains_element(&element, offset) || ends_at(&element, offset))
.then(|| element.into_node())
.flatten()
});
match next {
Some(child) => node = child,
None => return found,
}
}
}
fn ends_at(element: &cpp_parser::CppSyntaxElement, offset: usize) -> bool {
let range = element.text_range();
usize::from(range.end()) == offset && usize::from(range.start()) < offset
}
#[derive(Debug, Clone)]
pub struct MemberAccess {
pub object: CppSyntaxNode,
pub member: String,
pub member_range: SourceRange,
pub arrow: bool,
}
pub fn member_access_at(root: &CppSyntaxNode, offset: usize) -> Option<MemberAccess> {
let node = member_node_at(root, offset)?;
let access = member_access_of(&node)?;
contains_range(access.member_range, SourceRange::new(offset, 0)).then_some(access)
}
pub fn expression_at(root: &CppSyntaxNode, offset: usize) -> Option<CppSyntaxNode> {
let mut found = None;
let mut node = root.clone();
loop {
if !contains(&node, offset) {
return found;
}
if cpp_parser::CppExpr::can_cast(node.kind().into()) {
found = Some(node.clone());
}
match node
.children_with_tokens()
.find(|element| contains_element(element, offset))
.and_then(|element| element.into_node())
{
Some(child) => node = child,
None => return found,
}
}
}
pub fn member_access_of(node: &CppSyntaxNode) -> Option<MemberAccess> {
let elements: Vec<cpp_parser::CppSyntaxElement> = node.children_with_tokens().collect();
let operator = elements.iter().position(|element| {
element
.as_token()
.is_some_and(|token| token.text() == "." || token.text() == "->")
})?;
let operator_range = elements[operator].as_token()?.text_range();
let arrow = elements[operator]
.as_token()
.is_some_and(|token| token.text() == "->");
let object = elements[..operator]
.iter()
.find_map(|element| element.as_node().cloned())?;
let after_operator: Vec<cpp_parser::CppSyntaxToken> = node
.descendants_with_tokens()
.filter_map(|element| element.into_token())
.filter(|token| {
cpp_parser::CppTokenKind::from(token.kind()) == cpp_parser::CppTokenKind::Identifier
&& token.text_range().start() >= operator_range.end()
})
.collect();
let Some(member_token) = after_operator.into_iter().next() else {
return Some(MemberAccess {
object,
member: String::new(),
member_range: SourceRange::new(usize::from(operator_range.end()), 0),
arrow,
});
};
Some(MemberAccess {
object,
member: member_token.text().to_string(),
member_range: cpp_parser::source_range(member_token.text_range()),
arrow,
})
}
fn member_node_at(root: &CppSyntaxNode, offset: usize) -> Option<CppSyntaxNode> {
let mut found = None;
let mut node = root.clone();
loop {
if !reaches(&node, offset) {
return found;
}
if matches!(
CppSyntaxKind::from(node.kind()),
CppSyntaxKind::MemberExpr | CppSyntaxKind::ArrowExpr | CppSyntaxKind::IndexExpr
) {
found = Some(node.clone());
}
match node
.children_with_tokens()
.find(|element| reaches_element(element, offset))
.and_then(|element| element.into_node())
{
Some(child) => node = child,
None => return found,
}
}
}
pub fn definition_at(scopes: &ScopeTree, root: &CppSyntaxNode, offset: usize) -> Known<Binding> {
match definitions_at(scopes, root, offset) {
Known::Yes(mut found) => Known::Yes(found.remove(0)),
Known::Unknown(reason) => Known::Unknown(reason),
Known::No => Known::No,
}
}
fn the_generated_member_spelling(
root: &CppSyntaxNode,
offset: usize,
written: &str,
) -> Option<String> {
let (generated, rest) = written
.strip_prefix("Super")
.map(|rest| ("Super", rest))
.or_else(|| {
written
.strip_prefix("ThisClass")
.map(|rest| ("ThisClass", rest))
})?;
if !(rest.is_empty() || rest.starts_with("::")) {
return None;
}
let name = name_node_around(root, offset)?;
let class = name.ancestors().find(|node| {
matches!(
CppSyntaxKind::from(node.kind()),
CppSyntaxKind::ClassDef | CppSyntaxKind::StructDef
)
})?;
let has_generated_code = cpp_parser::typed_descendants::<cpp_parser::CppNameExpr>(&class)
.any(|name| name.syntax().text().to_string().trim() == "StaticClass");
if !has_generated_code {
return None;
}
if generated == "ThisClass" {
let own = cpp_parser::typed_descendants::<cpp_parser::CppNameExpr>(&class).next()?;
return Some(format!("{}{rest}", own.syntax().text()));
}
let base = class
.descendants()
.find(|node| cpp_parser::CppBaseSpecifier::can_cast(node.kind().into()))?;
let base_name = cpp_parser::typed_descendants::<cpp_parser::CppNameExpr>(&base).next()?;
Some(format!("{}{rest}", base_name.syntax().text()))
}
pub fn definitions_at(
scopes: &ScopeTree,
root: &CppSyntaxNode,
offset: usize,
) -> Known<Vec<Binding>> {
let Some((written, _)) = qualified_name_at(root, offset) else {
if let Some(binding) = scopes.binding_declared_at(offset)
&& binding.kind == BindingKind::Enumerator
{
return Known::Yes(vec![binding.clone()]);
}
return Known::Unknown(UnknownReason::UnparsableName);
};
let Some(innermost) = scopes.scope_at(offset) else {
return Known::No;
};
let rewritten = the_generated_member_spelling(root, offset, &written);
let written = match &rewritten {
Some(spelling) => spelling.clone(),
None => written,
};
if written.contains("::") {
let qualified = qualified_definitions_at(scopes, innermost, &written);
if rewritten.is_some() && !matches!(qualified, Known::Yes(_)) {
let global = qualified_definitions_at(scopes, innermost, &format!("::{written}"));
if matches!(global, Known::Yes(_)) {
return global;
}
}
return qualified;
}
let name = Name::identifier(written.clone());
let mut pending = using_directive_targets(scopes);
pending.extend(scopes_to_search(scopes, innermost));
let mut visited = Vec::new();
let mut searched_any_scope = false;
while let Some(scope) = pending.pop() {
if visited.contains(&scope) {
continue;
}
visited.push(scope);
searched_any_scope = true;
let Some(scope_data) = scopes.scope(scope) else {
continue;
};
let found = bindings_named(scope_data, &name);
if !found.is_empty() {
return Known::Yes(found.into_iter().cloned().collect());
}
}
for ancestor in scopes.scope_chain(innermost) {
let Some(scope_data) = scopes.scope(ancestor) else {
continue;
};
for child in scope_data.children.clone() {
let Some(child_data) = scopes.scope(child) else {
continue;
};
if !child_data.unscoped_enum {
continue;
}
let found = bindings_named(child_data, &name);
if !found.is_empty() {
return Known::Yes(found.into_iter().cloned().collect());
}
}
}
if !searched_any_scope {
return Known::No;
}
Known::Unknown(UnknownReason::NotDeclaredHere(Box::from(written)))
}
fn qualified_definitions_at(
scopes: &ScopeTree,
innermost: ScopeId,
written: &str,
) -> Known<Vec<Binding>> {
let (global, spelling) = match written.strip_prefix("::") {
Some(rest) => (true, rest),
None => (false, written),
};
let segments: Vec<&str> = spelling.split("::").collect();
let (last, qualifier) = match segments.split_last() {
Some((last, rest)) if !rest.is_empty() => (*last, rest.join("::")),
_ => return Known::Unknown(UnknownReason::NotDeclaredHere(Box::from(written))),
};
let anchors: Vec<Option<String>> = if global {
vec![None]
} else {
scopes
.scope_chain(innermost)
.into_iter()
.map(|scope| scopes.qualified_name_of(scope))
.collect()
};
let name = Name::identifier(last.to_string());
for anchor in anchors {
let candidate = match anchor {
Some(prefix) => format!("{prefix}::{qualifier}"),
None => qualifier.clone(),
};
let Some(scope) = scopes.scope_with_qualified_name(&candidate) else {
continue;
};
let Some(scope_data) = scopes.scope(scope) else {
continue;
};
let found = bindings_named(scope_data, &name);
if !found.is_empty() {
return Known::Yes(found.into_iter().cloned().collect());
}
}
Known::Unknown(UnknownReason::NotDeclaredHere(Box::from(written)))
}
fn using_directive_targets(scopes: &ScopeTree) -> Vec<ScopeId> {
let named: Vec<String> = scopes
.scopes()
.iter()
.flat_map(|scope| scope.bindings.iter())
.filter(|binding| binding.kind == BindingKind::UsingDirective)
.map(|binding| binding.name.text())
.collect();
if named.is_empty() {
return Vec::new();
}
scopes
.scopes()
.iter()
.enumerate()
.filter(|(_, scope)| {
scope.kind == crate::ScopeKind::Namespace
&& scope
.name
.as_deref()
.is_some_and(|name| named.iter().any(|named| named == name))
})
.map(|(index, _)| ScopeId(index))
.collect()
}
fn scopes_to_search(scopes: &ScopeTree, innermost: ScopeId) -> Vec<ScopeId> {
let mut enclosing: Vec<ScopeId> = scopes
.scopes()
.iter()
.enumerate()
.filter_map(|(index, scope)| {
let range = scope.range?;
contains_range(range, scopes.scope(innermost)?.range?).then_some(ScopeId(index))
})
.collect();
enclosing.sort_by_key(|id| {
std::cmp::Reverse(
scopes
.scope(*id)
.and_then(|scope| scope.range)
.map(|range| range.length),
)
});
let mut chain = scopes.scope_chain(innermost);
chain.reverse();
enclosing.extend(chain);
enclosing
}
fn bindings_named<'a>(scope: &'a Scope, name: &Name) -> Vec<&'a Binding> {
scope
.bindings_of(name)
.filter(|binding| {
!matches!(
binding.kind,
BindingKind::Constructor | BindingKind::Destructor
)
})
.filter(|binding| binding.kind != BindingKind::UsingDirective)
.collect()
}
fn contains(node: &CppSyntaxNode, offset: usize) -> bool {
let range = node.text_range();
offset >= usize::from(range.start()) && offset < usize::from(range.end())
}
fn reaches(node: &CppSyntaxNode, offset: usize) -> bool {
let range = node.text_range();
offset >= usize::from(range.start()) && offset <= usize::from(range.end())
}
fn reaches_element(element: &cpp_parser::CppSyntaxElement, offset: usize) -> bool {
let range = element.text_range();
offset >= usize::from(range.start()) && offset <= usize::from(range.end())
}
fn contains_element(element: &cpp_parser::CppSyntaxElement, offset: usize) -> bool {
let range = element.text_range();
offset >= usize::from(range.start()) && offset < usize::from(range.end())
}
fn contains_token(token: &cpp_parser::CppSyntaxToken, offset: usize) -> bool {
let range = token.text_range();
offset >= usize::from(range.start()) && offset < usize::from(range.end())
}
fn contains_range(outer: SourceRange, inner: SourceRange) -> bool {
outer.start_offset <= inner.start_offset && outer.end_offset() >= inner.end_offset()
}
#[cfg(test)]
mod tests {
use super::{
definition_at, header_name_at, identifier_written_at, name_at, name_node_at,
qualified_name_at,
};
use crate::sema::scopes::build_scopes;
use crate::sema::symbol::{BindingKind, Known, UnknownReason};
use cpp_parser::{CppParser, ParserConfig};
fn tree(source: &str) -> cpp_parser::CppSyntaxTree {
let tree = CppParser::parse(source, ParserConfig::default());
assert_eq!(
tree.get_errors(),
[],
"the input must parse cleanly: {source:?}"
);
tree
}
fn at(source: &str, needle: &str) -> usize {
source
.rfind(needle)
.unwrap_or_else(|| panic!("{needle:?} is not in {source:?}"))
}
fn definition_of(source: &str, needle: &str) -> Known<crate::Binding> {
let parsed = tree(source);
let root = parsed.get_red_root();
let scopes = build_scopes(&root, &crate::NoMacroBodies);
definition_at(&scopes, &root, at(source, needle))
}
#[test]
fn a_member_access_with_nothing_after_the_operator_answers_at_the_operator_and_after_it() {
let source = "#include <string>\nint main() {\n std::string full;\n full. \n;\n}\n";
let parsed = CppParser::parse(source, ParserConfig::default());
let errors = parsed.get_errors();
let root = parsed.get_red_root();
let dot = source.find("full.").expect("the fixture") + "full.".len() - 1;
assert_eq!(&source[dot..dot + 1], ".", "the fixture's operator");
let access = super::member_access_at(&root, dot + 1).unwrap_or_else(|| {
panic!(
"the offset after the `.` must read as a member access; the parser said {:?}",
errors
.iter()
.map(|error| &error.message)
.collect::<Vec<_>>()
)
});
assert_eq!(access.object.text().to_string(), "full");
assert!(access.member.is_empty(), "nothing is written after the dot");
assert_eq!(
access.member_range.start_offset,
dot + 1,
"and the name goes immediately after the operator"
);
}
#[test]
fn a_header_name_is_read_without_its_delimiters() {
let source = "#include <vector>\n#include \"local.h\"\n#include MACRO\n";
let parsed = tree(source);
let root = parsed.get_red_root();
let (angled, range) =
header_name_at(&root, at(source, "vector")).expect("`vector` is a header name");
assert_eq!(angled, "vector");
assert_eq!(&source[range.start_offset..range.end_offset()], "<vector>");
let (quoted, _) =
header_name_at(&root, at(source, "local.h")).expect("`local.h` is a header name");
assert_eq!(quoted, "local.h");
assert!(
header_name_at(&root, at(source, "MACRO")).is_none(),
"`#include MACRO` names a macro, not a header"
);
assert!(
header_name_at(&root, 0).is_none(),
"the `#` is not the name"
);
assert!(
header_name_at(&root, source.find("include").expect("the fixture") + 2).is_none(),
"and neither is `include`"
);
}
#[test]
fn the_name_under_the_cursor_is_the_innermost_one() {
let source = "ns::Widget value;\n";
let parsed = tree(source);
let root = parsed.get_red_root();
let (name, range) = name_at(&root, at(source, "Widget")).expect("Widget is a name");
assert_eq!(name, "Widget");
assert_eq!(
&source[range.start_offset..range.end_offset()],
"Widget",
"the range is the identifier, not the whole qualified name"
);
let (qualifier, _) = name_at(&root, at(source, "ns")).expect("ns is a name");
assert_eq!(qualifier, "ns");
}
#[test]
fn punctuation_and_the_end_of_the_file_are_not_names() {
let source = "int x = 1;\n";
let parsed = tree(source);
let root = parsed.get_red_root();
assert!(name_at(&root, at(source, "=")).is_none(), "an operator");
assert!(name_at(&root, at(source, "1")).is_none(), "a literal");
assert!(name_at(&root, source.len() + 10).is_none(), "past the end");
}
#[test]
fn a_qualified_name_is_read_one_segment_at_a_time() {
let source = "ns::Widget value;\n";
let parsed = tree(source);
let root = parsed.get_red_root();
let widget = name_node_at(&root, at(source, "Widget")).expect("a name node");
assert_eq!(
identifier_written_at(&widget, at(source, "Widget")).as_deref(),
Some("Widget")
);
}
#[test]
fn a_local_definition_is_found_from_a_use() {
let source = "void f() {\n int count = 0;\n count = 1;\n}\n";
let found = definition_of(source, "count = 1;");
let Known::Yes(binding) = found else {
panic!("the local must resolve: {found:?}");
};
assert_eq!(binding.kind, BindingKind::Variable);
assert_eq!(binding.name.identifier_text(), Some("count"));
}
#[test]
fn the_innermost_declaration_of_a_name_wins() {
let source = "int count = 0;\nvoid f() {\n int count = 1;\n count = 2;\n}\n";
let found = definition_of(source, "count = 2;");
let Known::Yes(binding) = found else {
panic!("the local must resolve: {found:?}");
};
assert!(
binding.range.start_offset > at(source, "void f"),
"the jump goes to the local, not to the file-scope declaration"
);
}
#[test]
fn a_definition_is_found_from_inside_the_declaration_itself() {
let source = "void f() {\n int count = 0;\n}\n";
let found = definition_of(source, "count = 0;");
let Known::Yes(binding) = found else {
panic!("the declaration must resolve to itself: {found:?}");
};
assert_eq!(binding.name.identifier_text(), Some("count"));
}
#[test]
fn a_member_is_found_from_a_use_inside_the_class() {
let source = "struct Widget {\n int size;\n int get() { return size; }\n};\n";
let found = definition_of(source, "size; }");
let Known::Yes(binding) = found else {
panic!("the member must resolve: {found:?}");
};
assert_eq!(binding.name.identifier_text(), Some("size"));
assert_eq!(binding.kind, BindingKind::Variable);
}
#[test]
fn a_namespace_member_is_found_from_a_use_inside_the_namespace() {
let source = "namespace ns {\n int count = 0;\n void f() {\n count = 1;\n }\n}\n";
let found = definition_of(source, "count = 1;");
let Known::Yes(binding) = found else {
panic!("the namespace member must resolve: {found:?}");
};
assert_eq!(binding.name.identifier_text(), Some("count"));
assert!(
binding.range.start_offset < at(source, "void f"),
"the jump goes to the declaration above the function"
);
}
#[test]
fn the_written_name_is_the_whole_qualifier_up_to_the_cursor() {
let source = "namespace ns {\n struct Widget { int x; };\n}\n\
::Global g;\n\
ns::Widget<int> w;\n";
let root = tree(source).get_red_root();
let at_widget = |needle: &str| {
let offset = at(source, needle);
qualified_name_at(&root, offset).map(|(written, _)| written)
};
assert_eq!(
at_widget("Widget<int> w;").as_deref(),
Some("ns::Widget"),
"the template argument list is not part of the name"
);
assert_eq!(
at_widget("ns::Widget<int>").as_deref(),
Some("ns"),
"a cursor on the qualifier asks about the qualifier"
);
assert_eq!(
at_widget("Global g;").as_deref(),
Some("::Global"),
"a leading `::` is part of the spelling: it asks about the global name space"
);
assert_eq!(
at_widget("x; };").as_deref(),
Some("x"),
"and a bare name is still a bare name"
);
}
#[test]
fn a_qualified_name_resolves_into_its_namespace() {
let source = "namespace ns {\n int count = 0;\n}\nvoid f() {\n ns::count = 1;\n}\n";
let found = definition_of(source, "count = 1;");
let Known::Yes(binding) = found else {
panic!("the qualifier names a namespace this file declares: {found:?}");
};
assert_eq!(binding.name.identifier_text(), Some("count"));
assert!(
binding.range.start_offset < at(source, "void f"),
"and the jump goes into the namespace, not to the use"
);
}
#[test]
fn a_qualifier_picks_the_right_namespace_when_the_name_is_in_two_of_them() {
let source = "namespace a {\n struct Widget { int from_a; };\n}\n\
namespace b {\n struct Widget { int from_b; };\n}\n\
void f() {\n b::Widget w;\n}\n";
let found = definition_of(source, "Widget w;");
let Known::Yes(binding) = found else {
panic!("`b::Widget` is the one in `b`");
};
assert!(
binding.range.start_offset > at(source, "namespace b"),
"the jump lands in `b`, not in `a`: {:?}",
binding.range
);
}
#[test]
fn a_nested_qualifier_walks_every_segment() {
let source = "namespace a {\n namespace b {\n int count = 0;\n }\n}\n\
void f() {\n a::b::count = 1;\n}\n";
let found = definition_of(source, "count = 1;");
let Known::Yes(binding) = found else {
panic!("both segments name scopes this file declares: {found:?}");
};
assert_eq!(binding.name.identifier_text(), Some("count"));
}
#[test]
fn a_relative_qualifier_is_anchored_in_the_enclosing_scope() {
let source = "namespace a {\n namespace b {\n int count = 0;\n }\n void f() {\n b::count = 1;\n }\n}\n";
let found = definition_of(source, "count = 1;");
let Known::Yes(binding) = found else {
panic!("a relative qualifier is resolved from the enclosing scope: {found:?}");
};
assert_eq!(binding.name.identifier_text(), Some("count"));
}
#[test]
fn a_cursor_on_the_qualifier_asks_about_the_qualifier() {
let source = "namespace ns {\n int count = 0;\n}\nvoid f() {\n ns::count = 1;\n}\n";
let found = definition_of(source, "ns::count");
let Known::Yes(binding) = found else {
panic!("the qualifier is a name this file declares: {found:?}");
};
assert_eq!(binding.name.identifier_text(), Some("ns"));
}
#[test]
fn a_qualifier_that_names_nothing_is_unknown_rather_than_guessed() {
let source = "namespace ns {\n int count = 0;\n}\nvoid f() {\n nope::count = 1;\n}\n";
let found = definition_of(source, "count = 1;");
assert!(
matches!(found, Known::Unknown(UnknownReason::NotDeclaredHere(_))),
"and the reason must carry the qualified spelling, which is what the cross-file layer looks up: \
{found:?}"
);
let Known::Unknown(UnknownReason::NotDeclaredHere(written)) = found else {
unreachable!("just checked");
};
assert_eq!(&*written, "nope::count");
}
#[test]
fn an_out_of_line_definition_resolves_to_the_declaration_in_the_class() {
let source =
"struct C {\n int value() const;\n};\nint C::value() const {\n return 0;\n}\n";
let found = definition_of(source, "value() const {");
let Known::Yes(binding) = found else {
panic!("`C::value` names the member declared in `C`: {found:?}");
};
assert_eq!(binding.name.identifier_text(), Some("value"));
assert!(
binding.range.start_offset < at(source, "int C::value"),
"and the jump goes to the declaration, not to the definition it is standing on"
);
}
#[test]
fn a_using_directive_makes_a_namespace_reachable() {
let source = "namespace ns {\n int count = 0;\n}\nusing namespace ns;\nvoid f() {\n count = 1;\n}\n";
let found = definition_of(source, "count = 1;");
let Known::Yes(binding) = found else {
panic!("`using namespace ns` makes `count` visible: {found:?}");
};
assert_eq!(binding.name.identifier_text(), Some("count"));
}
#[test]
fn a_name_declared_nowhere_in_the_file_is_unknown_rather_than_absent() {
let source =
"#include <vector>\nstd::vector<int> values;\nvoid f() {\n values.push_back(1);\n}\n";
let found = definition_of(source, "push_back");
assert!(
matches!(found, Known::Unknown(UnknownReason::NotDeclaredHere(_))),
"a name from a header is unknown, not absent: {found:?}"
);
if let Known::Unknown(reason) = found {
assert!(
reason.describe().contains("push_back"),
"the message names what could not be resolved: {}",
reason.describe()
);
}
}
#[test]
fn a_qualified_name_that_cannot_be_resolved_is_unknown() {
let source = "void f() {\n ns::Widget value;\n}\n";
let found = definition_of(source, "Widget");
assert!(
matches!(found, Known::Unknown(_)),
"a qualifier this file cannot see means the answer is elsewhere: {found:?}"
);
}
#[test]
fn a_binding_that_is_not_a_definition_is_skipped() {
let source = "namespace ns {\n int count = 0;\n}\nusing namespace ns;\n";
let found = definition_of(source, "ns;");
let Known::Yes(binding) = found else {
panic!("the namespace itself is declared in this file: {found:?}");
};
assert_eq!(binding.kind, BindingKind::Namespace);
}
#[test]
fn a_non_identifier_name_reports_that_it_could_not_be_read() {
let source = "struct S {\n S operator+(const S&);\n};\n";
let found = definition_of(source, "operator+");
assert!(
matches!(found, Known::Unknown(UnknownReason::UnparsableName)),
"an operator name is not an identifier: {found:?}"
);
}
}