use cpp_parser::{SymbolKind, SymbolTable};
use crate::sema::symbol::{BindingKind, Name, ScopeTree};
impl SymbolTable for ScopeTree {
fn kind_of(&self, name: &str) -> Option<SymbolKind> {
if name.is_empty() || name.contains("::") {
return None;
}
let mut answer: Option<SymbolKind> = None;
let written = Name::identifier(name);
for scope in self.scopes() {
for binding in scope.bindings_of(&written) {
let Some(kind) = symbol_kind_of(binding.kind) else {
continue;
};
answer = Some(match (answer, kind) {
(Some(SymbolKind::Type), _) | (_, SymbolKind::Type) => SymbolKind::Type,
(Some(SymbolKind::Function), _) | (_, SymbolKind::Function) => {
SymbolKind::Function
}
(Some(previous), _) => previous,
(None, kind) => kind,
});
if answer == Some(SymbolKind::Type) {
return answer;
}
}
}
answer
}
}
fn symbol_kind_of(kind: BindingKind) -> Option<SymbolKind> {
Some(match kind {
BindingKind::Class | BindingKind::Enum | BindingKind::Alias | BindingKind::Typedef => {
SymbolKind::Type
}
BindingKind::TemplateParameter => SymbolKind::Type,
BindingKind::Namespace => SymbolKind::Namespace,
BindingKind::Function
| BindingKind::Constructor
| BindingKind::Destructor
| BindingKind::ConversionFunction
| BindingKind::OperatorFunction
| BindingKind::LiteralOperator => SymbolKind::Function,
BindingKind::Variable | BindingKind::Enumerator => SymbolKind::Variable,
BindingKind::UsingDeclaration
| BindingKind::UsingDirective
| BindingKind::Label
| BindingKind::Other => return None,
#[allow(unreachable_patterns)]
_ => return None,
})
}
pub use cpp_parser::SymbolKind as ParserSymbolKind;
#[cfg(test)]
mod tests {
use super::{ScopeTree, SymbolKind, SymbolTable, symbol_kind_of};
use crate::sema::symbol::BindingKind;
#[test]
fn every_binding_kind_is_either_translated_or_deliberately_silent() {
let translated = [
(BindingKind::Class, SymbolKind::Type),
(BindingKind::Enum, SymbolKind::Type),
(BindingKind::Alias, SymbolKind::Type),
(BindingKind::Typedef, SymbolKind::Type),
(BindingKind::TemplateParameter, SymbolKind::Type),
(BindingKind::Namespace, SymbolKind::Namespace),
(BindingKind::Function, SymbolKind::Function),
(BindingKind::Constructor, SymbolKind::Function),
(BindingKind::Destructor, SymbolKind::Function),
(BindingKind::ConversionFunction, SymbolKind::Function),
(BindingKind::OperatorFunction, SymbolKind::Function),
(BindingKind::LiteralOperator, SymbolKind::Function),
(BindingKind::Variable, SymbolKind::Variable),
(BindingKind::Enumerator, SymbolKind::Variable),
];
for (kind, expected) in translated {
assert_eq!(symbol_kind_of(kind), Some(expected), "{kind:?}");
}
for kind in [
BindingKind::UsingDeclaration,
BindingKind::UsingDirective,
BindingKind::Label,
BindingKind::Other,
] {
assert_eq!(
symbol_kind_of(kind),
None,
"{kind:?} answers nothing about the name, which is `None` and not a `no`"
);
}
}
#[test]
fn the_trait_is_implemented_for_the_scope_tree() {
fn assert_implemented<T: SymbolTable>() {}
assert_implemented::<ScopeTree>();
let tree = ScopeTree::new();
let table: &dyn SymbolTable = &tree;
assert_eq!(
table.kind_of("anything"),
None,
"an empty tree knows nothing, and says so"
);
assert_eq!(
table.kind_of("ns::Widget"),
None,
"qualified names are not answered"
);
assert_eq!(table.kind_of(""), None);
}
}