use cpp_parser::CppAstNode;
use cpp_parser::{CppDeclaration, CppTemplateDecl};
use crate::sema::types::parse_type_spelling;
use crate::{DeclFact, DeclKind, DeclModifiers};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Parameter {
pub ty: String,
pub name: Option<String>,
pub default: Option<String>,
pub variadic: bool,
}
impl Parameter {
fn said(&self) -> String {
if self.variadic && self.ty.is_empty() {
return "...".to_string();
}
let mut out = self.ty.clone();
if let Some(name) = &self.name {
if !out.is_empty() {
out.push(' ');
}
out.push_str(name);
}
if let Some(default) = &self.default {
out.push_str(" = ");
out.push_str(default);
}
out
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TemplateParameter {
pub keyword: String,
pub name: String,
pub default: Option<String>,
pub pack: bool,
pub is_type: bool,
}
pub fn an_item(
fact: &DeclFact,
syntax: Option<&CppDeclaration>,
value: Option<i64>,
) -> Vec<String> {
let mut lines = Vec::new();
if let Some(reflection) = &fact.reflection {
lines.push(reflection.said());
}
if let Some(head) = a_template_head(fact, syntax) {
lines.push(head);
}
lines.push(a_line(fact, syntax, value));
lines
}
pub fn a_line(fact: &DeclFact, syntax: Option<&CppDeclaration>, value: Option<i64>) -> String {
match fact.kind {
DeclKind::Function => a_function(fact),
DeclKind::Type if fact.type_of.is_some() => {
format!(
"using {} = {}{};",
fact.name,
the_written_qualifiers(syntax),
a_type(fact.type_of.as_deref().unwrap_or(""))
)
}
DeclKind::Type => a_class(fact, syntax),
DeclKind::Variable => a_variable(fact, value, syntax),
DeclKind::Namespace => match &fact.type_of {
Some(target) => format!("namespace {} = {target}", fact.name),
None => format!("namespace {}", fact.name),
},
DeclKind::MacroLike | DeclKind::Other => a_variable(fact, value, syntax),
}
}
fn a_template_head(fact: &DeclFact, syntax: Option<&CppDeclaration>) -> Option<String> {
if let Some(syntax) = syntax
&& let Some(head) = syntax.child::<CppTemplateDecl>()
&& let Some(list) = head.get_param_list()
{
let parameters: Vec<TemplateParameter> = list
.get_params()
.map(|parameter| a_template_parameter(¶meter))
.collect();
if !parameters.is_empty() {
return Some(a_head(¶meters));
}
}
if fact.scope.is_some() || fact.parameters.is_empty() {
return None;
}
let parameters: Vec<TemplateParameter> = fact
.parameters
.iter()
.enumerate()
.filter(|(_, name)| !name.is_empty())
.map(|(at, name)| TemplateParameter {
keyword: "class".to_string(),
name: name.clone(),
default: fact
.parameter_defaults
.get(at)
.filter(|default| !default.trim().is_empty())
.map(|default| a_default(default)),
pack: false,
is_type: true,
})
.collect();
(!parameters.is_empty()).then(|| a_head(¶meters))
}
fn a_head(parameters: &[TemplateParameter]) -> String {
let said: Vec<String> = parameters.iter().map(a_template_parameter_said).collect();
format!("template <{}>", said.join(", "))
}
fn a_template_parameter_said(parameter: &TemplateParameter) -> String {
let mut out = parameter.keyword.clone();
if parameter.pack {
out.push_str("...");
}
if !parameter.name.is_empty() {
out.push(' ');
out.push_str(¶meter.name);
}
if let Some(default) = ¶meter.default {
out.push_str(" = ");
out.push_str(default);
}
out
}
fn a_template_parameter(parameter: &cpp_parser::CppTemplateParam) -> TemplateParameter {
let written = parameter.syntax().text().to_string();
let name = parameter
.get_name()
.map(|name| name.get_name_text().to_string())
.unwrap_or_default();
let (declared, default) = match split_at_a_top_level_default(&written) {
Some((declared, default)) => (declared, Some(a_default(default))),
None => (written.as_str(), None),
};
let declared = declared.trim_end();
let pack = declared.contains("...");
let is_type = parameter.is_type_param();
let keyword = if is_type {
if declared.trim_start().starts_with("typename") {
"typename".to_string()
} else {
"class".to_string()
}
} else {
let before_the_name = match declared.find(&name) {
Some(at) if !name.is_empty() => &declared[..at],
_ => declared,
};
a_type(before_the_name.trim_end().trim_end_matches('.').trim_end())
};
TemplateParameter {
keyword,
name,
default,
pack,
is_type,
}
}
fn a_function(fact: &DeclFact) -> String {
let mut out = String::new();
for (bit, word) in [
(DeclModifiers::STATIC, "static "),
(DeclModifiers::INLINE, "inline "),
(DeclModifiers::CONSTEXPR, "constexpr "),
(DeclModifiers::CONSTEVAL, "consteval "),
(DeclModifiers::CONSTINIT, "constinit "),
(DeclModifiers::VIRTUAL, "virtual "),
(DeclModifiers::EXPLICIT, "explicit "),
] {
if fact.modifiers.bits() & bit.bits() != 0 {
out.push_str(word);
}
}
if let Some(returns) = fact
.returns
.as_deref()
.filter(|returns| !returns.trim().is_empty())
{
out.push_str(&a_type(returns));
out.push(' ');
}
out.push_str(&fact.name);
match fact.parameter_list.as_deref() {
Some(list) => {
let parameters: Vec<String> = parameters(list).iter().map(Parameter::said).collect();
out.push('(');
out.push_str(¶meters.join(", "));
out.push(')');
}
None => out.push_str("(…)"),
}
out.push_str(&a_trailing(fact));
out
}
fn a_trailing(fact: &DeclFact) -> String {
let mut out = String::new();
for (bit, word) in [
(DeclModifiers::CONST, " const"),
(DeclModifiers::VOLATILE, " volatile"),
(DeclModifiers::RVALUE_REFERENCE, " &&"),
(DeclModifiers::LVALUE_REFERENCE, " &"),
(DeclModifiers::OVERRIDE, " override"),
(DeclModifiers::FINAL, " final"),
] {
if fact.modifiers.bits() & bit.bits() != 0 {
out.push_str(word);
}
}
if fact.modifiers.bits() & DeclModifiers::DELETED.bits() != 0 {
out.push_str(" = delete");
} else if fact.modifiers.bits() & DeclModifiers::DEFAULTED.bits() != 0 {
out.push_str(" = default");
}
if let Some(clause) = fact
.requires_clause
.as_deref()
.filter(|clause| !clause.trim().is_empty())
{
out.push(' ');
if !clause.trim_start().starts_with("requires") {
out.push_str("requires ");
}
out.push_str(clause.trim());
}
out
}
fn a_class(fact: &DeclFact, syntax: Option<&CppDeclaration>) -> String {
let keyword = syntax.and_then(a_class_keyword);
let mut out = String::new();
if let Some(keyword) = keyword {
out.push_str(&keyword);
out.push(' ');
}
out.push_str(&fact.name);
let bases: Vec<String> = fact
.bases
.iter()
.filter(|base| !base.trim().is_empty())
.map(|base| a_type(base))
.collect();
if !bases.is_empty() {
out.push_str(" : ");
out.push_str(&bases.join(", "));
}
out
}
fn a_class_keyword(declaration: &CppDeclaration) -> Option<String> {
if let Some(class) = declaration.get_class_def() {
return Some(
match (class.is_struct(), class.is_union()) {
(true, _) => "struct",
(_, true) => "union",
_ => "class",
}
.to_string(),
);
}
if let Some(enumeration) = declaration.get_enum_def() {
return Some(match enumeration.is_scoped() {
true => "enum class".to_string(),
false => "enum".to_string(),
});
}
None
}
fn a_variable(fact: &DeclFact, value: Option<i64>, syntax: Option<&CppDeclaration>) -> String {
let mut out = String::new();
for (bit, word) in [
(DeclModifiers::STATIC, "static "),
(DeclModifiers::INLINE, "inline "),
(DeclModifiers::CONSTEXPR, "constexpr "),
(DeclModifiers::CONSTEVAL, "consteval "),
] {
if fact.modifiers.bits() & bit.bits() != 0 {
out.push_str(word);
}
}
if let Some(ty) = fact.type_of.as_deref().filter(|ty| !ty.trim().is_empty()) {
out.push_str(the_written_qualifiers(syntax));
out.push_str(&a_type(ty));
out.push(' ');
}
out.push_str(&fact.name);
if let Some(value) = value {
out.push_str(&format!(" = {value}"));
}
out
}
fn the_written_qualifiers(syntax: Option<&CppDeclaration>) -> &'static str {
let Some(specifiers) = syntax.and_then(|declaration| declaration.get_decl_specifiers()) else {
return "";
};
use cpp_parser::CppTokenKind;
let volatile = specifiers.has_keyword(CppTokenKind::VolatileKeyword);
let constant = specifiers.has_keyword(CppTokenKind::ConstKeyword);
match (constant, volatile) {
(true, true) => "const volatile ",
(true, false) => "const ",
(false, true) => "volatile ",
(false, false) => "",
}
}
pub fn a_type(written: &str) -> String {
let written = written.trim();
if written.is_empty() {
return String::new();
}
parse_type_spelling(written).to_string()
}
pub fn parameters(written: &str) -> Vec<Parameter> {
let inner = written.trim();
let inner = inner.strip_prefix('(').unwrap_or(inner);
let inner = inner.strip_suffix(')').unwrap_or(inner);
split_at_top_level_commas(inner)
.into_iter()
.map(|parameter| a_parameter(parameter.trim()))
.collect()
}
fn a_parameter(written: &str) -> Parameter {
if written.is_empty() {
return Parameter {
ty: String::new(),
name: None,
default: None,
variadic: false,
};
}
if written == "..." || written == "…" {
return Parameter {
ty: String::new(),
name: None,
default: None,
variadic: true,
};
}
let (declared, default) = match split_at_a_top_level_default(written) {
Some((declared, default)) => (declared, Some(a_default(default))),
None => (written, None),
};
let declared = declared.trim();
let (ty, name) = a_type_and_its_name(declared);
Parameter {
ty,
name,
default,
variadic: false,
}
}
fn a_type_and_its_name(written: &str) -> (String, Option<String>) {
if let Some(name) = a_name_in_parentheses(written) {
return (a_type(written), Some(name));
}
let words: Vec<(usize, &str)> = identifier_runs(written);
let Some((at, last)) = words.last().copied() else {
return (a_type(written), None);
};
if is_a_keyword(last) {
return (a_type(written), None);
}
let after = written[at + last.len()..].trim();
let before = &written[..at];
let follows_a_type = before.ends_with(char::is_whitespace)
|| before.trim_end().ends_with(['*', '&', '>', ']', ')']);
let is_not_qualified = !before.trim_end().ends_with("::");
let is_a_declarator_end = after.is_empty() || after.starts_with('[');
if follows_a_type && is_not_qualified && is_a_declarator_end {
let ty = written[..at].trim();
(a_type(ty), Some(last.to_string()))
} else {
(a_type(written), None)
}
}
fn a_name_in_parentheses(written: &str) -> Option<String> {
let open = written.find("(*")?;
let rest = &written[open + 2..];
let close = rest.find(')')?;
let inside = rest[..close].trim();
let name = inside.trim_start_matches(['&', '*']).trim();
(!name.is_empty()
&& name
.chars()
.all(|character| character.is_alphanumeric() || character == '_'))
.then(|| name.to_string())
}
fn identifier_runs(written: &str) -> Vec<(usize, &str)> {
let mut runs = Vec::new();
let mut start = None;
for (at, character) in written.char_indices() {
match (character.is_alphanumeric() || character == '_', start) {
(true, None) => start = Some(at),
(false, Some(from)) => {
runs.push((from, &written[from..at]));
start = None;
}
_ => {}
}
}
if let Some(from) = start {
runs.push((from, &written[from..]));
}
runs
}
fn is_a_keyword(word: &str) -> bool {
matches!(
word,
"const"
| "volatile"
| "constexpr"
| "consteval"
| "constinit"
| "static"
| "inline"
| "mutable"
| "unsigned"
| "signed"
| "long"
| "short"
| "int"
| "char"
| "float"
| "double"
| "void"
| "bool"
| "auto"
| "struct"
| "class"
| "union"
| "enum"
| "typename"
)
}
fn a_default(written: &str) -> String {
let written = written.trim();
if written.is_empty() {
return "…".to_string();
}
let single_word = written
.chars()
.all(|character| character.is_alphanumeric() || matches!(character, '_' | '.' | '+' | '-'));
if single_word {
return written.to_string();
}
"…".to_string()
}
fn split_at_top_level_commas(written: &str) -> Vec<&str> {
let mut parts = Vec::new();
let mut depth = 0i32;
let mut start = 0usize;
for (at, character) in written.char_indices() {
match character {
'<' | '(' | '[' => depth += 1,
'>' | ')' | ']' => depth -= 1,
',' if depth == 0 => {
parts.push(&written[start..at]);
start = at + 1;
}
_ => {}
}
}
parts.push(&written[start..]);
parts
}
fn split_at_a_top_level_default(written: &str) -> Option<(&str, &str)> {
let bytes = written.as_bytes();
let mut depth = 0i32;
for (at, byte) in bytes.iter().enumerate() {
match byte {
b'<' | b'(' | b'[' => depth += 1,
b'>' | b')' | b']' => depth -= 1,
b'=' if depth == 0 => {
let before = written[..at].trim_end();
let ends_with_operator = before.ends_with(['=', '!', '<', '>']);
let starts_with_equals = bytes.get(at + 1) == Some(&b'=');
if !ends_with_operator && !starts_with_equals {
return Some((&written[..at], &written[at + 1..]));
}
}
_ => {}
}
}
None
}
#[cfg(test)]
mod tests {
use super::*;
use cpp_parser::{CppParser, ParserConfig};
fn rendered(source: &str, name: &str) -> Vec<String> {
let tree = CppParser::parse(source, ParserConfig::default());
assert_eq!(tree.get_errors(), [], "the fixture must parse cleanly");
let root = tree.get_red_root();
let scopes = crate::sema::scopes::build_scopes(&root, &crate::NoMacroBodies);
let (facts, _) = crate::sema::declarations::build_facts(
&scopes,
&crate::preprocess(source, tree.get_tokens()),
&root,
&[],
true,
);
let fact = facts
.iter()
.find(|fact| fact.name == name)
.unwrap_or_else(|| panic!("{name} must be a fact: {facts:?}"));
let declaration =
cpp_parser::token_at(&root, fact.name_range.start_offset).and_then(|token| {
token
.parent_ancestors()
.find_map(cpp_parser::CppDeclaration::cast)
});
an_item(fact, declaration.as_ref(), None)
}
#[test]
fn a_function_is_rebuilt_from_its_facts() {
let lines = rendered(
"int total(const Widget& w, int scale = 2, ...) const &;\n",
"total",
);
assert_eq!(
lines,
["int total(const Widget& w, int scale = 2, ...) const &"]
);
}
#[test]
fn a_template_head_keeps_its_kinds_and_defaults() {
let lines = rendered(
"template <typename T, typename Alloc = std::allocator<T>>\nclass Box : public Base<T> { };\n",
"Box",
);
assert_eq!(lines[0], "template <typename T, typename Alloc = …>");
assert_eq!(lines[1], "class Box : Base<T>");
}
#[test]
fn a_non_type_parameter_and_a_pack_are_read_from_the_syntax() {
let lines = rendered(
"template <int N, char... Digits>\nconstexpr int count();\n",
"count",
);
assert_eq!(lines[0], "template <int N, char... Digits>");
assert_eq!(lines[1], "constexpr int count()");
}
#[test]
fn a_class_says_its_own_keyword() {
assert_eq!(rendered("struct S { };\n", "S")[0], "struct S");
assert_eq!(rendered("union U { int a; };\n", "U")[0], "union U");
assert_eq!(
rendered("enum class Color { Red };\n", "Color")[0],
"enum class Color"
);
}
#[test]
fn an_alias_is_a_using_line() {
assert_eq!(
rendered("using Size = unsigned long;\n", "Size"),
["using Size = unsigned long;"]
);
assert_eq!(
rendered("typedef const char* Name;\n", "Name"),
["using Name = const char*;"]
);
}
#[test]
fn a_variable_keeps_its_qualifiers() {
assert_eq!(
rendered("static const Widget* first;\n", "first"),
["static const Widget* first"]
);
}
#[test]
fn a_parameter_list_is_parsed() {
let parameters = parameters("(const std::map<int, int>& table, int n = npos, ...)");
assert_eq!(
parameters,
[
Parameter {
ty: "const std::map<int, int>&".to_string(),
name: Some("table".to_string()),
default: None,
variadic: false,
},
Parameter {
ty: "int".to_string(),
name: Some("n".to_string()),
default: Some("npos".to_string()),
variadic: false,
},
Parameter {
ty: String::new(),
name: None,
default: None,
variadic: true,
},
]
);
}
#[test]
fn a_constrained_function_does_not_repeat_its_keyword() {
let lines = rendered(
"template <typename T>\nvoid f(int x) requires (sizeof(T) > 2) {}\n",
"f",
);
assert_eq!(
lines,
[
"template <typename T>",
"void f(int x) requires (sizeof(T) > 2)"
],
"one keyword, as the file writes it"
);
let lines = rendered(
"template <typename Fn>\nvoid g(Fn &&fn) requires requires { fn(1); } { fn(1); }\n",
"g",
);
assert_eq!(
lines,
[
"template <typename Fn>",
"void g(Fn&& fn) requires requires { fn(1); }"
],
"the nested requirement keeps both, and no third"
);
}
#[test]
fn a_type_is_printed_by_the_model() {
assert_eq!(
a_type("std::vector<std::string> &"),
"std::vector<std::string>&"
);
assert_eq!(a_type("const char * const"), "const char*");
assert_eq!(a_type("typename Alloc::value_type"), "Alloc::value_type");
}
}