use crate::file::coordinates::{FileOffset, ReadingOffset};
use crate::{DeclKind, DeclModifiers, FileProvider, FileView, Known, Session};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MissingDefinition {
pub class: String,
pub name: String,
pub qualified_name: String,
pub returns: Option<String>,
pub parameters: String,
pub qualifiers: String,
pub is_a_template: bool,
}
impl MissingDefinition {
pub fn text(&self) -> String {
let mut line = String::new();
if let Some(returns) = &self.returns
&& !returns.trim().is_empty()
{
line.push_str(returns.trim());
line.push(' ');
}
line.push_str(&self.qualified_name);
line.push_str(&self.parameters);
line.push_str(&self.qualifiers);
format!("{line}\n{{\n}}")
}
}
impl<F: FileProvider + Clone> Session<F> {
pub fn missing_definition_at(
&self,
view: &FileView,
offset: ReadingOffset,
) -> Option<MissingDefinition> {
let in_the_file = view.file_offset_of(offset)?.get();
let summary = self.index().summary(&view.path)?;
let fact = summary
.declarations
.iter()
.find(|fact| fact.name_range.start_offset == in_the_file)?;
if fact.kind != DeclKind::Function
|| fact.modifiers.contains(DeclModifiers::DEFINED)
|| fact.modifiers.contains(DeclModifiers::PURE)
{
return None;
}
let class = fact.scope.clone()?;
let name = fact.name.to_string();
for (_, summary) in self.index().all_summaries() {
let defined = summary.declarations.iter().any(|other| {
other.kind == DeclKind::Function
&& other.name == name
&& other.scope.as_deref() == Some(class.as_str())
&& other.modifiers.contains(DeclModifiers::DEFINED)
});
if defined {
return None;
}
}
let (parameters, qualifiers) =
written_parameters_and_qualifiers(view, fact.name_range.start_offset)?;
let is_a_template = self.index().summary(&view.path).is_some_and(|summary| {
summary.declarations.iter().any(|declared| {
declared.kind == DeclKind::Type
&& declared.name == class
&& !declared.parameters().is_empty()
})
});
Some(MissingDefinition {
qualified_name: format!("{class}::{name}"),
class: class.to_string(),
name: name.to_string(),
returns: fact.returns.as_deref().map(str::to_string),
parameters,
qualifiers,
is_a_template,
})
}
pub fn pure_virtuals_of(&self, view: &FileView, class: &str) -> Vec<MissingDefinition> {
let Known::Yes(list) = self.members_of(view, class) else {
return Vec::new();
};
let mut found: Vec<MissingDefinition> = Vec::new();
for member in &list.members {
if member.fact.kind != DeclKind::Function
|| !member.fact.modifiers.contains(DeclModifiers::PURE)
{
continue;
}
let overridden = list.members.iter().any(|other| {
other.fact.kind == DeclKind::Function
&& other.fact.name == member.fact.name
&& other.depth < member.depth
&& !other.fact.modifiers.contains(DeclModifiers::PURE)
});
if overridden {
continue;
}
let Some((parameters, qualifiers)) = signature_of(self, &member.file, &member.fact)
else {
continue;
};
found.push(MissingDefinition {
qualified_name: format!("{class}::{}", member.fact.name),
class: class.to_string(),
name: member.fact.name.to_string(),
returns: member.fact.returns.as_deref().map(str::to_string),
parameters,
qualifiers,
is_a_template: false,
});
}
found
}
}
fn signature_of<F: FileProvider + Clone>(
session: &Session<F>,
file: &std::path::Path,
fact: &crate::DeclFact,
) -> Option<(String, String)> {
let parameters = match fact.parameter_list().map(str::to_string) {
Some(parameters) => parameters,
None => {
let view = session
.view_of_the_file(file)
.or_else(|| session.view(file))?;
written_parameters_and_qualifiers(&view, fact.name_range.start_offset)?.0
}
};
let mut qualifiers = String::new();
if fact.modifiers.contains(DeclModifiers::CONST) {
qualifiers.push_str(" const");
}
if fact.modifiers.contains(DeclModifiers::LVALUE_REFERENCE) {
qualifiers.push_str(" &");
}
if fact.modifiers.contains(DeclModifiers::RVALUE_REFERENCE) {
qualifiers.push_str(" &&");
}
Some((parameters, qualifiers))
}
fn written_parameters_and_qualifiers(
view: &FileView,
in_the_file: usize,
) -> Option<(String, String)> {
use cpp_parser::CppAstNode;
let reading = view.reading_offset_of(FileOffset::new(in_the_file))?;
let token = cpp_parser::token_at(&view.root, reading.get())?;
let declarator = token
.parent()?
.ancestors()
.find(|node| cpp_parser::CppDeclarator::can_cast(node.kind().into()))?;
let parameters = declarator
.children()
.find_map(cpp_parser::CppParamList::cast)?;
let text = parameters.syntax().text().to_string();
let after = parameters.syntax().text_range().end();
let declaration = declarator
.ancestors()
.find(|node| cpp_parser::CppDeclaration::can_cast(node.kind().into()))?;
let mut words: Vec<String> = Vec::new();
for element in declaration.descendants_with_tokens() {
let Some(token) = element.as_token() else {
continue;
};
if token.text_range().start() < after {
continue;
}
let word = token.text();
match word {
"const" => words.push("const".to_string()),
"&" | "&&" => words.push(word.to_string()),
"noexcept" if !words.iter().any(|held| held == "noexcept") => {
words.push("noexcept".to_string());
}
_ => {}
}
}
let qualifiers = if words.is_empty() {
String::new()
} else {
format!(" {}", words.join(" "))
};
Some((text, qualifiers))
}