use oxc_ast::ast::*;
use super::super::visit_chain_names::is_member_call;
use super::super::{call_receiver_name, static_member_object_name, unwrap_static_expr};
use super::durable_objects::{ReceiverAlias, ResolvedReceiver};
use super::{StructuralParamMemberCollector, THIS_ENV_RECEIVER};
impl StructuralParamMemberCollector {
pub(super) fn resolve_receiver_path(
&self,
object: &Expression<'_>,
allow_call_arguments: bool,
) -> Option<(String, String)> {
self.resolve_receiver(object, allow_call_arguments)
.map(|receiver| (receiver.param, receiver.path))
}
fn resolve_receiver(
&self,
object: &Expression<'_>,
allow_call_arguments: bool,
) -> Option<ResolvedReceiver> {
self.resolve_receivers(object, allow_call_arguments)
.into_iter()
.next()
}
fn resolve_receivers(
&self,
object: &Expression<'_>,
allow_call_arguments: bool,
) -> Vec<ResolvedReceiver> {
let object_path = if allow_call_arguments {
call_receiver_name(object)
} else {
static_member_object_name(object)
};
let Some(object_path) = object_path else {
return Vec::new();
};
let (root, suffix) = self.receiver_root(&object_path);
for (aliases, shadowed) in self.alias_stack.iter().zip(&self.shadowed_stack).rev() {
if let Some(alias) = aliases.get(root) {
return std::iter::once(&alias.target)
.chain(&alias.alternatives)
.map(|(param, alias_path)| ResolvedReceiver {
param: param.clone(),
path: join_receiver_path(alias_path, suffix),
via_stub: alias.stub,
})
.collect();
}
if shadowed.contains(root) {
return Vec::new();
}
}
if self.target_params.contains(root) {
vec![ResolvedReceiver {
param: root.to_string(),
path: suffix.to_string(),
via_stub: false,
}]
} else {
Vec::new()
}
}
pub(super) fn resolve_member_receivers(
&self,
object: &Expression<'_>,
) -> Vec<ResolvedReceiver> {
if let Some(stub) = self.inline_stub_receiver(object) {
return vec![stub];
}
self.resolve_receivers(object, true)
}
fn receiver_root<'p>(&self, object_path: &'p str) -> (&'p str, &'p str) {
if self.target_params.contains(THIS_ENV_RECEIVER)
&& let Some(rest) = object_path.strip_prefix(THIS_ENV_RECEIVER)
{
if rest.is_empty() {
return (THIS_ENV_RECEIVER, "");
}
if let Some(suffix) = rest.strip_prefix('.') {
return (THIS_ENV_RECEIVER, suffix);
}
}
object_path
.split_once('.')
.map_or((object_path, ""), |(root, suffix)| (root, suffix))
}
fn call_result_alias(&self, init: &Expression<'_>) -> Option<ReceiverAlias> {
let init = unwrap_static_expr(init);
if !is_member_call(init) && !matches!(init, Expression::ConditionalExpression(_)) {
return None;
}
let mut targets = Vec::new();
self.collect_call_result_alias_targets(init, &mut targets);
let mut unique: Vec<(String, String)> = Vec::with_capacity(targets.len());
for target in targets {
if !unique.contains(&target) {
unique.push(target);
}
}
let mut targets = unique.into_iter();
let target = targets.next()?;
Some(ReceiverAlias {
target,
stub: false,
alternatives: targets.collect(),
})
}
fn collect_call_result_alias_targets(
&self,
expr: &Expression<'_>,
targets: &mut Vec<(String, String)>,
) {
crate::cost::walk_step();
let expr = unwrap_static_expr(expr);
let receivers = match expr {
Expression::ConditionalExpression(conditional) => {
self.collect_call_result_alias_targets(&conditional.consequent, targets);
self.collect_call_result_alias_targets(&conditional.alternate, targets);
return;
}
_ if is_member_call(expr) => self.resolve_receivers(expr, true),
Expression::CallExpression(_)
| Expression::ChainExpression(_)
| Expression::NewExpression(_) => return,
_ => self.resolve_receivers(expr, false),
};
targets.extend(
receivers
.into_iter()
.filter(|receiver| !receiver.via_stub)
.map(|receiver| (receiver.param, receiver.path)),
);
}
pub(super) fn declarator_receiver_alias(
&mut self,
declarator: &VariableDeclarator<'_>,
) -> Option<(String, ReceiverAlias)> {
if let Some(stub) = self.durable_object_stub_alias(declarator) {
return Some(stub);
}
let BindingPattern::BindingIdentifier(local) = &declarator.id else {
return None;
};
if self.durable_objects.holds_id(local.name.as_str()) {
return None;
}
let alias = self.call_result_alias(declarator.init.as_ref()?)?;
Some((local.name.to_string(), alias))
}
}
fn join_receiver_path(alias_path: &str, suffix: &str) -> String {
match (alias_path.is_empty(), suffix.is_empty()) {
(true, _) => suffix.to_string(),
(_, true) => alias_path.to_string(),
(false, false) => format!("{alias_path}.{suffix}"),
}
}