use cpp_parser::{CppAstNode, CppAstToken, CppExpr, CppTokenKind};
use super::CheckContext;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum Origin {
Local,
StaticLocal,
ByValueParameter,
ReferenceParameter,
Member,
Global,
Temporary,
StringLiteral,
Unknown,
}
pub(crate) struct Borrowed {
pub(crate) kind: Origin,
pub(crate) description: String,
pub(crate) through: Option<&'static str>,
pub(crate) address_of: bool,
}
pub(crate) fn view_name_of(return_type: &str) -> Option<String> {
let return_type = return_type.split('<').next().unwrap_or(return_type);
let mut head = return_type.trim().trim_end_matches('&').trim();
head = head
.trim_start_matches("const ")
.trim_start_matches("volatile ")
.trim();
let base = head.rsplit("::").next()?.trim();
let base = base.trim_end_matches('*').trim();
match base {
"string_view" | "basic_string_view" | "span" | "initializer_list" | "StringRef" => {
Some(base.to_string())
}
_ => None,
}
}
fn is_an_owner(spelling: &str) -> bool {
matches!(
spelling,
"string"
| "wstring"
| "basic_string"
| "vector"
| "deque"
| "list"
| "array"
| "map"
| "set"
| "unordered_map"
| "unordered_set"
| "optional"
| "variant"
| "tuple"
| "pair"
| "unique_ptr"
| "shared_ptr"
| "function"
)
}
pub(crate) fn origin_of(
context: &CheckContext<'_>,
expression: &cpp_parser::CppSyntaxNode,
function_body: &cpp_parser::CppSyntaxNode,
) -> Option<Borrowed> {
let Some(expression_node) = CppExpr::cast(expression.clone()) else {
return Some(unknown(expression.text().to_string()));
};
match &expression_node {
CppExpr::ParenExpr(paren) => origin_of(context, paren.get_expr()?.syntax(), function_body),
CppExpr::NameExpr(name) => {
let description = name.syntax().text().to_string();
let offset = usize::from(name.get_last_name_token()?.get_range().start());
let crate::Known::Yes(binding) =
crate::sema::resolve::definition_at(context.scopes(), context.tree(), offset)
else {
return Some(unknown(description));
};
let Some(scope) = context.scopes().scope(binding.scope) else {
return Some(unknown(description));
};
let inside_the_body = binding.name_range.start_offset
>= usize::from(function_body.text_range().start())
&& binding.name_range.end_offset() <= usize::from(function_body.text_range().end());
let before_the_body =
binding.name_range.start_offset < usize::from(function_body.text_range().start());
let origin = match scope.kind {
crate::ScopeKind::Class => Origin::Member,
crate::ScopeKind::Function if before_the_body => {
if a_parameter_is_a_reference(context, &binding) {
Origin::ReferenceParameter
} else {
Origin::ByValueParameter
}
}
_ if !inside_the_body => Origin::Global,
_ if declared_static(context, &binding) => Origin::StaticLocal,
_ => Origin::Local,
};
Some(Borrowed {
kind: origin,
description,
through: None,
address_of: false,
})
}
CppExpr::MemberExpr(member) => {
let mut borrowed = origin_of(context, member.get_object()?.syntax(), function_body)?;
borrowed.description = member.syntax().text().to_string();
Some(borrowed)
}
CppExpr::IndexExpr(index) => {
let mut borrowed = origin_of(context, index.get_object()?.syntax(), function_body)?;
borrowed.description = index.syntax().text().to_string();
Some(borrowed)
}
CppExpr::ThisExpr(_) => Some(Borrowed {
kind: Origin::Member,
description: "this".to_string(),
through: None,
address_of: false,
}),
CppExpr::UnaryExpr(unary) => {
let operator = unary.get_operator_text();
if operator.as_deref() == Some("&") {
let mut borrowed =
origin_of(context, unary.get_operand()?.syntax(), function_body)?;
borrowed.address_of = true;
borrowed.description = unary.syntax().text().to_string();
return Some(borrowed);
}
if operator.as_deref() == Some("*") {
return Some(unknown(unary.syntax().text().to_string()));
}
Some(temporary(unary.syntax()))
}
CppExpr::CallExpr(call) => {
let callee_name = call
.get_callee()
.and_then(|callee| the_last_name_of(callee.syntax()));
if let Some(callee) = call.get_callee()
&& let Some(receiver) = a_member_access_object(&callee)
{
let mut borrowed = origin_of(context, receiver.syntax(), function_body)?;
borrowed.through = match callee_name.as_deref() {
Some("c_str") => Some("c_str"),
Some("data") => Some("data"),
_ => None,
};
return Some(borrowed);
}
if let Some(name) = callee_name.as_deref() {
if matches!(name, "move" | "forward") {
return origin_of(context, call.get_args().first()?.syntax(), function_body);
}
if view_name_of(name).is_some() {
return match call.get_args().first() {
Some(argument) => origin_of(context, argument.syntax(), function_body),
None => Some(temporary(call.syntax())),
};
}
if is_an_owner(name) {
return Some(temporary(call.syntax()));
}
}
Some(unknown(call.syntax().text().to_string()))
}
CppExpr::InitListExpr(list) => {
if list.get_constructed_type().is_some() {
return Some(temporary(list.syntax()));
}
match list.get_elements().next() {
Some(element) => origin_of(context, element.syntax(), function_body),
None => Some(temporary(list.syntax())),
}
}
CppExpr::LiteralExpr(literal) => {
let is_string = literal
.get_literal_token()
.is_some_and(|token| token.get_token_kind() == CppTokenKind::StringLiteral);
Some(Borrowed {
kind: if is_string {
Origin::StringLiteral
} else {
Origin::Temporary
},
description: literal.syntax().text().to_string(),
through: None,
address_of: false,
})
}
_ => Some(unknown(expression.text().to_string())),
}
}
fn a_parameter_is_a_reference(context: &CheckContext<'_>, binding: &crate::Binding) -> bool {
let start = binding.range.start_offset;
let end = binding.range.end_offset();
let parameter = context
.own::<cpp_parser::CppParam>()
.filter(|parameter| {
let range = parameter.syntax().text_range();
usize::from(range.start()) <= start && end <= usize::from(range.end())
})
.max_by_key(|parameter| usize::from(parameter.syntax().text_range().start()));
parameter
.and_then(|parameter| parameter.get_declarator())
.is_some_and(|declarator| declarator.is_a_reference())
}
fn unknown(description: String) -> Borrowed {
Borrowed {
kind: Origin::Unknown,
description,
through: None,
address_of: false,
}
}
fn temporary(expression: &cpp_parser::CppSyntaxNode) -> Borrowed {
Borrowed {
kind: Origin::Temporary,
description: expression.text().to_string(),
through: None,
address_of: false,
}
}
fn declared_static(context: &CheckContext<'_>, binding: &crate::Binding) -> bool {
let name_start = binding.name_range.start_offset;
let declaration = context
.own::<cpp_parser::CppDeclaration>()
.filter(|declaration| {
let range = declaration.syntax().text_range();
usize::from(range.start()) <= name_start && name_start < usize::from(range.end())
})
.max_by_key(|declaration| usize::from(declaration.syntax().text_range().start()));
let Some(declaration) = declaration else {
return false;
};
declaration.get_decl_specifiers().is_some_and(|specifiers| {
specifiers.has_keyword(CppTokenKind::StaticKeyword)
|| specifiers.has_keyword(CppTokenKind::ThreadLocalKeyword)
})
}
fn a_member_access_object(expression: &CppExpr) -> Option<CppExpr> {
match expression {
CppExpr::MemberExpr(member) => member.get_object(),
CppExpr::IndexExpr(index) if index.is_a_member_access() => index.get_object(),
_ => None,
}
}
fn the_last_name_of(expression: &cpp_parser::CppSyntaxNode) -> Option<String> {
match CppExpr::cast(expression.clone())? {
CppExpr::NameExpr(name) => name
.get_last_name_token()
.map(|token| token.get_name_text().to_string()),
CppExpr::MemberExpr(member) => member
.get_member_name()
.map(|token| token.get_name_text().to_string()),
CppExpr::IndexExpr(index) => index
.get_member_name()
.map(|token| token.get_name_text().to_string()),
_ => None,
}
}