use rustc_hash::{FxHashMap, FxHashSet};
use crate::ast::{Expr, ForeachVal, Param, Stmt, StmtKind};
pub struct Promoted {
pub names: Vec<String>,
pub numeric: FxHashSet<String>,
}
pub fn promotable(
params: &[Param],
body: &[Stmt],
is_generator: bool,
by_ref_arg: &dyn Fn(&str, usize) -> bool,
) -> Promoted {
if is_generator {
return Promoted {
names: Vec::new(),
numeric: FxHashSet::default(),
};
}
let mut s = Scan {
banned: FxHashSet::default(),
poisoned: false,
detached: false,
by_ref_arg,
};
for p in params {
s.ban(&p.name);
}
s.stmts(body);
if s.poisoned {
return Promoted {
names: Vec::new(),
numeric: FxHashSet::default(),
};
}
let banned = s.banned;
let mut flow = Flow {
assigned: FxHashSet::default(),
banned,
order: Vec::new(),
seen: FxHashSet::default(),
non_numeric: FxHashSet::default(),
};
flow.stmts(body);
let names: Vec<String> = flow
.order
.into_iter()
.filter(|n| !flow.banned.contains(n))
.collect();
let numeric = names
.iter()
.filter(|n| !flow.non_numeric.contains(*n))
.cloned()
.collect();
Promoted { names, numeric }
}
fn numeric_literal(e: &Expr) -> bool {
matches!(e, Expr::Int(_) | Expr::Float(_))
}
fn pattern_binds_by_ref(e: &Expr) -> bool {
match e {
Expr::Array(elems, _) => elems
.iter()
.any(|el| el.by_ref || pattern_binds_by_ref(&el.value)),
Expr::ListElem(_, v) => pattern_binds_by_ref(v),
_ => false,
}
}
fn eligible(name: &str) -> bool {
!crate::host::is_superglobal(name) && name != "this" && !name.starts_with('@')
}
struct Scan<'a> {
banned: FxHashSet<String>,
poisoned: bool,
detached: bool,
by_ref_arg: &'a dyn Fn(&str, usize) -> bool,
}
impl Scan<'_> {
fn ban(&mut self, n: &str) {
self.banned.insert(n.to_string());
}
fn poison(&mut self) {
self.poisoned = true;
}
fn ban_path_root(&mut self, e: &Expr) {
match e {
Expr::Var(n) => self.ban(n),
Expr::Index(r, _) | Expr::Append(r) | Expr::PropGet(r, _) => self.ban_path_root(r),
Expr::Array(..) | Expr::ListElem(..) => self.ban_all_vars(e),
_ => {}
}
}
fn ban_all_vars(&mut self, e: &Expr) {
let saved = self.detached;
self.detached = true;
self.expr(e);
self.detached = saved;
}
fn detached_stmts(&mut self, body: &[Stmt]) {
let saved = self.detached;
self.detached = true;
self.stmts(body);
self.detached = saved;
}
fn stmts(&mut self, body: &[Stmt]) {
for s in body {
self.stmt(s);
}
}
fn stmt(&mut self, s: &Stmt) {
match &s.kind {
StmtKind::Echo(es) => self.exprs(es),
StmtKind::Expr(e) | StmtKind::Return(Some(e)) => self.expr(e),
StmtKind::If {
cond,
then,
elifs,
els,
} => {
self.expr(cond);
self.stmts(then);
for (c, b) in elifs {
self.expr(c);
self.stmts(b);
}
if let Some(b) = els {
self.stmts(b);
}
}
StmtKind::While { cond, body } | StmtKind::DoWhile { cond, body } => {
self.expr(cond);
self.stmts(body);
}
StmtKind::For {
init,
cond,
step,
body,
} => {
self.exprs(init);
if let Some(c) = cond {
self.expr(c);
}
self.exprs(step);
self.stmts(body);
}
StmtKind::Foreach {
arr,
key_var,
val,
body,
..
} => {
self.expr(arr);
if let Some(k) = key_var {
self.ban(k);
}
match val {
ForeachVal::Var(n) => self.ban(n),
ForeachVal::Pattern(e) => self.ban_all_vars(e),
}
self.stmts(body);
}
StmtKind::Switch { subj, cases } => {
self.expr(subj);
for c in cases {
if let Some(e) = &c.test {
self.expr(e);
}
self.stmts(&c.body);
}
}
StmtKind::Try {
body,
catches,
finally,
} => {
self.detached_stmts(body);
for c in catches {
if let Some(v) = &c.var {
self.ban(v);
}
self.detached_stmts(&c.body);
}
if let Some(f) = finally {
self.detached_stmts(f);
}
}
StmtKind::Block(b) => self.stmts(b),
StmtKind::Global(names) => {
for n in names {
self.ban(n);
}
}
StmtKind::StaticLocal(decls) => {
for (n, init) in decls {
self.ban(n);
if let Some(e) = init {
self.expr(e);
}
}
}
StmtKind::ConstDecl(ds) => {
for (_, e) in ds {
self.expr(e);
}
}
StmtKind::Function { .. }
| StmtKind::Class(_)
| StmtKind::InlineHtml(_)
| StmtKind::Return(None)
| StmtKind::Break(_)
| StmtKind::Label(_)
| StmtKind::Continue(_) => {}
StmtKind::Goto(_) => self.poison(),
}
}
fn exprs(&mut self, es: &[Expr]) {
for e in es {
self.expr(e);
}
}
fn call_args(&mut self, callee: Option<&str>, args: &[Expr]) {
for (i, a) in args.iter().enumerate() {
let inner = match a {
Expr::NamedArg(_, v) => v,
Expr::Spread(v) => v,
other => other,
};
match callee {
Some(name) if !(self.by_ref_arg)(name, i) => {}
_ => self.ban_path_root(inner),
}
self.expr(inner);
}
}
fn expr(&mut self, e: &Expr) {
match e {
Expr::VarVar(_) => self.poison(),
Expr::Var(n) => {
if self.detached {
self.ban(n);
}
}
Expr::Null | Expr::Hole | Expr::Bool(_) | Expr::Int(_) | Expr::Float(_) => {}
Expr::Str(_) | Expr::ConstFetch(_) | Expr::Magic(_) => {}
Expr::StaticGet(class, _) => {
if let Some(op) = class.operand() {
self.expr(op);
}
}
Expr::Interp(parts) => {
for p in parts {
if let crate::ast::InterpPart::Expr(e) = p {
self.expr(e);
}
}
}
Expr::Array(elems, _) => {
for el in elems {
if let Some(k) = &el.key {
self.expr(k);
}
if el.by_ref {
self.ban_path_root(&el.value);
}
self.expr(&el.value);
}
}
Expr::Index(r, k) => {
self.expr(r);
self.expr(k);
}
Expr::ListElem(a, b) => {
self.expr(a);
self.expr(b);
}
Expr::Append(r) => self.expr(r),
Expr::Unary(_, x) | Expr::Spread(x) | Expr::NamedArg(_, x) => self.expr(x),
Expr::Binary(_, a, b)
| Expr::InstanceOfDyn(a, b)
| Expr::Elvis(a, b)
| Expr::Coalesce(a, b) => {
self.expr(a);
self.expr(b);
}
Expr::Assign(lhs, _, rhs) => {
if !matches!(lhs.as_ref(), Expr::Var(_)) {
self.ban_all_vars(lhs);
if pattern_binds_by_ref(lhs) {
self.ban_all_vars(rhs);
}
}
self.expr(lhs);
self.expr(rhs);
}
Expr::IncDec { target, .. } => {
if !matches!(target.as_ref(), Expr::Var(_)) {
self.ban_path_root(target);
}
self.expr(target);
}
Expr::RefAssign(a, b) => {
self.ban_path_root(a);
self.ban_path_root(b);
self.expr(a);
self.expr(b);
}
Expr::Call(name, args) => {
let bare = name
.rsplit('\\')
.next()
.unwrap_or(name)
.to_ascii_lowercase();
if matches!(
bare.as_str(),
"extract"
| "compact"
| "get_defined_vars"
| "eval"
| "parse_str"
| "settype"
| "func_get_args"
) {
self.poison();
}
self.call_args(Some(&bare), args);
}
Expr::Fcc { callable, .. } => self.expr(callable),
Expr::CallValue(f, args) => {
self.expr(f);
self.call_args(None, args);
}
Expr::MethodCall(r, m, args) | Expr::NullsafeMethodCall(r, m, args) => {
self.expr(r);
if let Some(d) = m.operand() {
self.expr(d);
}
self.call_args(None, args);
}
Expr::StaticCall(class, _, args) => {
if let Some(op) = class.operand() {
self.expr(op);
}
self.call_args(None, args);
}
Expr::New(_, args) => self.call_args(None, args),
Expr::NewAnon { args, .. } => self.call_args(None, args),
Expr::NewDyn(class, args) => {
self.expr(class);
self.call_args(None, args);
}
Expr::Closure { uses, .. } => {
for u in uses {
self.ban(&u.name);
}
}
Expr::ArrowFn { params, body, .. } => {
let mut free = Vec::new();
crate::compiler::collect_free_vars(body, &mut free);
for n in free {
if !params.iter().any(|p| p.name == n) {
self.ban(&n);
}
}
}
Expr::PropGet(r, m) | Expr::NullsafePropGet(r, m) => {
self.expr(r);
if let Some(d) = m.operand() {
self.expr(d);
}
}
Expr::StaticProp(class, name) => {
for op in class.operand().into_iter().chain(name.operand()) {
self.expr(op);
}
}
Expr::Include(_, x) | Expr::Eval(x) => {
self.poison();
self.expr(x);
}
Expr::Clone(x) | Expr::Throw(x) | Expr::YieldFrom(x) | Expr::Print(x) => self.expr(x),
Expr::InstanceOf(x, _) => self.expr(x),
Expr::Ternary(a, b, c) => {
self.expr(a);
self.expr(b);
self.expr(c);
}
Expr::Match { subj, arms } => {
self.expr(subj);
for a in arms {
for c in a.conds.iter().flatten() {
self.expr(c);
}
self.expr(&a.body);
}
}
Expr::Unset(targets) => {
for t in targets {
self.ban_path_root(t);
}
}
Expr::IssetOf(x) | Expr::EmptyOf(x) | Expr::Quiet(x) | Expr::Suppress(x) => {
self.expr(x)
}
Expr::Yield { key, value } => {
if let Some(k) = key {
self.expr(k);
}
if let Some(v) = value {
self.expr(v);
}
}
}
}
}
struct Flow {
assigned: FxHashSet<String>,
banned: FxHashSet<String>,
order: Vec<String>,
seen: FxHashSet<String>,
non_numeric: FxHashSet<String>,
}
impl Flow {
fn read(&mut self, n: &str) {
if eligible(n) && !self.assigned.contains(n) {
self.banned.insert(n.to_string());
}
}
fn write(&mut self, n: &str) {
if !eligible(n) {
return;
}
self.assigned.insert(n.to_string());
if self.seen.insert(n.to_string()) {
self.order.push(n.to_string());
}
}
fn maybe(&mut self, f: impl FnOnce(&mut Self)) {
let saved = self.assigned.clone();
f(self);
self.assigned = saved;
}
fn stmts(&mut self, body: &[Stmt]) {
for s in body {
self.stmt(s);
}
}
fn stmt(&mut self, s: &Stmt) {
match &s.kind {
StmtKind::Echo(es) => self.exprs(es),
StmtKind::Expr(e) | StmtKind::Return(Some(e)) => self.expr(e),
StmtKind::If {
cond,
then,
elifs,
els,
} => {
self.expr(cond);
self.maybe(|f| f.stmts(then));
for (c, b) in elifs {
self.expr(c);
self.maybe(|f| f.stmts(b));
}
if let Some(b) = els {
self.maybe(|f| f.stmts(b));
}
}
StmtKind::While { cond, body } => {
self.expr(cond);
self.maybe(|f| f.stmts(body));
}
StmtKind::DoWhile { cond, body } => {
self.stmts(body);
self.expr(cond);
}
StmtKind::For {
init,
cond,
step,
body,
} => {
self.exprs(init);
if let Some(c) = cond {
self.expr(c);
}
self.maybe(|f| {
f.stmts(body);
f.exprs(step);
});
}
StmtKind::Foreach { arr, body, .. } => {
self.expr(arr);
self.maybe(|f| f.stmts(body));
}
StmtKind::Switch { subj, cases } => {
self.expr(subj);
for c in cases {
if let Some(e) = &c.test {
self.expr(e);
}
self.maybe(|f| f.stmts(&c.body));
}
}
StmtKind::Try {
body,
catches,
finally,
} => {
self.maybe(|f| f.stmts(body));
for c in catches {
self.maybe(|f| f.stmts(&c.body));
}
if let Some(fin) = finally {
self.maybe(|f| f.stmts(fin));
}
}
StmtKind::Block(b) => self.stmts(b),
StmtKind::StaticLocal(decls) => {
for (_, init) in decls {
if let Some(e) = init {
self.expr(e);
}
}
}
StmtKind::ConstDecl(ds) => {
for (_, e) in ds {
self.expr(e);
}
}
StmtKind::Global(_)
| StmtKind::Function { .. }
| StmtKind::Class(_)
| StmtKind::InlineHtml(_)
| StmtKind::Return(None)
| StmtKind::Break(_)
| StmtKind::Goto(_)
| StmtKind::Label(_)
| StmtKind::Continue(_) => {}
}
}
fn exprs(&mut self, es: &[Expr]) {
for e in es {
self.expr(e);
}
}
fn expr(&mut self, e: &Expr) {
match e {
Expr::Var(n) => self.read(n),
Expr::Assign(lhs, op, rhs) => {
self.expr(rhs);
match lhs.as_ref() {
Expr::Var(n) => {
if op.is_some() {
self.read(n);
}
if !numeric_literal(rhs) {
self.non_numeric.insert(n.to_string());
}
self.write(n);
}
other => self.expr(other),
}
}
Expr::IncDec { target, .. } => {
if let Expr::Var(n) = target.as_ref() {
self.read(n);
self.write(n);
} else {
self.expr(target);
}
}
Expr::IssetOf(x) | Expr::EmptyOf(x) | Expr::Quiet(x) | Expr::Suppress(x) => {
self.expr(x)
}
Expr::Interp(parts) => {
for p in parts {
if let crate::ast::InterpPart::Expr(e) = p {
self.expr(e);
}
}
}
Expr::Array(elems, _) => {
for el in elems {
if let Some(k) = &el.key {
self.expr(k);
}
self.expr(&el.value);
}
}
Expr::Index(a, b) | Expr::ListElem(a, b) => {
self.expr(a);
self.expr(b);
}
Expr::Append(x) | Expr::Unary(_, x) | Expr::Spread(x) | Expr::NamedArg(_, x) => {
self.expr(x)
}
Expr::Binary(_, a, b)
| Expr::InstanceOfDyn(a, b)
| Expr::Elvis(a, b)
| Expr::Coalesce(a, b) => {
self.expr(a);
self.expr(b);
}
Expr::RefAssign(a, b) => {
self.expr(a);
self.expr(b);
}
Expr::Call(_, args) | Expr::New(_, args) => self.exprs(args),
Expr::StaticCall(class, _, args) => {
if let Some(op) = class.operand() {
self.expr(op);
}
self.exprs(args);
}
Expr::NewAnon { args, .. } => self.exprs(args),
Expr::NewDyn(class, args) => {
self.expr(class);
self.exprs(args);
}
Expr::Fcc { callable, .. } => self.expr(callable),
Expr::CallValue(f, args) => {
self.expr(f);
self.exprs(args);
}
Expr::MethodCall(r, m, args) | Expr::NullsafeMethodCall(r, m, args) => {
self.expr(r);
if let Some(d) = m.operand() {
self.expr(d);
}
self.exprs(args);
}
Expr::PropGet(r, m) | Expr::NullsafePropGet(r, m) => {
self.expr(r);
if let Some(d) = m.operand() {
self.expr(d);
}
}
Expr::Include(_, x) | Expr::Eval(x) => self.expr(x),
Expr::Clone(x)
| Expr::Throw(x)
| Expr::YieldFrom(x)
| Expr::Print(x)
| Expr::InstanceOf(x, _) => self.expr(x),
Expr::Ternary(a, b, c) => {
self.expr(a);
self.maybe(|f| f.expr(b));
self.maybe(|f| f.expr(c));
}
Expr::Match { subj, arms } => {
self.expr(subj);
for a in arms {
for c in a.conds.iter().flatten() {
self.expr(c);
}
self.maybe(|f| f.expr(&a.body));
}
}
Expr::Unset(ts) => self.exprs(ts),
Expr::Yield { key, value } => {
if let Some(k) = key {
self.expr(k);
}
if let Some(v) = value {
self.expr(v);
}
}
Expr::VarVar(x) => self.expr(x),
Expr::Closure { .. } | Expr::ArrowFn { .. } => {}
Expr::Null
| Expr::Hole
| Expr::Bool(_)
| Expr::Int(_)
| Expr::Float(_)
| Expr::Str(_)
| Expr::ConstFetch(_)
| Expr::Magic(_) => {}
Expr::StaticGet(class, _) => {
if let Some(op) = class.operand() {
self.expr(op);
}
}
Expr::StaticProp(class, name) => {
for op in class.operand().into_iter().chain(name.operand()) {
self.expr(op);
}
}
}
}
}
pub fn globals_reached(stmts: &[Stmt]) -> Option<FxHashSet<String>> {
let mut g = GlobalScan {
names: FxHashSet::default(),
any_globals_array: false,
};
g.stmts(stmts);
(!g.any_globals_array).then_some(g.names)
}
struct GlobalScan {
names: FxHashSet<String>,
any_globals_array: bool,
}
impl GlobalScan {
fn stmts(&mut self, body: &[Stmt]) {
for s in body {
self.stmt(s);
}
}
fn stmt(&mut self, s: &Stmt) {
match &s.kind {
StmtKind::Global(names) => {
for n in names {
self.names.insert(n.clone());
}
}
StmtKind::Echo(es) => self.exprs(es),
StmtKind::Expr(e) | StmtKind::Return(Some(e)) => self.expr(e),
StmtKind::If {
cond,
then,
elifs,
els,
} => {
self.expr(cond);
self.stmts(then);
for (c, b) in elifs {
self.expr(c);
self.stmts(b);
}
if let Some(b) = els {
self.stmts(b);
}
}
StmtKind::While { cond, body } | StmtKind::DoWhile { cond, body } => {
self.expr(cond);
self.stmts(body);
}
StmtKind::For {
init,
cond,
step,
body,
} => {
self.exprs(init);
if let Some(c) = cond {
self.expr(c);
}
self.exprs(step);
self.stmts(body);
}
StmtKind::Foreach { arr, body, .. } => {
self.expr(arr);
self.stmts(body);
}
StmtKind::Switch { subj, cases } => {
self.expr(subj);
for c in cases {
if let Some(e) = &c.test {
self.expr(e);
}
self.stmts(&c.body);
}
}
StmtKind::Try {
body,
catches,
finally,
} => {
self.stmts(body);
for c in catches {
self.stmts(&c.body);
}
if let Some(f) = finally {
self.stmts(f);
}
}
StmtKind::Block(b) => self.stmts(b),
StmtKind::Function { body, .. } => self.stmts(body),
StmtKind::Class(decl) => {
for m in &decl.methods {
self.stmts(&m.body);
}
}
StmtKind::StaticLocal(decls) => {
for (_, init) in decls {
if let Some(e) = init {
self.expr(e);
}
}
}
StmtKind::ConstDecl(ds) => {
for (_, e) in ds {
self.expr(e);
}
}
StmtKind::InlineHtml(_)
| StmtKind::Return(None)
| StmtKind::Break(_)
| StmtKind::Goto(_)
| StmtKind::Label(_)
| StmtKind::Continue(_) => {}
}
}
fn exprs(&mut self, es: &[Expr]) {
for e in es {
self.expr(e);
}
}
fn expr(&mut self, e: &Expr) {
match e {
Expr::Var(n) => {
if n == "GLOBALS" {
self.any_globals_array = true;
}
}
Expr::Closure { body, .. } => self.stmts(body),
Expr::ArrowFn { body, .. } => self.expr(body),
Expr::Interp(parts) => {
for p in parts {
if let crate::ast::InterpPart::Expr(x) = p {
self.expr(x);
}
}
}
Expr::Array(elems, _) => {
for el in elems {
if let Some(k) = &el.key {
self.expr(k);
}
self.expr(&el.value);
}
}
Expr::Index(a, b)
| Expr::ListElem(a, b)
| Expr::Binary(_, a, b)
| Expr::InstanceOfDyn(a, b)
| Expr::Elvis(a, b)
| Expr::Coalesce(a, b)
| Expr::RefAssign(a, b) => {
self.expr(a);
self.expr(b);
}
Expr::Assign(a, _, b) => {
self.expr(a);
self.expr(b);
}
Expr::Append(x)
| Expr::Unary(_, x)
| Expr::Spread(x)
| Expr::NamedArg(_, x)
| Expr::Clone(x)
| Expr::Throw(x)
| Expr::YieldFrom(x)
| Expr::Print(x)
| Expr::InstanceOf(x, _)
| Expr::IssetOf(x)
| Expr::EmptyOf(x)
| Expr::Quiet(x)
| Expr::Suppress(x)
| Expr::VarVar(x) => self.expr(x),
Expr::Include(_, x) | Expr::Eval(x) => {
self.any_globals_array = true;
self.expr(x);
}
Expr::IncDec { target, .. } => self.expr(target),
Expr::Call(_, args) | Expr::New(_, args) | Expr::NewAnon { args, .. } => {
self.exprs(args)
}
Expr::NewDyn(class, args) => {
self.expr(class);
self.exprs(args);
}
Expr::StaticCall(class, _, args) => {
if let Some(op) = class.operand() {
self.expr(op);
}
self.exprs(args);
}
Expr::Fcc { callable, .. } => self.expr(callable),
Expr::CallValue(f, args) => {
self.expr(f);
self.exprs(args);
}
Expr::MethodCall(r, m, args) | Expr::NullsafeMethodCall(r, m, args) => {
self.expr(r);
if let Some(d) = m.operand() {
self.expr(d);
}
self.exprs(args);
}
Expr::PropGet(r, m) | Expr::NullsafePropGet(r, m) => {
self.expr(r);
if let Some(d) = m.operand() {
self.expr(d);
}
}
Expr::Ternary(a, b, c) => {
self.expr(a);
self.expr(b);
self.expr(c);
}
Expr::Match { subj, arms } => {
self.expr(subj);
for a in arms {
for c in a.conds.iter().flatten() {
self.expr(c);
}
self.expr(&a.body);
}
}
Expr::Unset(ts) => self.exprs(ts),
Expr::Yield { key, value } => {
if let Some(k) = key {
self.expr(k);
}
if let Some(v) = value {
self.expr(v);
}
}
Expr::Null
| Expr::Hole
| Expr::Bool(_)
| Expr::Int(_)
| Expr::Float(_)
| Expr::Str(_)
| Expr::ConstFetch(_)
| Expr::Magic(_) => {}
Expr::StaticGet(class, _) => {
if let Some(op) = class.operand() {
self.expr(op);
}
}
Expr::StaticProp(class, name) => {
for op in class.operand().into_iter().chain(name.operand()) {
self.expr(op);
}
}
}
}
}
pub fn slot_map(names: &[String]) -> FxHashMap<String, u16> {
names
.iter()
.enumerate()
.map(|(i, n)| (n.clone(), i as u16))
.collect()
}