use fallow_types::extract::{
ArgFact, BindingRoot, CallTarget, FunctionContractFacts, ImportBindingReference, KeyValue,
};
use oxc_span::Span;
use rustc_hash::FxHashSet;
use super::{ModuleInfo, ModuleInfoExtractor};
#[derive(Default)]
pub(super) struct OpaqueLoadState {
spans: FxHashSet<Span>,
template_reads_root: bool,
pub(super) ambient_require: bool,
}
impl ModuleInfoExtractor {
pub(crate) fn imported_call_reference_candidates(&self) -> FxHashSet<Span> {
self.pending_imported_call_sites
.iter()
.map(|(span, _)| *span)
.collect()
}
pub(crate) fn resolve_imported_call_sites(&mut self, references: &FxHashSet<Span>) {
self.imported_call_sites.extend(
self.pending_imported_call_sites
.drain(..)
.filter(|(span, _)| references.contains(span))
.map(|(_, call)| call),
);
}
pub(crate) fn set_import_binding_references(
&mut self,
references: Vec<ImportBindingReference>,
) {
self.import_binding_references = references;
}
pub(crate) fn set_function_contracts(&mut self, facts: FunctionContractFacts) {
self.function_contracts = facts;
self.opaque_loads.spans.clear();
}
pub(crate) const fn set_template_reads_root(&mut self, value: bool) {
self.opaque_loads.template_reads_root = value;
}
pub(crate) const fn template_reads_root(&self) -> bool {
self.opaque_loads.template_reads_root
}
pub(super) fn record_declaration_name(&mut self, name: &str, ambient: bool) {
self.opaque_loads.ambient_require |= ambient && name == "require";
self.record_local_declaration_name(name);
}
pub(crate) fn opaque_load_candidates(&self) -> FxHashSet<Span> {
self.opaque_loads.spans.clone()
}
pub(super) fn mark_opaque_module_load(&mut self, span: Span) {
self.opaque_loads.spans.insert(span);
self.function_contracts.opaque_loads.escapes = true;
}
pub(super) fn mark_opaque_load_escape(&mut self) {
self.mark_opaque_module_load(Span::default());
}
pub(super) fn merge_function_contracts(&mut self, info: &mut ModuleInfo) {
let incoming = std::mem::take(&mut self.function_contracts);
if incoming.is_empty() {
return;
}
let import_base = u32::try_from(info.imports.len()).unwrap_or(u32::MAX);
let facts = info.function_contracts.get_or_insert_with(Box::default);
let local_base = u32::try_from(facts.declarations.len()).unwrap_or(u32::MAX);
facts.declarations.extend(incoming.declarations);
facts
.calls
.extend(incoming.calls.into_iter().map(|mut calls| {
calls.target = match calls.target {
CallTarget::Import(index) => {
CallTarget::Import(index.saturating_add(import_base))
}
CallTarget::Local(index) => CallTarget::Local(index.saturating_add(local_base)),
};
for site in &mut calls.sites {
merge_binding_args(&mut site.args, import_base);
}
calls
}));
facts.literal_consts.extend(incoming.literal_consts);
facts
.escapes
.extend(incoming.escapes.into_iter().map(|mut escape| {
escape.contract = escape.contract.saturating_add(local_base);
escape
}));
facts.template_callers |= incoming.template_callers;
facts.direct_eval |= incoming.direct_eval;
facts.opaque_loads.merge(incoming.opaque_loads);
facts
.calls
.sort_by_key(|calls| calls.sites.first().map_or(0, |site| site.span_start));
facts.escapes.sort_by_key(|escape| escape.span_start);
}
}
fn merge_binding_args(args: &mut [ArgFact], import_base: u32) {
for arg in args {
match arg {
ArgFact::Binding(binding) => match &mut binding.root {
BindingRoot::Import(index) => *index = index.saturating_add(import_base),
BindingRoot::Local => *arg = ArgFact::Unknown,
},
ArgFact::Object(keys) => {
for key in keys {
if let KeyValue::Binding(binding) = &mut key.value {
match &mut binding.root {
BindingRoot::Import(index) => {
*index = index.saturating_add(import_base);
}
BindingRoot::Local => key.value = KeyValue::Unknown,
}
}
}
}
ArgFact::Literal(_) | ArgFact::Param(_) | ArgFact::Unknown => {}
}
}
}
pub fn mark_template_callers(info: &mut ModuleInfo) {
info.function_contracts
.get_or_insert_with(Box::default)
.template_callers = true;
}