refactor(natu): rename xatu

src/natu/scope_graph.rs

@@ -0,0 +1,194 @@
+use crate::ast::{self, ParsedFile};
+
+#[derive(Debug)]
+pub(crate) struct ScopeGraph {
+    nodes: Vec<Node>,
+    edges: Vec<Edge>,
+    lets: Vec<LetScope>,
+}
+
+impl ScopeGraph {
+    pub(crate) fn from_file(file: &ParsedFile) -> Self {
+        let mut graph = Self {
+            nodes: Vec::new(),
+            edges: Vec::new(),
+            lets: Vec::new(),
+        };
+        let root = graph.add_scope(None);
+        graph.build_expr(&file.root, root);
+        graph
+    }
+
+    pub(crate) fn let_scopes(&self) -> &[LetScope] {
+        &self.lets
+    }
+
+    fn build_expr(&mut self, expr: &ast::Expr, scope: NodeId) -> Vec<NodeId> {
+        match expr {
+            ast::Expr::Ident(ident) => vec![self.add_reference(&ident.name, scope)],
+            ast::Expr::Let { bindings, body } => self.build_let(bindings, body, scope),
+            ast::Expr::AttrSet(bindings) => bindings
+                .iter()
+                .flat_map(|binding| self.build_expr(&binding.value, scope))
+                .collect(),
+            ast::Expr::Lambda { parameters, body } => {
+                let scope = self.add_scope(Some(scope));
+                for parameter in parameters {
+                    self.add_declaration(&parameter.name, scope);
+                }
+                self.build_expr(body, scope)
+            }
+            ast::Expr::Other(expressions) => expressions
+                .iter()
+                .flat_map(|expression| self.build_expr(expression, scope))
+                .collect(),
+            ast::Expr::Select(_) => Vec::new(),
+        }
+    }
+
+    fn build_let(
+        &mut self,
+        bindings: &[ast::Binding],
+        body: &ast::Expr,
+        parent: NodeId,
+    ) -> Vec<NodeId> {
+        let scope = self.add_scope(Some(parent));
+        let mut graph_bindings = bindings
+            .iter()
+            .map(|binding| Binding {
+                declaration: self.add_declaration(&binding.key.name, scope),
+                name: binding.key.name.clone(),
+                references: Vec::new(),
+                range: binding.range,
+            })
+            .collect::<Vec<_>>();
+
+        for (binding, graph_binding) in bindings.iter().zip(&mut graph_bindings) {
+            graph_binding.references = self.build_expr(&binding.value, scope);
+        }
+
+        let entry_references = self.build_expr(body, scope);
+        let references = graph_bindings
+            .iter()
+            .flat_map(|binding| binding.references.iter().copied())
+            .chain(entry_references.iter().copied())
+            .collect();
+        self.lets.push(LetScope {
+            bindings: graph_bindings,
+            entry_references,
+        });
+
+        references
+    }
+
+    pub(crate) fn resolve(&self, reference: NodeId) -> Vec<NodeId> {
+        let Node::Reference(name) = &self.nodes[reference.0] else {
+            return Vec::new();
+        };
+        let Some(mut scope) = self.edge_target(reference, Node::is_scope) else {
+            return Vec::new();
+        };
+
+        loop {
+            let declarations = self
+                .edge_targets(scope, |node| matches!(node, Node::Declaration(declaration) if declaration.name == *name))
+                .collect::<Vec<_>>();
+            if !declarations.is_empty() {
+                return declarations;
+            }
+
+            let Some(parent) = self.edge_target(scope, Node::is_scope) else {
+                return Vec::new();
+            };
+            scope = parent;
+        }
+    }
+
+    fn add_scope(&mut self, parent: Option<NodeId>) -> NodeId {
+        let scope = self.add_node(Node::Scope);
+        if let Some(parent) = parent {
+            self.add_edge(scope, parent);
+        }
+        scope
+    }
+
+    fn add_declaration(&mut self, name: &str, scope: NodeId) -> NodeId {
+        let declaration = self.add_node(Node::Declaration(Declaration {
+            name: name.to_owned(),
+        }));
+        self.add_edge(scope, declaration);
+        declaration
+    }
+
+    fn add_reference(&mut self, name: &str, scope: NodeId) -> NodeId {
+        let reference = self.add_node(Node::Reference(name.to_owned()));
+        self.add_edge(reference, scope);
+        reference
+    }
+
+    fn add_node(&mut self, node: Node) -> NodeId {
+        let id = NodeId(self.nodes.len());
+        self.nodes.push(node);
+        id
+    }
+
+    fn add_edge(&mut self, from: NodeId, to: NodeId) {
+        self.edges.push(Edge { from, to });
+    }
+
+    fn edge_target(&self, from: NodeId, predicate: fn(&Node) -> bool) -> Option<NodeId> {
+        self.edge_targets(from, predicate).next()
+    }
+
+    fn edge_targets<'graph>(
+        &'graph self,
+        from: NodeId,
+        predicate: impl Fn(&Node) -> bool + 'graph,
+    ) -> impl Iterator<Item = NodeId> + 'graph {
+        self.edges
+            .iter()
+            .filter(move |edge| edge.from == from && predicate(&self.nodes[edge.to.0]))
+            .map(|edge| edge.to)
+    }
+}
+
+#[derive(Debug)]
+enum Node {
+    Scope,
+    Declaration(Declaration),
+    Reference(String),
+}
+
+impl Node {
+    fn is_scope(&self) -> bool {
+        matches!(self, Self::Scope)
+    }
+}
+
+#[derive(Debug)]
+struct Declaration {
+    name: String,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) struct NodeId(usize);
+
+#[derive(Debug)]
+struct Edge {
+    from: NodeId,
+    to: NodeId,
+}
+
+#[derive(Debug)]
+pub(crate) struct LetScope {
+    pub(crate) bindings: Vec<Binding>,
+    pub(crate) entry_references: Vec<NodeId>,
+}
+
+#[derive(Debug)]
+pub(crate) struct Binding {
+    pub(crate) declaration: NodeId,
+    pub(crate) name: String,
+    pub(crate) references: Vec<NodeId>,
+    pub(crate) range: ast::SourceRange,
+}