use super::*;
pub(crate) fn range_for_element_type(
memo: &TypeMemo,
index: &ProjectIndex,
declaring: &mut dyn FnMut(&Path) -> Option<crate::FileView>,
scopes: &crate::ScopeTree,
root: &cpp_parser::CppSyntaxNode,
path: &Path,
named: &NamedDeclaration,
depth: usize,
) -> Option<Known<Type>> {
let NamedDeclaration::Here(binding) = named else {
return None;
};
let declared_at = binding.name_range.start_offset;
let loop_node = cpp_parser::token_at(root, declared_at)?
.parent_ancestors()
.find(|node| {
cpp_parser::CppSyntaxKind::from(node.kind()) == cpp_parser::CppSyntaxKind::RangeForStat
})?;
if !is_in_the_head_of(&loop_node, declared_at) {
return None;
}
let range = range_expression_of_the_pattern(&loop_node)?;
if let Some(element) = element_of_a_range_expression(
memo,
index,
declaring,
scopes,
root,
path,
&range,
depth + 1,
) {
return Some(element.map(|(type_of, _)| type_of));
}
let Known::Yes((container, _)) = type_of_expression_memoed(
memo,
&crate::sema::declarations::ShapeTable::new(),
index,
declaring,
scopes,
root,
path,
&range,
depth + 1,
) else {
return Some(Known::Unknown(UnknownReason::UnknownType(Box::from(
"auto",
))));
};
Some(match range_element_of(as_a_range(&container)) {
Some(element) => Known::Yes(crate::sema::types::parse_type_spelling(&element)),
None => Known::Unknown(UnknownReason::UnknownType(Box::from(container.to_string()))),
})
}
pub(crate) fn element_of_a_range_expression(
memo: &TypeMemo,
index: &ProjectIndex,
declaring: &mut dyn FnMut(&Path) -> Option<crate::FileView>,
scopes: &crate::ScopeTree,
root: &cpp_parser::CppSyntaxNode,
path: &Path,
expression: &cpp_parser::CppSyntaxNode,
depth: usize,
) -> Option<Known<(Type, PathBuf)>> {
use cpp_parser::CppAstNode;
if let Some((left, right)) = the_two_operands_of_a_pipe(expression)
&& let Some(left_element) = element_of_a_range_expression(
memo,
index,
declaring,
scopes,
root,
path,
&left,
depth + 1,
)
{
return Some(adapted_element(
&left_element,
&right,
index,
scopes,
root,
path,
));
}
if CppSyntaxKind::from(expression.kind()) != CppSyntaxKind::BinaryExpr
&& a_call_to_a_function(expression).is_none()
&& let Known::Yes((container, file)) = type_of_expression_memoed(
memo,
&crate::sema::declarations::ShapeTable::new(),
index,
declaring,
scopes,
root,
path,
expression,
depth + 1,
)
&& let Some(element) = range_element_of(as_a_range(&container))
{
return Some(Known::Yes((
crate::sema::types::parse_type_spelling(&element),
file,
)));
}
if depth <= MAX_TYPE_DEPTH
&& cpp_parser::CppNameExpr::cast(expression.clone()).is_some()
&& let Some(initializer) = the_initializer_a_name_binds(expression, scopes, root)
&& let Some(element) = element_of_a_range_expression(
memo,
index,
declaring,
scopes,
root,
path,
&initializer,
depth + 1,
)
{
return Some(element);
}
if let Some(callee) = a_call_to_a_function(expression) {
let written = callee.text().to_string();
let written = written.trim();
let name = written.rsplit("::").next().unwrap_or(written);
if name == "iota" {
let arguments = crate::sema::call_syntax::arguments_of(expression).unwrap_or_default();
let first = arguments.first()?;
return Some(
match type_of_expression_memoed(
memo,
&crate::sema::declarations::ShapeTable::new(),
index,
declaring,
scopes,
root,
path,
first,
depth + 1,
) {
Known::Yes((type_of, file)) => Known::Yes((type_of, file)),
_ => Known::Unknown(UnknownReason::UnknownType(Box::from("std::views::iota"))),
},
);
}
if name == "subrange" {
let arguments = crate::sema::call_syntax::arguments_of(expression).unwrap_or_default();
let first = arguments.first()?;
if let Some(element) = element_of_an_iterator_expression(
memo,
index,
declaring,
scopes,
root,
path,
first,
depth + 1,
) {
return Some(element);
}
}
}
None
}
fn the_initializer_a_name_binds(
expression: &cpp_parser::CppSyntaxNode,
scopes: &crate::ScopeTree,
root: &cpp_parser::CppSyntaxNode,
) -> Option<cpp_parser::CppSyntaxNode> {
let at = end_of_the_written_name(expression);
let Known::Yes(binding) = crate::sema::resolve::definition_at(scopes, root, at) else {
return None;
};
let named = NamedDeclaration::Here(binding);
deduction_inputs(root, &named).map(|(_, initializer)| initializer)
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn the_element_a_lambda_parameter_receives(
memo: &TypeMemo,
index: &ProjectIndex,
declaring: &mut dyn FnMut(&Path) -> Option<crate::FileView>,
scopes: &crate::ScopeTree,
root: &cpp_parser::CppSyntaxNode,
path: &Path,
binding: &crate::Binding,
written: &str,
depth: usize,
) -> Option<String> {
use cpp_parser::CppAstNode;
if depth > MAX_TYPE_DEPTH {
return None;
}
let token = cpp_parser::token_at(root, binding.name_range.start_offset)?;
let lambda = token
.parent_ancestors()
.find_map(cpp_parser::CppLambdaExpr::cast)?;
let list = lambda.get_params()?;
let at = binding.name_range.start_offset;
let mut position = None;
for (index, parameter) in list.get_params().enumerate() {
let range = parameter.syntax().text_range();
if usize::from(range.start()) <= at && at < usize::from(range.end()) {
if !parameter.is_auto() {
return None;
}
position = Some(index);
break;
}
}
if position? != 0 {
return None;
}
let call = lambda
.syntax()
.ancestors()
.skip(1)
.find(|node| CppSyntaxKind::from(node.kind()) == CppSyntaxKind::CallExpr)?;
let callee = call.children().next()?;
let callee_text = callee.text().to_string();
let callee_text = callee_text.trim();
const ADAPTORS: [&str; 4] = [
"views::filter",
"views::transform",
"views::take_while",
"views::drop_while",
];
const ALGORITHMS: [&str; 6] = [
"ranges::for_each",
"ranges::find_if",
"ranges::any_of",
"ranges::all_of",
"ranges::none_of",
"ranges::count_if",
];
let is_a_standard_callable = ADAPTORS
.iter()
.chain(ALGORITHMS.iter())
.any(|suffix| callee_text.ends_with(suffix));
if !is_a_standard_callable {
return None;
}
let arguments = crate::sema::call_syntax::arguments_of(&call)?;
let lambda_at = arguments
.iter()
.position(|argument| argument.text_range() == lambda.syntax().text_range())?;
let range = match arguments.len() {
1 => {
let parent = call.parent()?;
let (left, right) = the_two_operands_of_a_pipe(&parent)?;
if right.text_range() != call.text_range() {
return None;
}
left
}
2 if lambda_at == 1 => arguments[0].clone(),
_ => return None,
};
let Some(Known::Yes((element, _))) = element_of_a_range_expression(
memo,
index,
declaring,
scopes,
root,
path,
&range,
depth + 1,
) else {
return None;
};
auto_substituted(written, &element, true)
}
pub(crate) fn the_two_operands_of_a_pipe(
expression: &cpp_parser::CppSyntaxNode,
) -> Option<(cpp_parser::CppSyntaxNode, cpp_parser::CppSyntaxNode)> {
if CppSyntaxKind::from(expression.kind()) != CppSyntaxKind::BinaryExpr {
return None;
}
let is_a_pipe = expression
.children_with_tokens()
.filter_map(|element| element.into_token())
.any(|token| token.text() == "|");
if !is_a_pipe {
return None;
}
let mut operands = expression.children();
let left = operands.next()?;
let right = operands.next()?;
Some((left, right))
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn adapted_element(
element: &Known<(Type, PathBuf)>,
adaptor: &cpp_parser::CppSyntaxNode,
index: &ProjectIndex,
scopes: &crate::ScopeTree,
root: &cpp_parser::CppSyntaxNode,
path: &Path,
) -> Known<(Type, PathBuf)> {
use cpp_parser::CppAstNode;
let Known::Yes((element, file)) = element else {
return element.clone();
};
let written = adaptor.text().to_string();
let written = written.trim();
if written.contains("views::transform") || written.contains("views::transform_view") {
let lambda = adaptor
.descendants()
.find(|child| CppSyntaxKind::from(child.kind()) == CppSyntaxKind::LambdaExpr);
let label = lambda.and_then(|lambda| {
if let Some(label) = crate::sema::declarations::a_lambdas_return_type(
&lambda,
std::slice::from_ref(element),
) {
return Some(label);
}
let lambda = cpp_parser::CppLambdaExpr::cast(lambda)?;
the_member_a_lambdas_return_names(&lambda, element, index, scopes, root, path)
});
return match label {
Some(label) => Known::Yes((
crate::sema::types::parse_type_spelling(&label),
file.clone(),
)),
None => Known::Unknown(UnknownReason::UnknownType(Box::from(
"std::views::transform",
))),
};
}
if written.contains("views::keys") {
return match pair_component(element, 0) {
Some(component) => Known::Yes((component, file.clone())),
None => Known::Unknown(UnknownReason::UnknownType(Box::from("std::views::keys"))),
};
}
if written.contains("views::values") {
return match pair_component(element, 1) {
Some(component) => Known::Yes((component, file.clone())),
None => Known::Unknown(UnknownReason::UnknownType(Box::from("std::views::values"))),
};
}
if written.contains("views::join") {
return match element_of_the_element(element) {
Some(inner) => Known::Yes((inner, file.clone())),
None => Known::Unknown(UnknownReason::UnknownType(Box::from("std::views::join"))),
};
}
Known::Yes((element.clone(), file.clone()))
}
fn the_member_a_lambdas_return_names(
lambda: &cpp_parser::CppLambdaExpr,
element: &Type,
index: &ProjectIndex,
scopes: &crate::ScopeTree,
root: &cpp_parser::CppSyntaxNode,
path: &Path,
) -> Option<String> {
use cpp_parser::CppAstNode;
let body = lambda.get_body()?;
let parameters: Vec<cpp_parser::CppParam> = lambda.get_params()?.get_params().collect();
let mut agreed: Option<String> = None;
for statement in body
.syntax()
.descendants()
.filter_map(cpp_parser::CppReturnStat::cast)
{
if statement
.syntax()
.ancestors()
.take_while(|ancestor| ancestor != body.syntax())
.any(|ancestor| CppSyntaxKind::from(ancestor.kind()) == CppSyntaxKind::LambdaExpr)
{
continue;
}
let expression = statement.get_expr()?;
let access = crate::sema::resolve::member_access_of(expression.syntax())?;
let object = cpp_parser::CppNameExpr::cast(access.object)?.get_name_text()?;
let parameter = parameters
.iter()
.find(|parameter| parameter.get_name_text().as_deref() == Some(object.as_str()))?;
let spelled = if parameter.is_auto() {
element.clone()
} else {
crate::sema::types::parse_type_spelling(¶meter.get_type_text())
};
let class = as_a_range(&spelled).to_string();
let Known::Yes(listed) = members_of(index, scopes, root, path, &class) else {
return None;
};
let Known::Yes(listed) = substituted_members(index, path, &class, Known::Yes(listed))
else {
return None;
};
let member = listed.members.iter().find(|member| {
member.fact.name == access.member && member.fact.kind == crate::DeclKind::Variable
})?;
let written = member.fact.type_of.clone()?.to_string();
match &agreed {
None => agreed = Some(written),
Some(previous) if *previous == written => {}
Some(_) => return None,
}
}
agreed
}
pub(crate) fn pair_component(element: &Type, position: usize) -> Option<Type> {
let Type::Named { name, arguments } = element else {
return None;
};
let plain = name.rsplit("::").next().unwrap_or(name);
if plain != "pair" && plain != "tuple" {
return None;
}
let component = arguments.get(position)?.clone();
Some(strip_a_leading_const(&component))
}
pub(crate) fn strip_a_leading_const(type_of: &Type) -> Type {
let written = type_of.to_string();
match written.strip_prefix("const ") {
Some(rest) => crate::sema::types::parse_type_spelling(rest),
None => type_of.clone(),
}
}
pub(crate) fn element_of_the_element(element: &Type) -> Option<Type> {
let written = element_of(element, 0)?;
Some(crate::sema::types::parse_type_spelling(&written))
}
pub(crate) fn element_of_an_iterator_expression(
memo: &TypeMemo,
index: &ProjectIndex,
declaring: &mut dyn FnMut(&Path) -> Option<crate::FileView>,
scopes: &crate::ScopeTree,
root: &cpp_parser::CppSyntaxNode,
path: &Path,
expression: &cpp_parser::CppSyntaxNode,
depth: usize,
) -> Option<Known<(Type, PathBuf)>> {
if let Some(access) = crate::sema::resolve::member_access_of(expression) {
let written = access.member.clone();
if written == "begin" || written.ends_with(".begin") {
let Known::Yes((container, file)) = type_of_expression_memoed(
memo,
&crate::sema::declarations::ShapeTable::new(),
index,
declaring,
scopes,
root,
path,
&access.object,
depth + 1,
) else {
return None;
};
let element = range_element_of(as_a_range(&container))?;
return Some(Known::Yes((
crate::sema::types::parse_type_spelling(&element),
file,
)));
}
}
if CppSyntaxKind::from(expression.kind()) == CppSyntaxKind::BinaryExpr {
let left = expression.children().next()?;
return element_of_an_iterator_expression(
memo,
index,
declaring,
scopes,
root,
path,
&left,
depth + 1,
);
}
None
}
pub(crate) fn a_call_to_a_function(
expression: &cpp_parser::CppSyntaxNode,
) -> Option<cpp_parser::CppSyntaxNode> {
if CppSyntaxKind::from(expression.kind()) != CppSyntaxKind::CallExpr {
return None;
}
expression.children().next()
}
pub(crate) fn as_a_range(type_of: &Type) -> &Type {
match type_of {
Type::Reference { to, .. } => as_a_range(to),
Type::Qualified { of } => as_a_range(of),
other => other,
}
}
pub(crate) fn range_element_of(container: &Type) -> Option<String> {
let Some(name) = container.class_name() else {
return match container {
Type::Array { of, .. } => Some(of.to_string()),
_ => None,
};
};
let arguments = container.arguments();
let plain = name.rsplit("::").next().unwrap_or(name);
if matches!(
plain,
"map" | "unordered_map" | "multimap" | "unordered_multimap"
) && arguments.len() >= 2
{
return Some(format!(
"std::pair<const {}, {}>",
arguments[0], arguments[1]
));
}
if !arguments.is_empty()
&& matches!(
plain,
"vector"
| "list"
| "deque"
| "forward_list"
| "set"
| "unordered_set"
| "multiset"
| "unordered_multiset"
| "basic_string"
| "string"
| "span"
| "initializer_list"
| "valarray"
)
{
return Some(arguments[0].to_string());
}
if matches!(plain, "array") && !arguments.is_empty() {
return Some(arguments[0].to_string());
}
None
}
pub(crate) fn initializer_type(
memo: &TypeMemo,
index: &ProjectIndex,
declaring: &mut dyn FnMut(&Path) -> Option<crate::FileView>,
scopes: &crate::ScopeTree,
root: &cpp_parser::CppSyntaxNode,
path: &Path,
named: &NamedDeclaration,
depth: usize,
) -> Known<(Type, PathBuf)> {
let Some((_, expression)) = deduction_inputs(root, named) else {
return Known::Unknown(UnknownReason::UnknownType(Box::from("auto")));
};
type_of_expression_memoed(
memo,
&crate::sema::declarations::ShapeTable::new(),
index,
declaring,
scopes,
root,
path,
&expression,
depth,
)
}
pub(crate) fn a_typeof_payload(
root: &cpp_parser::CppSyntaxNode,
named: &NamedDeclaration,
) -> Option<cpp_parser::CppSyntaxNode> {
let NamedDeclaration::Here(binding) = named else {
return None;
};
let declarator = node_covering(root, binding.name_range.start_offset, binding.range)?;
let specifiers = declarator.ancestors().find_map(|node| {
node.children().find(|child| {
cpp_parser::CppSyntaxKind::from(child.kind())
== cpp_parser::CppSyntaxKind::DeclSpecifierSeq
})
})?;
let typeof_node = specifiers.children().find(|child| {
let text = child.text().to_string();
let name = text
.trim()
.split('(')
.next()
.unwrap_or("")
.trim()
.to_string();
matches!(
name.as_str(),
"typeof" | "typeof_unqual" | "__typeof__" | "__typeof" | "__decltype" | "decltype"
)
})?;
typeof_node.children().find(|child| {
!matches!(
cpp_parser::CppSyntaxKind::from(child.kind()),
cpp_parser::CppSyntaxKind::TypeId | cpp_parser::CppSyntaxKind::DeclSpecifierSeq
)
})
}
pub(crate) fn an_unnamed_class_body(
specifiers: &cpp_parser::CppSyntaxNode,
) -> Option<cpp_parser::CppSyntaxNode> {
let body = specifiers.children().find(|child| {
matches!(
cpp_parser::CppSyntaxKind::from(child.kind()),
cpp_parser::CppSyntaxKind::ClassDef
| cpp_parser::CppSyntaxKind::StructDef
| cpp_parser::CppSyntaxKind::UnionDef
)
})?;
let tag = body.children().any(|child| {
cpp_parser::CppSyntaxKind::from(child.kind()) == cpp_parser::CppSyntaxKind::NameExpr
});
(!tag).then_some(body)
}
pub(crate) fn deduction_inputs(
root: &cpp_parser::CppSyntaxNode,
named: &NamedDeclaration,
) -> Option<(String, cpp_parser::CppSyntaxNode)> {
let NamedDeclaration::Here(binding) = named else {
return None;
};
let declarator = node_covering(root, binding.name_range.start_offset, binding.range)?;
let is_an_initializer = |node: &cpp_parser::CppSyntaxNode| {
cpp_parser::CppSyntaxKind::from(node.kind()) == cpp_parser::CppSyntaxKind::Initializer
};
let declarator = if declarator.children().any(|child| is_an_initializer(&child)) {
declarator
} else {
declarator.children().find(|child| {
cpp_parser::CppSyntaxKind::from(child.kind()) == cpp_parser::CppSyntaxKind::Declarator
})?
};
let initializer = declarator
.children()
.find(|child| is_an_initializer(child))?;
let first = initializer.children().next()?;
let expression = if cpp_parser::CppSyntaxKind::from(first.kind())
== cpp_parser::CppSyntaxKind::ArgumentList
{
first.children().next()?
} else {
first
};
let specifiers = declarator
.ancestors()
.find_map(|node| {
node.children().find(|child| {
cpp_parser::CppSyntaxKind::from(child.kind())
== cpp_parser::CppSyntaxKind::DeclSpecifierSeq
})
})
.map(|node| node.text().to_string())
.unwrap_or_default();
let name_range = binding.name_range;
let name = root
.text()
.to_string()
.get(name_range.start_offset..name_range.end_offset())
.unwrap_or_default()
.to_string();
let operators: String = declarator
.children()
.find(|child| {
cpp_parser::CppSyntaxKind::from(child.kind()) == cpp_parser::CppSyntaxKind::Declarator
})
.map(|node| node.text().to_string())
.unwrap_or_default()
.replace(&name, "")
.split_whitespace()
.collect();
Some((
format!("{} {}", specifiers.trim(), operators)
.trim()
.to_string(),
expression,
))
}
pub(crate) fn node_covering(
root: &cpp_parser::CppSyntaxNode,
offset: usize,
range: cpp_parser::SourceRange,
) -> Option<cpp_parser::CppSyntaxNode> {
let matches = |node: &cpp_parser::CppSyntaxNode| {
usize::from(node.text_range().start()) == range.start_offset
&& usize::from(node.text_range().end()) == range.end_offset()
};
let mut node = root.clone();
loop {
if matches(&node) {
return Some(node);
}
let next = node
.children_with_tokens()
.find(|element| {
element.as_node().is_some_and(|child| {
let start = usize::from(child.text_range().start());
let end = usize::from(child.text_range().end());
offset >= start && offset < end
})
})
.and_then(|element| element.into_node())?;
node = next;
}
}
pub(crate) fn auto_substituted(
written: &str,
deduced: &Type,
initializer_is_an_lvalue: bool,
) -> Option<String> {
if written.trim() == "decltype(auto)" {
return Some(deduced.to_string().trim().to_string());
}
let deduced = deduced.to_string();
let deduced = deduced.as_str();
let is_word = |byte: u8| byte.is_ascii_alphanumeric() || byte == b'_';
let bytes = written.as_bytes();
let mut at = 0usize;
let mut found = None;
while at < bytes.len() {
if !is_word(bytes[at]) {
at += 1;
continue;
}
let start = at;
while at < bytes.len() && is_word(bytes[at]) {
at += 1;
}
if matches!(&written[start..at], "auto" | "__auto_type") {
found = Some((start, at));
break;
}
}
let (start, end) = found?;
let prefix: String = written[..start]
.split_whitespace()
.filter(|word| {
!matches!(
*word,
"static"
| "inline"
| "constexpr"
| "consteval"
| "constinit"
| "extern"
| "thread_local"
| "mutable"
| "register"
)
})
.collect::<Vec<_>>()
.join(" ");
let prefix = prefix.as_str();
let suffix = written[end..].trim();
let mut base = deduced.trim().to_string();
for _ in 0..suffix.matches('*').count() {
base = pointee_type_name(&base)?.to_string();
}
if !suffix.contains('&') {
while base.ends_with('&') {
base.pop();
base = base.trim_end().to_string();
}
for qualifier in ["const ", "volatile "] {
if let Some(rest) = base.strip_prefix(qualifier) {
base = rest.trim_start().to_string();
}
}
}
let mut reference = "";
if suffix.contains('&') {
let deduced_had_one = base.ends_with("&&") || base.ends_with('&');
if deduced_had_one {
let trimmed = base.trim_end_matches('&').trim_end().len();
base.truncate(trimmed);
base = base.trim_end().to_string();
}
reference = match (
suffix.contains("&&"),
deduced_had_one || initializer_is_an_lvalue,
) {
(true, false) => "&&",
_ => "&",
};
}
let stars = "*".repeat(suffix.matches('*').count());
let mut type_of = String::new();
if !prefix.is_empty() {
type_of.push_str(prefix);
type_of.push(' ');
}
type_of.push_str(base.trim());
type_of.push_str(&stars);
type_of.push_str(reference);
Some(type_of)
}
pub(crate) fn is_a_placeholder(written: &str) -> bool {
matches!(
written.trim(),
"auto" | "auto&" | "auto&&" | "const auto" | "const auto&" | "decltype(auto)"
)
}
pub(crate) fn what_a_call_has_in(fact: &DeclFact) -> Option<Type> {
match fact.kind {
crate::DeclKind::Type => Some(Type::named(fact.qualified_name())),
_ => fact
.returns
.as_deref()
.filter(|written| !is_a_placeholder(written))
.map(parse_type_spelling),
}
}
pub(crate) fn written_like_a_macro(word: &str) -> bool {
word.starts_with('_')
|| (word.len() > 1
&& word
.chars()
.all(|character| !character.is_alphabetic() || character.is_uppercase()))
}
pub(crate) fn structured_binding_type(
memo: &TypeMemo,
index: &ProjectIndex,
declaring: &mut dyn FnMut(&Path) -> Option<crate::FileView>,
scopes: &crate::ScopeTree,
root: &cpp_parser::CppSyntaxNode,
path: &Path,
expression: &cpp_parser::CppSyntaxNode,
depth: usize,
) -> Option<Known<(Type, PathBuf)>> {
let at = end_of_the_written_name(expression);
let Known::Yes(binding) = crate::sema::resolve::definition_at(scopes, root, at) else {
return None;
};
if binding.kind != crate::BindingKind::Variable {
return None;
}
let declared_at = binding.name_range.start_offset;
let pattern = cpp_parser::token_at(root, declared_at)?
.parent_ancestors()
.find(|node| {
cpp_parser::CppSyntaxKind::from(node.kind())
== cpp_parser::CppSyntaxKind::StructuredBinding
})?;
let mut position = None;
let mut seen = 0usize;
for child in pattern.children() {
if cpp_parser::CppSyntaxKind::from(child.kind()) != cpp_parser::CppSyntaxKind::NameExpr {
continue;
}
let range = cpp_parser::source_range(child.text_range());
if range.start_offset == declared_at {
position = Some(seen);
break;
}
seen += 1;
}
let position = position?;
let container = match range_expression_of_the_pattern(&pattern) {
Some(range) => type_of_expression_memoed(
memo,
&crate::sema::declarations::ShapeTable::new(),
index,
declaring,
scopes,
root,
path,
&range,
depth + 1,
),
None => {
let initializer = initializer_of_the_pattern(&pattern)?;
type_of_expression_memoed(
memo,
&crate::sema::declarations::ShapeTable::new(),
index,
declaring,
scopes,
root,
path,
&initializer,
depth + 1,
)
}
};
let Known::Yes((container, file)) = container else {
return Some(container);
};
let element = element_of(&container, position).or_else(|| {
let Type::Named { name, .. } = &container else {
return None;
};
let wanted = match position {
0 => "first",
1 => "second",
_ => return None,
};
let Known::Yes(listed) = members_of(index, scopes, root, path, name) else {
return None;
};
let Known::Yes(listed) =
substituted_members(index, path, &container.to_string(), Known::Yes(listed))
else {
return None;
};
listed
.members
.iter()
.find(|member| {
member.fact.name == wanted && member.fact.kind == crate::DeclKind::Variable
})
.and_then(|member| member.fact.type_of.clone().map(|target| target.to_string()))
});
Some(match element {
Some(element) => Known::Yes((crate::sema::types::parse_type_spelling(&element), file)),
None => Known::Unknown(UnknownReason::UnknownType(Box::from(container.to_string()))),
})
}
pub(crate) fn is_in_the_head_of(loop_node: &cpp_parser::CppSyntaxNode, offset: usize) -> bool {
use cpp_parser::{CppSyntaxElement, CppTokenKind};
let mut colon = None;
for child in loop_node.children_with_tokens() {
let CppSyntaxElement::Token(token) = child else {
continue;
};
if CppTokenKind::from(token.kind()) == CppTokenKind::Colon {
colon = Some(usize::from(token.text_range().start()));
break;
}
}
colon.is_some_and(|colon| offset < colon)
}
pub(crate) fn range_expression_of_the_pattern(
binding: &cpp_parser::CppSyntaxNode,
) -> Option<cpp_parser::CppSyntaxNode> {
use cpp_parser::CppTokenKind;
let loop_node = binding.ancestors().find(|node| {
cpp_parser::CppSyntaxKind::from(node.kind()) == cpp_parser::CppSyntaxKind::RangeForStat
})?;
let mut after_the_colon = false;
for child in loop_node.children_with_tokens() {
match child {
cpp_parser::CppSyntaxElement::Token(token) => {
if CppTokenKind::from(token.kind()) == CppTokenKind::Colon {
after_the_colon = true;
}
}
cpp_parser::CppSyntaxElement::Node(node) => {
if after_the_colon && node != *binding {
return Some(node);
}
}
}
}
None
}
pub(crate) fn initializer_of_the_pattern(
pattern: &cpp_parser::CppSyntaxNode,
) -> Option<cpp_parser::CppSyntaxNode> {
use cpp_parser::CppTokenKind;
let holders: Vec<cpp_parser::CppSyntaxNode> = pattern
.ancestors()
.take_while(|node| {
!matches!(
cpp_parser::CppSyntaxKind::from(node.kind()),
cpp_parser::CppSyntaxKind::FunctionDef | cpp_parser::CppSyntaxKind::TranslationUnit
)
})
.filter(|node| {
matches!(
cpp_parser::CppSyntaxKind::from(node.kind()),
cpp_parser::CppSyntaxKind::InitDeclarator | cpp_parser::CppSyntaxKind::Declaration
)
})
.collect();
for holder in holders {
let mut after_the_equals = false;
for child in holder.children_with_tokens() {
match child {
cpp_parser::CppSyntaxElement::Token(token) => {
if CppTokenKind::from(token.kind()) == CppTokenKind::Assign {
after_the_equals = true;
}
}
cpp_parser::CppSyntaxElement::Node(node) if after_the_equals => return Some(node),
cpp_parser::CppSyntaxElement::Node(_) => {}
}
}
}
None
}
pub(crate) fn element_of(container: &Type, position: usize) -> Option<String> {
let Type::Named { name, arguments } = container else {
return match container {
Type::Array { of, .. } => Some(of.to_string()),
_ => None,
};
};
let plain = name.rsplit("::").next().unwrap_or(name);
if matches!(
plain,
"map" | "unordered_map" | "multimap" | "unordered_multimap"
) && arguments.len() == 2
{
return match position {
0 => Some(format!("const {}", arguments[0])),
_ => Some(arguments[1].to_string()),
};
}
if matches!(plain, "array") && arguments.len() == 2 {
return Some(arguments[0].to_string());
}
if arguments.len() == 1
&& matches!(
plain,
"vector"
| "list"
| "deque"
| "forward_list"
| "set"
| "unordered_set"
| "multiset"
| "unordered_multiset"
| "basic_string"
| "string"
| "span"
| "initializer_list"
| "valarray"
)
{
return Some(arguments[0].to_string());
}
if matches!(plain, "pair" | "tuple") {
return arguments
.get(position)
.map(|component| component.to_string());
}
None
}
pub(crate) fn writes_a_name(written: &str) -> bool {
let spelling = written.strip_prefix("::").unwrap_or(written);
if spelling.contains('(')
|| spelling.contains(')')
|| spelling.contains(',')
|| spelling.contains('{')
|| spelling.contains('}')
{
return false;
}
!spelling.is_empty()
&& spelling
.split("::")
.all(|segment| {
let bare = segment.split('<').next().unwrap_or(segment);
let mut words = bare.split_whitespace();
words.clone().count() > 0 && words.all(is_an_identifier)
})
}
pub(crate) fn is_an_identifier(segment: &str) -> bool {
!segment.is_empty()
&& segment
.chars()
.all(|character| character.is_alphanumeric() || character == '_')
}
pub(crate) fn deduce_the_parameters(
names: &[String],
written_list: Option<&str>,
argument_types: &[Type],
) -> Vec<Type> {
let mut deduced: Vec<Type> = names.iter().map(Type::named).collect();
if names.is_empty() || argument_types.is_empty() {
return deduced;
}
let Some(list) = written_list else {
return deduced;
};
for (at, parameter) in written_parameters(list).into_iter().enumerate() {
let words: Vec<&str> = parameter.split_whitespace().collect();
let written_type = match words.len() {
0 => continue,
1 => words[0],
_ => {
¶meter[..parameter
.rfind(words[words.len() - 1])
.unwrap_or(parameter.len())]
}
};
let written_type = written_type.trim();
if written_type.is_empty() {
continue;
}
let bare = written_type
.strip_suffix("&&")
.or_else(|| written_type.strip_suffix('&'))
.map(str::trim)
.unwrap_or(written_type);
let Some(name_at) = names.iter().position(|name| name == bare) else {
continue;
};
let Some(argument) = argument_types.get(at) else {
continue;
};
deduced[name_at] = argument.clone();
}
deduced
}
pub(crate) fn written_parameters(list: &str) -> Vec<String> {
let body = list.trim();
let body = body.strip_prefix('(').unwrap_or(body);
let body = body.strip_suffix(')').unwrap_or(body);
let mut out = Vec::new();
let mut depth = 0usize;
let mut at = 0usize;
for (index, character) in body.char_indices() {
match character {
'(' | '[' | '<' => depth += 1,
')' | ']' | '>' => depth = depth.saturating_sub(1),
',' if depth == 0 => {
out.push(body[at..index].to_string());
at = index + 1;
}
_ => {}
}
}
out.push(body[at..].to_string());
out
}
pub(crate) fn end_of_the_written_name(expression: &cpp_parser::CppSyntaxNode) -> usize {
let mut last = None;
for element in expression.descendants_with_tokens() {
let Some(token) = element.into_token() else {
continue;
};
if cpp_parser::CppTokenKind::from(token.kind()) != cpp_parser::CppTokenKind::Identifier {
continue;
}
if token
.parent_ancestors()
.any(|node| CppSyntaxKind::from(node.kind()) == CppSyntaxKind::TemplateArgumentList)
{
continue;
}
last = Some(usize::from(token.text_range().start()));
}
last.unwrap_or_else(|| usize::from(expression.text_range().start()))
}