use std::collections::{BTreeSet, HashMap};
use crate::ast::{self, Expr, ExprKind, Pattern, PatternKind, StmtKind};
use super::capabilities::{capability_effect_for_call, capability_effect_for_macro};
const MUTATING_METHODS: &[&str] = &[
"push", "pop", "insert", "remove", "clear", "release", "set", "sort", "extend", "truncate",
"push_str", "append", "swap", "reverse", "retain", "drain", "fill",
];
fn macro_name(path: &ast::Path) -> String {
path.segments
.last()
.map(|s| s.ident.name.to_string())
.unwrap_or_default()
}
fn simple_name(e: &Expr) -> Option<String> {
match &e.kind {
ExprKind::Ident(i) => Some(i.name.to_string()),
ExprKind::Path(p) if p.is_simple() => p.last_ident().map(|i| i.name.to_string()),
_ => None,
}
}
pub(super) fn block_exprs(block: &ast::Block, out: &mut Vec<Expr>) {
for stmt in &block.stmts {
stmt_exprs(stmt, out);
}
}
pub(super) fn stmt_exprs(stmt: &ast::Stmt, out: &mut Vec<Expr>) {
match &stmt.kind {
StmtKind::Local(l) => {
if let Some(init) = &l.init {
out.push((*init.expr).clone());
if let Some(d) = &init.diverge {
out.push((**d).clone());
}
}
}
StmtKind::Expr(e) | StmtKind::Semi(e) => out.push((**e).clone()),
StmtKind::Macro { path, tokens, .. } => out.push(Expr {
kind: ExprKind::Macro {
path: path.clone(),
delimiter: crate::lexer::Delimiter::Paren,
tokens: tokens.clone(),
},
span: stmt.span,
id: stmt.id,
attrs: Vec::new(),
}),
StmtKind::Item(_) | StmtKind::Empty => {}
}
}
pub(crate) fn children(e: &Expr) -> Vec<Expr> {
let mut out: Vec<Expr> = Vec::new();
let one = |x: &Expr, out: &mut Vec<Expr>| out.push(x.clone());
match &e.kind {
ExprKind::Array(xs) | ExprKind::Tuple(xs) => out.extend(xs.iter().cloned()),
ExprKind::ArrayRepeat { element, count } => {
one(element, &mut out);
one(count, &mut out);
}
ExprKind::Struct { fields, rest, .. } => {
for f in fields {
if let Some(v) = &f.value {
one(v, &mut out);
}
}
if let Some(r) = rest {
one(r, &mut out);
}
}
ExprKind::Unary { expr, .. }
| ExprKind::Field { expr, .. }
| ExprKind::TupleField { expr, .. }
| ExprKind::Deref(expr)
| ExprKind::Ref { expr, .. }
| ExprKind::Cast { expr, .. }
| ExprKind::TypeAscription { expr, .. }
| ExprKind::Try(expr)
| ExprKind::Await(expr)
| ExprKind::Paren(expr)
| ExprKind::AIInfer { expr, .. } => one(expr, &mut out),
ExprKind::Binary { left, right, .. } => {
one(left, &mut out);
one(right, &mut out);
}
ExprKind::Assign { target, value, .. } => {
one(target, &mut out);
one(value, &mut out);
}
ExprKind::Index { expr, index } => {
one(expr, &mut out);
one(index, &mut out);
}
ExprKind::Call { func, args } => {
one(func, &mut out);
out.extend(args.iter().cloned());
}
ExprKind::MethodCall { receiver, args, .. } => {
one(receiver, &mut out);
out.extend(args.iter().cloned());
}
ExprKind::Perform { args, .. } => out.extend(args.iter().cloned()),
ExprKind::If {
condition,
then_branch,
else_branch,
} => {
one(condition, &mut out);
block_exprs(then_branch, &mut out);
if let Some(e) = else_branch {
one(e, &mut out);
}
}
ExprKind::IfLet {
expr,
then_branch,
else_branch,
..
} => {
one(expr, &mut out);
block_exprs(then_branch, &mut out);
if let Some(e) = else_branch {
one(e, &mut out);
}
}
ExprKind::Match { scrutinee, arms } => {
one(scrutinee, &mut out);
for arm in arms {
if let Some(g) = &arm.guard {
one(g, &mut out);
}
one(&arm.body, &mut out);
}
}
ExprKind::While {
condition, body, ..
} => {
one(condition, &mut out);
block_exprs(body, &mut out);
}
ExprKind::WhileLet { expr, body, .. }
| ExprKind::For {
iter: expr, body, ..
} => {
one(expr, &mut out);
block_exprs(body, &mut out);
}
ExprKind::Loop { body, .. }
| ExprKind::Block(body)
| ExprKind::Unsafe(body)
| ExprKind::Async { body, .. } => block_exprs(body, &mut out),
ExprKind::Handle { handlers, body, .. } => {
block_exprs(body, &mut out);
for h in handlers {
one(&h.body, &mut out);
}
}
ExprKind::Return(Some(x)) | ExprKind::Resume(Some(x)) => one(x, &mut out),
ExprKind::Break { value: Some(x), .. } => one(x, &mut out),
ExprKind::Range { start, end, .. } => {
if let Some(s) = start {
one(s, &mut out);
}
if let Some(x) = end {
one(x, &mut out);
}
}
ExprKind::Closure { body, .. } => one(body, &mut out),
ExprKind::AIQuery { prompt, options } => {
one(prompt, &mut out);
for (_, v) in options {
one(v, &mut out);
}
}
ExprKind::Macro { path, tokens, .. } => {
out.extend(super::macro_args::macro_call_arg_exprs(
¯o_name(path),
tokens,
));
}
_ => {}
}
out
}
pub(super) fn descendants(e: &Expr) -> Vec<Expr> {
let mut out = Vec::new();
let mut stack = vec![e.clone()];
while let Some(x) = stack.pop() {
let kids = children(&x);
out.push(x);
stack.extend(kids.into_iter().rev());
}
out
}
pub(super) fn pattern_names(p: &Pattern, out: &mut BTreeSet<String>) {
match &p.kind {
PatternKind::Ident {
name, subpattern, ..
} => {
out.insert(name.name.to_string());
if let Some(s) = subpattern {
pattern_names(s, out);
}
}
PatternKind::Tuple(ps) | PatternKind::Slice(ps) | PatternKind::Or(ps) => {
ps.iter().for_each(|x| pattern_names(x, out))
}
PatternKind::TupleStruct { patterns, .. } => {
patterns.iter().for_each(|x| pattern_names(x, out))
}
PatternKind::Struct { fields, .. } => {
fields.iter().for_each(|f| pattern_names(&f.pattern, out))
}
PatternKind::Ref { pattern, .. }
| PatternKind::Box(pattern)
| PatternKind::Paren(pattern) => pattern_names(pattern, out),
_ => {}
}
}
pub(super) fn bound_names(e: &Expr) -> BTreeSet<String> {
let mut out = BTreeSet::new();
for x in descendants(e) {
match &x.kind {
ExprKind::Block(b)
| ExprKind::Loop { body: b, .. }
| ExprKind::While { body: b, .. }
| ExprKind::Unsafe(b) => block_bound(b, &mut out),
ExprKind::If { then_branch, .. } => block_bound(then_branch, &mut out),
ExprKind::IfLet {
pattern,
then_branch,
..
} => {
pattern_names(pattern, &mut out);
block_bound(then_branch, &mut out);
}
ExprKind::WhileLet { pattern, body, .. } | ExprKind::For { pattern, body, .. } => {
pattern_names(pattern, &mut out);
block_bound(body, &mut out);
}
ExprKind::Match { arms, .. } => arms
.iter()
.for_each(|a| pattern_names(&a.pattern, &mut out)),
ExprKind::Closure { params, .. } => params
.iter()
.for_each(|p| pattern_names(&p.pattern, &mut out)),
_ => {}
}
}
out
}
fn block_bound(b: &ast::Block, out: &mut BTreeSet<String>) {
for s in &b.stmts {
if let StmtKind::Local(l) = &s.kind {
pattern_names(&l.pattern, out);
}
}
}
pub(super) fn read_names(e: &Expr) -> BTreeSet<String> {
descendants(e).iter().filter_map(simple_name).collect()
}
pub(super) fn direct_effects(e: &Expr, rows: &HashMap<String, Vec<String>>) -> BTreeSet<String> {
let mut out = BTreeSet::new();
for x in descendants(e) {
match &x.kind {
ExprKind::Macro { path, .. } => {
if let Some(eff) = capability_effect_for_macro(¯o_name(path)) {
out.insert(eff.to_string());
}
}
ExprKind::Perform { effect, .. } => {
out.insert(effect.name.to_string());
}
ExprKind::Call { func, .. } => {
if let Some(name) = simple_name(func) {
if let Some(row) = rows.get(&name) {
out.extend(row.iter().cloned());
} else if let Some(eff) = capability_effect_for_call(&name) {
out.insert(eff.to_string());
}
}
}
_ => {}
}
}
out
}
fn root_name(e: &Expr) -> Option<String> {
match &e.kind {
ExprKind::Field { expr, .. }
| ExprKind::TupleField { expr, .. }
| ExprKind::Index { expr, .. }
| ExprKind::Deref(expr)
| ExprKind::Paren(expr) => root_name(expr),
_ => simple_name(e),
}
}
pub(super) fn written_names(e: &Expr) -> BTreeSet<String> {
let mut out = BTreeSet::new();
for x in descendants(e) {
match &x.kind {
ExprKind::Assign { target, .. } => out.extend(root_name(target)),
ExprKind::MethodCall {
receiver, method, ..
} if MUTATING_METHODS.contains(&method.name.as_ref()) => {
out.extend(root_name(receiver))
}
_ => {}
}
}
out
}
pub(super) fn called_names(e: &Expr) -> BTreeSet<String> {
descendants(e)
.iter()
.filter_map(|x| match &x.kind {
ExprKind::Call { func, .. } => simple_name(func),
_ => None,
})
.collect()
}
pub(super) fn body_expr(f: &ast::FnDef) -> Option<Expr> {
let b = f.body.as_ref()?;
Some(Expr {
kind: ExprKind::Block(b.clone()),
span: b.span,
id: b.id,
attrs: Vec::new(),
})
}