use super::*;
pub(crate) const MAX_ALIAS_HOPS: usize = 24;
pub(crate) const MAX_ALIAS_PASSES: usize = 4;
pub(crate) fn a_spelling_through_the_aliases(
index: &ProjectIndex,
scopes: &crate::ScopeTree,
root: &cpp_parser::CppSyntaxNode,
path: &Path,
class: &Type,
visited: &[Type],
written: &str,
depth: usize,
) -> String {
a_spelling_through_the_aliases_in(
index,
scopes,
root,
path,
class,
visited,
&[],
written,
depth,
)
}
pub(crate) fn substituted_through(
spelling: &str,
parameters: &[String],
defaults: &[String],
arguments: &[String],
environment: &[(String, String)],
) -> String {
let mut result = spelling.to_string();
for (name, value) in environment {
if name.is_empty() || value.is_empty() {
continue;
}
result = crate::sema::types::substituted_spelling(
&result,
std::slice::from_ref(name),
std::slice::from_ref(value),
);
}
crate::sema::types::substituted_spelling_with_defaults(&result, parameters, defaults, arguments)
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn a_spelling_through_the_aliases_in(
index: &ProjectIndex,
scopes: &crate::ScopeTree,
root: &cpp_parser::CppSyntaxNode,
path: &Path,
class: &Type,
visited: &[Type],
environment: &[(String, String)],
written: &str,
depth: usize,
) -> String {
if depth == 0 {
return written.to_string();
}
let (leading, core, trailing) = split_the_operators_of(written);
let a_name = !core.is_empty()
&& core.chars().all(|character| {
character.is_alphanumeric() || matches!(character, '_' | ':' | '<' | '>' | ',' | ' ')
});
if !a_name {
return written.to_string();
}
let Some(class_name) = class.class_name() else {
return written.to_string();
};
let arguments: Vec<String> = class
.arguments()
.iter()
.map(|one| one.to_string())
.collect();
let parameters = index.template_parameters_for(class_name, path, &arguments);
let defaults = index.template_parameter_defaults_for(class_name, path, &arguments);
let mut here = environment.to_vec();
for (name, value) in parameters.iter().zip(arguments.iter()) {
if !name.is_empty() && !value.is_empty() {
here.push((name.clone(), value.clone()));
}
}
if crate::probes::inference() {
eprintln!(
"[inference] alias step: {written:?} in {class:?} (class {class_name:?}, parameters {parameters:?}, \
arguments {arguments:?})"
);
}
let Some((qualifier, last)) = split_at_the_last_scope(&core) else {
let mut found = None;
for candidate in std::iter::once(class).chain(visited.iter().rev()) {
if let Some(fact) = a_member_the_class_declares(
index,
scopes,
root,
path,
&candidate.to_string(),
&core,
)
&& fact.type_of.is_some()
{
found = Some((candidate.clone(), fact));
break;
}
}
if found.is_none()
&& let Some((named, member)) = the_alias_behind(index, path, &core)
{
let qualified = format!("{named}::{member}");
if qualified != core {
let followed = a_spelling_through_the_aliases(
index,
scopes,
root,
path,
class,
visited,
&qualified,
depth.saturating_sub(1),
);
if followed != core {
return format!("{leading}{followed}{trailing}");
}
}
}
let Some((declared_in, fact)) = found else {
return written.to_string();
};
let Some(target) = fact.type_of.as_deref() else {
return written.to_string();
};
let target = substituted_through(target, ¶meters, &defaults, &arguments, environment);
if target == core {
return written.to_string();
}
let mut deeper = visited.to_vec();
if declared_in.to_string() != class.to_string() {
deeper.push(class.clone());
}
let followed = a_spelling_through_the_aliases_in(
index,
scopes,
root,
path,
&declared_in,
&deeper,
&here,
&target,
depth - 1,
);
if followed != core {
return format!("{leading}{followed}{trailing}");
}
return written.to_string();
};
let qualifier = {
let substituted =
substituted_through(&qualifier, ¶meters, &defaults, &arguments, environment);
if substituted.trim().is_empty() {
qualifier
} else {
substituted
}
};
let inner = a_spelling_through_the_aliases_in(
index,
scopes,
root,
path,
class,
visited,
&here,
&qualifier,
depth - 1,
);
if inner.trim() == qualifier.trim()
&& !matches!(members_of(index, scopes, root, path, &inner), Known::Yes(_))
{
return written.to_string();
}
if names_a_namespace(index, path, &inner) {
return written.to_string();
}
let inner_type = crate::sema::types::parse_type_spelling(&inner);
let Some(inner_name) = inner_type.class_name() else {
return written.to_string();
};
let inner_arguments: Vec<String> = crate::sema::builtins::split_arguments(
inner
.split_once('<')
.map(|(_, rest)| rest.trim_end().strip_suffix('>').unwrap_or(rest))
.unwrap_or_default(),
);
let inner_class = {
let qualified = resolve_aliases(
&crate::sema::declarations::ShapeTable::new(),
index,
scopes,
root,
path,
inner_name,
);
if qualified.is_empty() || qualified == inner_name {
inner_name.to_string()
} else {
qualified
}
};
let inner_parameters = index.template_parameters_for(&inner_class, path, &inner_arguments);
let inner_defaults =
index.template_parameter_defaults_for(&inner_class, path, &inner_arguments);
let (member_name, member_arguments) = the_name_and_its_arguments(&last);
let found = a_member_the_class_declares(index, scopes, root, path, &inner, member_name);
if crate::probes::inference() {
eprintln!(
"[inference] qualified: {written:?} -> qualifier {qualifier:?} resolved {inner:?}, member {member_name:?} \
({member_arguments:?}), fact {:?}",
found
.as_ref()
.map(|fact| (fact.type_of.clone(), fact.pattern(), fact.kind))
);
}
let Some(fact) = found else {
return written.to_string();
};
if fact.kind == crate::DeclKind::Type && fact.type_of.is_none() && !member_arguments.is_empty()
{
let resolved_arguments: Vec<String> = member_arguments
.iter()
.map(|argument| {
substituted_through(argument, ¶meters, &defaults, &arguments, environment)
})
.collect();
let nested = format!(
"{}::{}<{}>",
a_class_name_without_spaces(&inner_class),
member_name,
resolved_arguments.join(", ")
);
return format!("{leading}{nested}{trailing}");
}
let Some(target) = fact.type_of.as_deref() else {
return written.to_string();
};
let (pattern_parameters, pattern_arguments) = fact
.pattern()
.map(|pattern| the_pairing_its_pattern_implies(pattern, &inner_arguments))
.filter(|(parameters, _)| !parameters.is_empty())
.unwrap_or_else(|| (inner_parameters.clone(), inner_arguments.clone()));
let target = substituted_through(
target,
&pattern_parameters,
&inner_defaults,
&pattern_arguments,
environment,
);
let target = if member_arguments.is_empty() {
target
} else {
crate::sema::types::substituted_spelling_with_defaults(
&target,
fact.parameters(),
fact.parameter_defaults(),
&member_arguments,
)
};
let mut deeper = visited.to_vec();
if inner != class.to_string() {
deeper.push(class.clone());
}
let followed = a_spelling_through_the_aliases_in(
index,
scopes,
root,
path,
&inner_type,
&deeper,
&here,
&target,
depth - 1,
);
format!("{leading}{followed}{trailing}")
}
pub(crate) fn a_member_the_class_declares(
index: &ProjectIndex,
scopes: &crate::ScopeTree,
root: &cpp_parser::CppSyntaxNode,
path: &Path,
class: &str,
name: &str,
) -> Option<DeclFact> {
let listed = members_of(index, scopes, root, path, class);
let name = the_member_name(name);
if crate::probes::inference() {
match &listed {
Known::Yes(members) => eprintln!(
"[inference] member of {class:?}: {} listed, {} unlisted, looking for {name:?}",
members.members.len(),
members.unlisted.len()
),
other => eprintln!("[inference] member of {class:?}: {other:?}"),
}
}
let arguments: Vec<String> = class
.split_once('<')
.map(|(_, rest)| {
crate::sema::builtins::split_arguments(
rest.trim_end().strip_suffix('>').unwrap_or(rest),
)
})
.unwrap_or_default();
let parameters = index.template_parameters_for(class, path, &arguments);
if let Some(found) = listed.value().and_then(|members| {
members
.members
.iter()
.filter(|member| member.fact.name == name)
.filter(|member| {
a_pattern_matches(member.fact.pattern(), ¶meters, Some(&arguments))
})
.map(|member| member.fact.clone())
.find(|fact| fact.type_of.is_some())
}) {
return Some(found);
}
direct_member(
&crate::sema::declarations::ShapeTable::new(),
index,
scopes,
root,
path,
class,
name,
None,
)
.map(|(fact, _)| fact)
}
pub(crate) fn the_pairing_its_pattern_implies(
pattern: &str,
written: &[String],
) -> (Vec<String>, Vec<String>) {
let slots = arguments_in_a_spelling(pattern).unwrap_or_default();
let mut parameters = Vec::new();
let mut arguments = Vec::new();
for (at, slot) in slots.iter().enumerate() {
let slot = slot.trim();
let Some(argument) = written.get(at) else {
continue;
};
let a_name = !slot.is_empty()
&& slot
.chars()
.all(|character| character.is_alphanumeric() || character == '_')
&& !matches!(slot, "true" | "false");
if a_name {
parameters.push(slot.to_string());
arguments.push(argument.clone());
}
}
(parameters, arguments)
}
pub(crate) fn split_at_the_last_scope(spelling: &str) -> Option<(String, String)> {
let bytes = spelling.as_bytes();
let mut depth = 0usize;
let mut boundary = None;
let mut at = 0usize;
while at + 1 < bytes.len() {
match bytes[at] {
b'<' => depth += 1,
b'>' => depth = depth.saturating_sub(1),
b':' if depth == 0 && bytes[at + 1] == b':' => {
boundary = Some(at);
at += 1;
}
_ => {}
}
at += 1;
}
let boundary = boundary?;
let qualifier = spelling[..boundary].trim().to_string();
let last = spelling[boundary + 2..].trim().to_string();
(!qualifier.is_empty() && !last.is_empty()).then_some((qualifier, last))
}
pub(crate) fn the_member_name(spelling: &str) -> &str {
let mut rest = spelling.trim();
loop {
let Some((keyword, after)) = ["template", "typename", "class", "struct", "enum"]
.iter()
.find_map(|keyword| rest.strip_prefix(keyword).map(|after| (*keyword, after)))
else {
return rest;
};
if !after.starts_with(char::is_whitespace) && !after.starts_with('<') {
return rest;
}
let _ = keyword;
rest = after.trim_start();
}
}
pub(crate) fn the_name_and_its_arguments(spelling: &str) -> (&str, Vec<String>) {
let name = the_member_name(spelling);
let Some((head, rest)) = name.split_once('<') else {
return (name, Vec::new());
};
let inside = rest.trim_end().strip_suffix('>').unwrap_or(rest);
let arguments = crate::sema::builtins::split_arguments(inside);
(head.trim(), arguments)
}
pub(crate) fn split_the_operators_of(spelling: &str) -> (String, String, String) {
let mut leading = String::new();
let mut rest = spelling.trim();
for qualifier in ["const", "volatile", "constexpr", "static"] {
if let Some(after) = rest.strip_prefix(qualifier)
&& after.starts_with(char::is_whitespace)
{
leading.push_str(qualifier);
leading.push(' ');
rest = after.trim_start();
}
}
loop {
let trimmed = rest.trim_start();
let Some(after) = ["typename", "class", "struct", "union", "enum"]
.iter()
.find_map(|keyword| trimmed.strip_prefix(keyword))
else {
break;
};
if !after.starts_with(char::is_whitespace) {
break;
}
rest = after.trim_start();
}
let trimmed = rest.trim_end();
let mut trailing = String::new();
let mut core = trimmed;
for _ in 0..4 {
if let Some(before) = core
.strip_suffix("&&")
.or_else(|| core.strip_suffix('&'))
.or_else(|| core.strip_suffix('*'))
{
let operator = &core[before.len()..];
trailing.insert_str(0, operator);
core = before.trim_end();
continue;
}
break;
}
(leading, core.to_string(), trailing)
}
pub(crate) fn through_an_operator_arrow(
index: &ProjectIndex,
scopes: &crate::ScopeTree,
root: &cpp_parser::CppSyntaxNode,
path: &Path,
class: &str,
member: &str,
arguments: Option<&[String]>,
) -> Option<(DeclFact, PathBuf)> {
let target = the_class_an_arrow_points_at(index, scopes, root, path, class, arguments)?;
direct_member(
&crate::sema::declarations::ShapeTable::new(),
index,
scopes,
root,
path,
&target,
member,
None,
)
}
pub(crate) fn the_class_an_arrow_points_at(
index: &ProjectIndex,
scopes: &crate::ScopeTree,
root: &cpp_parser::CppSyntaxNode,
path: &Path,
class: &str,
arguments: Option<&[String]>,
) -> Option<String> {
let bare = without_arguments(class).to_string();
let arguments: Vec<String> = arguments
.map(<[String]>::to_vec)
.or_else(|| {
class.split_once('<').map(|(_, rest)| {
crate::sema::builtins::split_arguments(
rest.trim_end().strip_suffix('>').unwrap_or(rest),
)
})
})
.unwrap_or_default();
let (arrow, _) = direct_member(
&crate::sema::declarations::ShapeTable::new(),
index,
scopes,
root,
path,
&bare,
"operator->",
Some(&arguments),
)?;
let arrows_parameters = arrow.parameters().to_vec();
let returns = arrow.returns?;
if crate::probes::inference() {
eprintln!(
"[inference] operator-> of {bare} on arguments {arguments:?}: the member wrote {returns:?}"
);
}
if arguments.is_empty() {
return None;
}
let parameters = index.template_parameters_for(&bare, path, &arguments);
let defaults = index.template_parameter_defaults_for(&bare, path, &arguments);
let class_type = crate::sema::types::parse_type_spelling(class);
let resolved = a_spelling_through_the_aliases(
index,
scopes,
root,
path,
&class_type,
&[],
&returns,
MAX_ALIAS_HOPS,
);
let substituted = crate::sema::types::substituted_spelling_with_defaults(
&resolved,
¶meters,
&defaults,
&arguments,
);
let mut target = base_type_name(&substituted).to_string();
let names_nothing =
index.files_declaring(&target, path).is_empty() && !is_a_builtin_name(&target);
if target.is_empty()
|| target == bare
|| names_nothing
|| arrows_parameters.iter().any(|name| name == &target)
{
let names_a_class = |name: &str| {
let bare = base_type_name(name);
is_a_builtin_name(bare)
|| index.files_declaring(bare, path).iter().any(|found| {
found.fact.kind == crate::DeclKind::Type && found.fact.type_of.is_none()
})
};
let walked = the_element_type_of(index, scopes, root, path, class, &bare, &arguments);
target = match walked {
Some(walked) if names_a_class(&walked) => walked,
_ => match arguments.as_slice() {
[only] if names_a_class(only) => base_type_name(only).to_string(),
_ => target,
},
};
}
if crate::probes::inference() {
eprintln!(
"[inference] operator-> substitution: parameters {parameters:?}, the member's own {arrow_parameters:?}, {returns:?} -> {substituted:?} -> {target:?}",
arrow_parameters = arrows_parameters
);
}
(!target.is_empty() && target != bare).then_some(target)
}
pub(crate) fn is_a_builtin_name(name: &str) -> bool {
matches!(
name,
"int"
| "char"
| "bool"
| "void"
| "float"
| "double"
| "long"
| "short"
| "signed"
| "unsigned"
| "auto"
| "wchar_t"
| "char8_t"
| "char16_t"
| "char32_t"
| "size_t"
)
}
pub fn element_type_of(
index: &ProjectIndex,
scopes: &crate::ScopeTree,
root: &cpp_parser::CppSyntaxNode,
path: &Path,
class: &str,
bare: &str,
arguments: &[String],
) -> Option<String> {
the_element_type_of(index, scopes, root, path, class, bare, arguments)
}
pub(crate) fn the_element_type_of(
index: &ProjectIndex,
scopes: &crate::ScopeTree,
root: &cpp_parser::CppSyntaxNode,
path: &Path,
class: &str,
bare: &str,
arguments: &[String],
) -> Option<String> {
let parameters = index.template_parameters_for(bare, path, arguments);
let through_the_members = an_element_type_through_the_members(
index,
scopes,
root,
path,
class,
¶meters,
arguments,
0,
);
if through_the_members.is_some() {
return through_the_members;
}
let Known::Yes(members) = members_of(index, scopes, root, path, class) else {
if crate::probes::inference() {
eprintln!("[inference] element_type: no member list for {class}");
}
return None;
};
if crate::probes::inference() {
let found: Vec<String> = members
.members
.iter()
.filter(|member| matches!(member.fact.name.as_str(), "element_type" | "value_type"))
.map(|member| {
format!(
"{} kind {:?} type_of {:?}",
member.fact.name, member.fact.kind, member.fact.type_of
)
})
.collect();
eprintln!(
"[inference] element_type: {class} has {} member(s), {found:?}",
members.members.len()
);
}
for name in ["element_type", "value_type"] {
let Some(fact) = members
.members
.iter()
.find(|member| member.fact.name == name)
.map(|member| &member.fact)
else {
continue;
};
let Some(written) = fact.type_of.as_deref() else {
continue;
};
let substituted = crate::sema::types::substituted_spelling(written, ¶meters, arguments);
let target = base_type_name(&substituted).to_string();
if crate::probes::inference() {
eprintln!(
"[inference] element_type: {class}::{name} wrote {written:?} -> {substituted:?} -> {target:?} ({} member(s))",
members.members.len()
);
}
if !target.is_empty()
&& target != bare
&& !parameters.iter().any(|parameter| parameter == &target)
{
return Some(target);
}
}
None
}