use std::collections::{HashMap, HashSet};
use std::ops::Range;
use rhai::{ASTNode, Engine, Expr, Ident, Position, Stmt, Token};
use crate::lex::Tok;
use crate::stream::LineIndex;
#[derive(Debug, Clone)]
pub struct Binding {
pub name: String,
pub decl: usize,
pub scope: Range<usize>,
pub sites: Vec<usize>,
}
#[derive(Debug, Default)]
pub struct Analysis {
pub bindings: Vec<Binding>,
pub unclassified: Vec<(usize, String)>,
pub taken: HashSet<String>,
}
struct Blocks(Vec<Range<usize>>);
impl Blocks {
fn new(toks: &[&Tok]) -> Self {
let mut open: Vec<usize> = Vec::new();
let mut ranges = Vec::new();
for tok in toks {
match tok.token {
Token::LeftBrace | Token::MapStart => open.push(tok.span.start),
Token::RightBrace => {
if let Some(start) = open.pop() {
ranges.push(start..tok.span.end);
}
}
_ => (),
}
}
Self(ranges)
}
fn innermost(&self, offset: usize) -> Option<&Range<usize>> {
self.0
.iter()
.filter(|r| r.start < offset && offset < r.end)
.max_by_key(|r| r.start)
}
fn containing(&self, offset: usize) -> Option<Range<usize>> {
self.innermost(offset).cloned()
}
}
fn body_block(toks: &[&Tok], from: usize, blocks: &Blocks) -> Option<Range<usize>> {
let mut depth = 0i32;
for tok in &toks[from..] {
match tok.token {
Token::LeftParen | Token::LeftBracket | Token::MapStart => depth += 1,
Token::RightParen | Token::RightBracket | Token::RightBrace if depth > 0 => depth -= 1,
Token::LeftBrace if depth == 0 => {
return blocks.0.iter().find(|r| r.start == tok.span.start).cloned();
}
Token::LeftBrace => depth += 1,
_ => (),
}
}
None
}
#[derive(Default)]
struct FromAst {
decls: Vec<(usize, String, DeclKind)>,
refs: Vec<(usize, String)>,
blocked: HashSet<usize>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum DeclKind {
Var,
Loop,
Catch,
}
fn walk_ast(src: &str, lines: &LineIndex, engine: &Engine) -> Result<FromAst, String> {
let ast = engine
.compile(src)
.map_err(|e| format!("input script does not parse: {e}"))?;
let mut found = FromAst::default();
let offset_of = |pos: Position| lines.byte_offset_of(src, pos);
let visit = |node: &ASTNode, found: &mut FromAst| match node {
ASTNode::Stmt(stmt) => match stmt {
Stmt::Var(x, ..) => push_decl(&mut found.decls, &x.0, DeclKind::Var, &offset_of),
Stmt::For(x, ..) => {
push_decl(&mut found.decls, &x.0, DeclKind::Loop, &offset_of);
if let Some(counter) = &x.1 {
push_decl(&mut found.decls, counter, DeclKind::Loop, &offset_of);
}
}
Stmt::TryCatch(x, ..) => {
if let Expr::Variable(v, .., pos) = &x.expr
&& let Some(offset) = offset_of(*pos)
{
found.decls.push((offset, v.1.to_string(), DeclKind::Catch));
}
}
_ => (),
},
ASTNode::Expr(expr) => match expr {
Expr::Variable(x, .., pos) => {
if let Some(offset) = offset_of(*pos) {
found.refs.push((offset, x.1.to_string()));
}
}
Expr::Property(x, pos) => {
if let Some(offset) = offset_of(*pos) {
found.blocked.insert(offset);
}
let _ = &x.2;
}
Expr::Map(x, ..) => {
for (key, _) in x.0.iter() {
if let Some(offset) = offset_of(key.pos) {
found.blocked.insert(offset);
}
}
}
_ => (),
},
_ => (),
};
let path = &mut Vec::new();
for stmt in ast.statements() {
stmt.walk(path, &mut |p| {
if let Some(node) = p.last() {
visit(node, &mut found);
}
true
});
}
#[cfg(not(feature = "no_function"))]
for func in ast.iter_fn_def() {
for stmt in func.body.iter() {
stmt.walk(path, &mut |p| {
if let Some(node) = p.last() {
visit(node, &mut found);
}
true
});
}
}
Ok(found)
}
fn push_decl(
out: &mut Vec<(usize, String, DeclKind)>,
ident: &Ident,
kind: DeclKind,
offset_of: &impl Fn(Position) -> Option<usize>,
) {
if let Some(offset) = offset_of(ident.pos) {
out.push((offset, ident.name.to_string(), kind));
}
}
mod keywords {
use rhai::Token;
fn lookup(syntax: &str) -> Option<Token> {
Token::lookup_symbol_from_syntax(syntax)
}
pub fn fn_decl() -> Option<Token> {
lookup("fn")
}
pub fn module_alias() -> Option<Token> {
lookup("as")
}
pub fn elvis() -> Option<Token> {
lookup("?.")
}
}
fn is_keyword(token: &Token, expected: &Option<Token>) -> bool {
expected.as_ref() == Some(token)
}
fn parameter_lists(toks: &[&Tok], blocks: &Blocks) -> Parameters {
let mut found = Parameters::default();
let fn_decl = keywords::fn_decl();
for (i, tok) in toks.iter().enumerate() {
let header = if is_keyword(&tok.token, &fn_decl) {
let mut j = i + 1;
while j < toks.len() && !matches!(toks[j].token, Token::LeftParen | Token::Unit) {
j += 1;
}
match toks.get(j).map(|t| &t.token) {
Some(Token::Unit) => Some((Vec::new(), j)),
Some(Token::LeftParen) => read_params(toks, j + 1, Token::RightParen),
_ => None,
}
} else if matches!(tok.token, Token::Pipe) {
read_params(toks, i + 1, Token::Pipe)
} else {
continue;
};
let Some((params, after)) = header else {
continue;
};
found.known.extend(params.iter().copied());
if let Some(body) = body_block(toks, after, blocks) {
found.scoped.push((body, params));
}
}
found
}
fn statement_end(toks: &[&Tok], from: usize) -> Option<usize> {
let mut depth = 0i32;
for tok in &toks[from..] {
match tok.token {
Token::LeftParen | Token::LeftBracket | Token::LeftBrace | Token::MapStart => {
depth += 1
}
Token::RightParen | Token::RightBracket | Token::RightBrace if depth > 0 => depth -= 1,
Token::SemiColon if depth == 0 => return Some(tok.span.end),
_ => (),
}
}
None
}
fn read_params(toks: &[&Tok], from: usize, closer: Token) -> Option<(Vec<usize>, usize)> {
let mut params = Vec::new();
for (offset, tok) in toks.iter().enumerate().skip(from) {
match &tok.token {
t if *t == closer => return Some((params, offset)),
Token::Identifier(..) => params.push(tok.span.start),
Token::Comma => (),
_ => return None,
}
}
None
}
#[derive(Default)]
struct Parameters {
known: HashSet<usize>,
scoped: Vec<(Range<usize>, Vec<usize>)>,
}
fn syntactic_non_variables(toks: &[&Tok]) -> HashSet<usize> {
let (fn_decl, module_alias, elvis) = (
keywords::fn_decl(),
keywords::module_alias(),
keywords::elvis(),
);
let mut out = HashSet::new();
for (i, tok) in toks.iter().enumerate() {
if !matches!(tok.token, Token::Identifier(..)) {
continue;
}
let next = toks.get(i + 1).map(|t| &t.token);
let prev = i.checked_sub(1).and_then(|p| toks.get(p)).map(|t| &t.token);
let is_call = matches!(next, Some(Token::LeftParen | Token::Unit | Token::Bang));
let is_namespaced =
matches!(next, Some(Token::DoubleColon)) || matches!(prev, Some(Token::DoubleColon));
let is_member =
matches!(prev, Some(Token::Period)) || prev.is_some_and(|p| is_keyword(p, &elvis));
let follows_keyword =
prev.is_some_and(|p| is_keyword(p, &fn_decl) || is_keyword(p, &module_alias));
if is_call || is_namespaced || is_member || follows_keyword {
out.insert(tok.span.start);
}
}
out
}
pub fn analyse(engine: &Engine, src: &str, toks: &[Tok]) -> Result<Analysis, String> {
let lines = LineIndex::new(src);
let from_ast = walk_ast(src, &lines, engine)?;
let significant: Vec<&Tok> = toks.iter().filter(|t| !t.is_comment()).collect();
let blocks = Blocks::new(&significant);
let non_variables = syntactic_non_variables(&significant);
let params = parameter_lists(&significant, &blocks);
let mut analysis = Analysis::default();
for tok in &significant {
if let Token::Identifier(name) = &tok.token {
analysis.taken.insert(name.to_string());
}
}
let ref_offsets: HashMap<usize, String> = from_ast.refs.iter().cloned().collect();
let decl_offsets: HashMap<usize, (String, DeclKind)> = from_ast
.decls
.iter()
.map(|(o, n, k)| (*o, (n.clone(), *k)))
.collect();
for tok in &significant {
if !matches!(tok.token, Token::Identifier(..)) {
continue;
}
let at = tok.span.start;
let explained = ref_offsets.contains_key(&at)
|| decl_offsets.contains_key(&at)
|| params.known.contains(&at)
|| from_ast.blocked.contains(&at)
|| non_variables.contains(&at);
if !explained {
analysis.unclassified.push((at, tok.text(src).to_string()));
}
}
if !analysis.unclassified.is_empty() {
return Ok(analysis);
}
let mut candidates: Vec<Binding> = Vec::new();
for (offset, name, kind) in &from_ast.decls {
let token_index = significant.iter().position(|t| t.span.start == *offset);
let scope = match kind {
DeclKind::Var => match (blocks.containing(*offset), token_index) {
(Some(block), Some(i)) => {
let start = statement_end(&significant, i)
.unwrap_or(*offset)
.min(block.end);
start..block.end
}
_ => continue,
},
DeclKind::Loop | DeclKind::Catch => {
match token_index.and_then(|i| body_block(&significant, i, &blocks)) {
Some(body) => body,
None => continue,
}
}
};
candidates.push(Binding {
name: name.clone(),
decl: *offset,
scope,
sites: vec![*offset],
});
}
for (body, offsets) in ¶ms.scoped {
for offset in offsets {
let name = significant
.iter()
.find(|t| t.span.start == *offset)
.map(|t| t.text(src).to_string());
if let Some(name) = name {
candidates.push(Binding {
name,
decl: *offset,
scope: body.clone(),
sites: vec![*offset],
});
}
}
}
for (offset, name) in &from_ast.refs {
let winner = candidates
.iter()
.enumerate()
.filter(|(_, b)| &b.name == name && b.decl <= *offset && b.scope.contains(offset))
.max_by_key(|(_, b)| b.decl)
.map(|(i, _)| i);
if let Some(i) = winner {
candidates[i].sites.push(*offset);
}
}
for (offset, name) in &from_ast.refs {
let covered = candidates
.iter()
.any(|b| b.sites.contains(offset) && &b.name == name);
if !covered {
analysis.taken.insert(name.clone());
}
}
analysis.bindings = candidates;
Ok(analysis)
}