#[derive(Debug, Clone, Default, PartialEq, Eq, bitcode::Encode, bitcode::Decode)]
pub struct FunctionContractFacts {
pub declarations: Vec<FunctionContract>,
pub calls: Vec<FunctionCalls>,
pub escapes: Vec<LocalFunctionEscape>,
pub template_callers: bool,
pub direct_eval: bool,
pub opaque_loads: OpaqueLoads,
pub literal_consts: Vec<Box<str>>,
}
impl FunctionContractFacts {
pub fn call_sites(&self) -> impl Iterator<Item = (CallTarget, &str, &CallSite)> {
self.calls.iter().flat_map(|calls| {
calls
.sites
.iter()
.map(|site| (calls.target, &*calls.member_path, site))
})
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.declarations.is_empty()
&& self.calls.is_empty()
&& self.escapes.is_empty()
&& !self.template_callers
&& !self.direct_eval
&& self.opaque_loads.is_empty()
&& self.literal_consts.is_empty()
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq, bitcode::Encode, bitcode::Decode)]
pub struct OpaqueLoads {
pub names: Vec<String>,
pub escapes: bool,
pub loaders: Vec<LoaderReturn>,
}
impl OpaqueLoads {
#[must_use]
pub const fn is_empty(&self) -> bool {
self.names.is_empty() && !self.escapes && self.loaders.is_empty()
}
pub fn merge(&mut self, other: Self) {
self.names.extend(other.names);
self.names.sort_unstable();
self.names.dedup();
self.escapes |= other.escapes;
self.loaders.extend(other.loaders);
self.loaders.sort_unstable();
self.loaders.dedup();
}
pub fn shift_loaders(&mut self, base: u32) {
for loader in &mut self.loaders {
loader.contract = loader.contract.saturating_add(base);
}
}
}
#[derive(
Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, bitcode::Encode, bitcode::Decode,
)]
pub struct LoaderReturn {
pub contract: u32,
pub promise: bool,
}
#[derive(Debug, Clone, Default, PartialEq, Eq, bitcode::Encode, bitcode::Decode)]
pub struct CallResultReads {
pub value: OpaqueLoads,
pub promise: OpaqueLoads,
}
impl CallResultReads {
pub fn merge(&mut self, other: Self) {
self.value.merge(other.value);
self.promise.merge(other.promise);
}
pub fn shift_loaders(&mut self, base: u32) {
self.value.shift_loaders(base);
self.promise.shift_loaders(base);
}
}
#[derive(Debug, Clone, PartialEq, Eq, bitcode::Encode, bitcode::Decode)]
pub struct FunctionContract {
pub binding_name: Box<str>,
pub span_start: u32,
pub params: Vec<ParamFact>,
pub returns_value: bool,
pub is_async: bool,
pub incomplete: Option<ContractIncomplete>,
}
#[derive(Debug, Clone, PartialEq, Eq, bitcode::Encode, bitcode::Decode)]
pub struct ParamFact {
pub name: Option<Box<str>>,
pub span_start: u32,
pub kind: ParamKind,
pub optional: bool,
pub has_default: bool,
pub is_rest: bool,
pub condition_reads: u32,
pub written: bool,
pub keys: Vec<OptionKeyFact>,
}
#[derive(Debug, Clone, PartialEq, Eq, bitcode::Encode, bitcode::Decode)]
pub struct OptionKeyFact {
pub key: Box<str>,
pub binding: Box<str>,
pub span_start: u32,
pub has_default: bool,
pub condition_reads: u32,
pub written: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, bitcode::Encode, bitcode::Decode)]
pub enum ParamKind {
Identifier,
Object,
Array,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, bitcode::Encode, bitcode::Decode)]
pub enum ContractIncomplete {
Overload,
ArgumentsRead,
DirectEval,
MutableBinding,
Reassigned,
Decorator,
Generator,
DuplicateDeclaration,
}
#[derive(Debug, Clone, PartialEq, Eq, bitcode::Encode, bitcode::Decode)]
pub struct FunctionCalls {
pub target: CallTarget,
pub member_path: Box<str>,
pub sites: Vec<CallSite>,
pub results: CallResultReads,
}
#[derive(Debug, Clone, PartialEq, Eq, bitcode::Encode, bitcode::Decode)]
pub struct CallSite {
pub arg_count: u32,
pub args: Vec<ArgFact>,
pub spread_from: Option<u32>,
pub result_used: bool,
pub span_start: u32,
}
impl CallSite {
#[must_use]
pub fn arg_at(&self, index: u32) -> ArgAt<'_> {
if self.spread_from.is_some_and(|spread| index >= spread) {
return ArgAt::Unknown;
}
if index >= self.arg_count {
return ArgAt::Omitted;
}
match usize::try_from(index).ok().and_then(|at| self.args.get(at)) {
Some(ArgFact::Unknown) | None => ArgAt::Unknown,
Some(fact) => ArgAt::Fact(fact),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ArgAt<'a> {
Fact(&'a ArgFact),
Unknown,
Omitted,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, bitcode::Encode, bitcode::Decode)]
pub enum CallTarget {
Import(u32),
Local(u32),
}
#[derive(Debug, Clone, PartialEq, Eq, bitcode::Encode, bitcode::Decode)]
pub enum ArgFact {
Literal(LiteralValue),
Param(u32),
Binding(BindingArg),
Object(Vec<KeyArg>),
Unknown,
}
#[derive(Debug, Clone, PartialEq, Eq, bitcode::Encode, bitcode::Decode)]
pub struct BindingArg {
pub root: BindingRoot,
pub path: Box<str>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, bitcode::Encode, bitcode::Decode)]
pub enum BindingRoot {
Local,
Import(u32),
}
#[derive(Debug, Clone, PartialEq, Eq, bitcode::Encode, bitcode::Decode)]
pub struct KeyArg {
pub key: Box<str>,
pub value: KeyValue,
}
#[derive(Debug, Clone, PartialEq, Eq, bitcode::Encode, bitcode::Decode)]
pub enum KeyValue {
Literal(LiteralValue),
Binding(BindingArg),
PassThrough,
Unknown,
}
#[derive(Debug, Clone, PartialEq, Eq, bitcode::Encode, bitcode::Decode)]
pub enum LiteralValue {
Boolean(bool),
Null,
Undefined,
Number(u64),
String(Box<str>),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, bitcode::Encode, bitcode::Decode)]
pub struct LocalFunctionEscape {
pub contract: u32,
pub span_start: u32,
}
#[cfg(test)]
mod tests {
use super::*;
fn site(arg_count: u32, args: Vec<ArgFact>, spread_from: Option<u32>) -> CallSite {
CallSite {
arg_count,
args,
spread_from,
result_used: false,
span_start: 0,
}
}
const TRUE: ArgFact = ArgFact::Literal(LiteralValue::Boolean(true));
#[test]
fn a_position_from_the_spread_on_is_unknown() {
let call = site(2, vec![TRUE], Some(1));
assert_eq!(call.arg_at(0), ArgAt::Fact(&TRUE));
assert_eq!(call.arg_at(1), ArgAt::Unknown);
assert_eq!(call.arg_at(3), ArgAt::Unknown);
assert_eq!(site(1, Vec::new(), Some(0)).arg_at(3), ArgAt::Unknown);
}
#[test]
fn a_position_past_the_count_is_omitted() {
assert_eq!(site(0, Vec::new(), None).arg_at(0), ArgAt::Omitted);
assert_eq!(site(1, vec![TRUE], None).arg_at(1), ArgAt::Omitted);
}
#[test]
fn empty_args_with_a_count_are_unknown() {
let call = site(2, Vec::new(), None);
assert_eq!(call.arg_at(0), ArgAt::Unknown);
assert_eq!(call.arg_at(1), ArgAt::Unknown);
assert_eq!(call.arg_at(2), ArgAt::Omitted);
}
#[test]
fn a_stored_unknown_is_unknown_and_a_param_is_a_fact() {
let call = site(2, vec![ArgFact::Unknown, ArgFact::Param(0)], None);
assert_eq!(call.arg_at(0), ArgAt::Unknown);
assert_eq!(call.arg_at(1), ArgAt::Fact(&ArgFact::Param(0)));
}
#[test]
fn a_position_past_the_kept_facts_is_unknown() {
let call = site(40, vec![TRUE; 16], None);
assert_eq!(call.arg_at(15), ArgAt::Fact(&TRUE));
assert_eq!(call.arg_at(16), ArgAt::Unknown);
assert_eq!(call.arg_at(39), ArgAt::Unknown);
assert_eq!(call.arg_at(40), ArgAt::Omitted);
}
}