#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BinOp {
Add,
Sub,
Mul,
Div,
Mod,
Pow,
Concat, LooseEq, LooseNe, StrictEq, StrictNe, Lt,
Gt,
Le,
Ge,
Spaceship, BitAnd, BitOr, BitXor, Shl, Shr, And, Or, }
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum UnOp {
Neg, Pos, Not, BitNot, }
#[derive(Debug, Clone, PartialEq)]
pub enum StrPart {
Lit(String),
Var(String),
Raw(String),
}
#[derive(Debug, Clone)]
pub enum InterpPart {
Lit(String),
Expr(Box<Expr>),
}
#[derive(Debug, Clone)]
pub enum ClassRef {
Name(String),
Expr(Box<Expr>),
}
impl ClassRef {
pub fn name(&self) -> Option<&str> {
match self {
ClassRef::Name(n) => Some(n),
ClassRef::Expr(_) => None,
}
}
pub fn operand(&self) -> Option<&Expr> {
match self {
ClassRef::Name(_) => None,
ClassRef::Expr(e) => Some(e),
}
}
}
#[derive(Debug, Clone)]
pub struct ArrayElem {
pub key: Option<Expr>,
pub value: Expr,
pub by_ref: bool,
}
impl ArrayElem {
pub fn new(key: Option<Expr>, value: Expr) -> Self {
Self {
key,
value,
by_ref: false,
}
}
}
#[derive(Debug, Clone)]
pub enum Expr {
Null,
Bool(bool),
Int(i64),
Float(f64),
Str(String),
Interp(Vec<InterpPart>),
Var(String),
VarVar(Box<Expr>),
Array(Vec<ArrayElem>),
Index(Box<Expr>, Box<Expr>),
ListElem(Box<Expr>, Box<Expr>),
Append(Box<Expr>),
Unary(UnOp, Box<Expr>),
Binary(BinOp, Box<Expr>, Box<Expr>),
Assign(Box<Expr>, Option<BinOp>, Box<Expr>),
IncDec {
target: Box<Expr>,
inc: bool,
prefix: bool,
},
Call(String, Vec<Expr>),
Spread(Box<Expr>),
CallValue(Box<Expr>, Vec<Expr>),
Closure {
params: Vec<Param>,
uses: Vec<Capture>,
body: Vec<Stmt>,
ret: Option<TypeHint>,
is_static: bool,
line: u32,
},
ArrowFn {
params: Vec<Param>,
body: Box<Expr>,
ret: Option<TypeHint>,
line: u32,
},
New(String, Vec<Expr>),
NewAnon {
decl: Box<ClassDecl>,
args: Vec<Expr>,
line: u32,
},
PropGet(Box<Expr>, String),
MethodCall(Box<Expr>, String, Vec<Expr>),
NullsafePropGet(Box<Expr>, String),
NullsafeMethodCall(Box<Expr>, String, Vec<Expr>),
NamedArg(String, Box<Expr>),
StaticGet(ClassRef, String),
StaticProp(ClassRef, String),
StaticCall(ClassRef, String, Vec<Expr>),
Clone(Box<Expr>),
Ternary(Box<Expr>, Box<Expr>, Box<Expr>),
Elvis(Box<Expr>, Box<Expr>),
Coalesce(Box<Expr>, Box<Expr>),
Match {
subj: Box<Expr>,
arms: Vec<MatchArm>,
},
Throw(Box<Expr>),
ConstFetch(String),
Magic(MagicConst),
Unset(Vec<Expr>),
InstanceOf(Box<Expr>, String),
RefAssign(Box<Expr>, Box<Expr>),
Quiet(Box<Expr>),
Suppress(Box<Expr>),
IssetOf(Box<Expr>),
EmptyOf(Box<Expr>),
Yield {
key: Option<Box<Expr>>,
value: Option<Box<Expr>>,
},
YieldFrom(Box<Expr>),
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum MagicConst {
File { prefix: String, suffix: String },
Class { prefix: String, suffix: String },
Dir,
}
impl MagicConst {
pub fn wrap(&self, before: &str, after: &str) -> MagicConst {
let wrapped = |prefix: &String, suffix: &String| {
(format!("{before}{prefix}"), format!("{suffix}{after}"))
};
match self {
MagicConst::File { prefix, suffix } => {
let (prefix, suffix) = wrapped(prefix, suffix);
MagicConst::File { prefix, suffix }
}
MagicConst::Class { prefix, suffix } => {
let (prefix, suffix) = wrapped(prefix, suffix);
MagicConst::Class { prefix, suffix }
}
MagicConst::Dir => MagicConst::Dir,
}
}
}
#[derive(Debug, Clone)]
pub struct MatchArm {
pub conds: Option<Vec<Expr>>,
pub body: Box<Expr>,
}
#[derive(Debug, Clone)]
pub struct Stmt {
pub line: u32,
pub kind: StmtKind,
}
#[derive(Debug, Clone)]
pub enum ForeachVal {
Var(String),
Pattern(Expr),
}
#[derive(Debug, Clone)]
pub enum StmtKind {
InlineHtml(String),
Echo(Vec<Expr>),
Expr(Expr),
If {
cond: Expr,
then: Vec<Stmt>,
elifs: Vec<(Expr, Vec<Stmt>)>,
els: Option<Vec<Stmt>>,
},
While {
cond: Expr,
body: Vec<Stmt>,
},
DoWhile {
cond: Expr,
body: Vec<Stmt>,
},
Switch {
subj: Expr,
cases: Vec<SwitchCase>,
},
For {
init: Vec<Expr>,
cond: Option<Expr>,
step: Vec<Expr>,
body: Vec<Stmt>,
},
Foreach {
arr: Expr,
key_var: Option<String>,
val: ForeachVal,
by_ref: bool,
body: Vec<Stmt>,
},
Function {
name: String,
params: Vec<Param>,
body: Vec<Stmt>,
ret: Option<TypeHint>,
by_ref_return: bool,
},
Class(ClassDecl),
Return(Option<Expr>),
Break(u32),
Continue(u32),
Try {
body: Vec<Stmt>,
catches: Vec<CatchArm>,
finally: Option<Vec<Stmt>>,
},
Block(Vec<Stmt>),
StaticLocal(Vec<(String, Option<Expr>)>),
Global(Vec<String>),
ConstDecl(Vec<(String, Expr)>),
}
#[derive(Debug, Clone)]
pub struct CatchArm {
pub types: Vec<String>,
pub var: Option<String>,
pub body: Vec<Stmt>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TypeHint {
pub parts: Vec<String>,
}
impl TypeHint {
pub fn scalar(&self) -> Option<&str> {
let mut real = self
.parts
.iter()
.filter(|p| !p.eq_ignore_ascii_case("null"));
let one = real.next()?;
if real.next().is_some() {
return None;
}
match one.to_ascii_lowercase().as_str() {
"int" => Some("int"),
"float" => Some("float"),
"string" => Some("string"),
"bool" => Some("bool"),
_ => None,
}
}
pub fn nullable(&self) -> bool {
self.parts.iter().any(|p| p.eq_ignore_ascii_case("null"))
}
pub fn render(&self) -> String {
match (self.scalar(), self.nullable()) {
(Some(s), true) => format!("?{s}"),
(Some(s), false) => s.to_string(),
_ => self.parts.join("|"),
}
}
}
#[derive(Debug, Clone)]
pub struct Param {
pub name: String,
pub line: u32,
pub ty: Option<TypeHint>,
pub default: Option<Expr>,
pub variadic: bool,
pub promoted: bool,
pub readonly: bool,
pub by_ref: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Visibility {
Public,
Protected,
Private,
}
#[derive(Debug, Clone)]
pub struct PropDecl {
pub name: String,
pub default: Option<Expr>,
pub is_static: bool,
pub visibility: Visibility,
pub readonly: bool,
}
#[derive(Debug, Clone)]
pub struct ClassDecl {
pub name: String,
pub parent: Option<String>,
pub implements: Vec<String>,
pub uses: Vec<String>,
pub trait_insteadof: Vec<TraitInsteadof>,
pub trait_aliases: Vec<TraitAlias>,
pub is_interface: bool,
pub is_readonly: bool,
pub is_abstract: bool,
pub is_enum: bool,
pub enum_backing: Option<String>,
pub cases: Vec<EnumCase>,
pub consts: Vec<(String, Expr)>,
pub props: Vec<PropDecl>,
pub methods: Vec<Method>,
pub attributes: Vec<String>,
}
#[derive(Debug, Clone)]
pub struct TraitInsteadof {
pub winner: String,
pub method: String,
pub losers: Vec<String>,
}
#[derive(Debug, Clone)]
pub struct TraitAlias {
pub from: Option<String>,
pub method: String,
pub alias: Option<String>,
pub visibility: Option<Visibility>,
}
#[derive(Debug, Clone)]
pub struct EnumCase {
pub name: String,
pub value: Option<Expr>,
}
#[derive(Debug, Clone)]
pub struct Method {
pub name: String,
pub params: Vec<Param>,
pub body: Vec<Stmt>,
pub ret: Option<TypeHint>,
pub is_static: bool,
pub visibility: Visibility,
pub by_ref_return: bool,
}
#[derive(Debug, Clone)]
pub struct SwitchCase {
pub test: Option<Expr>,
pub body: Vec<Stmt>,
}
#[derive(Debug, Clone, PartialEq)]
pub struct Capture {
pub name: String,
pub by_ref: bool,
}