init

.gitignore

···
+target/

Cargo.lock

···
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "ahash"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0453232ace82dee0dd0b4c87a59bd90f7b53b314f3e0f61fe2ee7c8a16482289"
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "cc"
+version = "1.0.83"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "darling"
+version = "0.20.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c376d08ea6aa96aafe61237c7200d1241cb177b7d3a542d791f2d118e9cbb955"
+dependencies = [
+ "darling_core",
+ "darling_macro",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.20.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33043dcd19068b8192064c704b3f83eb464f91f1ff527b44a4e2b08d9cdb8855"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.20.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5a91391accf613803c2a9bf9abccdbaa07c54b4244a5b64883f9c3c137c86be"
+dependencies = [
+ "darling_core",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "derive_builder"
+version = "0.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0350b5cb0331628a5916d6c5c0b72e97393b8b6b03b47a9284f4e7f5a405ffd7"
+dependencies = [
+ "derive_builder_macro",
+]
+
+[[package]]
+name = "derive_builder_core"
+version = "0.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d48cda787f839151732d396ac69e3473923d54312c070ee21e9effcaa8ca0b1d"
+dependencies = [
+ "darling",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "derive_builder_macro"
+version = "0.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "206868b8242f27cecce124c19fd88157fbd0dd334df2587f36417bafbc85097b"
+dependencies = [
+ "derive_builder_core",
+ "syn",
+]
+
+[[package]]
+name = "dissimilar"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86e3bdc80eee6e16b2b6b0f87fbc98c04bee3455e35174c0de1a125d0688c632"
+
+[[package]]
+name = "equivalent"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
+
+[[package]]
+name = "expect-test"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30d9eafeadd538e68fb28016364c9732d78e420b9ff8853fa5e4058861e9f8d3"
+dependencies = [
+ "dissimilar",
+ "once_cell",
+]
+
+[[package]]
+name = "fixedbitset"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "hashbrown"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7afe4a420e3fe79967a00898cc1f4db7c8a49a9333a29f8a4bd76a253d5cd04"
+dependencies = [
+ "ahash",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.14.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604"
+
+[[package]]
+name = "ident_case"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
+[[package]]
+name = "indexmap"
+version = "2.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "233cf39063f058ea2caae4091bf4a3ef70a653afbc026f5c4a4135d114e3c177"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.14.3",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1a46d1a171d865aa5f83f92695765caa047a9b4cbae2cbf37dbd613a793fd4c"
+
+[[package]]
+name = "libc"
+version = "0.2.153"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
+
+[[package]]
+name = "log"
+version = "0.4.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f"
+
+[[package]]
+name = "memchr"
+version = "2.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149"
+
+[[package]]
+name = "once_cell"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+
+[[package]]
+name = "petgraph"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1d3afd2628e69da2be385eb6f2fd57c8ac7977ceeff6dc166ff1657b0e386a9"
+dependencies = [
+ "fixedbitset",
+ "indexmap",
+ "serde",
+ "serde_derive",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2422ad645d89c99f8f3e6b88a9fdeca7fabeac836b1002371c4367c8f984aae"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "regex"
+version = "1.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b62dbe01f0b06f9d8dc7d49e05a0785f153b00b2c227856282f671e0318c9b15"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5bb987efffd3c6d0d8f5f89510bb458559eab11e4f869acb20bf845e016259cd"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
+
+[[package]]
+name = "ryu"
+version = "1.0.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f98d2aa92eebf49b69786be48e4477826b256916e84a57ff2a4f21923b48eb4c"
+
+[[package]]
+name = "serde"
+version = "1.0.196"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "870026e60fa08c69f064aa766c10f10b1d62db9ccd4d0abb206472bee0ce3b32"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.196"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33c85360c95e7d137454dc81d9a4ed2b8efd8fbe19cee57357b32b9771fccb67"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.113"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69801b70b1c3dac963ecb03a364ba0ceda9cf60c71cfe475e99864759c8b8a79"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "smallvec"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6ecd384b10a64542d77071bd64bd7b231f4ed5940fba55e98c3de13824cf3d7"
+
+[[package]]
+name = "stag"
+version = "0.1.0"
+dependencies = [
+ "derive_builder",
+ "expect-test",
+ "once_cell",
+ "petgraph",
+ "serde",
+ "thiserror",
+ "tree-sitter",
+ "tree-sitter-graph",
+ "tree-sitter-rust",
+]
+
+[[package]]
+name = "string-interner"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "383196d1876517ee6f9f0864d1fc1070331b803335d3c6daaa04bbcccd823c08"
+dependencies = [
+ "cfg-if",
+ "hashbrown 0.9.1",
+]
+
+[[package]]
+name = "strsim"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
+
+[[package]]
+name = "syn"
+version = "2.0.48"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f3531638e407dfc0814761abb7c00a5b54992b849452a0646b7f65c9f770f3f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e45bcbe8ed29775f228095caf2cd67af7a4ccf756ebff23a306bf3e8b47b24b"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a953cb265bef375dae3de6663da4d3804eee9682ea80d8e2542529b73c531c81"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tree-sitter"
+version = "0.20.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e747b1f9b7b931ed39a548c1fae149101497de3c1fc8d9e18c62c1a66c683d3d"
+dependencies = [
+ "cc",
+ "regex",
+]
+
+[[package]]
+name = "tree-sitter-graph"
+version = "0.11.0"
+dependencies = [
+ "log",
+ "regex",
+ "serde",
+ "serde_json",
+ "smallvec",
+ "string-interner",
+ "thiserror",
+ "tree-sitter",
+]
+
+[[package]]
+name = "tree-sitter-rust"
+version = "0.20.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0832309b0b2b6d33760ce5c0e818cb47e1d72b468516bfe4134408926fa7594"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"

Cargo.toml

···
+[package]
+name = "stag"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+
+[dependencies]
+petgraph = { version = "0.6.4", default-features = false, features = ["serde-1"] }
+serde = {version = "1.0.188", features = ["derive"]}
+once_cell = "1.19.0"
+thiserror = "1.0.56"
+tree-sitter-graph = { path = "../tree-sitter-graph/"}
+tree-sitter-rust = "0.20.4"
+tree-sitter = "0.20.10"
+derive_builder = "0.20.0"
+expect-test = "1.4.1"
+

src/debug.rs

···
+use std::fmt;
+
+use crate::text_range::TextRange;
+use crate::{EdgeKind, LocalDef, NodeKind};
+
+use petgraph::{
+    graph::{Graph, NodeIndex},
+    visit::EdgeRef,
+    Direction,
+};
+
+pub struct ScopeDebug {
+    range: TextRange,
+    defs: Vec<DefDebug>,
+    imports: Vec<ImportDebug>,
+    scopes: Vec<ScopeDebug>,
+}
+
+struct DefDebug {
+    name: String,
+    range: TextRange,
+    context: String,
+    refs: Vec<RefDebug>,
+}
+
+struct RefDebug {
+    context: String,
+}
+
+struct ImportDebug {
+    name: String,
+    range: TextRange,
+    context: String,
+    refs: Vec<RefDebug>,
+}
+
+impl DefDebug {
+    fn new(range: TextRange, name: String, refs: Vec<TextRange>, src: &[u8]) -> Self {
+        Self {
+            name,
+            range,
+            context: context(range, src),
+            refs: refs
+                .into_iter()
+                .map(|r| context(r, src))
+                .map(|context| RefDebug { context })
+                .collect(),
+        }
+    }
+}
+
+impl ImportDebug {
+    fn new(range: TextRange, name: String, refs: Vec<TextRange>, src: &[u8]) -> Self {
+        Self {
+            name,
+            range,
+            context: context(range, src),
+            refs: refs
+                .into_iter()
+                .map(|r| context(r, src))
+                .map(|context| RefDebug { context })
+                .collect(),
+        }
+    }
+}
+
+impl ScopeDebug {
+    fn empty(range: TextRange) -> Self {
+        Self {
+            range,
+            defs: Vec::new(),
+            imports: Vec::new(),
+            scopes: Vec::new(),
+        }
+    }
+
+    fn build(&mut self, graph: &Graph<NodeKind, EdgeKind>, start: NodeIndex<u32>, src: &[u8]) {
+        let mut defs = graph
+            .edges_directed(start, Direction::Incoming)
+            .filter(|edge| *edge.weight() == EdgeKind::DefToScope)
+            .map(|edge| {
+                let def_node = edge.source();
+
+                // range of this def
+                let range = graph[def_node].range();
+
+                // text source of this def
+                let text = std::str::from_utf8(&src[range.start.byte..range.end.byte])
+                    .unwrap()
+                    .to_owned();
+
+                // all references of this def, sorted by range
+                let mut refs = graph
+                    .edges_directed(def_node, Direction::Incoming)
+                    .filter(|edge| *edge.weight() == EdgeKind::RefToDef)
+                    .map(|edge| graph[edge.source()].range())
+                    .collect::<Vec<_>>();
+
+                refs.sort();
+
+                DefDebug::new(range, text, refs, src)
+            })
+            .collect::<Vec<_>>();
+
+        let mut imports = graph
+            .edges_directed(start, Direction::Incoming)
+            .filter(|edge| *edge.weight() == EdgeKind::ImportToScope)
+            .map(|edge| {
+                let imp_node = edge.source();
+
+                // range of this import
+                let range = graph[imp_node].range();
+
+                // text source of this import
+                let text = std::str::from_utf8(&src[range.start.byte..range.end.byte])
+                    .unwrap()
+                    .to_owned();
+
+                // all references of this import, sorted by range
+                let mut refs = graph
+                    .edges_directed(imp_node, Direction::Incoming)
+                    .filter(|edge| *edge.weight() == EdgeKind::RefToImport)
+                    .map(|edge| graph[edge.source()].range())
+                    .collect::<Vec<_>>();
+
+                refs.sort();
+
+                ImportDebug::new(range, text, refs, src)
+            })
+            .collect::<Vec<_>>();
+
+        let mut scopes = graph
+            .edges_directed(start, Direction::Incoming)
+            .filter(|edge| *edge.weight() == EdgeKind::ScopeToScope)
+            .map(|edge| {
+                let source_scope = edge.source();
+                let mut scope_debug = ScopeDebug::empty(graph[source_scope].range());
+                scope_debug.build(graph, source_scope, src);
+                scope_debug
+            })
+            .collect::<Vec<_>>();
+
+        // sort defs by their ranges
+        defs.sort_by(|a, b| a.range.cmp(&b.range));
+        // sort imports by their ranges
+        imports.sort_by(|a, b| a.range.cmp(&b.range));
+        // sort scopes by their ranges
+        scopes.sort_by(|a, b| a.range.cmp(&b.range));
+
+        self.defs = defs;
+        self.imports = imports;
+        self.scopes = scopes;
+    }
+
+    pub fn new(graph: &Graph<NodeKind, EdgeKind>, start: NodeIndex<u32>, src: &[u8]) -> Self {
+        let mut scope_debug = Self::empty(graph[start].range());
+        scope_debug.build(graph, start, src);
+        scope_debug
+    }
+}
+
+impl fmt::Debug for ScopeDebug {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.imports.is_empty() {
+            f.debug_struct("scope")
+                .field("definitions", &self.defs)
+                .field("child scopes", &self.scopes)
+                .finish()
+        } else {
+            f.debug_struct("scope")
+                .field("definitions", &self.defs)
+                .field("imports", &self.imports)
+                .field("child scopes", &self.scopes)
+                .finish()
+        }
+    }
+}
+
+impl fmt::Debug for DefDebug {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut s = f.debug_struct(&self.name);
+        let d = s.field("context", &self.context);
+
+        if self.refs.is_empty() {
+            d
+        } else {
+            d.field(&format!("referenced in ({})", self.refs.len()), &self.refs)
+        }
+        .finish()
+    }
+}
+
+impl fmt::Debug for ImportDebug {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut s = f.debug_struct(&self.name);
+        let d = s.field("context", &self.context);
+
+        if self.refs.is_empty() {
+            d
+        } else {
+            d.field(&format!("referenced in ({})", self.refs.len()), &self.refs)
+        }
+        .finish()
+    }
+}
+
+impl fmt::Debug for RefDebug {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "`{}`", self.context)
+    }
+}
+
+fn context(range: TextRange, src: &[u8]) -> String {
+    // first new line before start
+    let context_start = src
+        .iter()
+        .enumerate()
+        .take(range.start.byte)
+        .rev()
+        .find_map(|(idx, &c)| (c == b'\n').then_some(idx))
+        .unwrap_or(range.start.byte - 1)
+        .saturating_add(1);
+
+    // first new line after end
+    let context_end: usize = src
+        .iter()
+        .enumerate()
+        .skip(range.end.byte)
+        .find_map(|(idx, &c)| (c == b'\n').then_some(idx))
+        .unwrap_or(range.end.byte + 1)
+        .saturating_sub(1);
+
+    let from_utf8 = |bytes| std::str::from_utf8(bytes).unwrap();
+    format!(
+        "{}§{}§{}",
+        from_utf8(&src[context_start..range.start.byte]).trim_start(),
+        from_utf8(&src[range.start.byte..range.end.byte]),
+        from_utf8(&src[range.end.byte..=context_end]).trim_end()
+    )
+}

src/error.rs

···
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum StagError {
+    #[error("tree-sitter: {0}")]
+    TreeSitter(#[from] tree_sitter::LanguageError),
+
+    #[error("config error: {0}")]
+    Config(#[from] ConfigError),
+}
+
+#[derive(Error, Debug)]
+pub enum ConfigError {
+    #[error("no language configured")]
+    MissingLanguage,
+
+    #[error("no stag query configured")]
+    MissingStagSource,
+
+    #[error("no source file configured")]
+    MissingSource,
+
+    #[error("parse error: {0}")]
+    Parse(#[from] tree_sitter_graph::ParseError),
+
+    #[error("tree-sitter graph execution error: {0}")]
+    TsgExecute(#[from] tree_sitter_graph::ExecutionError),
+}

src/lib.rs

···
+mod text_range;
+use petgraph::{graph::NodeIndex, visit::EdgeRef, Direction, Graph};
+use serde::{Deserialize, Serialize};
+use text_range::TextRange;
+use tree_sitter_graph::{
+    ast::File, functions::Functions, ExecutionConfig, Identifier, NoCancellation, Variables,
+};
+
+mod debug;
+mod error;
+mod stdlib;
+
+use error::{ConfigError, StagError};
+
+#[derive(Default)]
+pub struct StagBuilder<'a> {
+    language: Option<tree_sitter::Language>,
+    stag_file: Option<&'a str>,
+    filename: Option<&'a str>,
+    source: Option<&'a str>,
+}
+
+impl<'a> StagBuilder<'a> {
+    pub fn with_language(&mut self, language: tree_sitter::Language) -> &mut Self {
+        self.language = Some(language);
+        self
+    }
+
+    pub fn with_stag_file(&mut self, stag_file: &'a str) -> &mut Self {
+        self.stag_file = Some(stag_file);
+        self
+    }
+
+    pub fn with_source(&mut self, source: &'a str) -> &mut Self {
+        self.source = Some(source);
+        self
+    }
+
+    pub fn with_file_name(&mut self, filename: &'a str) -> &mut Self {
+        self.filename = Some(filename);
+        self
+    }
+
+    pub fn execute(&self) -> Result<ScopeGraph, StagError> {
+        let mut parser = tree_sitter::Parser::new();
+        let language = self.language.ok_or(ConfigError::MissingLanguage)?;
+        parser.set_language(language)?;
+
+        let file = File::from_str(
+            language,
+            self.stag_file.ok_or(ConfigError::MissingStagSource)?,
+        )
+        .map_err(ConfigError::from)?;
+
+        let mut functions = Functions::stdlib();
+        functions.add(Identifier::from("scope"), stdlib::ScopeShorthand);
+        functions.add(Identifier::from("def"), stdlib::DefShorthand);
+        functions.add(Identifier::from("ref"), stdlib::RefShortHand);
+        functions.add(Identifier::from("cover"), stdlib::CoverRanges);
+        functions.add(Identifier::from("range"), stdlib::NodeRange);
+        let globals = Variables::new();
+        let config = ExecutionConfig::new(&functions, &globals);
+
+        let src = self.source.ok_or(ConfigError::MissingSource)?;
+        let tree = parser.parse(src.as_bytes(), None).unwrap();
+        let graph = file
+            .execute(&tree, &src, &config, &NoCancellation)
+            .map_err(ConfigError::from)?;
+
+        let mut sg = ScopeGraph::new(tree.root_node().range().into());
+        sg = build_scope_graph(graph, sg);
+        Ok(sg)
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
+pub struct LocalDef {
+    pub range: TextRange,
+    pub text: String,
+    pub symbol: Option<String>,
+}
+
+impl LocalDef {
+    /// Initialize a new definition
+    pub fn new(range: TextRange, text: String, symbol: Option<String>) -> Self {
+        Self {
+            range,
+            text,
+            symbol,
+        }
+    }
+
+    pub fn name<'a>(&self, buffer: &'a [u8]) -> &'a [u8] {
+        &buffer[self.range.start.byte..self.range.end.byte]
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
+pub struct LocalImport {
+    pub range: TextRange,
+    pub text: String,
+}
+
+impl LocalImport {
+    /// Initialize a new import
+    pub fn new(range: TextRange, text: String) -> Self {
+        Self { range, text }
+    }
+
+    pub fn name<'a>(&self, buffer: &'a [u8]) -> &'a [u8] {
+        &buffer[self.range.start.byte..self.range.end.byte]
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Reference {
+    pub range: TextRange,
+    pub text: String,
+    pub symbol: Option<String>,
+}
+
+impl Reference {
+    /// Initialize a new reference
+    pub fn new(range: TextRange, text: String, symbol: Option<String>) -> Self {
+        Self {
+            range,
+            text,
+            symbol,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+pub struct LocalScope {
+    pub range: TextRange,
+}
+
+impl LocalScope {
+    pub fn new(range: TextRange) -> Self {
+        Self { range }
+    }
+}
+
+pub struct ScopeStack<'a> {
+    pub scope_graph: &'a ScopeGraph,
+    pub start: Option<NodeIndex<u32>>,
+}
+
+impl<'a> Iterator for ScopeStack<'a> {
+    type Item = NodeIndex<u32>;
+    fn next(&mut self) -> Option<Self::Item> {
+        if let Some(start) = self.start {
+            let parent = self
+                .scope_graph
+                .graph
+                .edges_directed(start, Direction::Outgoing)
+                .find(|edge| *edge.weight() == EdgeKind::ScopeToScope)
+                .map(|edge| edge.target());
+            let original = start;
+            self.start = parent;
+            Some(original)
+        } else {
+            None
+        }
+    }
+}
+
+/// The type of a node in the ScopeGraph
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub enum NodeKind {
+    /// A scope node
+    Scope(LocalScope),
+
+    /// A definition node
+    Def(LocalDef),
+
+    /// An import node
+    Import(LocalImport),
+
+    /// A reference node
+    Ref(Reference),
+}
+
+impl NodeKind {
+    /// Construct a scope node from a range
+    pub fn scope(range: TextRange) -> Self {
+        Self::Scope(LocalScope::new(range))
+    }
+
+    /// Produce the range spanned by this node
+    pub fn range(&self) -> TextRange {
+        match self {
+            Self::Scope(l) => l.range,
+            Self::Def(d) => d.range,
+            Self::Ref(r) => r.range,
+            Self::Import(i) => i.range,
+        }
+    }
+}
+
+/// Describes the relation between two nodes in the ScopeGraph
+#[derive(Serialize, Deserialize, PartialEq, Eq, Copy, Clone, Debug)]
+pub enum EdgeKind {
+    /// The edge weight from a nested scope to its parent scope
+    ScopeToScope,
+
+    /// The edge weight from a definition to its definition scope
+    DefToScope,
+
+    /// The edge weight from an import to its definition scope
+    ImportToScope,
+
+    /// The edge weight from a reference to its definition
+    RefToDef,
+
+    /// The edge weight from a reference to its import
+    RefToImport,
+}
+
+/// A graph representation of scopes and names in a single syntax tree
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct ScopeGraph {
+    /// The raw graph
+    pub graph: Graph<NodeKind, EdgeKind>,
+
+    // Graphs do not have the concept of a `root`, but lexical scopes follow the syntax
+    // tree, and as a result, have a "root" node. The root_idx points to a scope node that
+    // encompasses the entire file: the file-global scope.
+    root_idx: NodeIndex,
+}
+
+impl ScopeGraph {
+    pub fn new(range: TextRange) -> Self {
+        let mut graph = Graph::new();
+        let root_idx = graph.add_node(NodeKind::scope(range));
+        Self { graph, root_idx }
+    }
+
+    pub fn get_node(&self, node_idx: NodeIndex) -> Option<&NodeKind> {
+        self.graph.node_weight(node_idx)
+    }
+
+    /// Insert a local scope into the scope-graph
+    fn insert_local_scope(&mut self, new: LocalScope) {
+        if let Some(parent_scope) = self.scope_by_range(new.range, self.root_idx) {
+            let new_scope = NodeKind::Scope(new);
+            let new_idx = self.graph.add_node(new_scope);
+            self.graph
+                .add_edge(new_idx, parent_scope, EdgeKind::ScopeToScope);
+        }
+    }
+
+    /// Insert a def into the scope-graph
+    fn insert_local_def(&mut self, new: LocalDef) {
+        if let Some(defining_scope) = self.scope_by_range(new.range, self.root_idx) {
+            let new_def = NodeKind::Def(new);
+            let new_idx = self.graph.add_node(new_def);
+            self.graph
+                .add_edge(new_idx, defining_scope, EdgeKind::DefToScope);
+        }
+    }
+
+    /// Insert a def into the scope-graph, at the root scope
+    #[allow(unused)]
+    fn insert_global_def(&mut self, new: LocalDef) {
+        let new_def = NodeKind::Def(new);
+        let new_idx = self.graph.add_node(new_def);
+        self.graph
+            .add_edge(new_idx, self.root_idx, EdgeKind::DefToScope);
+    }
+
+    /// Insert an import into the scope-graph
+    fn insert_local_import(&mut self, new: LocalImport) {
+        if let Some(defining_scope) = self.scope_by_range(new.range, self.root_idx) {
+            let new_imp = NodeKind::Import(new);
+            let new_idx = self.graph.add_node(new_imp);
+            self.graph
+                .add_edge(new_idx, defining_scope, EdgeKind::ImportToScope);
+        }
+    }
+
+    /// Insert a ref into the scope-graph
+    fn insert_ref(&mut self, new: Reference) {
+        let mut possible_defs = vec![];
+        let mut possible_imports = vec![];
+        if let Some(local_scope_idx) = self.scope_by_range(new.range, self.root_idx) {
+            // traverse the scopes from the current-scope to the root-scope
+            for scope in self.scope_stack(local_scope_idx) {
+                // find candidate definitions in each scope
+                for local_def in self
+                    .graph
+                    .edges_directed(scope, Direction::Incoming)
+                    .filter(|edge| *edge.weight() == EdgeKind::DefToScope)
+                    .map(|edge| edge.source())
+                {
+                    if let NodeKind::Def(def) = &self.graph[local_def] {
+                        if new.text == def.text {
+                            match (def.symbol.as_ref(), new.symbol.as_ref()) {
+                                // both contain symbols, but they don't belong to the same namepspace
+                                (Some(d), Some(r)) if d != r => {}
+
+                                // in all other cases, form an edge from the ref to def.
+                                // an empty symbol belongs to all namespaces:
+                                // * (None, None)
+                                // * (None, Some(_))
+                                // * (Some(_), None)
+                                // * (Some(_), Some(_)) if def.namespace == ref.namespace
+                                _ => {
+                                    possible_defs.push(local_def);
+                                }
+                            };
+                        }
+                    }
+                }
+
+                // find candidate imports in each scope
+                for local_import in self
+                    .graph
+                    .edges_directed(scope, Direction::Incoming)
+                    .filter(|edge| *edge.weight() == EdgeKind::ImportToScope)
+                    .map(|edge| edge.source())
+                {
+                    if let NodeKind::Import(import) = &self.graph[local_import] {
+                        if new.text == import.text {
+                            possible_imports.push(local_import);
+                        }
+                    }
+                }
+            }
+        }
+
+        if !possible_defs.is_empty() || !possible_imports.is_empty() {
+            let new_ref = NodeKind::Ref(new);
+            let ref_idx = self.graph.add_node(new_ref);
+            for def_idx in possible_defs {
+                self.graph.add_edge(ref_idx, def_idx, EdgeKind::RefToDef);
+            }
+            for imp_idx in possible_imports {
+                self.graph.add_edge(ref_idx, imp_idx, EdgeKind::RefToImport);
+            }
+        }
+    }
+
+    fn scope_stack(&self, start: NodeIndex) -> ScopeStack<'_> {
+        ScopeStack {
+            scope_graph: self,
+            start: Some(start),
+        }
+    }
+
+    // The smallest scope that encompasses `range`. Start at `start` and narrow down if possible.
+    fn scope_by_range(&self, range: TextRange, start: NodeIndex) -> Option<NodeIndex> {
+        let target_range = self.graph[start].range();
+        if target_range.contains(&range) {
+            let mut child_scopes = self
+                .graph
+                .edges_directed(start, Direction::Incoming)
+                .filter(|edge| *edge.weight() == EdgeKind::ScopeToScope)
+                .map(|edge| edge.source())
+                .collect::<Vec<_>>();
+
+            child_scopes.sort_by_key(|s| self.graph[*s].range());
+            let target_child_scope = child_scopes.binary_search_by(|x| {
+                if self.graph[*x].range().contains(&range) {
+                    std::cmp::Ordering::Equal
+                } else {
+                    self.graph[*x].range().cmp(&range)
+                }
+            });
+
+            if let Some(t) = target_child_scope
+                .ok()
+                .and_then(|idx| child_scopes.get(idx))
+                .and_then(|s| self.scope_by_range(range, *s))
+            {
+                return Some(t);
+            } else {
+                return Some(start);
+            }
+        }
+        None
+    }
+
+    /// Produce a list of interesting ranges: ranges of defs and refs
+    pub fn hoverable_ranges(&self) -> Box<dyn Iterator<Item = TextRange> + '_> {
+        let iterator =
+            self.graph
+                .node_indices()
+                .filter_map(|node_idx| match &self.graph[node_idx] {
+                    NodeKind::Scope(_) => None,
+                    NodeKind::Def(d) => Some(d.range),
+                    NodeKind::Ref(r) => Some(r.range),
+                    NodeKind::Import(i) => Some(i.range),
+                });
+        Box::new(iterator)
+    }
+
+    /// Produce possible definitions for a reference
+    pub fn definitions(
+        &self,
+        reference_node: NodeIndex,
+    ) -> Box<dyn Iterator<Item = NodeIndex> + '_> {
+        let iterator = self
+            .graph
+            .edges_directed(reference_node, Direction::Outgoing)
+            .filter(|edge| *edge.weight() == EdgeKind::RefToDef)
+            .map(|edge| edge.target());
+        Box::new(iterator)
+    }
+
+    /// Produce possible imports for a reference
+    pub fn imports(&self, reference_node: NodeIndex) -> Box<dyn Iterator<Item = NodeIndex> + '_> {
+        let iterator = self
+            .graph
+            .edges_directed(reference_node, Direction::Outgoing)
+            .filter(|edge| *edge.weight() == EdgeKind::RefToImport)
+            .map(|edge| edge.target());
+        Box::new(iterator)
+    }
+
+    /// Produce possible references for a definition/import node
+    pub fn references(
+        &self,
+        definition_node: NodeIndex,
+    ) -> Box<dyn Iterator<Item = NodeIndex> + '_> {
+        let iterator = self
+            .graph
+            .edges_directed(definition_node, Direction::Incoming)
+            .filter(|edge| {
+                *edge.weight() == EdgeKind::RefToDef || *edge.weight() == EdgeKind::RefToImport
+            })
+            .map(|edge| edge.source());
+        Box::new(iterator)
+    }
+
+    pub fn node_by_range(&self, start_byte: usize, end_byte: usize) -> Option<NodeIndex> {
+        self.graph
+            .node_indices()
+            .filter(|&idx| self.is_definition(idx) || self.is_reference(idx) || self.is_import(idx))
+            .find(|&idx| {
+                let node = self.graph[idx].range();
+                start_byte >= node.start.byte && end_byte <= node.end.byte
+            })
+    }
+
+    pub fn node_by_position(&self, line: usize, column: usize) -> Option<NodeIndex> {
+        self.graph
+            .node_indices()
+            .filter(|&idx| self.is_definition(idx) || self.is_reference(idx))
+            .find(|&idx| {
+                let node = self.graph[idx].range();
+                node.start.line == line
+                    && node.end.line == line
+                    && node.start.column <= column
+                    && node.end.column >= column
+            })
+    }
+
+    #[cfg(test)]
+    pub fn find_node_by_name(&self, src: &[u8], name: &[u8]) -> Option<NodeIndex> {
+        self.graph.node_indices().find(|idx| {
+            matches!(
+                    &self.graph[*idx],
+                    NodeKind::Def(d) if d.name(src) == name)
+        })
+    }
+
+    #[cfg(test)]
+    pub fn debug(&self, src: &[u8]) -> debug::ScopeDebug {
+        let graph = &self.graph;
+        let start = self.root_idx;
+        debug::ScopeDebug::new(graph, start, src)
+    }
+
+    pub fn is_definition(&self, node_idx: NodeIndex) -> bool {
+        matches!(self.graph[node_idx], NodeKind::Def(_))
+    }
+
+    pub fn is_reference(&self, node_idx: NodeIndex) -> bool {
+        matches!(self.graph[node_idx], NodeKind::Ref(_))
+    }
+
+    pub fn is_scope(&self, node_idx: NodeIndex) -> bool {
+        matches!(self.graph[node_idx], NodeKind::Scope(_))
+    }
+
+    pub fn is_import(&self, node_idx: NodeIndex) -> bool {
+        matches!(self.graph[node_idx], NodeKind::Import(_))
+    }
+}
+
+fn build_scope_graph(
+    tsg: tree_sitter_graph::graph::Graph,
+    mut scope_graph: ScopeGraph,
+) -> ScopeGraph {
+    let nodes = tsg.iter_nodes().collect::<Vec<_>>();
+    for node in nodes
+        .iter()
+        .map(|node_ref| &tsg[*node_ref])
+        .filter(|node| is_scope(node))
+    {
+        let range =
+            text_range::value_to_range(node.attributes.get(&Identifier::from("range")).unwrap());
+        let scope = LocalScope::new(range.into());
+        scope_graph.insert_local_scope(scope);
+    }
+
+    for node in nodes
+        .iter()
+        .map(|node_ref| &tsg[*node_ref])
+        .filter(|node| is_import(node))
+    {
+        let range =
+            text_range::value_to_range(node.attributes.get(&Identifier::from("range")).unwrap());
+        let text = node
+            .attributes
+            .get(&Identifier::from("text"))
+            .and_then(|id| id.clone().into_string().ok())
+            .expect("import without text");
+        let import = LocalImport::new(range.into(), text);
+        scope_graph.insert_local_import(import);
+    }
+
+    for node in nodes
+        .iter()
+        .map(|node_ref| &tsg[*node_ref])
+        .filter(|node| is_def(node))
+    {
+        let range =
+            text_range::value_to_range(node.attributes.get(&Identifier::from("range")).unwrap());
+        let symbol = node
+            .attributes
+            .get(&Identifier::from("symbol"))
+            .and_then(|id| id.clone().into_string().ok());
+        let text = node
+            .attributes
+            .get(&Identifier::from("text"))
+            .and_then(|id| id.clone().into_string().ok())
+            .expect("def without text");
+        let local_def = LocalDef::new(range.into(), text, symbol);
+
+        // TODO: fix scoping here
+        scope_graph.insert_local_def(local_def);
+    }
+
+    for node in nodes
+        .iter()
+        .map(|node_ref| &tsg[*node_ref])
+        .filter(|node| is_ref(node))
+    {
+        let range =
+            text_range::value_to_range(node.attributes.get(&Identifier::from("range")).unwrap());
+        let symbol = node
+            .attributes
+            .get(&Identifier::from("symbol"))
+            .and_then(|id| id.clone().into_string().ok());
+        let text = node
+            .attributes
+            .get(&Identifier::from("text"))
+            .and_then(|id| id.clone().into_string().ok())
+            .expect("ref without text");
+        let ref_ = Reference::new(range.into(), text, symbol);
+
+        scope_graph.insert_ref(ref_);
+    }
+
+    scope_graph
+}
+
+fn is_string_attr(node: &tree_sitter_graph::graph::GraphNode, key: &str, value: &str) -> bool {
+    matches!(node.attributes.get(&Identifier::from(key)).and_then(|v| v.as_str().ok()), Some(v) if v == value)
+}
+
+fn is_scope(node: &tree_sitter_graph::graph::GraphNode) -> bool {
+    is_string_attr(node, "kind", "scope")
+}
+
+fn is_import(node: &tree_sitter_graph::graph::GraphNode) -> bool {
+    is_string_attr(node, "kind", "import")
+}
+
+fn is_def(node: &tree_sitter_graph::graph::GraphNode) -> bool {
+    is_string_attr(node, "kind", "def")
+}
+
+fn is_ref(node: &tree_sitter_graph::graph::GraphNode) -> bool {
+    is_string_attr(node, "kind", "ref")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use expect_test::{expect, Expect};
+
+    fn counts(src: &str) -> (usize, usize, usize, usize) {
+        let sg = build_graph(src);
+        let nodes = sg.graph.node_weights();
+
+        nodes.fold((0, 0, 0, 0), |(s, d, r, i), node| match node {
+            NodeKind::Scope(_) => (s + 1, d, r, i),
+            NodeKind::Def(_) => (s, d + 1, r, i),
+            NodeKind::Ref(_) => (s, d, r + 1, i),
+            NodeKind::Import(_) => (s, d, r, i + 1),
+        })
+    }
+
+    pub fn test_scopes(src: &str, expected: Expect) {
+        let graph = build_graph(src);
+        let observed = graph.debug(src.as_bytes());
+        expected.assert_debug_eq(&observed)
+    }
+
+    pub fn build_graph(src: &str) -> ScopeGraph {
+        StagBuilder::default()
+            .with_source(src)
+            .with_stag_file(include_str!("stag.tsg"))
+            .with_language(tree_sitter_rust::language())
+            .execute()
+            .unwrap()
+    }
+
+    #[test]
+    fn declare_const_and_static() {
+        let src = r#"
+            const a: () = ();
+            static b: () = ();
+        "#;
+
+        let (_, def_count, _, _) = counts(src);
+
+        // a, b
+        assert_eq!(def_count, 2);
+    }
+
+    #[test]
+    fn declare_let_statement() {
+        let src = r#"
+            fn main() {
+                let a = ();
+                let (b, c) = ();
+                let S { d, e } = ();
+                let S { field: f, g } = ();
+                let S { h, .. } = ();
+                let S { i, field: _ } = ();
+            }
+        "#;
+        let (_, def_count, _, _) = counts(src);
+
+        // main, a, b, c, d, e, f, g, h, i
+        assert_eq!(def_count, 10);
+    }
+
+    #[test]
+    fn declare_function_params() {
+        let src = r#"
+            fn f1(a: T) {}
+            fn f2(b: T, c: T) {}
+            fn f3((d, e): (T, U)) {}
+            fn f4(S {f, g}: S) {}
+            fn f5(S {h, ..}: S) {}
+            fn f6(S { field: i }: S) {}
+        "#;
+        let (_, def_count, _, _) = counts(src);
+
+        // f1, f2, f3, f4, f5, f6, a, b, c, d, e, f, g, h, i
+        assert_eq!(def_count, 15);
+    }
+
+    #[test]
+    fn declare_closure_params() {
+        let src = r#"
+            fn main() {
+                let _ = |x| {};
+                let _ = |x, y| {};
+                let _ = |x: ()| {};
+                let _ = |(x, y): ()| {};
+            }
+        "#;
+        let (_, def_count, _, _) = counts(src);
+
+        // main,
+        // x,
+        // x, y,
+        // x,
+        // x, y
+        assert_eq!(def_count, 7);
+    }
+
+    #[test]
+    fn declare_labels() {
+        let src = r#"
+            fn main() {
+                'loop: loop {};
+                'loop: for _ in () {}
+                'loop: while true {}
+            }
+        "#;
+        let (_, def_count, _, _) = counts(src);
+
+        // main, 'loop x3
+        assert_eq!(def_count, 4);
+    }
+
+    #[test]
+    fn declare_types() {
+        let src = r#"
+            struct One {
+                two: T,
+                three: T,
+            }
+
+            enum Four {
+                Five,
+                Six(T),
+                Seven {
+                    eight: T
+                }
+            }
+
+            union Nine {}
+
+            type Ten = ();
+        "#;
+        let (_, def_count, _, _) = counts(src);
+
+        assert_eq!(def_count, 10);
+    }
+
+    #[test]
+    fn declare_namespaces() {
+        let src = r#"
+            mod one {}
+            pub mod two {}
+            mod three {
+                mod four {}
+            }
+        "#;
+        let (_, def_count, _, _) = counts(src);
+
+        assert_eq!(def_count, 4);
+    }
+
+    #[test]
+    fn declare_let_expr() {
+        let src = r#"
+            if let a = () {}
+            if let Some(a) = () {}
+
+            while let a = () {}
+            while let Some(a) = () {}
+        "#;
+        let (_, def_count, _, _) = counts(src);
+
+        assert_eq!(def_count, 4);
+    }
+
+    #[test]
+    fn refer_unary_expr() {
+        let src = r#"
+            fn main() {
+                let a = 2;
+                !a;
+                -a;
+                *a;
+            }
+        "#;
+        let (_, _, ref_count, _) = counts(src);
+
+        assert_eq!(ref_count, 3);
+    }
+
+    #[test]
+    fn refer_binary_expr() {
+        let src = r#"
+            fn main() {
+                let a = 2;
+                let b = 3;
+                a + b;
+                a >> b;
+            }
+        "#;
+        let (_, _, ref_count, _) = counts(src);
+
+        assert_eq!(ref_count, 4);
+    }
+
+    #[test]
+    fn refer_control_flow() {
+        let src = r#"
+            fn main() {
+                let a = 2;
+
+                // 1
+                if a {}
+
+                // 2
+                if _ {} else if a {}
+
+                // 3
+                while a {
+                    // 4
+                    break a;
+                }
+
+                // 5
+                a?;
+
+                // 6
+                return a;
+
+                // 7
+                a.await;
+
+                // 8
+                yield a;
+            }
+        "#;
+        let (_, _, ref_count, _) = counts(src);
+
+        assert_eq!(ref_count, 8);
+    }
+
+    #[test]
+    fn refer_assignment() {
+        let src = r#"
+            fn main() {
+                let mut a = 2;
+                a += 2;
+                a = 2;
+                a *= 2;
+            }
+        "#;
+        let (_, _, ref_count, _) = counts(src);
+
+        assert_eq!(ref_count, 3);
+    }
+
+    #[test]
+    fn refer_struct_expr() {
+        let src = r#"
+            fn main() {
+                let a = 2;
+                let b = 2;
+                S { a, b };
+                S { ..a };
+                S { field: a, b };
+            }
+        "#;
+        let (_, _, ref_count, _) = counts(src);
+
+        assert_eq!(ref_count, 5);
+    }
+
+    #[test]
+    fn refer_dot() {
+        let src = r#"
+            fn main() {
+                let a = S {};
+
+                a.b;
+                a.foo();
+            }
+        "#;
+        let (_, _, ref_count, _) = counts(src);
+
+        assert_eq!(ref_count, 2);
+    }
+
+    #[test]
+    fn refer_arguments() {
+        let src = r#"
+            fn main() {
+                let a = 2;
+                let b = 3;
+                foo(a, b);
+            }
+        "#;
+        let (_, _, ref_count, _) = counts(src);
+
+        assert_eq!(ref_count, 2);
+    }
+
+    #[test]
+    fn function_params() {
+        test_scopes(
+            r#"
+            fn foo(t: T, u: U) -> R {}
+            "#,
+            expect![[r#"
+                scope {
+                    definitions: [
+                        foo {
+                            context: "fn §foo§(t: T, u: U) -> R {}",
+                        },
+                    ],
+                    child scopes: [
+                        scope {
+                            definitions: [
+                                t {
+                                    context: "fn foo(§t§: T, u: U) -> R {}",
+                                },
+                                u {
+                                    context: "fn foo(t: T, §u§: U) -> R {}",
+                                },
+                            ],
+                            child scopes: [],
+                        },
+                        scope {
+                            definitions: [],
+                            child scopes: [],
+                        },
+                    ],
+                }
+            "#]],
+        );
+    }
+
+    #[test]
+    fn use_statements() {
+        test_scopes(
+            r#"
+            mod intelligence;
+
+            use bleep;
+            use super::test_utils;
+            use intelligence::language as lang;
+            use crate::text_range::{TextRange, Point};
+            "#,
+            expect![[r#"
+                scope {
+                    definitions: [
+                        intelligence {
+                            context: "mod §intelligence§;",
+                            referenced in (1): [
+                                `use §intelligence§::language as lang;`,
+                            ],
+                        },
+                        bleep {
+                            context: "use §bleep§;",
+                        },
+                        test_utils {
+                            context: "use super::§test_utils§;",
+                        },
+                        lang {
+                            context: "use intelligence::language as §lang§;",
+                        },
+                        TextRange {
+                            context: "use crate::text_range::{§TextRange§, Point};",
+                        },
+                        Point {
+                            context: "use crate::text_range::{TextRange, §Point§};",
+                        },
+                    ],
+                    child scopes: [],
+                }
+            "#]],
+        )
+    }
+
+    #[test]
+    fn lifetimes() {
+        test_scopes(
+            r#"
+            impl<'a, T> Trait for Struct<'a, T> {
+                fn foo<'b>(&'a self) -> &'b T { }
+            }
+            "#,
+            expect![[r#"
+                scope {
+                    definitions: [],
+                    child scopes: [
+                        scope {
+                            definitions: [
+                                'a {
+                                    context: "impl<§'a§, T> Trait for Struct<'a, T> {",
+                                    referenced in (2): [
+                                        `impl<'a, T> Trait for Struct<§'a§, T> {`,
+                                        `fn foo<'b>(&§'a§ self) -> &'b T { }`,
+                                    ],
+                                },
+                                T {
+                                    context: "impl<'a, §T§> Trait for Struct<'a, T> {",
+                                    referenced in (2): [
+                                        `impl<'a, T> Trait for Struct<'a, §T§> {`,
+                                        `fn foo<'b>(&'a self) -> &'b §T§ { }`,
+                                    ],
+                                },
+                            ],
+                            child scopes: [
+                                scope {
+                                    definitions: [
+                                        foo {
+                                            context: "fn §foo§<'b>(&'a self) -> &'b T { }",
+                                        },
+                                        'b {
+                                            context: "fn foo<§'b§>(&'a self) -> &'b T { }",
+                                            referenced in (1): [
+                                                `fn foo<'b>(&'a self) -> &§'b§ T { }`,
+                                            ],
+                                        },
+                                    ],
+                                    child scopes: [
+                                        scope {
+                                            definitions: [
+                                                self {
+                                                    context: "fn foo<'b>(&'a §self§) -> &'b T { }",
+                                                },
+                                            ],
+                                            child scopes: [],
+                                        },
+                                        scope {
+                                            definitions: [],
+                                            child scopes: [],
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                    ],
+                }
+            "#]],
+        )
+    }
+
+    #[test]
+    fn generics_and_traits() {
+        test_scopes(
+            r#"
+            trait Foo {}
+
+            fn foo<'a, 'b, T, U: Foo<T> + 'a>(t: T, u: U) 
+              where T: Foo + 'b,
+            { }
+            "#,
+            expect![[r#"
+                scope {
+                    definitions: [
+                        Foo {
+                            context: "trait §Foo§ {}",
+                            referenced in (2): [
+                                `fn foo<'a, 'b, T, U: §Foo§<T> + 'a>(t: T, u: U)`,
+                                `where T: §Foo§ + 'b,`,
+                            ],
+                        },
+                        foo {
+                            context: "fn §foo§<'a, 'b, T, U: Foo<T> + 'a>(t: T, u: U)",
+                        },
+                        'a {
+                            context: "fn foo<§'a§, 'b, T, U: Foo<T> + 'a>(t: T, u: U)",
+                            referenced in (1): [
+                                `fn foo<'a, 'b, T, U: Foo<T> + §'a§>(t: T, u: U)`,
+                            ],
+                        },
+                        'b {
+                            context: "fn foo<'a, §'b§, T, U: Foo<T> + 'a>(t: T, u: U)",
+                            referenced in (1): [
+                                `where T: Foo + §'b§,`,
+                            ],
+                        },
+                        T {
+                            context: "fn foo<'a, 'b, §T§, U: Foo<T> + 'a>(t: T, u: U)",
+                            referenced in (3): [
+                                `fn foo<'a, 'b, T, U: Foo<§T§> + 'a>(t: T, u: U)`,
+                                `fn foo<'a, 'b, T, U: Foo<T> + 'a>(t: §T§, u: U)`,
+                                `where §T§: Foo + 'b,`,
+                            ],
+                        },
+                        U {
+                            context: "fn foo<'a, 'b, T, §U§: Foo<T> + 'a>(t: T, u: U)",
+                            referenced in (1): [
+                                `fn foo<'a, 'b, T, U: Foo<T> + 'a>(t: T, u: §U§)`,
+                            ],
+                        },
+                    ],
+                    child scopes: [
+                        scope {
+                            definitions: [],
+                            child scopes: [
+                                scope {
+                                    definitions: [],
+                                    child scopes: [
+                                        scope {
+                                            definitions: [],
+                                            child scopes: [],
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                        scope {
+                            definitions: [
+                                t {
+                                    context: "fn foo<'a, 'b, T, U: Foo<T> + 'a>(§t§: T, u: U)",
+                                },
+                                u {
+                                    context: "fn foo<'a, 'b, T, U: Foo<T> + 'a>(t: T, §u§: U)",
+                                },
+                            ],
+                            child scopes: [],
+                        },
+                        scope {
+                            definitions: [],
+                            child scopes: [],
+                        },
+                    ],
+                }
+            "#]],
+        )
+    }
+
+    #[test]
+    fn type_constructors() {
+        test_scopes(
+            r#"
+            struct Highlight {}
+
+            enum Direction { Incoming, Outgoing }
+
+            fn foo() -> Highlight {
+                Highlight { }
+            }
+
+            fn bar() -> Direction {
+                Direction::Incoming
+            }
+            "#,
+            expect![[r#"
+                scope {
+                    definitions: [
+                        Highlight {
+                            context: "struct §Highlight§ {}",
+                            referenced in (2): [
+                                `fn foo() -> §Highlight§ {`,
+                                `§Highlight§ { }`,
+                            ],
+                        },
+                        Direction {
+                            context: "enum §Direction§ { Incoming, Outgoing }",
+                            referenced in (2): [
+                                `fn bar() -> §Direction§ {`,
+                                `§Direction§::Incoming`,
+                            ],
+                        },
+                        foo {
+                            context: "fn §foo§() -> Highlight {",
+                        },
+                        bar {
+                            context: "fn §bar§() -> Direction {",
+                        },
+                    ],
+                    child scopes: [
+                        scope {
+                            definitions: [],
+                            child scopes: [
+                                scope {
+                                    definitions: [],
+                                    child scopes: [],
+                                },
+                            ],
+                        },
+                        scope {
+                            definitions: [],
+                            child scopes: [
+                                scope {
+                                    definitions: [
+                                        Incoming {
+                                            context: "enum Direction { §Incoming§, Outgoing }",
+                                        },
+                                        Outgoing {
+                                            context: "enum Direction { Incoming, §Outgoing§ }",
+                                        },
+                                    ],
+                                    child scopes: [],
+                                },
+                            ],
+                        },
+                        scope {
+                            definitions: [],
+                            child scopes: [],
+                        },
+                        scope {
+                            definitions: [],
+                            child scopes: [],
+                        },
+                        scope {
+                            definitions: [],
+                            child scopes: [],
+                        },
+                        scope {
+                            definitions: [],
+                            child scopes: [],
+                        },
+                    ],
+                }
+            "#]],
+        )
+    }
+
+    #[test]
+    fn macros() {
+        test_scopes(
+            r#"
+            fn main() {
+                let (a, b, c) = ();
+                // top-level tokens
+                assert_eq!(a, b + c);
+
+                // nested tokens
+                println!("{}", if a { b } then { c });
+            }
+            "#,
+            expect![[r#"
+                scope {
+                    definitions: [
+                        main {
+                            context: "fn §main§() {",
+                        },
+                    ],
+                    child scopes: [
+                        scope {
+                            definitions: [],
+                            child scopes: [],
+                        },
+                        scope {
+                            definitions: [
+                                a {
+                                    context: "let (§a§, b, c) = ();",
+                                    referenced in (2): [
+                                        `assert_eq!(§a§, b + c);`,
+                                        `println!("{}", if §a§ { b } then { c });`,
+                                    ],
+                                },
+                                b {
+                                    context: "let (a, §b§, c) = ();",
+                                    referenced in (2): [
+                                        `assert_eq!(a, §b§ + c);`,
+                                        `println!("{}", if a { §b§ } then { c });`,
+                                    ],
+                                },
+                                c {
+                                    context: "let (a, b, §c§) = ();",
+                                    referenced in (2): [
+                                        `assert_eq!(a, b + §c§);`,
+                                        `println!("{}", if a { b } then { §c§ });`,
+                                    ],
+                                },
+                            ],
+                            child scopes: [],
+                        },
+                    ],
+                }
+            "#]],
+        )
+    }
+
+    // Self::method and self.method can be raised as references
+    #[test]
+    fn handle_self_type_and_var() {
+        test_scopes(
+            r#"
+            struct MyStruct {}
+
+            impl MyStruct {
+                fn foo() {
+                    Self::foo()
+                }
+
+                fn bar(&self) {
+                    self.bar()
+                }
+            }
+            "#,
+            expect![[r#"
+                scope {
+                    definitions: [
+                        MyStruct {
+                            context: "struct §MyStruct§ {}",
+                            referenced in (1): [
+                                `impl §MyStruct§ {`,
+                            ],
+                        },
+                    ],
+                    child scopes: [
+                        scope {
+                            definitions: [],
+                            child scopes: [
+                                scope {
+                                    definitions: [],
+                                    child scopes: [],
+                                },
+                            ],
+                        },
+                        scope {
+                            definitions: [],
+                            child scopes: [
+                                scope {
+                                    definitions: [
+                                        foo {
+                                            context: "fn §foo§() {",
+                                            referenced in (1): [
+                                                `Self::§foo§()`,
+                                            ],
+                                        },
+                                        bar {
+                                            context: "fn §bar§(&self) {",
+                                            referenced in (1): [
+                                                `self.§bar§()`,
+                                            ],
+                                        },
+                                    ],
+                                    child scopes: [
+                                        scope {
+                                            definitions: [],
+                                            child scopes: [],
+                                        },
+                                        scope {
+                                            definitions: [],
+                                            child scopes: [],
+                                        },
+                                        scope {
+                                            definitions: [
+                                                self {
+                                                    context: "fn bar(&§self§) {",
+                                                },
+                                            ],
+                                            child scopes: [],
+                                        },
+                                        scope {
+                                            definitions: [],
+                                            child scopes: [],
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                    ],
+                }
+            "#]],
+        )
+    }
+
+    #[test]
+    fn let_else_1_65_support() {
+        test_scopes(
+            r#"
+            fn main() {
+                let a = 3;
+                if let b = a 
+                && let c = b 
+                && let d = c {
+                    d
+                } else {
+                    return;
+                }
+            }
+            "#,
+            expect![[r#"
+                scope {
+                    definitions: [
+                        main {
+                            context: "fn §main§() {",
+                        },
+                    ],
+                    child scopes: [
+                        scope {
+                            definitions: [],
+                            child scopes: [],
+                        },
+                        scope {
+                            definitions: [
+                                a {
+                                    context: "let §a§ = 3;",
+                                    referenced in (1): [
+                                        `if let b = §a§`,
+                                    ],
+                                },
+                            ],
+                            child scopes: [
+                                scope {
+                                    definitions: [
+                                        b {
+                                            context: "if let §b§ = a",
+                                            referenced in (1): [
+                                                `&& let c = §b§`,
+                                            ],
+                                        },
+                                        c {
+                                            context: "&& let §c§ = b",
+                                            referenced in (1): [
+                                                `&& let d = §c§ {`,
+                                            ],
+                                        },
+                                        d {
+                                            context: "&& let §d§ = c {",
+                                        },
+                                    ],
+                                    child scopes: [],
+                                },
+                                scope {
+                                    definitions: [],
+                                    child scopes: [],
+                                },
+                                scope {
+                                    definitions: [],
+                                    child scopes: [],
+                                },
+                            ],
+                        },
+                    ],
+                }
+            "#]],
+        )
+    }
+}

src/main.rs

···
+use stag::StagBuilder;
+
+fn main() {
+    let scopes = std::fs::read_to_string("src/stag.tsg").unwrap();
+    let src = r#"
+    fn main() {
+        let x = 2;
+        let a = 5;
+        if let _ = z {
+            a[x];
+        }
+    }
+    "#;
+
+    let sg = StagBuilder::default()
+        .with_source(src)
+        .with_stag_file(&scopes)
+        .with_language(tree_sitter_rust::language())
+        .execute()
+        .unwrap();
+
+    for edge in sg.graph.raw_edges() {
+        let s = edge.source();
+        let t = edge.target();
+        let sn = &sg.graph[s];
+        let st = &sg.graph[t];
+        println!("{:?} -> {:?}", edge.source(), edge.target());
+        println!("{:#?} -> {:#?}", sn, st);
+    }
+}

src/scopes.scm

···
+;; see tree-sitter-rust/src/grammar.json for an exhaustive list of productions
+
+;; scopes
+(block) @local.scope              ; { ... }
+(function_item) @local.scope
+(declaration_list) @local.scope   ; mod { ... }
+
+;; impl items can define types and lifetimes:
+;;
+;;    impl<'a, T> Trait for Struct { .. }
+;;
+;; in order to constrain those to the impl block,
+;; we add a local scope here:
+(impl_item) @local.scope
+(struct_item) @local.scope
+(enum_item) @local.scope
+(union_item) @local.scope
+(type_item) @local.scope
+(trait_item) @local.scope
+
+;; let expressions create scopes
+(if_expression
+  [(let_condition)
+   (let_chain)]) @local.scope
+
+;; each match arm can bind variables with
+;; patterns, without creating a block scope;
+;;
+;;     match _ {
+;;        (a, b) => a,
+;;     }
+;;
+;; The bindings for a, b are constrained to
+;; the match arm.
+(match_arm) @local.scope
+
+;; loop labels are defs that are available only
+;; within the scope they create:
+;;
+;;     'outer: loop {
+;;         let x = 2;
+;;     };
+;;     let y = 2;
+;; 
+;; Produces a scope graph like so:
+;;
+;; { 
+;;   defs: [ y ],
+;;   scopes: [
+;;     {
+;;       defs: [ 'outer ],
+;;       scopes: [
+;;         {
+;;           defs: [ x ]
+;;         }
+;;       ]
+;;     }
+;;   ]
+;; }
+;;
+(loop_expression) @local.scope
+(for_expression) @local.scope
+(while_expression) @local.scope
+
+
+;; defs
+
+;; let x = ...;
+(let_declaration 
+  pattern: (identifier) @local.definition.variable)
+
+;; if let x = ...;
+;; while let x = ...;
+(let_condition
+  .
+  (identifier) @local.definition.variable)
+
+;; let (a, b, ...) = ..;
+;; if let (a, b, ...) = {}
+;; while let (a, b, ...) = {}
+;; match _ { (a, b) => { .. } }
+(tuple_pattern (identifier) @local.definition.variable)
+
+;; Some(a)
+(tuple_struct_pattern
+  type: (_)
+  (identifier) @local.definition.variable)
+
+;; let S { field: a } = ..;
+(struct_pattern 
+  (field_pattern 
+    (identifier) @local.definition.variable))
+
+;; let S { a, b } = ..;
+(struct_pattern 
+  (field_pattern 
+    (shorthand_field_identifier) @local.definition.variable))
+
+;; (mut x: T)
+(mut_pattern (identifier) @local.definition.variable)
+
+;; (ref x: T)
+(ref_pattern (identifier) @local.definition.variable)
+
+;; const x = ...;
+(const_item (identifier) @local.definition.const)
+
+;; static x = ...;
+(static_item (identifier) @local.definition.const)
+
+;; fn _(x: _)
+(parameters 
+  (parameter 
+    pattern: (identifier) @local.definition.variable))
+;; fn _(self)
+(parameters 
+  (self_parameter
+    (self) @local.definition.variable))
+
+;; type parameters
+(type_parameters
+  (type_identifier) @local.definition.typedef)
+(type_parameters
+  (lifetime) @local.definition.lifetime)
+(constrained_type_parameter
+  left: (type_identifier) @local.definition.typedef)
+
+;; |x| { ... }
+;; no type
+(closure_parameters (identifier) @local.definition.variable)
+
+;; |x: T| { ... }
+;; with type
+(closure_parameters
+  (parameter
+    (identifier) @local.definition.variable))
+
+;;fn x(..)
+(function_item (identifier) @hoist.definition.function)
+
+;; 'outer: loop { .. }
+(loop_expression
+  (loop_label) @local.definition.label)
+
+;; `for` exprs create two defs: a label (if any) and the
+;; loop variable 
+(for_expression . (identifier) @local.definition.variable)
+(for_expression (loop_label) @local.definition.label)
+
+;; 'label: while cond { .. }
+(while_expression
+  (loop_label) @local.definition.label)
+
+;; type definitions
+(struct_item (type_identifier) @hoist.definition.struct)
+(enum_item (type_identifier) @hoist.definition.enum)
+(union_item (type_identifier) @hoist.definition.union)
+(type_item . (type_identifier) @hoist.definition.typedef)
+(trait_item (type_identifier) @hoist.definition.interface)
+
+;; struct and union fields
+(field_declaration_list
+  (field_declaration 
+    (field_identifier) @local.definition.field))
+
+;; enum variants
+(enum_variant_list
+  (enum_variant 
+    (identifier) @local.definition.enumerator))
+
+;; mod x;
+(mod_item (identifier) @local.definition.module)
+
+;; use statements
+
+;; use item;
+(use_declaration
+  (identifier) @local.import)
+
+;; use path as item;
+(use_as_clause
+  alias: (identifier) @local.import)
+
+;; use path::item;
+(use_declaration 
+  (scoped_identifier 
+    name: (identifier) @local.import))
+
+;; use module::{member1, member2, member3};
+(use_list
+  (identifier) @local.import)
+(use_list 
+  (scoped_identifier
+    name: (identifier) @local.import))
+
+
+;; refs
+
+;; !x
+(unary_expression (identifier) @local.reference)
+
+;; &x
+(reference_expression (identifier) @local.reference)
+
+;; (x)
+(parenthesized_expression (identifier) @local.reference)
+
+;; x?
+(try_expression (identifier) @local.reference)
+
+;; a = b
+(assignment_expression (identifier) @local.reference)
+
+;; a op b
+(binary_expression (identifier) @local.reference)
+
+;; a op= b
+(compound_assignment_expr (identifier) @local.reference)
+
+;; a as b
+(type_cast_expression (identifier) @local.reference)
+
+;; a()
+(call_expression (identifier) @local.reference)
+
+;; Self::foo()
+;;
+;; `foo` can be resolved
+(call_expression
+  (scoped_identifier
+    (identifier) @_self_type
+    (identifier) @local.reference)
+  (#match? @_self_type "Self"))
+
+;; self.foo() 
+;;
+;; `foo` can be resolved
+(call_expression 
+  (field_expression
+    (self)
+    (field_identifier) @local.reference))
+
+;; return a
+(return_expression (identifier) @local.reference)
+
+;; break a
+(break_expression (identifier) @local.reference)
+
+;; break 'label
+(break_expression (loop_label) @local.reference)
+
+;; continue 'label;
+(continue_expression (loop_label) @local.reference)
+
+;; yield x;
+(yield_expression (identifier) @local.reference)
+
+;; await a
+(await_expression (identifier) @local.reference)
+
+;; (a, b)
+(tuple_expression (identifier) @local.reference)
+
+;; a[]
+(index_expression (identifier) @local.reference)
+
+;; ident;
+(expression_statement (identifier) @local.reference)
+
+;; a..b
+(range_expression (identifier) @local.reference)
+
+;; [ident; N]
+(array_expression (identifier) @local.reference)
+
+;; path::to::item
+;;
+;; `path` is a ref
+(scoped_identifier 
+  path: (identifier) @local.reference)
+
+;; rhs of let decls
+(let_declaration 
+  value: (identifier) @local.reference)
+
+;; type T = [T; N]
+;;
+;; N is a ident ref
+(array_type
+  length: (identifier) @local.reference)
+
+;; S { _ }
+(struct_expression
+  (type_identifier) @local.reference)
+
+;; S { a }
+(struct_expression
+  (field_initializer_list
+    (shorthand_field_initializer
+      (identifier) @local.reference)))
+
+;; S { a: value }
+(struct_expression
+  (field_initializer_list
+    (field_initializer 
+      (identifier) @local.reference)))
+
+;; S { ..a }
+(struct_expression
+  (field_initializer_list
+    (base_field_initializer 
+      (identifier) @local.reference)))
+
+;; if a {}
+(if_expression (identifier) @local.reference)
+
+;; for pattern in value {}
+;;
+;; `value` is a ref
+(for_expression
+  value: (identifier) @local.reference)
+
+;; while a {}
+(while_expression (identifier) @local.reference)
+
+;; if let _ = a {}
+;;
+;; the ident following the `=` is a ref
+;; the ident preceding the `=` is a def
+;; while let _ = a {}
+(let_condition 
+  "="
+  (identifier) @local.reference)
+
+
+;; match a
+(match_expression (identifier) @local.reference)
+
+;; match _ {
+;;     pattern => a,
+;; }
+;;
+;; this `a` is somehow not any expression form
+(match_arm (identifier) @local.reference)
+
+;; a.b
+;;
+;; `b` is ignored
+(field_expression
+  (identifier) @local.reference)
+
+;; { stmt; foo }
+(block
+  (identifier) @local.reference)
+
+;; arguments to method calls or function calls
+(arguments
+  (identifier) @local.reference)
+
+;; impl S { .. }
+(impl_item (type_identifier) @local.reference)
+
+;; where T: ...
+(where_predicate
+  left: (type_identifier) @local.reference)
+
+;; trait bounds
+(trait_bounds
+  (type_identifier) @local.reference)
+(trait_bounds
+  (lifetime) @local.reference)
+
+;; idents in macros
+(token_tree
+  (identifier) @local.reference)
+
+;; types
+
+;; (T, U)
+(tuple_type
+  (type_identifier) @local.reference)
+
+;; &T
+(reference_type
+  (type_identifier) @local.reference)
+
+;; &'a T
+(reference_type
+  (lifetime) @local.reference)
+
+;; &'a self
+(self_parameter 
+  (lifetime) @local.reference)
+
+;; *mut T
+;; *const T
+(pointer_type
+  (type_identifier) @local.reference)
+
+;; A<_>
+(generic_type
+  (type_identifier) @local.reference)
+
+;; _<V>
+(type_arguments
+  (type_identifier) @local.reference)
+(type_arguments
+  (lifetime) @local.reference)
+
+;; T<U = V>
+;;
+;; U is ignored
+;; V is a ref
+(type_binding
+  name: (_)
+  type: (type_identifier) @local.reference)
+
+;; [T]
+(array_type
+  (type_identifier) @local.reference)
+
+;; type T = U;
+;;
+;; T is a def
+;; U is a ref
+(type_item 
+  name: (_)
+  type: (type_identifier) @local.reference)
+
+(function_item 
+  return_type: (type_identifier) @local.reference)
+
+;; type refs in params
+;;
+;; fn _(_: T)
+(parameters 
+  (parameter 
+    type: (type_identifier) @local.reference))
+
+;; dyn T
+(dynamic_type
+  (type_identifier) @local.reference)
+
+;; <T>::call()
+(bracketed_type
+  (type_identifier) @local.reference)
+
+;; T as Trait
+(qualified_type
+  (type_identifier) @local.reference)
+
+;; module::T
+;;
+;; `module` is a def
+;; `T` is a ref
+(scoped_type_identifier
+  path: (identifier) @local.reference)
+
+;; struct _ { field: Type }
+;; `Type` is a ref
+ (field_declaration
+   name: (_)
+   type: (type_identifier) @local.reference)

src/stag.tsg

···
+[(block)
+ (declaration_list)
+ (impl_item)
+
+ ;; let expressions create scopes
+ (if_expression
+   [(let_condition)
+    (let_chain)])
+
+;; each match arm can bind variables with
+;; patterns, without creating a block scope;
+;;
+;;     match _ {
+;;        (a, b) => a,
+;;     }
+;;
+;; The bindings for a, b are constrained to
+;; the match arm.
+ (match_arm)
+
+;; loop labels are defs that are available only
+;; within the scope they create:
+;;
+;;     'outer: loop {
+;;         let x = 2;
+;;     };
+;;     let y = 2;
+;; 
+;; Produces a scope graph like so:
+;;
+;; { 
+;;   defs: [ y ],
+;;   scopes: [
+;;     {
+;;       defs: [ 'outer ],
+;;       scopes: [
+;;         {
+;;           defs: [ x ]
+;;         }
+;;       ]
+;;     }
+;;   ]
+;; }
+;;
+ (loop_expression)
+ (for_expression)
+ (while_expression)] @cap
+{
+  (scope (range @cap))
+}
+
+
+(function_item
+  (identifier) @i
+  (parameters) @params
+  (block) @body)
+{
+  (def @i "function")
+  (scope (cover @params @body))
+}
+
+
+;; impl items can define types and lifetimes:
+;;
+;;    impl<'a, T> Trait for Struct { .. }
+;;
+;; in order to constrain those to the impl block,
+;; we add a local scope here:
+[(struct_item (type_identifier) @i (type_parameters)? @t body: (_) @b)
+ (union_item  (type_identifier) @i (type_parameters)? @t body: (_) @b)
+ (enum_item   (type_identifier) @i (type_parameters)? @t body: (_) @b)
+ (type_item   (type_identifier) @i (type_parameters)? @t type: (_) @b)
+ (trait_item  (type_identifier) @i (type_parameters)? @t body: (_) @b)]
+{
+  (def @i)
+  (scope (cover @t @b))
+  (scope (range @b))
+}
+
+
+;; DEFS
+;; ----
+
+;; let x = ...;
+(let_declaration pattern: (identifier) @cap) 
+{
+  (def @cap "variable")
+}
+
+;; if let x = ...;
+;; while let x = ...;
+(let_condition (identifier) @cap . "=")
+{
+  (def @cap "variable")
+}
+
+;; let (a, b, ...) = ..;
+;; if let (a, b, ...) = {}
+;; while let (a, b, ...) = {}
+;; match _ { (a, b) => { .. } }
+(tuple_pattern (identifier) @cap)
+{
+  (def @cap "variable")
+}
+
+;; Some(a)
+(tuple_struct_pattern
+  type: (_)
+  (identifier) @cap) 
+{
+  (def @cap "variable")
+}
+
+;; let S { field: a } = ..;
+(struct_pattern 
+  (field_pattern 
+    (identifier) @cap)) 
+{
+  (def @cap "variable")
+}
+
+
+[
+ ;; (mut x: T)
+ (mut_pattern (identifier) @i)
+
+ ;; (ref x: T)
+ (ref_pattern (identifier) @i)
+
+ ;; const x = ...;
+ (const_item (identifier) @i)
+
+ ;; static x = ...;
+ (static_item (identifier) @i)]
+{
+  (def @i "variable")
+}
+
+;; fn _(x: _)
+(parameters 
+  (parameter 
+    pattern: (identifier) @cap)) 
+{
+  (def @cap)
+}
+
+;; fn _(self)
+(parameters 
+  (self_parameter
+    (self) @cap))
+{
+  (def @cap)
+}
+
+;; type parameters
+(type_parameters
+  (type_identifier) @cap)
+{
+  (def @cap)
+}
+(type_parameters
+  (lifetime) @cap)
+{
+  (def @cap)
+}
+(constrained_type_parameter
+  left: (type_identifier) @cap)
+{
+  (def @cap)
+}
+
+;; |x| { ... }
+;; no type
+(closure_parameters (identifier) @cap) 
+{
+  (def @cap)
+}
+
+;; |x: T| { ... }
+;; with type
+(closure_parameters
+  (parameter
+    (identifier) @cap))
+{
+  (def @cap)
+}
+
+;; 'outer: loop { .. }
+(loop_expression
+  (loop_label) @cap)
+{
+  (def @cap)
+}
+
+;; `for` exprs create two defs: a label (if any) and the
+;; loop variable 
+(for_expression . (identifier) @cap)
+{
+  (def @cap)
+}
+(for_expression (loop_label) @cap)
+{
+  (def @cap)
+}
+
+;; 'label: while cond { .. }
+(while_expression
+  (loop_label) @cap)
+{
+  (def @cap)
+}
+
+;; struct and union fields
+(field_declaration_list
+  (field_declaration 
+    (field_identifier) @cap))
+{
+  (def @cap)
+}
+
+;; enum variants
+(enum_variant_list
+  (enum_variant 
+    (identifier) @cap))
+{
+  (def @cap)
+}
+
+;; mod x;
+(mod_item (identifier) @cap)
+{
+  (def @cap)
+}
+
+
+;; IMPORTS
+;; -------
+
+;; use item;
+(use_declaration
+  (identifier) @cap)
+{
+  (def @cap)
+}
+
+;; use path as item;
+(use_as_clause
+  alias: (identifier) @cap)
+{
+  (def @cap)
+}
+
+;; use path::item;
+(use_declaration 
+  (scoped_identifier 
+    name: (identifier) @cap))
+{
+  (def @cap)
+}
+
+;; use module::{member1, member2, member3};
+(use_list
+  (identifier) @cap)
+{
+  (def @cap)
+}
+
+(use_list 
+  (scoped_identifier
+    name: (identifier) @cap))
+{
+  (def @cap)
+}
+
+
+;; REFS
+;; ----
+
+[
+  ;; !x
+  (unary_expression (identifier) @cap)
+  ;; &x
+  (reference_expression (identifier) @cap)
+
+  ;; (x)
+  (parenthesized_expression (identifier) @cap)
+
+  ;; x?
+  (try_expression (identifier) @cap)
+
+  ;; a = b
+  (assignment_expression (identifier) @cap)
+
+  ;; a op b
+  (binary_expression (identifier) @cap)
+
+  ;; a op= b
+  (compound_assignment_expr (identifier) @cap)
+
+  ;; a as b
+  (type_cast_expression (identifier) @cap)
+
+  ;; a()
+  (call_expression (identifier) @cap)
+
+  ;; return a
+  (return_expression (identifier) @cap)
+
+  ;; break a
+  (break_expression (identifier) @cap)
+
+  ;; break 'label
+  (break_expression (loop_label) @cap)
+
+  ;; continue 'label;
+  (continue_expression (loop_label) @cap)
+
+  ;; yield x;
+  (yield_expression (identifier) @cap)
+
+  ;; await a
+  (await_expression (identifier) @cap)
+
+  ;; (a, b)
+  (tuple_expression (identifier) @cap)
+
+  ;; a[]
+  (index_expression (identifier) @cap)
+
+  ;; ident;
+  (expression_statement (identifier) @cap)
+
+  ;; a..b
+  (range_expression (identifier) @cap)
+
+  ;; [ident; N]
+  (array_expression (identifier) @cap)
+
+  ;; path::to::item
+  ;;
+  ;; `path` is a ref
+  (scoped_identifier 
+    path: (identifier) @cap)
+
+  ;; rhs of let decls
+  (let_declaration 
+    value: (identifier) @cap)
+
+  ;; type T = [T; N]
+  ;;
+  ;; N is a ident ref
+  (array_type
+    length: (identifier) @cap)
+
+  ;; S { _ }
+  (struct_expression
+    (type_identifier) @cap)
+
+  ;; S { a }
+  (struct_expression
+    (field_initializer_list
+      (shorthand_field_initializer
+        (identifier) @cap)))
+
+  ;; S { a: value }
+  (struct_expression
+    (field_initializer_list
+      (field_initializer 
+        (identifier) @cap)))
+
+  ;; S { ..a }
+  (struct_expression
+    (field_initializer_list
+      (base_field_initializer 
+        (identifier) @cap)))
+
+  ;; if a {}
+  (if_expression (identifier) @cap)
+
+  ;; for pattern in value {}
+  ;;
+  ;; `value` is a ref
+  (for_expression
+    value: (identifier) @cap)
+
+  ;; while a {}
+  (while_expression (identifier) @cap)
+
+  ;; match a
+  (match_expression (identifier) @cap)
+
+  ;; match _ {
+  ;;     pattern => a,
+  ;; }
+  ;;
+  ;; this `a` is somehow not any expression form
+  (match_arm (identifier) @cap)
+
+  ;; a.b
+  ;;
+  ;; `b` is ignored
+  (field_expression
+    (identifier) @cap)
+
+  ;; { stmt; foo }
+  (block
+    (identifier) @cap)
+
+  ;; arguments to method calls or function calls
+  (arguments
+    (identifier) @cap)
+
+  ;; impl S { .. }
+  (impl_item (type_identifier) @cap)
+
+  ;; where T: ...
+  (where_predicate
+    left: (type_identifier) @cap)
+
+  ;; trait bounds
+  (trait_bounds
+    (type_identifier) @cap)
+  (trait_bounds
+    (lifetime) @cap)
+
+  ;; idents in macros
+  (token_tree
+    (identifier) @cap)
+
+
+  ;; types
+
+  ;; (T, U)
+  (tuple_type
+    (type_identifier) @cap)
+
+  ;; &T
+  (reference_type
+    (type_identifier) @cap)
+
+  ;; &'a T
+  (reference_type
+    (lifetime) @cap)
+
+  ;; &'a self
+  (self_parameter 
+    (lifetime) @cap)
+
+  ;; *mut T
+  ;; *const T
+  (pointer_type
+    (type_identifier) @cap)
+
+  ;; A<_>
+  (generic_type
+    (type_identifier) @cap)
+
+  ;; _<V>
+  (type_arguments
+    (type_identifier) @cap)
+  (type_arguments
+    (lifetime) @cap)
+
+  ;; T<U = V>
+  ;;
+  ;; U is ignored
+  ;; V is a ref
+  (type_binding
+    name: (_)
+    type: (type_identifier) @cap)
+
+  ;; [T]
+  (array_type
+    (type_identifier) @cap)
+
+  ;; type T = U;
+  ;;
+  ;; T is a def
+  ;; U is a ref
+  (type_item 
+    name: (_)
+    type: (type_identifier) @cap)
+
+  (function_item 
+    return_type: (type_identifier) @cap)
+
+  ;; type refs in params
+  ;;
+  ;; fn _(_: T)
+  (parameters 
+    (parameter 
+      type: (type_identifier) @cap))
+
+  ;; dyn T
+  (dynamic_type
+    (type_identifier) @cap)
+
+  ;; <T>::call()
+  (bracketed_type
+    (type_identifier) @cap)
+
+  ;; T as Trait
+  (qualified_type
+    (type_identifier) @cap)
+
+  ;; module::T
+  ;;
+  ;; `module` is a def
+  ;; `T` is a ref
+  (scoped_type_identifier
+    path: (identifier) @cap)
+
+  ;; struct _ { field: Type }
+  ;; `Type` is a ref
+   (field_declaration
+     name: (_)
+     type: (type_identifier) @cap)
+
+  ;; Self::foo()
+  ;;
+  ;; `foo` can be resolved
+  (call_expression
+    (scoped_identifier
+      (identifier) @_self_type
+      (identifier) @cap)
+    (#match? @_self_type "Self"))
+
+  ;; self.foo() 
+  ;;
+  ;; `foo` can be resolved
+  (call_expression 
+    (field_expression
+      (self)
+      (field_identifier) @cap))
+
+  ;; if let _ = a {}
+  ;;
+  ;; the ident following the `=` is a ref
+  ;; the ident preceding the `=` is a def
+  ;; while let _ = a {}
+  (let_condition 
+    "="
+    .
+    (identifier) @cap)
+]
+{
+  (ref @cap)
+}
+
+

src/stdlib.rs

···
+use tree_sitter_graph::{functions::Function, ExecutionError, Identifier};
+
+use crate::text_range;
+
+pub struct ScopeShorthand;
+
+#[allow(unused_must_use)]
+impl Function for ScopeShorthand {
+    fn call(
+        &self,
+        graph: &mut tree_sitter_graph::graph::Graph,
+        _source: &str,
+        parameters: &mut dyn tree_sitter_graph::functions::Parameters,
+    ) -> Result<tree_sitter_graph::graph::Value, ExecutionError> {
+        let target_range = parameters.param()?;
+        if target_range.as_list().is_err() {
+            return Err(ExecutionError::ExpectedList(format!(
+                "`scope` expects list"
+            )));
+        }
+        parameters.finish()?;
+
+        let graph_node = graph.add_graph_node();
+        graph[graph_node]
+            .attributes
+            .add::<String>(Identifier::from("kind"), "scope".into());
+        graph[graph_node]
+            .attributes
+            .add(Identifier::from("range"), target_range);
+
+        Ok(tree_sitter_graph::graph::Value::GraphNode(graph_node))
+    }
+}
+
+pub struct DefShorthand;
+
+#[allow(unused_must_use)]
+impl Function for DefShorthand {
+    fn call(
+        &self,
+        graph: &mut tree_sitter_graph::graph::Graph,
+        source: &str,
+        parameters: &mut dyn tree_sitter_graph::functions::Parameters,
+    ) -> Result<tree_sitter_graph::graph::Value, ExecutionError> {
+        let target_node = parameters.param()?.into_syntax_node_ref()?;
+        let ts_node = graph[target_node];
+        let symbol = parameters
+            .param()
+            .and_then(|p| p.as_str().map(ToOwned::to_owned))
+            .ok();
+        parameters.finish()?;
+
+        let graph_node = graph.add_graph_node();
+        graph[graph_node]
+            .attributes
+            .add::<String>(Identifier::from("kind"), "def".into());
+        graph[graph_node]
+            .attributes
+            .add::<String>(Identifier::from("scope"), "local".into());
+
+        if let Some(s) = symbol {
+            graph[graph_node]
+                .attributes
+                .add::<String>(Identifier::from("symbol"), s.into());
+        }
+        graph[graph_node].attributes.add::<String>(
+            Identifier::from("text"),
+            source[ts_node.byte_range()].to_string().into(),
+        );
+        graph[graph_node].attributes.add(
+            Identifier::from("range"),
+            text_range::range_to_value(&ts_node.range()),
+        );
+        graph[graph_node]
+            .attributes
+            .add::<tree_sitter_graph::graph::SyntaxNodeRef>(
+                Identifier::from("target"),
+                target_node.into(),
+            );
+
+        Ok(tree_sitter_graph::graph::Value::GraphNode(graph_node))
+    }
+}
+
+pub struct RefShortHand;
+
+#[allow(unused_must_use)]
+impl Function for RefShortHand {
+    fn call(
+        &self,
+        graph: &mut tree_sitter_graph::graph::Graph,
+        source: &str,
+        parameters: &mut dyn tree_sitter_graph::functions::Parameters,
+    ) -> Result<tree_sitter_graph::graph::Value, ExecutionError> {
+        let target_node = parameters.param()?.into_syntax_node_ref()?;
+        let ts_node = graph[target_node];
+        parameters.finish()?;
+
+        let graph_node = graph.add_graph_node();
+        graph[graph_node]
+            .attributes
+            .add::<String>(Identifier::from("kind"), "ref".into());
+        graph[graph_node].attributes.add::<String>(
+            Identifier::from("text"),
+            source[ts_node.byte_range()].to_string().into(),
+        );
+        graph[graph_node].attributes.add(
+            Identifier::from("range"),
+            text_range::range_to_value(&ts_node.range()),
+        );
+        graph[graph_node]
+            .attributes
+            .add::<tree_sitter_graph::graph::SyntaxNodeRef>(
+                Identifier::from("target"),
+                target_node.into(),
+            );
+
+        Ok(tree_sitter_graph::graph::Value::GraphNode(graph_node))
+    }
+}
+
+pub struct CoverRanges;
+
+impl Function for CoverRanges {
+    fn call(
+        &self,
+        graph: &mut tree_sitter_graph::graph::Graph,
+        _source: &str,
+        parameters: &mut dyn tree_sitter_graph::functions::Parameters,
+    ) -> Result<tree_sitter_graph::graph::Value, ExecutionError> {
+        let p1 = parameters.param()?;
+        let p2 = parameters.param()?;
+
+        match (p1.is_null(), p2.is_null()) {
+            (true, true) => panic!("all nulls"),
+            (false, true) => {
+                return Ok(text_range::range_to_value(
+                    &graph[p1.into_syntax_node_ref()?].range(),
+                ))
+            }
+            (true, false) => {
+                return Ok(text_range::range_to_value(
+                    &graph[p2.into_syntax_node_ref()?].range(),
+                ))
+            }
+            (false, false) => {
+                let node_a = p1.into_syntax_node_ref()?;
+                let node_b = p2.into_syntax_node_ref()?;
+                let ts_node_a = graph[node_a];
+                let ts_node_b = graph[node_b];
+
+                let mut range = cover(ts_node_a.range(), ts_node_b.range());
+                while let Ok(param) = parameters.param() {
+                    if !param.is_null() {
+                        range = cover(range, graph[param.into_syntax_node_ref()?].range())
+                    }
+                }
+
+                Ok(text_range::range_to_value(&range))
+            }
+        }
+    }
+}
+
+fn cover(a: tree_sitter::Range, b: tree_sitter::Range) -> tree_sitter::Range {
+    let (start_byte, start_point) = if a.start_point < b.start_point {
+        (a.start_byte, a.start_point)
+    } else {
+        (b.start_byte, b.start_point)
+    };
+    let (end_byte, end_point) = if a.end_point > b.end_point {
+        (a.end_byte, a.end_point)
+    } else {
+        (b.end_byte, b.end_point)
+    };
+    tree_sitter::Range {
+        start_byte,
+        start_point,
+        end_byte,
+        end_point,
+    }
+}
+
+pub struct NodeRange;
+
+impl Function for NodeRange {
+    fn call(
+        &self,
+        graph: &mut tree_sitter_graph::graph::Graph,
+        _source: &str,
+        parameters: &mut dyn tree_sitter_graph::functions::Parameters,
+    ) -> Result<tree_sitter_graph::graph::Value, ExecutionError> {
+        let target_node = parameters.param()?.into_syntax_node_ref()?;
+        let ts_node = graph[target_node];
+        Ok(text_range::range_to_value(&ts_node.range()))
+    }
+}

src/text_range.rs

···
+use serde::{Deserialize, Serialize};
+use tree_sitter_graph::graph::Value;
+
+use std::cmp::{Ord, Ordering};
+
+/// A singular position in a text document
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct Point {
+    /// The byte index
+    pub byte: usize,
+
+    /// 0-indexed line number
+    pub line: usize,
+
+    /// Position within the line
+    pub column: usize,
+}
+
+impl PartialOrd for Point {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for Point {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.byte.cmp(&other.byte)
+    }
+}
+
+impl Point {
+    pub fn new(byte: usize, line: usize, column: usize) -> Self {
+        Self { byte, line, column }
+    }
+
+    pub fn from_byte(byte: usize, line_end_indices: &[u32]) -> Self {
+        let line = line_end_indices
+            .iter()
+            .position(|&line_end_byte| (line_end_byte as usize) > byte)
+            .unwrap_or(0);
+
+        let column = line
+            .checked_sub(1)
+            .and_then(|idx| line_end_indices.get(idx))
+            .map(|&prev_line_end| byte.saturating_sub(prev_line_end as usize))
+            .unwrap_or(byte);
+
+        Self::new(byte, line, column)
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct TextRange {
+    pub start: Point,
+    pub end: Point,
+}
+
+impl PartialOrd for TextRange {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for TextRange {
+    fn cmp(&self, other: &Self) -> Ordering {
+        let compare_start_byte = self.start.byte.cmp(&other.start.byte);
+        let compare_size = self.size().cmp(&other.size());
+
+        compare_start_byte.then(compare_size)
+    }
+}
+
+impl TextRange {
+    pub fn new(start: Point, end: Point) -> Self {
+        assert!(start <= end);
+        Self { start, end }
+    }
+
+    pub fn contains(&self, other: &TextRange) -> bool {
+        // (self.start ... [other.start ... other.end] ... self.end)
+        self.start <= other.start && other.end <= self.end
+    }
+
+    pub fn contains_strict(&self, other: TextRange) -> bool {
+        // (self.start ... (other.start ... other.end) ... self.end)
+        self.start < other.start && other.end < self.end
+    }
+
+    pub fn size(&self) -> usize {
+        self.end.byte.saturating_sub(self.start.byte)
+    }
+
+    pub fn from_byte_range(range: std::ops::Range<usize>, line_end_indices: &[u32]) -> Self {
+        let start = Point::from_byte(range.start, line_end_indices);
+        let end = Point::from_byte(range.end, line_end_indices);
+        Self::new(start, end)
+    }
+}
+
+impl From<tree_sitter::Range> for TextRange {
+    fn from(r: tree_sitter::Range) -> Self {
+        Self {
+            start: Point {
+                byte: r.start_byte,
+                line: r.start_point.row,
+                column: r.start_point.column,
+            },
+            end: Point {
+                byte: r.end_byte,
+                line: r.end_point.row,
+                column: r.end_point.column,
+            },
+        }
+    }
+}
+
+impl From<TextRange> for std::ops::Range<usize> {
+    fn from(r: TextRange) -> std::ops::Range<usize> {
+        r.start.byte..r.end.byte
+    }
+}
+
+pub fn value_to_range(value: &Value) -> tree_sitter::Range {
+    let range = value.as_list().unwrap();
+    let start = range[0].as_list().unwrap();
+    let end = range[1].as_list().unwrap();
+    tree_sitter::Range {
+        start_byte: start[0].as_integer().unwrap() as usize,
+        start_point: tree_sitter::Point {
+            row: start[1].as_integer().unwrap() as usize,
+            column: start[2].as_integer().unwrap() as usize,
+        },
+        end_byte: end[0].as_integer().unwrap() as usize,
+        end_point: tree_sitter::Point {
+            row: end[1].as_integer().unwrap() as usize,
+            column: end[2].as_integer().unwrap() as usize,
+        },
+    }
+}
+
+pub fn range_to_value(value: &tree_sitter::Range) -> Value {
+    let start = Value::from(vec![
+        Value::from(value.start_byte as u32),
+        Value::from(value.start_point.row as u32),
+        Value::from(value.start_point.column as u32),
+    ]);
+    let end = Value::from(vec![
+        Value::from(value.end_byte as u32),
+        Value::from(value.end_point.row as u32),
+        Value::from(value.end_point.column as u32),
+    ]);
+    Value::from(vec![start, end])
+}