Merge pull request #13 from tree-sitter/no-context

Remove Context object and DisplayFromFoo traits

src/ast.rs

···
 use tree_sitter::Language;
 use tree_sitter::Query;
 
-use crate::Context;
-use crate::DisplayWithContext;
 use crate::Identifier;
 use crate::Location;
 
···
     ForIn(ForIn),
 }
 
-impl DisplayWithContext for Statement {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context) -> fmt::Result {
+impl std::fmt::Display for Statement {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
-            Statement::DeclareImmutable(stmt) => stmt.fmt(f, ctx),
-            Statement::DeclareMutable(stmt) => stmt.fmt(f, ctx),
-            Statement::Assign(stmt) => stmt.fmt(f, ctx),
-            Statement::CreateGraphNode(stmt) => stmt.fmt(f, ctx),
-            Statement::AddGraphNodeAttribute(stmt) => stmt.fmt(f, ctx),
-            Statement::CreateEdge(stmt) => stmt.fmt(f, ctx),
-            Statement::AddEdgeAttribute(stmt) => stmt.fmt(f, ctx),
-            Statement::Scan(stmt) => stmt.fmt(f, ctx),
-            Statement::Print(stmt) => stmt.fmt(f, ctx),
-            Statement::If(stmt) => stmt.fmt(f, ctx),
-            Statement::ForIn(stmt) => stmt.fmt(f, ctx),
+            Self::DeclareImmutable(stmt) => stmt.fmt(f),
+            Self::DeclareMutable(stmt) => stmt.fmt(f),
+            Self::Assign(stmt) => stmt.fmt(f),
+            Self::CreateGraphNode(stmt) => stmt.fmt(f),
+            Self::AddGraphNodeAttribute(stmt) => stmt.fmt(f),
+            Self::CreateEdge(stmt) => stmt.fmt(f),
+            Self::AddEdgeAttribute(stmt) => stmt.fmt(f),
+            Self::Scan(stmt) => stmt.fmt(f),
+            Self::Print(stmt) => stmt.fmt(f),
+            Self::If(stmt) => stmt.fmt(f),
+            Self::ForIn(stmt) => stmt.fmt(f),
         }
     }
 }
···
     }
 }
 
-impl DisplayWithContext for AddEdgeAttribute {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context) -> fmt::Result {
-        write!(
-            f,
-            "attr ({} -> {})",
-            self.source.display_with(ctx),
-            self.sink.display_with(ctx),
-        )?;
+impl std::fmt::Display for AddEdgeAttribute {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "attr ({} -> {})", self.source, self.sink)?;
         for attr in &self.attributes {
-            write!(f, " {}", attr.display_with(ctx))?;
+            write!(f, " {}", attr)?;
         }
         write!(f, " at {}", self.location)
     }
···
     }
 }
 
-impl DisplayWithContext for AddGraphNodeAttribute {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context) -> fmt::Result {
-        write!(f, "attr ({})", self.node.display_with(ctx),)?;
+impl std::fmt::Display for AddGraphNodeAttribute {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "attr ({})", self.node)?;
         for attr in &self.attributes {
-            write!(f, " {}", attr.display_with(ctx),)?;
+            write!(f, " {}", attr)?;
         }
         write!(f, " at {}", self.location)
     }
···
     }
 }
 
-impl DisplayWithContext for Assign {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context) -> fmt::Result {
+impl std::fmt::Display for Assign {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(
             f,
             "set {} = {} at {}",
-            self.variable.display_with(ctx),
-            self.value.display_with(ctx),
-            self.location,
+            self.variable, self.value, self.location,
         )
     }
 }
···
     pub value: Expression,
 }
 
-impl DisplayWithContext for Attribute {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context) -> fmt::Result {
-        write!(
-            f,
-            "{} = {}",
-            self.name.display_with(ctx),
-            self.value.display_with(ctx),
-        )
+impl std::fmt::Display for Attribute {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{} = {}", self.name, self.value)
     }
 }
 
···
     }
 }
 
-impl DisplayWithContext for CreateEdge {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context) -> fmt::Result {
+impl std::fmt::Display for CreateEdge {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(
             f,
             "edge {} -> {} at {}",
-            self.source.display_with(ctx),
-            self.sink.display_with(ctx),
-            self.location,
+            self.source, self.sink, self.location,
         )
     }
 }
···
     }
 }
 
-impl DisplayWithContext for CreateGraphNode {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context) -> fmt::Result {
-        write!(
-            f,
-            "node {} at {}",
-            self.node.display_with(ctx),
-            self.location
-        )
+impl std::fmt::Display for CreateGraphNode {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "node {} at {}", self.node, self.location)
     }
 }
 
···
     }
 }
 
-impl DisplayWithContext for DeclareImmutable {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context) -> fmt::Result {
+impl std::fmt::Display for DeclareImmutable {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(
             f,
             "let {} = {} at {}",
-            self.variable.display_with(ctx),
-            self.value.display_with(ctx),
-            self.location,
+            self.variable, self.value, self.location,
         )
     }
 }
···
     }
 }
 
-impl DisplayWithContext for DeclareMutable {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context) -> fmt::Result {
+impl std::fmt::Display for DeclareMutable {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(
             f,
             "var {} = {} at {}",
-            self.variable.display_with(ctx),
-            self.value.display_with(ctx),
-            self.location,
+            self.variable, self.value, self.location,
         )
     }
 }
···
     }
 }
 
-impl DisplayWithContext for Print {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context) -> fmt::Result {
+impl std::fmt::Display for Print {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "print")?;
         for val in &self.values {
-            write!(f, " {},", val.display_with(ctx),)?;
+            write!(f, " {},", val)?;
         }
         write!(f, " at {}", self.location)
     }
···
     }
 }
 
-impl DisplayWithContext for Scan {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context) -> fmt::Result {
-        write!(
-            f,
-            "scan {} {{ ... }} at {}",
-            self.value.display_with(ctx),
-            self.location
-        )
+impl std::fmt::Display for Scan {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "scan {} {{ ... }} at {}", self.value, self.location)
     }
 }
 
···
     }
 }
 
-impl DisplayWithContext for ScanArm {
-    fn fmt(&self, f: &mut fmt::Formatter, _ctx: &Context) -> fmt::Result {
+impl std::fmt::Display for ScanArm {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "{:?} {{ ... }}", self.regex.as_str())
     }
 }
···
     }
 }
 
-impl DisplayWithContext for If {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context) -> fmt::Result {
+impl std::fmt::Display for If {
+    fn fmt(&self, f: &mut fmt::Formatter) -> std::fmt::Result {
         let mut first = true;
         for arm in &self.arms {
             if first {
                 first = false;
-                write!(f, "if {} {{ ... }}", arm.conditions.display_with(ctx))?;
+                write!(f, "if {} {{ ... }}", DisplayConditions(&arm.conditions))?;
             } else {
                 if !arm.conditions.is_empty() {
-                    write!(f, " elif {} {{ ... }}", arm.conditions.display_with(ctx))?;
+                    write!(f, " elif {} {{ ... }}", DisplayConditions(&arm.conditions))?;
                 } else {
                     write!(f, " else {{ ... }}")?;
                 }
···
     pub location: Location,
 }
 
+struct DisplayConditions<'a>(&'a Vec<Condition>);
+
 #[derive(Debug, PartialEq, Eq)]
 pub enum Condition {
     Some {
···
     },
 }
 
-impl DisplayWithContext for Vec<Condition> {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context) -> fmt::Result {
+impl std::fmt::Display for DisplayConditions<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> std::fmt::Result {
         let mut first = true;
-        for condition in self.iter() {
+        for condition in self.0.iter() {
             if first {
                 first = false;
-                write!(f, "{}", condition.display_with(ctx))?;
+                write!(f, "{}", condition)?;
             } else {
-                write!(f, ", {}", condition.display_with(ctx))?;
+                write!(f, ", {}", condition)?;
             }
         }
         Ok(())
     }
 }
 
-impl DisplayWithContext for Condition {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context) -> fmt::Result {
+impl std::fmt::Display for Condition {
+    fn fmt(&self, f: &mut fmt::Formatter) -> std::fmt::Result {
         match self {
             Condition::Some { value, .. } => {
-                write!(f, "some {}", value.display_with(ctx))
+                write!(f, "some {}", value)
             }
             Condition::None { value, .. } => {
-                write!(f, "none {}", value.display_with(ctx))
+                write!(f, "none {}", value)
             }
             Condition::Bool { value, .. } => {
-                write!(f, "{}", value.display_with(ctx))
+                write!(f, "{}", value)
             }
         }
     }
···
     }
 }
 
-impl DisplayWithContext for ForIn {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context) -> fmt::Result {
+impl std::fmt::Display for ForIn {
+    fn fmt(&self, f: &mut fmt::Formatter) -> std::fmt::Result {
         write!(
             f,
             "for {} in {} {{ ... }} at {}",
-            self.variable.display_with(ctx),
-            self.value.display_with(ctx),
-            self.location,
+            self.variable, self.value, self.location,
         )
     }
 }
···
     Unscoped(UnscopedVariable),
 }
 
-impl DisplayWithContext for Variable {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context) -> fmt::Result {
+impl std::fmt::Display for Variable {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
-            Variable::Scoped(variable) => variable.fmt(f, ctx),
-            Variable::Unscoped(variable) => variable.fmt(f, ctx),
+            Variable::Scoped(variable) => variable.fmt(f),
+            Variable::Unscoped(variable) => variable.fmt(f),
         }
     }
 }
···
     }
 }
 
-impl DisplayWithContext for ScopedVariable {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context) -> fmt::Result {
-        write!(
-            f,
-            "{}.{}",
-            self.scope.display_with(ctx),
-            self.name.display_with(ctx),
-        )
+impl std::fmt::Display for ScopedVariable {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}.{}", self.scope, self.name)
     }
 }
 
···
     }
 }
 
-impl DisplayWithContext for UnscopedVariable {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context) -> fmt::Result {
-        write!(f, "{}", self.name.display_with(ctx))
+impl std::fmt::Display for UnscopedVariable {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}", self.name)
     }
 }
 
···
     RegexCapture(RegexCapture),
 }
 
-impl DisplayWithContext for Expression {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context) -> fmt::Result {
+impl std::fmt::Display for Expression {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             Expression::FalseLiteral => write!(f, "false"),
             Expression::NullLiteral => write!(f, "#null"),
             Expression::TrueLiteral => write!(f, "true"),
-            Expression::IntegerConstant(expr) => expr.fmt(f, ctx),
-            Expression::StringConstant(expr) => expr.fmt(f, ctx),
-            Expression::List(expr) => expr.fmt(f, ctx),
-            Expression::Set(expr) => expr.fmt(f, ctx),
-            Expression::Capture(expr) => expr.fmt(f, ctx),
-            Expression::Variable(expr) => expr.fmt(f, ctx),
-            Expression::Call(expr) => expr.fmt(f, ctx),
-            Expression::RegexCapture(expr) => expr.fmt(f, ctx),
+            Expression::IntegerConstant(expr) => expr.fmt(f),
+            Expression::StringConstant(expr) => expr.fmt(f),
+            Expression::List(expr) => expr.fmt(f),
+            Expression::Set(expr) => expr.fmt(f),
+            Expression::Capture(expr) => expr.fmt(f),
+            Expression::Variable(expr) => expr.fmt(f),
+            Expression::Call(expr) => expr.fmt(f),
+            Expression::RegexCapture(expr) => expr.fmt(f),
         }
     }
 }
···
     }
 }
 
-impl DisplayWithContext for Call {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context) -> fmt::Result {
-        write!(f, "({}", self.function.display_with(ctx))?;
+impl std::fmt::Display for Call {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "({}", self.function)?;
         for arg in &self.parameters {
-            write!(f, " {}", arg.display_with(ctx))?;
+            write!(f, " {}", arg)?;
         }
         write!(f, ")")
     }
···
     }
 }
 
-impl DisplayWithContext for Capture {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context) -> fmt::Result {
-        write!(f, "@{}", self.name.display_with(ctx))
+impl std::fmt::Display for Capture {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "@{}", self.name)
     }
 }
 
···
     }
 }
 
-impl DisplayWithContext for IntegerConstant {
-    fn fmt(&self, f: &mut fmt::Formatter, _ctx: &Context) -> fmt::Result {
+impl std::fmt::Display for IntegerConstant {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "{}", self.value)
     }
 }
···
     }
 }
 
-impl DisplayWithContext for ListComprehension {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context) -> fmt::Result {
+impl std::fmt::Display for ListComprehension {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "[")?;
         let mut first = true;
         for elem in &self.elements {
             if first {
-                write!(f, "{}", elem.display_with(ctx))?;
+                write!(f, "{}", elem)?;
                 first = false;
             } else {
-                write!(f, ", {}", elem.display_with(ctx))?;
+                write!(f, ", {}", elem)?;
             }
         }
         write!(f, "]")
···
     }
 }
 
-impl DisplayWithContext for RegexCapture {
-    fn fmt(&self, f: &mut fmt::Formatter, _ctx: &Context) -> fmt::Result {
+impl std::fmt::Display for RegexCapture {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "${}", self.match_index)
     }
 }
···
     }
 }
 
-impl DisplayWithContext for SetComprehension {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context) -> fmt::Result {
+impl std::fmt::Display for SetComprehension {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "{{")?;
         let mut first = true;
         for elem in &self.elements {
             if first {
-                write!(f, "{}", elem.display_with(ctx))?;
+                write!(f, "{}", elem)?;
                 first = false;
             } else {
-                write!(f, ", {}", elem.display_with(ctx))?;
+                write!(f, ", {}", elem)?;
             }
         }
         write!(f, "}}")
···
     }
 }
 
-impl DisplayWithContext for StringConstant {
-    fn fmt(&self, f: &mut fmt::Formatter, _ctx: &Context) -> fmt::Result {
+impl std::fmt::Display for StringConstant {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "{:?}", self.value)
     }
 }

src/bin/tree-sitter-graph/main.rs

···
 use tree_sitter_config::Config;
 use tree_sitter_graph::ast::File;
 use tree_sitter_graph::functions::Functions;
-use tree_sitter_graph::Context;
 use tree_sitter_graph::Variables;
 use tree_sitter_loader::Loader;
 
···
     let tree = parser
         .parse(&source, None)
         .ok_or_else(|| anyhow!("Could not parse {}", source_path.display()))?;
-    let mut ctx = Context::new();
-    let file = File::from_str(language, &mut ctx, &tsg)
-        .with_context(|| anyhow!("Error parsing TSG file {}", tsg_path.display()))?;
-    let mut functions = Functions::stdlib(&mut ctx);
+    let file = File::from_str(language, &tsg)
+        .with_context(|| format!("Error parsing TSG file {}", tsg_path.display()))?;
+    let mut functions = Functions::stdlib();
     let globals = Variables::new();
     let graph = if lazy {
-        file.execute_lazy(&mut ctx, &tree, &source, &mut functions, &globals)
+        file.execute_lazy(&tree, &source, &mut functions, &globals)
     } else {
-        file.execute(&mut ctx, &tree, &source, &mut functions, &globals)
+        file.execute(&tree, &source, &mut functions, &globals)
     }
-    .with_context(|| anyhow!("Could not execute TSG file {}", tsg_path.display()))?;
+    .with_context(|| format!("Could not execute TSG file {}", tsg_path.display()))?;
     let json = matches.is_present("json");
     if json {
-        graph.display_json(&ctx);
+        graph.display_json();
     } else if !quiet {
-        print!("{}", graph.display_with(&ctx));
+        print!("{}", graph.pretty_print());
     }
     Ok(())
 }

src/checker.rs

···
 use crate::variables::VariableError;
 use crate::variables::VariableMap;
 use crate::variables::Variables;
-use crate::Context;
-use crate::DisplayWithContext as _;
 use crate::Location;
 
 #[derive(Debug, Error)]
···
 
 /// Checker context
 struct CheckContext<'a> {
-    ctx: &'a Context,
     locals: &'a mut dyn Variables<ExpressionResult>,
     file_query: &'a Query,
     stanza_index: usize,
···
 // File
 
 impl ast::File {
-    pub fn check(&mut self, ctx: &Context) -> Result<(), CheckError> {
+    pub fn check(&mut self) -> Result<(), CheckError> {
         let file_query = self.query.as_ref().unwrap();
         for (index, stanza) in self.stanzas.iter_mut().enumerate() {
-            stanza.check(ctx, file_query, index)?;
+            stanza.check(file_query, index)?;
         }
         Ok(())
     }
···
 // Stanza
 
 impl ast::Stanza {
-    fn check(
-        &mut self,
-        ctx: &Context,
-        file_query: &Query,
-        stanza_index: usize,
-    ) -> Result<(), CheckError> {
+    fn check(&mut self, file_query: &Query, stanza_index: usize) -> Result<(), CheckError> {
         let mut locals = VariableMap::new();
         let mut ctx = CheckContext {
-            ctx,
             locals: &mut locals,
             file_query,
             stanza_index,
···
 
             let mut arm_locals = VariableMap::new_child(ctx.locals);
             let mut arm_ctx = CheckContext {
-                ctx: ctx.ctx,
                 locals: &mut arm_locals,
                 file_query: ctx.file_query,
                 stanza_index: ctx.stanza_index,
···
 
             let mut arm_locals = VariableMap::new_child(ctx.locals);
             let mut arm_ctx = CheckContext {
-                ctx: ctx.ctx,
                 locals: &mut arm_locals,
                 file_query: ctx.file_query,
                 stanza_index: ctx.stanza_index,
···
 
         let mut loop_locals = VariableMap::new_child(ctx.locals);
         let mut loop_ctx = CheckContext {
-            ctx: ctx.ctx,
             locals: &mut loop_locals,
             file_query: ctx.file_query,
             stanza_index: ctx.stanza_index,
···
 
 impl ast::Capture {
     fn check(&mut self, ctx: &mut CheckContext) -> Result<ExpressionResult, CheckError> {
-        let name = ctx.ctx.resolve(self.name);
+        let name = self.name.to_string();
         self.stanza_capture_index = ctx
             .stanza_query
-            .capture_index_for_name(name)
-            .ok_or_else(|| CheckError::UndefinedSyntaxCapture(name.to_string(), self.location))?
+            .capture_index_for_name(&name)
+            .ok_or_else(|| CheckError::UndefinedSyntaxCapture(name.clone(), self.location))?
             as usize;
-        self.file_capture_index = ctx.file_query.capture_index_for_name(name).unwrap() as usize;
+        self.file_capture_index = ctx.file_query.capture_index_for_name(&name).unwrap() as usize;
         self.quantifier =
             ctx.file_query.capture_quantifiers(ctx.stanza_index)[self.file_capture_index];
         Ok(ExpressionResult {
···
             value.is_local = false;
         }
         ctx.locals
-            .add(self.name, value, mutable)
-            .map_err(|e| CheckError::Variable(e, format!("{}", self.name.display_with(ctx.ctx))))
+            .add(self.name.clone(), value, mutable)
+            .map_err(|e| CheckError::Variable(e, format!("{}", self.name)))
     }
 
     fn check_set(
···
         // assignments, and can assume non-local to be sound.
         value.is_local = false;
         ctx.locals
-            .set(self.name, value)
-            .map_err(|e| CheckError::Variable(e, format!("{}", self.name.display_with(ctx.ctx))))
+            .set(self.name.clone(), value)
+            .map_err(|e| CheckError::Variable(e, format!("{}", self.name)))
     }
 
     fn check_get(&mut self, ctx: &mut CheckContext) -> Result<ExpressionResult, CheckError> {

src/execution.rs

···
 use crate::ast::UnscopedVariable;
 use crate::ast::Variable;
 use crate::functions::Functions;
-use crate::graph::DisplayWithGraph;
 use crate::graph::Graph;
-use crate::graph::GraphNodeRef;
 use crate::graph::SyntaxNodeRef;
 use crate::graph::Value;
 pub use crate::variables::Globals;
 use crate::variables::VariableMap;
 use crate::variables::Variables;
-use crate::Context;
-use crate::DisplayWithContext;
 
 impl File {
     /// Executes this graph DSL file against a source file.  You must provide the parsed syntax
···
     /// provide the set of functions and global variables that are available during execution.
     pub fn execute<'tree>(
         &self,
-        ctx: &Context,
         tree: &'tree Tree,
         source: &'tree str,
         functions: &mut Functions,
         globals: &Globals,
     ) -> Result<Graph<'tree>, ExecutionError> {
         let mut graph = Graph::new();
-        self.execute_into(ctx, &mut graph, tree, source, functions, globals)?;
+        self.execute_into(&mut graph, tree, source, functions, globals)?;
         Ok(graph)
     }
 
···
     /// “pre-seed” the graph with some predefined nodes and/or edges before executing the DSL file.
     pub fn execute_into<'tree>(
         &self,
-        ctx: &Context,
         graph: &mut Graph<'tree>,
         tree: &'tree Tree,
         source: &'tree str,
···
         let mut cursor = QueryCursor::new();
         for stanza in &self.stanzas {
             stanza.execute(
-                ctx,
                 tree,
                 source,
                 graph,
···
 }
 
 struct ExecutionContext<'a, 'g, 's, 'tree> {
-    ctx: &'a Context,
     source: &'tree str,
     graph: &'a mut Graph<'tree>,
     functions: &'a mut Functions,
···
 impl Stanza {
     fn execute<'l, 's, 'tree>(
         &self,
-        ctx: &Context,
         tree: &'tree Tree,
         source: &'tree str,
         graph: &mut Graph<'tree>,
···
         for mat in matches {
             locals.clear();
             let mut exec = ExecutionContext {
-                ctx,
                 source,
                 graph,
                 functions,
···
             for statement in &self.statements {
                 statement
                     .execute(&mut exec)
-                    .with_context(|| format!("Executing {}", statement.display_with(exec.ctx)))?;
+                    .with_context(|| format!("Executing {}", statement))?;
             }
         }
         Ok(())
···
 
 impl AddGraphNodeAttribute {
     fn execute(&self, exec: &mut ExecutionContext) -> Result<(), ExecutionError> {
-        let node = self.node.evaluate_as_node(exec)?;
+        let node = self.node.evaluate(exec)?.into_graph_node_ref()?;
         for attribute in &self.attributes {
             let value = attribute.value.evaluate(exec)?;
             exec.graph[node]
                 .attributes
-                .add(attribute.name, value)
+                .add(attribute.name.clone(), value)
                 .map_err(|_| {
                     ExecutionError::DuplicateAttribute(format!(
                         " {} on graph node ({}) in {}",
-                        attribute.name.display_with(exec.ctx),
-                        node.display_with(exec.graph),
-                        self.display_with(exec.ctx),
+                        attribute.name, node, self,
                     ))
                 })?;
         }
···
 
 impl CreateEdge {
     fn execute(&self, exec: &mut ExecutionContext) -> Result<(), ExecutionError> {
-        let source = self.source.evaluate_as_node(exec)?;
-        let sink = self.sink.evaluate_as_node(exec)?;
-        let ctx = exec.ctx;
+        let source = self.source.evaluate(exec)?.into_graph_node_ref()?;
+        let sink = self.sink.evaluate(exec)?.into_graph_node_ref()?;
         if let Err(_) = exec.graph[source].add_edge(sink) {
             Err(ExecutionError::DuplicateEdge(format!(
                 "({} -> {}) in {}",
-                source.display_with(exec.graph),
-                sink.display_with(exec.graph),
-                self.display_with(ctx)
+                source, sink, self,
             )))?;
         }
         Ok(())
···
 
 impl AddEdgeAttribute {
     fn execute(&self, exec: &mut ExecutionContext) -> Result<(), ExecutionError> {
-        let source = self.source.evaluate_as_node(exec)?;
-        let sink = self.sink.evaluate_as_node(exec)?;
+        let source = self.source.evaluate(exec)?.into_graph_node_ref()?;
+        let sink = self.sink.evaluate(exec)?.into_graph_node_ref()?;
         for attribute in &self.attributes {
             let value = attribute.value.evaluate(exec)?;
             let edge = match exec.graph[source].get_edge_mut(sink) {
                 Some(edge) => Ok(edge),
                 None => Err(ExecutionError::UndefinedEdge(format!(
                     "({} -> {}) in {}",
-                    source.display_with(exec.graph),
-                    sink.display_with(exec.graph),
-                    self.display_with(exec.ctx)
+                    source, sink, self,
                 ))),
             }?;
-            edge.attributes.add(attribute.name, value).map_err(|_| {
-                ExecutionError::DuplicateAttribute(format!(
-                    " {} on edge ({} -> {}) in {}",
-                    attribute.name.display_with(exec.ctx),
-                    source.display_with(exec.graph),
-                    sink.display_with(exec.graph),
-                    self.display_with(exec.ctx),
-                ))
-            })?;
+            edge.attributes
+                .add(attribute.name.clone(), value)
+                .map_err(|_| {
+                    ExecutionError::DuplicateAttribute(format!(
+                        " {} on edge ({} -> {}) in {}",
+                        attribute.name, source, sink, self,
+                    ))
+                })?;
         }
         Ok(())
     }
···
 
 impl Scan {
     fn execute(&self, exec: &mut ExecutionContext) -> Result<(), ExecutionError> {
-        let match_string = self.value.evaluate(exec)?.into_string(exec.graph)?;
+        let match_string = self.value.evaluate(exec)?.into_string()?;
 
         let mut i = 0;
         let mut matches = Vec::new();
···
 
             let mut arm_locals = VariableMap::new_child(exec.locals);
             let mut arm_exec = ExecutionContext {
-                ctx: exec.ctx,
                 source: exec.source,
                 graph: exec.graph,
                 functions: exec.functions,
···
             for statement in &arm.statements {
                 statement
                     .execute(&mut arm_exec)
-                    .with_context(|| format!("Executing {}", statement.display_with(arm_exec.ctx)))
+                    .with_context(|| format!("Executing {}", statement))
                     .with_context(|| {
                         format!(
                             "Matching {} with arm \"{}\" {{ ... }}",
···
                 eprint!("{}", expr.value);
             } else {
                 let value = value.evaluate(exec)?;
-                eprint!("{}", value.display_with(exec.graph));
+                eprint!("{}", value);
             }
         }
         eprintln!();
···
             if result {
                 let mut arm_locals = VariableMap::new_child(exec.locals);
                 let mut arm_exec = ExecutionContext {
-                    ctx: exec.ctx,
                     source: exec.source,
                     graph: exec.graph,
                     functions: exec.functions,
···
         match self {
             Condition::Some { value, .. } => Ok(!value.evaluate(exec)?.is_null()),
             Condition::None { value, .. } => Ok(value.evaluate(exec)?.is_null()),
-            Condition::Bool { value, .. } => Ok(value.evaluate(exec)?.into_bool(exec.graph)?),
+            Condition::Bool { value, .. } => Ok(value.evaluate(exec)?.into_boolean()?),
         }
     }
 }
 
 impl ForIn {
     fn execute(&self, exec: &mut ExecutionContext) -> Result<(), ExecutionError> {
-        let values = self.value.evaluate(exec)?.into_list(exec.graph)?;
+        let values = self.value.evaluate(exec)?.into_list()?;
         let mut loop_locals = VariableMap::new_child(exec.locals);
         for value in values {
             loop_locals.clear();
             let mut loop_exec = ExecutionContext {
-                ctx: exec.ctx,
                 source: exec.source,
                 graph: exec.graph,
                 functions: exec.functions,
···
             Expression::RegexCapture(expr) => expr.evaluate(exec),
         }
     }
-
-    fn evaluate_as_node(
-        &self,
-        exec: &mut ExecutionContext,
-    ) -> Result<GraphNodeRef, ExecutionError> {
-        let node = self.evaluate(exec)?;
-        match node {
-            Value::GraphNode(node) => Ok(node),
-            _ => Err(ExecutionError::ExpectedGraphNode(format!(
-                " {}, got {}",
-                self.display_with(exec.ctx),
-                node.display_with(exec.graph)
-            ))),
-        }
-    }
 }
 
 impl IntegerConstant {
···
             exec.function_parameters.push(parameter);
         }
         exec.functions.call(
-            exec.ctx,
-            self.function,
+            &self.function,
             exec.graph,
             exec.source,
             &mut exec
···
 
 impl RegexCapture {
     fn evaluate(&self, exec: &mut ExecutionContext) -> Result<Value, ExecutionError> {
-        let capture = exec.current_regex_captures.get(self.match_index).ok_or(
-            ExecutionError::UndefinedRegexCapture(format!("{}", self.display_with(exec.ctx))),
-        )?;
+        let capture = exec
+            .current_regex_captures
+            .get(self.match_index)
+            .ok_or(ExecutionError::UndefinedRegexCapture(format!("{}", self)))?;
         Ok(Value::String(capture.clone()))
     }
 }
···
             _ => {
                 return Err(ExecutionError::InvalidVariableScope(format!(
                     " got {}",
-                    scope.display_with(exec.graph)
+                    scope
                 )))
             }
         };
···
         } else {
             Err(ExecutionError::UndefinedVariable(format!(
                 "{} on node {}",
-                self.display_with(exec.ctx),
-                scope.display_with(exec.graph)
+                self, scope,
             )))
         }
     }
···
             _ => {
                 return Err(ExecutionError::InvalidVariableScope(format!(
                     " got {}",
-                    scope.display_with(exec.graph)
+                    scope
                 )))
             }
         };
         let variables = exec.scoped.get(scope);
-        variables.add(self.name, value, mutable).map_err(|_| {
-            ExecutionError::DuplicateVariable(format!(" {}", self.display_with(exec.ctx)))
-        })
+        variables
+            .add(self.name.clone(), value, mutable)
+            .map_err(|_| ExecutionError::DuplicateVariable(format!(" {}", self)))
     }
 
     fn set(&self, exec: &mut ExecutionContext, value: Value) -> Result<(), ExecutionError> {
···
             _ => {
                 return Err(ExecutionError::InvalidVariableScope(format!(
                     " got {}",
-                    scope.display_with(exec.graph)
+                    scope,
                 )))
             }
         };
         let variables = exec.scoped.get(scope);
-        variables.set(self.name, value).map_err(|_| {
-            ExecutionError::DuplicateVariable(format!(" {}", self.display_with(exec.ctx)))
-        })
+        variables
+            .set(self.name.clone(), value)
+            .map_err(|_| ExecutionError::DuplicateVariable(format!(" {}", self)))
     }
 }
 
···
         } else {
             exec.locals.get(&self.name)
         }
-        .ok_or_else(|| {
-            ExecutionError::UndefinedVariable(format!("{}", self.display_with(exec.ctx)))
-        })
+        .ok_or_else(|| ExecutionError::UndefinedVariable(format!("{}", self)))
     }
 
     fn add(
···
         if exec.globals.get(&self.name).is_some() {
             return Err(ExecutionError::DuplicateVariable(format!(
                 " global {}",
-                self.display_with(exec.ctx)
+                self,
             )));
         }
-        exec.locals.add(self.name, value, mutable).map_err(|_| {
-            ExecutionError::DuplicateVariable(format!(" local {}", self.display_with(exec.ctx)))
-        })
+        exec.locals
+            .add(self.name.clone(), value, mutable)
+            .map_err(|_| ExecutionError::DuplicateVariable(format!(" local {}", self)))
     }
 
     fn set(&self, exec: &mut ExecutionContext, value: Value) -> Result<(), ExecutionError> {
         if exec.globals.get(&self.name).is_some() {
             return Err(ExecutionError::CannotAssignImmutableVariable(format!(
                 " global {}",
-                self.display_with(exec.ctx)
+                self,
             )));
         }
-        exec.locals.set(self.name, value).map_err(|_| {
+        exec.locals.set(self.name.clone(), value).map_err(|_| {
             if exec.locals.get(&self.name).is_some() {
-                ExecutionError::CannotAssignImmutableVariable(format!(
-                    "{}",
-                    self.display_with(exec.ctx)
-                ))
+                ExecutionError::CannotAssignImmutableVariable(format!("{}", self))
             } else {
-                ExecutionError::UndefinedVariable(format!("{}", self.display_with(exec.ctx)))
+                ExecutionError::UndefinedVariable(format!("{}", self))
             }
         })
     }

src/functions.rs

···
 use crate::execution::ExecutionError;
 use crate::graph::Graph;
 use crate::graph::Value;
-use crate::Context;
-use crate::DisplayWithContext;
 use crate::Identifier;
 
 /// The implementation of a function that can be called from the graph DSL.
···
 /// # use tree_sitter_graph::graph::Value;
 /// # use tree_sitter_graph::ExecutionError;
 /// # fn main() -> Result<(), ExecutionError> {
-/// # let graph = Graph::new();
 /// # let param_vec = vec![Value::String("test".to_string()), Value::Integer(42)];
 /// # let mut params = param_vec.into_iter();
-/// let first_param = params.param()?.into_string(&graph)?;
-/// let second_param = params.param()?.into_integer(&graph)?;
+/// let first_param = params.param()?.into_string()?;
+/// let second_param = params.param()?.as_integer()?;
 /// // etc
 /// params.finish()?;
 /// # Ok(())
···
 
     /// Returns the standard library of functions, as defined in the [language
     /// reference][`crate::reference::functions`].
-    pub fn stdlib(ctx: &mut Context) -> Functions {
+    pub fn stdlib() -> Functions {
         let mut functions = Functions::new();
         // general functions
-        functions.add(ctx.add_identifier("is-null"), stdlib::IsNull);
+        functions.add(Identifier::from("is-null"), stdlib::IsNull);
         // tree functions
         functions.add(
-            ctx.add_identifier("named-child-index"),
+            Identifier::from("named-child-index"),
             stdlib::syntax::NamedChildIndex,
         );
+        functions.add(Identifier::from("source-text"), stdlib::syntax::SourceText);
+        functions.add(Identifier::from("start-row"), stdlib::syntax::StartRow);
         functions.add(
-            ctx.add_identifier("source-text"),
-            stdlib::syntax::SourceText,
-        );
-        functions.add(ctx.add_identifier("start-row"), stdlib::syntax::StartRow);
-        functions.add(
-            ctx.add_identifier("start-column"),
+            Identifier::from("start-column"),
             stdlib::syntax::StartColumn,
         );
-        functions.add(ctx.add_identifier("end-row"), stdlib::syntax::EndRow);
-        functions.add(ctx.add_identifier("end-column"), stdlib::syntax::EndColumn);
-        functions.add(ctx.add_identifier("node-type"), stdlib::syntax::NodeType);
+        functions.add(Identifier::from("end-row"), stdlib::syntax::EndRow);
+        functions.add(Identifier::from("end-column"), stdlib::syntax::EndColumn);
+        functions.add(Identifier::from("node-type"), stdlib::syntax::NodeType);
         functions.add(
-            ctx.add_identifier("named-child-count"),
+            Identifier::from("named-child-count"),
             stdlib::syntax::NamedChildCount,
         );
         // graph functions
-        functions.add(ctx.add_identifier("node"), stdlib::graph::Node);
+        functions.add(Identifier::from("node"), stdlib::graph::Node);
         // boolean functions
-        functions.add(ctx.add_identifier("not"), stdlib::bool::Not);
-        functions.add(ctx.add_identifier("and"), stdlib::bool::And);
-        functions.add(ctx.add_identifier("or"), stdlib::bool::Or);
+        functions.add(Identifier::from("not"), stdlib::bool::Not);
+        functions.add(Identifier::from("and"), stdlib::bool::And);
+        functions.add(Identifier::from("or"), stdlib::bool::Or);
         // math functions
-        functions.add(ctx.add_identifier("plus"), stdlib::math::Plus);
+        functions.add(Identifier::from("plus"), stdlib::math::Plus);
         // string functions
-        functions.add(ctx.add_identifier("replace"), stdlib::string::Replace);
+        functions.add(Identifier::from("replace"), stdlib::string::Replace);
         functions
     }
 
···
     /// Calls a named function, returning an error if there is no function with that name.
     pub fn call(
         &mut self,
-        ctx: &Context,
-        name: Identifier,
+        name: &Identifier,
         graph: &mut Graph,
         source: &str,
         parameters: &mut dyn Parameters,
     ) -> Result<Value, ExecutionError> {
         let function = self
             .functions
-            .get_mut(&name)
-            .ok_or(ExecutionError::UndefinedFunction(format!(
-                "{}",
-                name.display_with(ctx)
-            )))?;
+            .get_mut(name)
+            .ok_or(ExecutionError::UndefinedFunction(format!("{}", name)))?;
         function.call(graph, source, parameters)
     }
 }
···
                 _source: &str,
                 parameters: &mut dyn Parameters,
             ) -> Result<Value, ExecutionError> {
-                let node = graph[parameters.param()?.into_syntax_node_ref(graph)?];
+                let node = graph[parameters.param()?.into_syntax_node_ref()?];
                 parameters.finish()?;
                 let parent = match node.parent() {
                     Some(parent) => parent,
···
                 source: &str,
                 parameters: &mut dyn Parameters,
             ) -> Result<Value, ExecutionError> {
-                let node = graph[parameters.param()?.into_syntax_node_ref(graph)?];
+                let node = graph[parameters.param()?.into_syntax_node_ref()?];
                 parameters.finish()?;
                 Ok(Value::String(source[node.byte_range()].to_string()))
             }
···
                 _source: &str,
                 parameters: &mut dyn Parameters,
             ) -> Result<Value, ExecutionError> {
-                let node = graph[parameters.param()?.into_syntax_node_ref(graph)?];
+                let node = graph[parameters.param()?.into_syntax_node_ref()?];
                 parameters.finish()?;
                 Ok(Value::Integer(node.start_position().row as u32))
             }
···
                 _source: &str,
                 parameters: &mut dyn Parameters,
             ) -> Result<Value, ExecutionError> {
-                let node = graph[parameters.param()?.into_syntax_node_ref(graph)?];
+                let node = graph[parameters.param()?.into_syntax_node_ref()?];
                 parameters.finish()?;
                 Ok(Value::Integer(node.start_position().column as u32))
             }
···
                 _source: &str,
                 parameters: &mut dyn Parameters,
             ) -> Result<Value, ExecutionError> {
-                let node = graph[parameters.param()?.into_syntax_node_ref(graph)?];
+                let node = graph[parameters.param()?.into_syntax_node_ref()?];
                 parameters.finish()?;
                 Ok(Value::Integer(node.end_position().row as u32))
             }
···
                 _source: &str,
                 parameters: &mut dyn Parameters,
             ) -> Result<Value, ExecutionError> {
-                let node = graph[parameters.param()?.into_syntax_node_ref(graph)?];
+                let node = graph[parameters.param()?.into_syntax_node_ref()?];
                 parameters.finish()?;
                 Ok(Value::Integer(node.end_position().column as u32))
             }
···
                 _source: &str,
                 parameters: &mut dyn Parameters,
             ) -> Result<Value, ExecutionError> {
-                let node = graph[parameters.param()?.into_syntax_node_ref(graph)?];
+                let node = graph[parameters.param()?.into_syntax_node_ref()?];
                 parameters.finish()?;
                 Ok(Value::String(node.kind().to_string()))
             }
···
                 _source: &str,
                 parameters: &mut dyn Parameters,
             ) -> Result<Value, ExecutionError> {
-                let node = graph[parameters.param()?.into_syntax_node_ref(graph)?];
+                let node = graph[parameters.param()?.into_syntax_node_ref()?];
                 parameters.finish()?;
                 Ok(Value::Integer(node.named_child_count() as u32))
             }
···
         impl Function for Not {
             fn call(
                 &mut self,
-                graph: &mut Graph,
+                _graph: &mut Graph,
                 _source: &str,
                 parameters: &mut dyn Parameters,
             ) -> Result<Value, ExecutionError> {
-                let result = !parameters.param()?.into_bool(graph)?;
+                let result = !parameters.param()?.as_boolean()?;
                 parameters.finish()?;
                 Ok(result.into())
             }
···
         impl Function for And {
             fn call(
                 &mut self,
-                graph: &mut Graph,
+                _graph: &mut Graph,
                 _source: &str,
                 parameters: &mut dyn Parameters,
             ) -> Result<Value, ExecutionError> {
                 let mut result = true;
                 while let Ok(parameter) = parameters.param() {
-                    result &= parameter.into_bool(graph)?;
+                    result &= parameter.as_boolean()?;
                 }
                 Ok(result.into())
             }
···
         impl Function for Or {
             fn call(
                 &mut self,
-                graph: &mut Graph,
+                _graph: &mut Graph,
                 _source: &str,
                 parameters: &mut dyn Parameters,
             ) -> Result<Value, ExecutionError> {
                 let mut result = false;
                 while let Ok(parameter) = parameters.param() {
-                    result |= parameter.into_bool(graph)?;
+                    result |= parameter.as_boolean()?;
                 }
                 Ok(result.into())
             }
···
         impl Function for Plus {
             fn call(
                 &mut self,
-                graph: &mut Graph,
+                _graph: &mut Graph,
                 _source: &str,
                 parameters: &mut dyn Parameters,
             ) -> Result<Value, ExecutionError> {
                 let mut result = 0;
                 while let Ok(parameter) = parameters.param() {
-                    result += parameter.into_integer(graph)?;
+                    result += parameter.as_integer()?;
                 }
                 Ok(Value::Integer(result))
             }
···
         impl Function for Replace {
             fn call(
                 &mut self,
-                graph: &mut Graph,
+                _graph: &mut Graph,
                 _source: &str,
                 parameters: &mut dyn Parameters,
             ) -> Result<Value, ExecutionError> {
-                let text = parameters.param()?.into_string(graph)?;
-                let pattern = parameters.param()?.into_string(graph)?;
+                let text = parameters.param()?.into_string()?;
+                let pattern = parameters.param()?.into_string()?;
                 let pattern = Regex::new(&pattern).map_err(ExecutionError::other)?;
-                let replacement = parameters.param()?.into_string(graph)?;
+                let replacement = parameters.param()?.into_string()?;
                 parameters.finish()?;
                 Ok(Value::String(
                     pattern.replace_all(&text, replacement).to_string(),

src/graph.rs

···
 
 //! Defines data types for the graphs produced by the graph DSL
 
+use std::borrow::Borrow;
 use std::collections::hash_map::Entry;
 use std::collections::BTreeSet;
 use std::collections::HashMap;
 use std::fmt;
+use std::hash::Hash;
 use std::ops::Index;
 use std::ops::IndexMut;
 
-use smallvec::SmallVec;
-use tree_sitter::Node;
-
-use serde::ser;
 use serde::ser::SerializeMap;
 use serde::ser::SerializeSeq;
+use serde::Serialize;
+use serde::Serializer;
 use serde_json;
+use smallvec::SmallVec;
+use tree_sitter::Node;
 
 use crate::execution::ExecutionError;
-use crate::Context;
 use crate::Identifier;
 
 /// A graph produced by executing a graph DSL file.  Graphs include a lifetime parameter to ensure
 /// that they don't outlive the tree-sitter syntax tree that they are generated from.
 #[derive(Default)]
 pub struct Graph<'tree> {
-    syntax_nodes: HashMap<SyntaxNodeRef, Node<'tree>>,
+    syntax_nodes: HashMap<SyntaxNodeID, Node<'tree>>,
     graph_nodes: Vec<GraphNode>,
 }
 
···
     /// The graph won't contain _every_ syntax node in the parsed syntax tree; it will only contain
     /// those nodes that are referenced at some point during the execution of the graph DSL file.
     pub fn add_syntax_node(&mut self, node: Node<'tree>) -> SyntaxNodeRef {
-        let index = SyntaxNodeRef(node.id() as SyntaxNodeID);
-        self.syntax_nodes.insert(index, node);
-        index
+        let index = node.id() as SyntaxNodeID;
+        let node_ref = SyntaxNodeRef {
+            index,
+            kind: node.kind(),
+            position: node.start_position(),
+        };
+        self.syntax_nodes.entry(index).or_insert(node);
+        node_ref
     }
 
     /// Adds a new graph node to the graph, returning a graph DSL reference to it.
···
         GraphNodeRef(index)
     }
 
-    /// fmt::Displays the contents of this graph.
-    pub fn display_with<'a>(&'a self, ctx: &'a Context) -> impl fmt::Display + 'a {
-        struct DisplayGraph<'a, 'tree>(&'a Graph<'tree>, &'a Context);
+    /// Pretty-prints the contents of this graph.
+    pub fn pretty_print<'a>(&'a self) -> impl fmt::Display + 'a {
+        struct DisplayGraph<'a, 'tree>(&'a Graph<'tree>);
 
         impl<'a, 'tree> fmt::Display for DisplayGraph<'a, 'tree> {
             fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
                 let graph = self.0;
-                let ctx = self.1;
                 for (node_index, node) in graph.graph_nodes.iter().enumerate() {
-                    write!(
-                        f,
-                        "node {}\n{}",
-                        node_index,
-                        node.attributes.display_with(ctx, graph)
-                    )?;
+                    write!(f, "node {}\n{}", node_index, node.attributes)?;
                     for (sink, edge) in &node.outgoing_edges {
-                        write!(
-                            f,
-                            "edge {} -> {}\n{}",
-                            node_index,
-                            *sink,
-                            edge.attributes.display_with(ctx, graph)
-                        )?;
+                        write!(f, "edge {} -> {}\n{}", node_index, *sink, edge.attributes)?;
                     }
                 }
                 Ok(())
             }
         }
 
-        DisplayGraph(self, ctx)
+        DisplayGraph(self)
     }
 
-    pub fn display_json<'a>(&'a self, ctx: &'a Context) -> () {
-        // TODO: move this all into a new module
-        struct InContext<'a, T>(&'a T, &'a Context);
-
-        impl<'a> Context {
-            fn with<T>(&'a self, t: &'a T) -> InContext<'a, T> {
-                InContext(t, self)
-            }
-        }
-
-        impl<'a, 'tree> ser::Serialize for InContext<'a, Graph<'tree>> {
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: serde::Serializer,
-            {
-                let graph = self.0;
-                let ctx = self.1;
-                let mut seq = serializer.serialize_seq(Some(graph.graph_nodes.len()))?;
-                for (node_index, node) in graph.graph_nodes.iter().enumerate() {
-                    seq.serialize_element(&ctx.with(&(node_index, node)))?;
-                }
-                seq.end()
-            }
-        }
-
-        impl<'a> ser::Serialize for InContext<'a, (usize, &'a GraphNode)> {
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: serde::Serializer,
-            {
-                let node_index = self.0 .0;
-                let node = self.0 .1;
-                let ctx = self.1;
-                // serializing as a map instead of a struct so we don't have to encode a struct name
-                let mut map = serializer.serialize_map(None)?;
-                map.serialize_entry("id", &node_index)?;
-                map.serialize_entry("edges", &ctx.with(&node.outgoing_edges))?;
-                map.serialize_entry("attrs", &ctx.with(&node.attributes))?;
-                map.end()
-            }
-        }
-
-        impl<'a> ser::Serialize for InContext<'a, SmallVec<[(GraphNodeID, Edge); 8]>> {
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: serde::Serializer,
-            {
-                let elems = self.0;
-                let ctx = self.1;
-                let mut seq = serializer.serialize_seq(Some(elems.len()))?;
-                for (_, (id, edge)) in elems.iter().enumerate() {
-                    seq.serialize_element(&ctx.with(&(id, edge)))?;
-                }
-                seq.end()
-            }
-        }
-
-        impl<'a> ser::Serialize for InContext<'a, (&'a GraphNodeID, &'a Edge)> {
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: serde::Serializer,
-            {
-                let sink = self.0 .0;
-                let edge = self.0 .1;
-                let ctx = self.1;
-                let mut map = serializer.serialize_map(None)?;
-                map.serialize_entry("sink", &sink)?;
-                map.serialize_entry("attrs", &ctx.with(&edge.attributes))?;
-                map.end()
-            }
-        }
-
-        impl<'a> ser::Serialize for InContext<'a, Attributes> {
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: serde::Serializer,
-            {
-                let attrs = self.0;
-                let ctx = self.1;
-                let mut map = serializer.serialize_map(None)?;
-                for (_, (key, value)) in attrs.values.iter().enumerate() {
-                    map.serialize_entry(&ctx.with(key), &ctx.with(value))?;
-                }
-                map.end()
-            }
-        }
-
-        impl<'a> ser::Serialize for InContext<'a, Identifier> {
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: serde::Serializer,
-            {
-                let identifier = self.0;
-                let ctx = self.1;
-                let symbol = ctx.identifiers.resolve(identifier.0).unwrap();
-                serializer.serialize_str(symbol)
-            }
-        }
-
-        impl<'a> ser::Serialize for InContext<'a, Value> {
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: serde::Serializer,
-            {
-                let value = self.0;
-                let ctx = self.1;
-                match value {
-                    Value::Null => serializer.serialize_none(),
-                    Value::Boolean(bool) => serializer.serialize_bool(*bool),
-                    Value::Integer(integer) => serializer.serialize_u32(*integer),
-                    Value::String(string) => serializer.serialize_str(string),
-                    // FIXME: there's no way to distinguish sets and lists, so we can't roundtrip accurately
-                    Value::List(list) => {
-                        serializer.collect_seq(list.iter().map(|value| ctx.with(value)))
-                    }
-                    Value::Set(set) => {
-                        serializer.collect_seq(set.iter().map(|value| ctx.with(value)))
-                    }
-                    // FIXME: we don't distinguish between syntax tree node IDs, graph node IDs, and integers
-                    Value::SyntaxNode(node) => serializer.serialize_u32(node.0),
-                    Value::GraphNode(node) => serializer.serialize_u32(node.0),
-                }
-            }
-        }
-
-        let json_graph = ctx.with(self);
-        let s = serde_json::to_string_pretty(&json_graph).unwrap();
+    pub fn display_json(&self) {
+        let s = serde_json::to_string_pretty(self).unwrap();
         print!("{}", s)
     }
 
···
 
 impl<'tree> Index<SyntaxNodeRef> for Graph<'tree> {
     type Output = Node<'tree>;
-    fn index(&self, index: SyntaxNodeRef) -> &Node<'tree> {
-        &self.syntax_nodes[&index]
+    fn index(&self, node_ref: SyntaxNodeRef) -> &Node<'tree> {
+        &self.syntax_nodes[&node_ref.index]
     }
 }
 
···
 impl<'tree> IndexMut<GraphNodeRef> for Graph<'_> {
     fn index_mut(&mut self, index: GraphNodeRef) -> &mut GraphNode {
         &mut self.graph_nodes[index.0 as usize]
+    }
+}
+
+impl<'tree> Serialize for Graph<'tree> {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        let mut seq = serializer.serialize_seq(Some(self.graph_nodes.len()))?;
+        for (node_index, node) in self.graph_nodes.iter().enumerate() {
+            seq.serialize_element(&SerializeGraphNode(node_index, node))?;
+        }
+        seq.end()
     }
 }
 
···
     }
 }
 
+struct SerializeGraphNode<'a>(usize, &'a GraphNode);
+
+impl<'a> Serialize for SerializeGraphNode<'a> {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        let node_index = self.0;
+        let node = self.1;
+        // serializing as a map instead of a struct so we don't have to encode a struct name
+        let mut map = serializer.serialize_map(None)?;
+        map.serialize_entry("id", &node_index)?;
+        map.serialize_entry("edges", &SerializeGraphNodeEdges(&node.outgoing_edges))?;
+        map.serialize_entry("attrs", &node.attributes)?;
+        map.end()
+    }
+}
+
+struct SerializeGraphNodeEdges<'a>(&'a SmallVec<[(GraphNodeID, Edge); 8]>);
+
+impl<'a> Serialize for SerializeGraphNodeEdges<'a> {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        let edges = self.0;
+        let mut seq = serializer.serialize_seq(Some(edges.len()))?;
+        for element in edges {
+            seq.serialize_element(&SerializeGraphNodeEdge(&element))?;
+        }
+        seq.end()
+    }
+}
+
+struct SerializeGraphNodeEdge<'a>(&'a (GraphNodeID, Edge));
+
+impl<'a> Serialize for SerializeGraphNodeEdge<'a> {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        let wrapped = &self.0;
+        let sink = &wrapped.0;
+        let edge = &wrapped.1;
+        let mut map = serializer.serialize_map(None)?;
+        map.serialize_entry("sink", sink)?;
+        map.serialize_entry("attrs", &edge.attributes)?;
+        map.end()
+    }
+}
+
 /// An edge between two nodes in a graph
 pub struct Edge {
     /// The set of attributes associated with this edge
···
     }
 
     /// Returns the value of a particular attribute, if it exists.
-    pub fn get(&self, name: Identifier) -> Option<&Value> {
-        self.values.get(&name)
+    pub fn get<Q>(&self, name: &Q) -> Option<&Value>
+    where
+        Q: ?Sized + Eq + Hash,
+        Identifier: Borrow<Q>,
+    {
+        self.values.get(name.borrow())
     }
-
-    /// fmt::Displays the contents of this attribute set.
-    pub fn display_with<'a>(
-        &'a self,
-        ctx: &'a Context,
-        graph: &'a Graph,
-    ) -> impl fmt::Display + 'a {
-        struct DisplayAttributes<'a, 'tree>(&'a Attributes, &'a Context, &'a Graph<'tree>);
-
-        impl<'a, 'tree> fmt::Display for DisplayAttributes<'a, 'tree> {
-            fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-                let attributes = self.0;
-                let ctx = self.1;
-                let graph = self.2;
+}
 
-                let mut keys = attributes
-                    .values
-                    .keys()
-                    .map(|k| (ctx.resolve(*k), k))
-                    .collect::<Vec<_>>();
-                keys.sort_by(|a, b| a.0.cmp(b.0));
-                for (name, key) in &keys {
-                    let value = &attributes.values[key];
-                    write!(f, "  {}: {}\n", name, value.display_with(graph),)?;
-                }
-                Ok(())
-            }
+impl std::fmt::Display for Attributes {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        let mut keys = self.values.keys().collect::<Vec<_>>();
+        keys.sort_by(|a, b| a.cmp(b));
+        for key in &keys {
+            let value = &self.values[*key];
+            write!(f, "  {}: {}\n", key, value)?;
         }
+        Ok(())
+    }
+}
 
-        DisplayAttributes(self, ctx, graph)
+impl Serialize for Attributes {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        let mut map = serializer.serialize_map(None)?;
+        for (key, value) in &self.values {
+            map.serialize_entry(key, value)?;
+        }
+        map.end()
     }
 }
 
···
 
 impl Value {
     /// Check if this value is null
-    pub fn is_null(self) -> bool {
+    pub fn is_null(&self) -> bool {
         match self {
             Value::Null => true,
             _ => false,
         }
     }
+
     /// Coerces this value into a boolean, returning an error if it's some other type of value.
-    pub fn into_bool(self, graph: &Graph) -> Result<bool, ExecutionError> {
+    pub fn into_boolean(self) -> Result<bool, ExecutionError> {
         match self {
             Value::Boolean(value) => Ok(value),
-            _ => Err(ExecutionError::ExpectedBoolean(format!(
-                "got {}",
-                self.display_with(graph)
-            ))),
+            _ => Err(ExecutionError::ExpectedBoolean(format!("got {}", self))),
         }
     }
 
-    pub fn as_bool(&self, graph: &Graph) -> Result<bool, ExecutionError> {
+    pub fn as_boolean(&self) -> Result<bool, ExecutionError> {
         match self {
             Value::Boolean(value) => Ok(*value),
-            _ => Err(ExecutionError::ExpectedBoolean(format!(
-                "got {}",
-                self.display_with(graph)
-            ))),
+            _ => Err(ExecutionError::ExpectedBoolean(format!("got {}", self))),
         }
     }
 
     /// Coerces this value into an integer, returning an error if it's some other type of value.
-    pub fn into_integer(self, graph: &Graph) -> Result<u32, ExecutionError> {
+    pub fn into_integer(self) -> Result<u32, ExecutionError> {
         match self {
             Value::Integer(value) => Ok(value),
-            _ => Err(ExecutionError::ExpectedInteger(format!(
-                "got {}",
-                self.display_with(graph)
-            ))),
+            _ => Err(ExecutionError::ExpectedInteger(format!("got {}", self))),
         }
     }
 
-    pub fn as_integer(&self, graph: &Graph) -> Result<u32, ExecutionError> {
+    pub fn as_integer(&self) -> Result<u32, ExecutionError> {
         match self {
             Value::Integer(value) => Ok(*value),
-            _ => Err(ExecutionError::ExpectedInteger(format!(
-                "got {}",
-                self.display_with(graph)
-            ))),
+            _ => Err(ExecutionError::ExpectedInteger(format!("got {}", self))),
         }
     }
 
     /// Coerces this value into a string, returning an error if it's some other type of value.
-    pub fn into_string(self, graph: &Graph) -> Result<String, ExecutionError> {
+    pub fn into_string(self) -> Result<String, ExecutionError> {
         match self {
             Value::String(value) => Ok(value),
-            _ => Err(ExecutionError::ExpectedString(format!(
-                "got {}",
-                self.display_with(graph)
-            ))),
+            _ => Err(ExecutionError::ExpectedString(format!("got {}", self))),
         }
     }
 
-    pub fn as_string(&self, graph: &Graph) -> Result<&str, ExecutionError> {
+    pub fn as_str(&self) -> Result<&str, ExecutionError> {
         match self {
             Value::String(value) => Ok(value),
-            _ => Err(ExecutionError::ExpectedString(format!(
-                "got {}",
-                self.display_with(graph)
-            ))),
+            _ => Err(ExecutionError::ExpectedString(format!("got {}", self))),
         }
     }
 
     /// Coerces this value into a list, returning an error if it's some other type of value.
-    pub fn into_list(self, graph: &Graph) -> Result<Vec<Value>, ExecutionError> {
+    pub fn into_list(self) -> Result<Vec<Value>, ExecutionError> {
         match self {
             Value::List(values) => Ok(values),
-            _ => Err(ExecutionError::ExpectedList(format!(
-                "got {}",
-                self.display_with(graph)
-            ))),
+            _ => Err(ExecutionError::ExpectedList(format!("got {}", self))),
         }
     }
 
-    pub fn as_list(&self, graph: &Graph) -> Result<&Vec<Value>, ExecutionError> {
+    pub fn as_list(&self) -> Result<&Vec<Value>, ExecutionError> {
         match self {
             Value::List(values) => Ok(values),
-            _ => Err(ExecutionError::ExpectedList(format!(
-                "got {}",
-                self.display_with(graph)
-            ))),
+            _ => Err(ExecutionError::ExpectedList(format!("got {}", self))),
         }
     }
 
     /// Coerces this value into a graph node reference, returning an error if it's some other type
     /// of value.
-    pub fn into_graph_node_ref<'a, 'tree>(
-        self,
-        graph: &'a Graph<'tree>,
-    ) -> Result<GraphNodeRef, ExecutionError> {
+    pub fn into_graph_node_ref<'a, 'tree>(self) -> Result<GraphNodeRef, ExecutionError> {
         match self {
             Value::GraphNode(node) => Ok(node),
-            _ => Err(ExecutionError::ExpectedGraphNode(format!(
-                "got {}",
-                self.display_with(graph)
-            ))),
+            _ => Err(ExecutionError::ExpectedGraphNode(format!("got {}", self))),
         }
     }
 
-    pub fn as_graph_node_ref<'a, 'tree>(
-        &self,
-        graph: &'a Graph<'tree>,
-    ) -> Result<GraphNodeRef, ExecutionError> {
+    pub fn as_graph_node_ref<'a, 'tree>(&self) -> Result<GraphNodeRef, ExecutionError> {
         match self {
             Value::GraphNode(node) => Ok(*node),
-            _ => Err(ExecutionError::ExpectedGraphNode(format!(
-                "got {}",
-                self.display_with(graph)
-            ))),
+            _ => Err(ExecutionError::ExpectedGraphNode(format!("got {}", self))),
         }
     }
 
     /// Coerces this value into a syntax node reference, returning an error if it's some other type
     /// of value.
-    pub fn into_syntax_node_ref<'a, 'tree>(
-        self,
-        graph: &'a Graph<'tree>,
-    ) -> Result<SyntaxNodeRef, ExecutionError> {
+    pub fn into_syntax_node_ref<'a, 'tree>(self) -> Result<SyntaxNodeRef, ExecutionError> {
         match self {
             Value::SyntaxNode(node) => Ok(node),
-            _ => Err(ExecutionError::ExpectedSyntaxNode(format!(
-                "got {}",
-                self.display_with(graph)
-            ))),
+            _ => Err(ExecutionError::ExpectedSyntaxNode(format!("got {}", self))),
         }
     }
 
···
         self,
         graph: &'a Graph<'tree>,
     ) -> Result<&'a Node<'tree>, ExecutionError> {
-        Ok(&graph[self.into_syntax_node_ref(graph)?])
+        Ok(&graph[self.into_syntax_node_ref()?])
     }
 
-    pub fn as_syntax_node_ref<'a, 'tree>(
-        &self,
-        graph: &'a Graph<'tree>,
-    ) -> Result<SyntaxNodeRef, ExecutionError> {
+    pub fn as_syntax_node_ref<'a, 'tree>(&self) -> Result<SyntaxNodeRef, ExecutionError> {
         match self {
             Value::SyntaxNode(node) => Ok(*node),
-            _ => Err(ExecutionError::ExpectedSyntaxNode(format!(
-                "got {}",
-                self.display_with(graph)
-            ))),
+            _ => Err(ExecutionError::ExpectedSyntaxNode(format!("got {}", self))),
         }
     }
 }
···
     }
 }
 
-impl DisplayWithGraph for Value {
-    fn fmt(&self, f: &mut fmt::Formatter, graph: &Graph) -> fmt::Result {
+impl std::fmt::Display for Value {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             Value::Null => write!(f, "#null"),
             Value::Boolean(value) => {
···
                 let mut first = true;
                 for element in value {
                     if first {
-                        write!(f, "{}", element.display_with(graph))?;
+                        write!(f, "{}", element)?;
                         first = false;
                     } else {
-                        write!(f, ", {}", element.display_with(graph))?;
+                        write!(f, ", {}", element)?;
                     }
                 }
                 write!(f, "]")
···
                 let mut first = true;
                 for element in value {
                     if first {
-                        write!(f, "{}", element.display_with(graph))?;
+                        write!(f, "{}", element)?;
                         first = false;
                     } else {
-                        write!(f, ", {}", element.display_with(graph))?;
+                        write!(f, ", {}", element)?;
                     }
                 }
                 write!(f, "}}")
             }
-            Value::SyntaxNode(node) => node.fmt(f, graph),
-            Value::GraphNode(node) => node.fmt(f, graph),
+            Value::SyntaxNode(node) => node.fmt(f),
+            Value::GraphNode(node) => node.fmt(f),
+        }
+    }
+}
+
+impl Serialize for Value {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        match self {
+            Value::Null => serializer.serialize_none(),
+            Value::Boolean(value) => serializer.serialize_bool(*value),
+            Value::Integer(value) => serializer.serialize_u32(*value),
+            Value::String(value) => serializer.serialize_str(value),
+            // FIXME: there's no way to distinguish sets and lists, so we can't roundtrip accurately
+            Value::List(list) => serializer.collect_seq(list),
+            Value::Set(set) => serializer.collect_seq(set),
+            // FIXME: we don't distinguish between syntax tree node IDs, graph node IDs, and integers
+            Value::SyntaxNode(node) => serializer.serialize_u32(node.index),
+            Value::GraphNode(node) => serializer.serialize_u32(node.0),
         }
     }
 }
 
 /// A reference to a syntax node in a graph
 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct SyntaxNodeRef(SyntaxNodeID);
+pub struct SyntaxNodeRef {
+    index: SyntaxNodeID,
+    kind: &'static str,
+    position: tree_sitter::Point,
+}
 
 impl From<SyntaxNodeRef> for Value {
     fn from(value: SyntaxNodeRef) -> Value {
···
     }
 }
 
-impl DisplayWithGraph for SyntaxNodeRef {
-    fn fmt(&self, f: &mut fmt::Formatter, graph: &Graph) -> fmt::Result {
-        let node = graph[*self];
-        write!(f, "{}", format_node(&node))
+impl std::fmt::Display for SyntaxNodeRef {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(
+            f,
+            "[syntax node {} ({}, {})]",
+            self.kind,
+            self.position.row + 1,
+            self.position.column + 1,
+        )
     }
 }
 
-pub fn format_node(node: &Node) -> String {
-    format!(
-        "[syntax node {} ({}, {})]",
-        node.kind(),
-        node.start_position().row + 1,
-        node.start_position().column + 1
-    )
-}
-
 /// A reference to a graph node
 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub struct GraphNodeRef(GraphNodeID);
 
+impl GraphNodeRef {
+    /// Returns the index of the graph node that this reference refers to.
+    pub fn index(self) -> usize {
+        self.0 as usize
+    }
+}
+
 impl From<GraphNodeRef> for Value {
     fn from(value: GraphNodeRef) -> Value {
         Value::GraphNode(value)
     }
 }
 
-impl DisplayWithGraph for GraphNodeRef {
-    fn fmt(&self, f: &mut fmt::Formatter, _graph: &Graph) -> fmt::Result {
+impl std::fmt::Display for GraphNodeRef {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "[graph node {}]", self.0)
     }
 }
-
-/// Trait to Display with a given Context
-pub trait DisplayWithGraph
-where
-    Self: Sized,
-{
-    fn fmt<'tree>(&self, f: &mut fmt::Formatter, graph: &Graph<'tree>) -> fmt::Result;
-
-    fn display_with<'a, 'tree>(&'a self, graph: &'a Graph<'tree>) -> Box<dyn fmt::Display + 'a> {
-        struct Impl<'a, 'tree, T: DisplayWithGraph>(&'a T, &'a Graph<'tree>);
-
-        impl<'a, 'tree, T: DisplayWithGraph> fmt::Display for Impl<'a, 'tree, T> {
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                self.0.fmt(f, self.1)
-            }
-        }
-
-        Box::new(Impl(self, graph))
-    }
-}

src/lazy_execution.rs

···
 use log::{debug, trace};
 
 use std::collections::HashMap;
-use std::fmt;
 
 use tree_sitter::CaptureQuantifier::One;
 use tree_sitter::QueryCursor;
···
 use crate::execution::ExecutionError;
 use crate::functions::Functions;
 use crate::graph;
-use crate::graph::DisplayWithGraph as _;
 use crate::graph::Graph;
 use crate::variables::Globals;
 use crate::variables::VariableMap;
 use crate::variables::Variables;
-use crate::Context;
-use crate::DisplayWithContext as _;
 use crate::Identifier;
 
 use statements::*;
···
     /// provide the set of functions and global variables that are available during execution.
     pub fn execute_lazy<'tree>(
         &self,
-        ctx: &Context,
         tree: &'tree Tree,
         source: &'tree str,
         functions: &mut Functions,
         globals: &Globals,
     ) -> Result<Graph<'tree>, ExecutionError> {
         let mut graph = Graph::new();
-        self.execute_lazy_into(ctx, &mut graph, tree, source, functions, globals)?;
+        self.execute_lazy_into(&mut graph, tree, source, functions, globals)?;
         Ok(graph)
     }
 
···
     /// “pre-seed” the graph with some predefined nodes and/or edges before executing the DSL file.
     pub fn execute_lazy_into<'tree>(
         &self,
-        ctx: &Context,
         graph: &mut Graph<'tree>,
         tree: &'tree Tree,
         source: &'tree str,
···
         for mat in matches {
             let stanza = &self.stanzas[mat.pattern_index];
             stanza.execute_lazy(
-                ctx,
                 source,
                 &mat,
                 graph,
···
         for graph_stmt in &lazy_graph {
             graph_stmt
                 .evaluate(&mut EvaluationContext {
-                    ctx,
                     source,
                     graph,
                     functions,
···
                     function_parameters: &mut function_parameters,
                     prev_element_debug_info: &mut prev_element_debug_info,
                 })
-                .with_context(|| format!("Executing {}", graph_stmt.display_with(ctx, &graph)))?;
+                .with_context(|| format!("Executing {}", graph_stmt))?;
         }
 
         Ok(())
···
 
 /// Context for execution, which executes stanzas to build the lazy graph
 struct ExecutionContext<'a, 'g, 'tree> {
-    ctx: &'a Context,
     source: &'tree str,
     graph: &'a mut Graph<'tree>,
     functions: &'a mut Functions,
···
 
 /// Context for evaluation, which evalautes the lazy graph to build the actual graph
 pub(self) struct EvaluationContext<'a, 'tree> {
-    pub ctx: &'a Context,
     pub source: &'tree str,
     pub graph: &'a mut Graph<'tree>,
     pub functions: &'a mut Functions,
···
 impl ast::Stanza {
     fn execute_lazy<'l, 'g, 'q, 'tree>(
         &self,
-        ctx: &Context,
         source: &'tree str,
         mat: &QueryMatch<'_, 'tree>,
         graph: &mut Graph<'tree>,
···
         let current_regex_captures = vec![];
         locals.clear();
         let mut exec = ExecutionContext {
-            ctx,
             source,
             graph,
             functions,
···
             prev_element_debug_info,
         };
         let node = query_capture_value(self.full_match_file_capture_index, One, &mat, exec.graph);
-        debug!(
-            "match {} at {}",
-            node.display_with(exec.graph),
-            self.location
-        );
+        debug!("match {} at {}", node, self.location);
         trace!("{{");
         for statement in &self.statements {
             statement
                 .execute_lazy(&mut exec)
-                .with_context(|| format!("Executing {}", statement.display_with(exec.ctx)))?;
+                .with_context(|| format!("Executing {}", statement))?;
         }
         trace!("}}");
         Ok(())
···
 
 impl ast::Scan {
     fn execute_lazy(&self, exec: &mut ExecutionContext) -> Result<(), ExecutionError> {
-        let match_string = self.value.evaluate_eager(exec)?.into_string(exec.graph)?;
+        let match_string = self.value.evaluate_eager(exec)?.into_string()?;
 
         let mut i = 0;
         let mut matches = Vec::new();
···
 
             let mut arm_locals = VariableMap::new_child(exec.locals);
             let mut arm_exec = ExecutionContext {
-                ctx: exec.ctx,
                 source: exec.source,
                 graph: exec.graph,
                 functions: exec.functions,
···
             for statement in &arm.statements {
                 statement
                     .execute_lazy(&mut arm_exec)
-                    .with_context(|| format!("Executing {}", statement.display_with(arm_exec.ctx)))
+                    .with_context(|| format!("Executing {}", statement))
                     .with_context(|| {
                         format!(
                             "Matching {} with arm \"{}\" {{ ... }}",
···
             if result {
                 let mut arm_locals = VariableMap::new_child(exec.locals);
                 let mut arm_exec = ExecutionContext {
-                    ctx: exec.ctx,
                     source: exec.source,
                     graph: exec.graph,
                     functions: exec.functions,
···
         match self {
             Self::Some { value, .. } => Ok(!value.evaluate_eager(exec)?.is_null()),
             Self::None { value, .. } => Ok(value.evaluate_eager(exec)?.is_null()),
-            Self::Bool { value, .. } => Ok(value.evaluate_eager(exec)?.into_bool(exec.graph)?),
+            Self::Bool { value, .. } => Ok(value.evaluate_eager(exec)?.into_boolean()?),
         }
     }
 }
 
 impl ast::ForIn {
     fn execute_lazy(&self, exec: &mut ExecutionContext) -> Result<(), ExecutionError> {
-        let values = self.value.evaluate_eager(exec)?.into_list(exec.graph)?;
+        let values = self.value.evaluate_eager(exec)?.into_list()?;
         let mut loop_locals = VariableMap::new_child(exec.locals);
         for value in values {
             loop_locals.clear();
             let mut loop_exec = ExecutionContext {
-                ctx: exec.ctx,
                 source: exec.source,
                 graph: exec.graph,
                 functions: exec.functions,
···
     // only be called on expressions that are local (i.e., `is_local = true` in the checker).
     fn evaluate_eager(&self, exec: &mut ExecutionContext) -> Result<graph::Value, ExecutionError> {
         self.evaluate_lazy(exec)?.evaluate(&mut EvaluationContext {
-            ctx: exec.ctx,
             source: exec.source,
             graph: exec.graph,
             functions: exec.functions,
···
         for parameter in &self.parameters {
             parameters.push(parameter.evaluate_lazy(exec)?);
         }
-        Ok(LazyCall::new(self.function, parameters).into())
+        Ok(LazyCall::new(self.function.clone(), parameters).into())
     }
 }
 
···
 impl ast::ScopedVariable {
     fn evaluate_lazy(&self, exec: &mut ExecutionContext) -> Result<LazyValue, ExecutionError> {
         let scope = self.scope.evaluate_lazy(exec)?;
-        let value = LazyScopedVariable::new(scope, self.name);
+        let value = LazyScopedVariable::new(scope, self.name.clone());
         Ok(value.into())
     }
 
···
         if mutable {
             return Err(ExecutionError::CannotDefineMutableScopedVariable(format!(
                 "{}",
-                self.display_with(exec.ctx)
+                self
             )));
         }
         let scope = self.scope.evaluate_lazy(exec)?;
-        let variable = exec
-            .store
-            .add(value, self.location.into(), exec.ctx, exec.graph);
+        let variable = exec.store.add(value, self.location.into());
         exec.scoped_store.add(
             scope,
-            self.name,
+            self.name.clone(),
             variable.into(),
             self.location.into(),
-            exec.ctx,
         )
     }
 
     fn set_lazy(
         &self,
-        exec: &mut ExecutionContext,
+        _exec: &mut ExecutionContext,
         _value: LazyValue,
     ) -> Result<(), ExecutionError> {
         Err(ExecutionError::CannotAssignScopedVariable(format!(
             "{}",
-            self.display_with(exec.ctx)
+            self
         )))
     }
 }
···
         } else {
             exec.locals.get(&self.name).map(|value| value.clone())
         }
-        .ok_or_else(|| {
-            ExecutionError::UndefinedVariable(format!("{}", self.display_with(exec.ctx)))
-        })
+        .ok_or_else(|| ExecutionError::UndefinedVariable(format!("{}", self)))
     }
 }
 
···
         if exec.globals.get(&self.name).is_some() {
             return Err(ExecutionError::DuplicateVariable(format!(
                 " global {}",
-                self.display_with(exec.ctx)
+                self
             )));
         }
-        let value = exec
-            .store
-            .add(value, self.location.into(), exec.ctx, exec.graph);
+        let value = exec.store.add(value, self.location.into());
         exec.locals
-            .add(self.name, value.into(), mutable)
-            .map_err(|_| {
-                ExecutionError::DuplicateVariable(format!(" local {}", self.display_with(exec.ctx)))
-            })
+            .add(self.name.clone(), value.into(), mutable)
+            .map_err(|_| ExecutionError::DuplicateVariable(format!(" local {}", self)))
     }
 
     fn set_lazy(
···
         if exec.globals.get(&self.name).is_some() {
             return Err(ExecutionError::CannotAssignImmutableVariable(format!(
                 " global {}",
-                self.display_with(exec.ctx)
+                self
             )));
         }
-        let value = exec
-            .store
-            .add(value, self.location.into(), exec.ctx, exec.graph);
-        exec.locals.set(self.name, value.into()).map_err(|_| {
-            if exec.locals.get(&self.name).is_some() {
-                ExecutionError::CannotAssignImmutableVariable(format!(
-                    "{}",
-                    self.display_with(exec.ctx)
-                ))
-            } else {
-                ExecutionError::UndefinedVariable(format!("{}", self.display_with(exec.ctx)))
-            }
-        })
+        let value = exec.store.add(value, self.location.into());
+        exec.locals
+            .set(self.name.clone(), value.into())
+            .map_err(|_| {
+                if exec.locals.get(&self.name).is_some() {
+                    ExecutionError::CannotAssignImmutableVariable(format!("{}", self))
+                } else {
+                    ExecutionError::UndefinedVariable(format!("{}", self))
+                }
+            })
     }
 }
 
 impl ast::Attribute {
     fn evaluate_lazy(&self, exec: &mut ExecutionContext) -> Result<LazyAttribute, ExecutionError> {
         let value = self.value.evaluate_lazy(exec)?;
-        let attribute = LazyAttribute::new(self.name, value);
+        let attribute = LazyAttribute::new(self.name.clone(), value);
         Ok(attribute)
     }
 }
-
-/// Trait to Display with a given Context and Graph
-pub trait DisplayWithContextAndGraph
-where
-    Self: Sized,
-{
-    fn fmt<'tree>(
-        &self,
-        f: &mut fmt::Formatter,
-        ctx: &Context,
-        graph: &Graph<'tree>,
-    ) -> fmt::Result;
-
-    fn display_with<'a, 'tree>(
-        &'a self,
-        ctx: &'a Context,
-        graph: &'a Graph<'tree>,
-    ) -> Box<dyn fmt::Display + 'a> {
-        struct Impl<'a, 'tree, T: DisplayWithContextAndGraph>(&'a T, &'a Context, &'a Graph<'tree>);
-
-        impl<'a, 'tree, T: DisplayWithContextAndGraph> fmt::Display for Impl<'a, 'tree, T> {
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                self.0.fmt(f, self.1, self.2)
-            }
-        }
-
-        Box::new(Impl(self, ctx, graph))
-    }
-}
-
-impl<T: DisplayWithContextAndGraph> DisplayWithContextAndGraph for Box<T> {
-    fn fmt<'tree>(
-        &self,
-        f: &mut fmt::Formatter,
-        ctx: &Context,
-        graph: &Graph<'tree>,
-    ) -> fmt::Result {
-        self.as_ref().fmt(f, ctx, graph)
-    }
-}

src/lazy_execution/statements.rs

···
 use std::fmt;
 
 use crate::execution::ExecutionError;
-use crate::graph::DisplayWithGraph;
-use crate::graph::Graph;
-use crate::Context;
-use crate::DisplayWithContext as _;
 use crate::Identifier;
 
 use super::store::DebugInfo;
 use super::values::*;
-use super::DisplayWithContextAndGraph;
 use super::EvaluationContext;
 use super::GraphElementKey;
 
···
 
 impl LazyStatement {
     pub(super) fn evaluate(&self, exec: &mut EvaluationContext) -> Result<(), ExecutionError> {
-        debug!("eval {}", self.display_with(exec.ctx, exec.graph));
+        debug!("eval {}", self);
         trace!("{{");
         let result = match self {
             Self::AddGraphNodeAttribute(stmt) => stmt.evaluate(exec),
···
     }
 }
 
-impl DisplayWithContextAndGraph for LazyStatement {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context, graph: &Graph) -> fmt::Result {
+impl fmt::Display for LazyStatement {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Self::AddGraphNodeAttribute(stmt) => stmt.fmt(f, ctx, graph),
-            Self::CreateEdge(stmt) => stmt.fmt(f, ctx, graph),
-            Self::AddEdgeAttribute(stmt) => stmt.fmt(f, ctx, graph),
-            Self::Print(stmt) => stmt.fmt(f, ctx, graph),
+            Self::AddGraphNodeAttribute(stmt) => stmt.fmt(f),
+            Self::CreateEdge(stmt) => stmt.fmt(f),
+            Self::AddEdgeAttribute(stmt) => stmt.fmt(f),
+            Self::Print(stmt) => stmt.fmt(f),
         }
     }
 }
···
         for attribute in &self.attributes {
             let value = attribute.value.evaluate(exec)?;
             let prev_debug_info = exec.prev_element_debug_info.insert(
-                GraphElementKey::NodeAttribute(node, attribute.name),
+                GraphElementKey::NodeAttribute(node, attribute.name.clone()),
                 self.debug_info,
             );
             exec.graph[node]
                 .attributes
-                .add(attribute.name, value)
+                .add(attribute.name.clone(), value)
                 .map_err(|_| {
                     ExecutionError::DuplicateAttribute(format!(
                         "{} on {} at {} and {}",
-                        attribute.name.display_with(exec.ctx),
-                        node.display_with(exec.graph),
+                        attribute.name,
+                        node,
                         prev_debug_info.unwrap(),
                         self.debug_info,
                     ))
···
     }
 }
 
-impl DisplayWithContextAndGraph for LazyAddGraphNodeAttribute {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context, graph: &Graph) -> fmt::Result {
-        write!(f, "attr ({})", self.node.display_with(ctx, graph))?;
+impl fmt::Display for LazyAddGraphNodeAttribute {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "attr ({})", self.node)?;
         for attr in &self.attributes {
-            write!(f, " {}", attr.display_with(ctx, graph))?;
+            write!(f, " {}", attr)?;
         }
         write!(f, " at {}", self.debug_info)
     }
···
         if let Err(_) = exec.graph[source].add_edge(sink) {
             Err(ExecutionError::DuplicateEdge(format!(
                 "({} -> {}) at {} and {}",
-                source.display_with(exec.graph),
-                sink.display_with(exec.graph),
+                source,
+                sink,
                 prev_debug_info.unwrap(),
                 self.debug_info,
             )))?;
···
     }
 }
 
-impl DisplayWithContextAndGraph for LazyCreateEdge {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context, graph: &Graph) -> fmt::Result {
+impl fmt::Display for LazyCreateEdge {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(
             f,
             "edge {} -> {} at {}",
-            self.source.display_with(ctx, graph),
-            self.sink.display_with(ctx, graph),
-            self.debug_info,
+            self.source, self.sink, self.debug_info,
         )
     }
 }
···
                 Some(edge) => Ok(edge),
                 None => Err(ExecutionError::UndefinedEdge(format!(
                     "({} -> {}) at {}",
-                    source.display_with(exec.graph),
-                    sink.display_with(exec.graph),
-                    self.debug_info,
+                    source, sink, self.debug_info,
                 ))),
             }?;
             let prev_debug_info = exec.prev_element_debug_info.insert(
-                GraphElementKey::EdgeAttribute(source, sink, attribute.name),
+                GraphElementKey::EdgeAttribute(source, sink, attribute.name.clone()),
                 self.debug_info,
             );
-            edge.attributes.add(attribute.name, value).map_err(|_| {
-                ExecutionError::DuplicateAttribute(format!(
-                    "{} on edge ({} -> {}) at {} and {}",
-                    attribute.name.display_with(exec.ctx),
-                    source.display_with(exec.graph),
-                    sink.display_with(exec.graph),
-                    prev_debug_info.unwrap(),
-                    self.debug_info,
-                ))
-            })?;
+            edge.attributes
+                .add(attribute.name.clone(), value)
+                .map_err(|_| {
+                    ExecutionError::DuplicateAttribute(format!(
+                        "{} on edge ({} -> {}) at {} and {}",
+                        attribute.name,
+                        source,
+                        sink,
+                        prev_debug_info.unwrap(),
+                        self.debug_info,
+                    ))
+                })?;
         }
         Ok(())
     }
 }
 
-impl DisplayWithContextAndGraph for LazyAddEdgeAttribute {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context, graph: &Graph) -> fmt::Result {
-        write!(
-            f,
-            "attr ({} -> {})",
-            self.source.display_with(ctx, graph),
-            self.sink.display_with(ctx, graph),
-        )?;
+impl fmt::Display for LazyAddEdgeAttribute {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "attr ({} -> {})", self.source, self.sink,)?;
         for attr in &self.attributes {
-            write!(f, " {}", attr.display_with(ctx, graph),)?;
+            write!(f, " {}", attr,)?;
         }
         write!(f, " at {}", self.debug_info)
     }
···
                 LazyPrintArgument::Text(string) => eprint!("{}", string),
                 LazyPrintArgument::Value(value) => {
                     let value = value.evaluate(exec)?;
-                    eprint!("{}", value.display_with(exec.graph));
+                    eprint!("{}", value);
                 }
             }
         }
···
     }
 }
 
-impl DisplayWithContextAndGraph for LazyPrint {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context, graph: &Graph) -> fmt::Result {
+impl fmt::Display for LazyPrint {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "print")?;
         let mut first = true;
         for argument in &self.arguments {
···
             }
             match argument {
                 LazyPrintArgument::Text(string) => write!(f, "\"{}\"", string)?,
-                LazyPrintArgument::Value(value) => write!(f, "{}", value.display_with(ctx, graph))?,
+                LazyPrintArgument::Value(value) => write!(f, "{}", value)?,
             };
         }
         write!(f, " at {}", self.debug_info)
···
     }
 }
 
-impl DisplayWithContextAndGraph for LazyAttribute {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context, graph: &Graph) -> fmt::Result {
-        write!(
-            f,
-            "{} = {}",
-            self.name.display_with(ctx),
-            self.value.display_with(ctx, graph),
-        )
+impl fmt::Display for LazyAttribute {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{} = {}", self.name, self.value,)
     }
 }

src/lazy_execution/store.rs

···
 
 use crate::execution::ExecutionError;
 use crate::graph;
-use crate::graph::DisplayWithGraph;
-use crate::graph::Graph;
 use crate::graph::SyntaxNodeRef;
 use crate::parser::Location;
-use crate::Context;
-use crate::DisplayWithContext;
 use crate::Identifier;
 
 use super::values::*;
-use super::DisplayWithContextAndGraph;
 use super::EvaluationContext;
 
 /// Variable that points to a thunk in the store
···
     }
 }
 
-impl DisplayWithContextAndGraph for LazyVariable {
-    fn fmt(&self, f: &mut fmt::Formatter, _ctx: &Context, _graph: &Graph) -> fmt::Result {
+impl fmt::Display for LazyVariable {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "(load {})", self.store_location)
     }
 }
···
         }
     }
 
-    pub(super) fn add(
-        &mut self,
-        value: LazyValue,
-        debug_info: DebugInfo,
-        ctx: &Context,
-        graph: &Graph,
-    ) -> LazyVariable {
+    pub(super) fn add(&mut self, value: LazyValue, debug_info: DebugInfo) -> LazyVariable {
         let store_location = self.elements.len();
         let variable = LazyVariable::new(store_location);
-        trace!(
-            "store {} = {}",
-            store_location,
-            value.display_with(ctx, graph)
-        );
+        trace!("store {} = {}", store_location, value);
         self.elements.push(Thunk::new(value, debug_info));
         variable
     }
···
     ) -> Result<graph::Value, ExecutionError> {
         let variable = &self.elements[variable.store_location];
         let debug_info = variable.debug_info;
-        let value = variable.force(exec).with_context(|| {
-            format!(
-                "via {} at {}",
-                (*variable.state.borrow()).display_with(exec.ctx, exec.graph),
-                debug_info
-            )
-        })?;
+        let value = variable
+            .force(exec)
+            .with_context(|| format!("via {} at {}", (*variable.state.borrow()), debug_info))?;
         Ok(value)
     }
 }
···
         name: Identifier,
         value: LazyValue,
         debug_info: DebugInfo,
-        ctx: &Context,
     ) -> Result<(), ExecutionError> {
         let values = self
             .variables
-            .entry(name)
+            .entry(name.clone())
             .or_insert_with(|| Cell::new(ScopedValues::new()));
         match values.replace(ScopedValues::Forcing) {
             ScopedValues::Unforced(mut pairs) => {
···
                 Ok(())
             }
             ScopedValues::Forcing => Err(ExecutionError::RecursivelyDefinedScopedVariable(
-                format!("{}", name.display_with(ctx)),
+                format!("{}", name),
             )),
             ScopedValues::Forced(map) => {
                 values.replace(ScopedValues::Forced(map));
                 Err(ExecutionError::VariableScopesAlreadyForced(format!(
                     "{}",
-                    name.display_with(ctx)
+                    name
                 )))
             }
         }
···
 
     pub(super) fn evaluate(
         &self,
-        scope: SyntaxNodeRef,
-        name: Identifier,
+        scope: &SyntaxNodeRef,
+        name: &Identifier,
         exec: &mut EvaluationContext,
     ) -> Result<LazyValue, ExecutionError> {
-        let values = match self.variables.get(&name) {
+        let values = match self.variables.get(name) {
             Some(v) => v,
             None => {
                 return Err(ExecutionError::UndefinedScopedVariable(format!(
                     "{}.{}",
-                    scope.display_with(exec.graph),
-                    name.display_with(exec.ctx),
+                    scope, name,
                 )));
             }
         };
···
                         Some(_) => {
                             return Err(ExecutionError::DuplicateVariable(format!(
                                 "{}.{} set at {} and {}",
-                                node.display_with(exec.graph),
-                                name.display_with(exec.ctx),
+                                node,
+                                name,
                                 prev_debug_info.unwrap(),
                                 debug_info,
                             )));
···
                     .get(&scope)
                     .ok_or(ExecutionError::UndefinedScopedVariable(format!(
                         "{}.{}",
-                        scope.display_with(exec.graph),
-                        name.display_with(exec.ctx),
+                        scope, name,
                     )))?
                     .clone();
                 values.replace(ScopedValues::Forced(map));
                 Ok(result)
             }
-            ScopedValues::Forcing => {
-                Err(ExecutionError::RecursivelyDefinedScopedVariable(format!(
-                    "_.{} requested on {}",
-                    name.display_with(exec.ctx),
-                    scope.display_with(exec.graph)
-                )))
-            }
+            ScopedValues::Forcing => Err(ExecutionError::RecursivelyDefinedScopedVariable(
+                format!("_.{} requested on {}", name, scope),
+            )),
             ScopedValues::Forced(map) => {
                 let result = map
                     .get(&scope)
                     .ok_or(ExecutionError::UndefinedScopedVariable(format!(
                         "{}.{}",
-                        scope.display_with(exec.graph),
-                        name.display_with(exec.ctx),
+                        scope, name,
                     )))?
                     .clone();
                 values.replace(ScopedValues::Forced(map));
···
     Forced(graph::Value),
 }
 
-impl DisplayWithContextAndGraph for ThunkState {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context, graph: &Graph) -> fmt::Result {
+impl fmt::Display for ThunkState {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Self::Unforced(value) => write!(f, "?{{{}}}", value.display_with(ctx, graph)),
+            Self::Unforced(value) => write!(f, "?{{{}}}", value),
             Self::Forcing => write!(f, "~{{?}}"),
-            Self::Forced(value) => write!(f, "!{{{}}}", value.display_with(graph)),
+            Self::Forced(value) => write!(f, "!{{{}}}", value),
         }
     }
 }
···
 
     fn force(&self, exec: &mut EvaluationContext) -> Result<graph::Value, ExecutionError> {
         let state = self.state.replace(ThunkState::Forcing);
-        trace!("force {}", state.display_with(exec.ctx, exec.graph));
+        trace!("force {}", state);
         let value = match state {
             ThunkState::Unforced(value) => {
                 // it is important that we do not hold a borrow of self.forced_values when executing self.value.evaluate

src/lazy_execution/values.rs

···
 use std::fmt;
 
 use crate::execution::ExecutionError;
-use crate::graph::DisplayWithGraph;
-use crate::graph::Graph;
 use crate::graph::GraphNodeRef;
 use crate::graph::SyntaxNodeRef;
 use crate::graph::Value;
-use crate::Context;
-use crate::DisplayWithContext;
 use crate::Identifier;
 
 use super::store::*;
-use super::DisplayWithContextAndGraph;
 use super::EvaluationContext;
 
 /// Lazy values
···
 
 impl LazyValue {
     pub(super) fn evaluate(&self, exec: &mut EvaluationContext) -> Result<Value, ExecutionError> {
-        trace!("eval {} {{", self.display_with(exec.ctx, exec.graph));
+        trace!("eval {} {{", self);
         let ret = match self {
             Self::Value(value) => Ok(value.clone()),
             Self::List(expr) => expr.evaluate(exec),
···
             Self::ScopedVariable(expr) => expr.evaluate(exec),
             Self::Call(expr) => expr.evaluate(exec),
         }?;
-        trace!("}} = {}", ret.display_with(exec.graph));
+        trace!("}} = {}", ret);
         Ok(ret)
     }
 
···
         let node = self.evaluate(exec)?;
         match node {
             Value::GraphNode(node) => Ok(node),
-            _ => Err(ExecutionError::ExpectedGraphNode(format!(
-                " got {}",
-                node.display_with(exec.graph)
-            ))),
+            _ => Err(ExecutionError::ExpectedGraphNode(format!(" got {}", node))),
         }
     }
 
···
         let node = self.evaluate(exec)?;
         match node {
             Value::SyntaxNode(node) => Ok(node),
-            _ => Err(ExecutionError::ExpectedSyntaxNode(format!(
-                " got {}",
-                node.display_with(exec.graph)
-            ))),
+            _ => Err(ExecutionError::ExpectedSyntaxNode(format!(" got {}", node))),
         }
     }
 }
 
-impl DisplayWithContextAndGraph for LazyValue {
-    fn fmt<'tree>(
-        &self,
-        f: &mut fmt::Formatter,
-        ctx: &Context,
-        graph: &Graph<'tree>,
-    ) -> fmt::Result {
+impl fmt::Display for LazyValue {
+    fn fmt<'tree>(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Self::Value(value) => write!(f, "{}", value.display_with(graph)),
-            Self::List(expr) => expr.fmt(f, ctx, graph),
-            Self::Set(expr) => expr.fmt(f, ctx, graph),
-            Self::Variable(expr) => expr.fmt(f, ctx, graph),
-            Self::ScopedVariable(expr) => expr.fmt(f, ctx, graph),
-            Self::Call(expr) => expr.fmt(f, ctx, graph),
+            Self::Value(value) => write!(f, "{}", value),
+            Self::List(expr) => expr.fmt(f),
+            Self::Set(expr) => expr.fmt(f),
+            Self::Variable(expr) => expr.fmt(f),
+            Self::ScopedVariable(expr) => expr.fmt(f),
+            Self::Call(expr) => expr.fmt(f),
         }
     }
 }
···
     fn resolve<'a>(&self, exec: &'a mut EvaluationContext) -> Result<LazyValue, ExecutionError> {
         let scope = self.scope.as_ref().evaluate_as_syntax_node(exec)?;
         let scoped_store = &exec.scoped_store;
-        scoped_store.evaluate(scope, self.name, exec)
+        scoped_store.evaluate(&scope, &self.name, exec)
     }
 
     pub(super) fn evaluate(&self, exec: &mut EvaluationContext) -> Result<Value, ExecutionError> {
···
     }
 }
 
-impl DisplayWithContextAndGraph for LazyScopedVariable {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context, graph: &Graph) -> fmt::Result {
-        write!(
-            f,
-            "(scoped {} '{})",
-            self.scope.display_with(ctx, graph),
-            self.name.display_with(ctx),
-        )
+impl fmt::Display for LazyScopedVariable {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "(scoped {} '{})", self.scope, self.name,)
     }
 }
 
···
     }
 }
 
-impl DisplayWithContextAndGraph for LazyList {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context, graph: &Graph) -> fmt::Result {
+impl fmt::Display for LazyList {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "(list")?;
         let mut first = true;
         for elem in &self.elements {
             if first {
                 first = false;
-                write!(f, "{}", elem.display_with(ctx, graph))?;
+                write!(f, "{}", elem)?;
             } else {
-                write!(f, " {}", elem.display_with(ctx, graph))?;
+                write!(f, " {}", elem)?;
             }
         }
         write!(f, ")")
···
     }
 }
 
-impl DisplayWithContextAndGraph for LazySet {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context, graph: &Graph) -> fmt::Result {
+impl fmt::Display for LazySet {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "(set")?;
         let mut first = true;
         for elem in &self.elements {
             if first {
                 first = false;
-                write!(f, "{}", elem.display_with(ctx, graph))?;
+                write!(f, "{}", elem)?;
             } else {
-                write!(f, " {}", elem.display_with(ctx, graph))?;
+                write!(f, " {}", elem)?;
             }
         }
         write!(f, ")")
···
         }
 
         exec.functions.call(
-            exec.ctx,
-            self.function,
+            &self.function,
             exec.graph,
             exec.source,
             &mut exec
···
     }
 }
 
-impl DisplayWithContextAndGraph for LazyCall {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context, graph: &Graph) -> fmt::Result {
-        write!(f, "(call '{}", self.function.display_with(ctx))?;
+impl fmt::Display for LazyCall {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "(call '{}", self.function)?;
         for arg in &self.arguments {
-            write!(f, " {}", arg.display_with(ctx, graph))?;
+            write!(f, " {}", arg)?;
         }
         write!(f, ")")
     }

src/lib.rs

···
 pub use parser::Location;
 pub use parser::ParseError;
 
-use string_interner::symbol::SymbolU32;
-use string_interner::StringInterner;
+use std::borrow::Borrow;
+use std::hash::Hash;
+use std::ops::Deref;
+use std::rc::Rc;
 
-use std::fmt;
+use serde::Serialize;
+use serde::Serializer;
 
 /// An identifier that appears in a graph DSL file or in the graph that is produced as an output.
-#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct Identifier(SymbolU32);
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub struct Identifier(Rc<String>);
 
-impl DisplayWithContext for Identifier {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context) -> fmt::Result {
-        write!(f, "{}", ctx.identifiers.resolve(self.0).unwrap())
+impl Identifier {
+    pub fn as_str(&self) -> &str {
+        self.0.as_str()
+    }
+
+    pub fn into_string(mut self) -> String {
+        Rc::make_mut(&mut self.0);
+        Rc::try_unwrap(self.0).unwrap()
     }
 }
 
-/// A context in which graph DSL files are executed.
-#[derive(Default)]
-pub struct Context {
-    identifiers: StringInterner,
+impl Borrow<str> for Identifier {
+    fn borrow(&self) -> &str {
+        self.as_str()
+    }
 }
 
-impl Context {
-    /// Creates a new, empty execution context.
-    pub fn new() -> Context {
-        Context::default()
+impl Deref for Identifier {
+    type Target = str;
+    fn deref(&self) -> &str {
+        self.as_str()
     }
+}
 
-    /// Adds an identifier to the context.
-    #[inline(always)]
-    pub fn add_identifier<T: AsRef<str>>(&mut self, identifier: T) -> Identifier {
-        Identifier(self.identifiers.get_or_intern(identifier))
+impl std::fmt::Display for Identifier {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        self.0.fmt(f)
     }
+}
 
-    /// Returns the [`Identifier`][] instance for an identifier, if it has already been added to
-    /// the context.  Returns `None` otherwise.
-    #[inline(always)]
-    pub fn get_identifier<T: AsRef<str>>(&self, identifier: T) -> Option<Identifier> {
-        self.identifiers.get(identifier).map(Identifier)
+impl From<&str> for Identifier {
+    fn from(value: &str) -> Identifier {
+        Identifier(Rc::new(String::from(value)))
     }
+}
 
-    pub fn resolve(&self, identifier: Identifier) -> &str {
-        self.identifiers.resolve(identifier.0).unwrap()
+impl Hash for Identifier {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.0.hash(state);
     }
 }
 
-/// Trait to Display with a given Context
-pub trait DisplayWithContext
-where
-    Self: Sized,
-{
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context) -> fmt::Result;
-
-    fn display_with<'a>(&'a self, ctx: &'a Context) -> Box<dyn fmt::Display + 'a> {
-        struct Impl<'a, T: DisplayWithContext>(&'a T, &'a Context);
+impl PartialEq<str> for Identifier {
+    fn eq(&self, other: &str) -> bool {
+        self.as_str() == other
+    }
+}
 
-        impl<'a, T: DisplayWithContext> fmt::Display for Impl<'a, T> {
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                self.0.fmt(f, self.1)
-            }
-        }
-
-        Box::new(Impl(self, ctx))
+impl<'a> PartialEq<&'a str> for Identifier {
+    fn eq(&self, other: &&'a str) -> bool {
+        self.as_str() == *other
     }
 }
 
-impl<T: DisplayWithContext> DisplayWithContext for Box<T> {
-    fn fmt(&self, f: &mut fmt::Formatter, ctx: &Context) -> fmt::Result {
-        self.as_ref().fmt(f, ctx)
+impl Serialize for Identifier {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        serializer.serialize_str(self.as_str())
     }
 }

src/parser.rs

···
 use tree_sitter::QueryError;
 
 use crate::ast;
-use crate::Context;
 use crate::Identifier;
 
 pub const FULL_MATCH: &str = "__tsg__full_match";
 
 impl ast::File {
     /// Parses a graph DSL file, returning a new `File` instance.
-    pub fn from_str(
-        language: Language,
-        ctx: &mut Context,
-        source: &str,
-    ) -> Result<Self, ParseError> {
+    pub fn from_str(language: Language, source: &str) -> Result<Self, ParseError> {
         let mut file = ast::File::new(language);
         #[allow(deprecated)]
-        file.parse(ctx, source)?;
-        file.check(ctx)?;
+        file.parse(source)?;
+        file.check()?;
         Ok(file)
     }
 
···
     #[deprecated(
         note = "Parsing multiple times into the same `File` instance is unsound. Use `File::from_str` instead."
     )]
-    pub fn parse(&mut self, ctx: &mut Context, content: &str) -> Result<(), ParseError> {
-        Parser::new(ctx, content).parse_into_file(self)
+    pub fn parse(&mut self, content: &str) -> Result<(), ParseError> {
+        Parser::new(content).parse_into_file(self)
     }
 }
 
···
     UnexpectedLiteral(String, Location),
     #[error(transparent)]
     Check(#[from] crate::checker::CheckError),
+    #[error(transparent)]
+    Other(#[from] anyhow::Error),
+}
+
+impl ParseError {
+    /// Wraps an existing [`std::error::Error`][] as an execution error
+    pub fn other<E>(err: E) -> ParseError
+    where
+        E: Into<anyhow::Error>,
+    {
+        Self::Other(err.into())
+    }
 }
 
 /// The location of a graph DSL entity within its file
···
 }
 
 struct Parser<'a> {
-    ctx: &'a mut Context,
     source: &'a str,
     chars: Peekable<Chars<'a>>,
     offset: usize,
     location: Location,
     query_source: String,
-    // Keywords
-    attr_keyword: Identifier,
-    edge_keyword: Identifier,
-    false_keyword: Identifier,
-    for_keyword: Identifier,
-    if_keyword: Identifier,
-    let_keyword: Identifier,
-    node_keyword: Identifier,
-    null_keyword: Identifier,
-    print_keyword: Identifier,
-    scan_keyword: Identifier,
-    set_keyword: Identifier,
-    true_keyword: Identifier,
-    var_keyword: Identifier,
 }
 
 fn is_ident_start(c: char) -> bool {
···
 }
 
 impl<'a> Parser<'a> {
-    fn new(ctx: &'a mut Context, source: &'a str) -> Parser<'a> {
+    fn new(source: &'a str) -> Parser<'a> {
         let chars = source.chars().peekable();
         let query_source = String::with_capacity(source.len());
-        // Keywords
-        let attr_keyword = ctx.add_identifier("attr");
-        let edge_keyword = ctx.add_identifier("edge");
-        let false_keyword = ctx.add_identifier("false");
-        let for_keyword = ctx.add_identifier("for");
-        let if_keyword = ctx.add_identifier("if");
-        let let_keyword = ctx.add_identifier("let");
-        let node_keyword = ctx.add_identifier("node");
-        let null_keyword = ctx.add_identifier("null");
-        let print_keyword = ctx.add_identifier("print");
-        let scan_keyword = ctx.add_identifier("scan");
-        let set_keyword = ctx.add_identifier("set");
-        let true_keyword = ctx.add_identifier("true");
-        let var_keyword = ctx.add_identifier("var");
         Parser {
-            ctx,
             source,
             chars,
             offset: 0,
             location: Location::default(),
             query_source,
-            // Keywords
-            attr_keyword,
-            edge_keyword,
-            false_keyword,
-            for_keyword,
-            let_keyword,
-            if_keyword,
-            node_keyword,
-            null_keyword,
-            print_keyword,
-            scan_keyword,
-            set_keyword,
-            true_keyword,
-            var_keyword,
         }
     }
 }
 
-impl Parser<'_> {
+impl<'a> Parser<'a> {
     fn peek(&mut self) -> Result<char, ParseError> {
         self.chars
             .peek()
···
         Ok(statements)
     }
 
+    fn parse_name(&mut self, within: &'static str) -> Result<&'a str, ParseError> {
+        let start = self.offset;
+        let ch = self.next()?;
+        if !is_ident_start(ch) {
+            return Err(ParseError::UnexpectedCharacter(ch, within, self.location));
+        }
+        self.consume_while(is_ident);
+        let end = self.offset;
+        Ok(&self.source[start..end])
+    }
+
     fn parse_statement(&mut self) -> Result<ast::Statement, ParseError> {
         let keyword_location = self.location;
-        let keyword = self.parse_identifier("keyword")?;
+        let keyword = self.parse_name("keyword")?;
         self.consume_whitespace();
-        if keyword == self.let_keyword {
+        if keyword == "let" {
             let variable = self.parse_variable()?;
             self.consume_whitespace();
             self.consume_token("=")?;
···
                 location: keyword_location,
             }
             .into())
-        } else if keyword == self.var_keyword {
+        } else if keyword == "var" {
             let variable = self.parse_variable()?;
             self.consume_whitespace();
             self.consume_token("=")?;
···
                 location: keyword_location,
             }
             .into())
-        } else if keyword == self.set_keyword {
+        } else if keyword == "set" {
             let variable = self.parse_variable()?;
             self.consume_whitespace();
             self.consume_token("=")?;
···
                 location: keyword_location,
             }
             .into())
-        } else if keyword == self.node_keyword {
+        } else if keyword == "node" {
             let node = self.parse_variable()?;
             Ok(ast::CreateGraphNode {
                 node,
                 location: keyword_location,
             }
             .into())
-        } else if keyword == self.edge_keyword {
+        } else if keyword == "edge" {
             let source = self.parse_expression()?;
             self.consume_whitespace();
             self.consume_token("->")?;
···
                 location: keyword_location,
             }
             .into())
-        } else if keyword == self.attr_keyword {
+        } else if keyword == "attr" {
             self.consume_token("(")?;
             self.consume_whitespace();
             let node_or_source = self.parse_expression()?;
···
                 }
                 .into())
             }
-        } else if keyword == self.print_keyword {
+        } else if keyword == "print" {
             let mut values = vec![self.parse_expression()?];
             self.consume_whitespace();
             while self.try_peek() == Some(',') {
···
                 location: keyword_location,
             }
             .into())
-        } else if keyword == self.scan_keyword {
+        } else if keyword == "scan" {
             let value = self.parse_expression()?;
             self.consume_whitespace();
             self.consume_token("{")?;
···
                 location: keyword_location,
             }
             .into())
-        } else if keyword == self.if_keyword {
+        } else if keyword == "if" {
             let mut arms = Vec::new();
 
             // if
···
                 location: keyword_location,
             }
             .into())
-        } else if keyword == self.for_keyword {
+        } else if keyword == "for" {
             self.consume_whitespace();
             let variable = match self.parse_variable()? {
                 ast::Variable::Unscoped(variable) => Ok(variable),
···
             .into())
         } else {
             Err(ParseError::UnexpectedKeyword(
-                self.ctx.resolve(keyword).into(),
+                keyword.into(),
                 keyword_location,
             ))
         }
···
     }
 
     fn parse_identifier(&mut self, within: &'static str) -> Result<Identifier, ParseError> {
-        let start = self.offset;
-        let ch = self.next()?;
-        if !is_ident_start(ch) {
-            return Err(ParseError::UnexpectedCharacter(ch, within, self.location));
-        }
-        self.consume_while(is_ident);
-        let end = self.offset;
-        Ok(self.ctx.add_identifier(&self.source[start..end]))
+        let content = self.parse_name(within)?;
+        Ok(Identifier::from(content))
     }
 
     fn parse_string(&mut self) -> Result<String, ParseError> {
···
         }
         self.consume_while(is_ident);
         let end = self.offset;
-        let name = &self.source[start + 1..end];
-        let name = self.ctx.add_identifier(name);
+        let name = Identifier::from(&self.source[start + 1..end]);
         Ok(ast::Capture {
             name,
             quantifier: Zero,                 // set in checker
···
     fn parse_literal(&mut self) -> Result<ast::Expression, ParseError> {
         let literal_location = self.location;
         self.consume_token("#")?;
-        let literal = self.parse_identifier("literal")?;
-        if literal == self.false_keyword {
+        let literal = self.parse_name("literal")?;
+        if literal == "false" {
             return Ok(ast::Expression::FalseLiteral);
-        } else if literal == self.null_keyword {
+        } else if literal == "null" {
             return Ok(ast::Expression::NullLiteral);
-        } else if literal == self.true_keyword {
+        } else if literal == "true" {
             return Ok(ast::Expression::TrueLiteral);
         } else {
             Err(ParseError::UnexpectedLiteral(
-                self.ctx.resolve(literal).into(),
+                literal.into(),
                 literal_location,
             ))
         }

src/variables.rs

···
 #[derive(Debug, Error)]
 pub enum VariableError {
     #[error("Cannot assign immutable variable")]
-    CannotAssignImmutableVariable(Identifier),
+    CannotAssignImmutableVariable(String),
     #[error("Variable already defined")]
-    VariableAlreadyDefined(Identifier),
+    VariableAlreadyDefined(String),
     #[error("Undefined variable")]
-    UndefinedVariable(Identifier),
+    UndefinedVariable(String),
 }
 
 /// An environment of named variables
···
                 v.insert(variable);
                 Ok(())
             }
-            Occupied(_) => Err(VariableError::VariableAlreadyDefined(name)),
+            Occupied(o) => Err(VariableError::VariableAlreadyDefined(o.key().to_string())),
         }
     }
 
     fn set(&mut self, name: Identifier, value: V) -> Result<(), VariableError> {
         match self.values.entry(name) {
-            Vacant(_) => self
+            Vacant(v) => self
                 .parent
                 .as_mut()
-                .map(|parent| parent.set(name, value))
-                .unwrap_or(Err(VariableError::UndefinedVariable(name))),
+                .map(|parent| parent.set(v.key().clone(), value))
+                .unwrap_or(Err(VariableError::UndefinedVariable(
+                    v.into_key().to_string(),
+                ))),
             Occupied(mut o) => {
                 let mut variable = o.get_mut();
                 if variable.mutable {
                     variable.value = value;
                     Ok(())
                 } else {
-                    Err(VariableError::CannotAssignImmutableVariable(name))
+                    Err(VariableError::CannotAssignImmutableVariable(
+                        o.key().to_string(),
+                    ))
                 }
             }
         }
···
 
     fn get(&self, name: &Identifier) -> Option<&V> {
         self.values
-            .get(&name)
+            .get(name)
             .map(|v| &v.value)
             .or_else(|| self.parent.as_ref().map(|p| p.get(name)).flatten())
     }

tests/it/execution.rs

···
 use tree_sitter::Parser;
 use tree_sitter_graph::ast::File;
 use tree_sitter_graph::functions::Functions;
-use tree_sitter_graph::Context;
 use tree_sitter_graph::ExecutionError;
+use tree_sitter_graph::Identifier;
 use tree_sitter_graph::Variables;
 
 fn init_log() {
···
     let mut parser = Parser::new();
     parser.set_language(tree_sitter_python::language()).unwrap();
     let tree = parser.parse(python_source, None).unwrap();
-    let mut ctx = Context::new();
-    let file = File::from_str(tree_sitter_python::language(), &mut ctx, dsl_source)
-        .expect("Cannot parse file");
-    let mut functions = Functions::stdlib(&mut ctx);
+    let file =
+        File::from_str(tree_sitter_python::language(), dsl_source).expect("Cannot parse file");
+    let mut functions = Functions::stdlib();
     let mut globals = Variables::new();
     globals
-        .add(ctx.add_identifier("filename"), "test.py".into())
+        .add(Identifier::from("filename"), "test.py".into())
         .map_err(|_| ExecutionError::DuplicateVariable("filename".into()))?;
-    let graph = file.execute(&ctx, &tree, python_source, &mut functions, &mut globals)?;
-    let result = graph.display_with(&ctx).to_string();
+    let graph = file.execute(&tree, python_source, &mut functions, &mut globals)?;
+    let result = graph.pretty_print().to_string();
     Ok(result)
 }
 

tests/it/graph.rs

···
 use tree_sitter::Parser;
 use tree_sitter_graph::graph::Graph;
 use tree_sitter_graph::graph::Value;
-use tree_sitter_graph::Context;
+use tree_sitter_graph::Identifier;
 
 #[test]
 fn can_overwrite_attributes() {
-    let mut ctx = Context::new();
     let mut graph = Graph::new();
     let node = graph.add_graph_node();
     let attrs = &mut graph[node].attributes;
-    let name = ctx.add_identifier("name");
-    attrs.add(name, "node0").unwrap();
-    attrs.add(name, "overwritten").unwrap_err();
-    assert_eq!(*attrs.get(name).unwrap(), Value::from("overwritten"));
+    let name = Identifier::from("name");
+    attrs.add(name.clone(), "node0").unwrap();
+    attrs.add(name.clone(), "overwritten").unwrap_err();
+    assert_eq!(*attrs.get(&name).unwrap(), Value::from("overwritten"));
 }
 
 #[test]
···
     parser.set_language(tree_sitter_python::language()).unwrap();
     let tree = parser.parse(python_source, None).unwrap();
 
-    let mut ctx = Context::new();
     let mut graph = Graph::new();
     let root = graph.add_syntax_node(tree.root_node());
     let node0 = graph.add_graph_node();
     graph[node0]
         .attributes
-        .add(ctx.add_identifier("name"), "node0")
+        .add(Identifier::from("name"), "node0")
         .unwrap();
     graph[node0]
         .attributes
-        .add(ctx.add_identifier("source"), root)
+        .add(Identifier::from("source"), root)
         .unwrap();
     let node1 = graph.add_graph_node();
     graph[node1]
         .attributes
-        .add(ctx.add_identifier("name"), "node1")
+        .add(Identifier::from("name"), "node1")
         .unwrap();
     let node2 = graph.add_graph_node();
     graph[node2]
         .attributes
-        .add(ctx.add_identifier("name"), "node2")
+        .add(Identifier::from("name"), "node2")
         .unwrap();
     graph[node2]
         .attributes
-        .add(ctx.add_identifier("parent"), node1)
+        .add(Identifier::from("parent"), node1)
         .unwrap();
     let edge01 = graph[node0]
         .add_edge(node1)
         .unwrap_or_else(|_| unreachable!());
     edge01
         .attributes
-        .add(ctx.add_identifier("precedence"), 14)
+        .add(Identifier::from("precedence"), 14)
         .unwrap();
     assert_eq!(
-        graph.display_with(&ctx).to_string(),
+        graph.pretty_print().to_string(),
         indoc! {r#"
           node 0
             name: "node0"

tests/it/lazy_execution.rs

···
 use tree_sitter::Parser;
 use tree_sitter_graph::ast::File;
 use tree_sitter_graph::functions::Functions;
-use tree_sitter_graph::Context;
 use tree_sitter_graph::ExecutionError;
 use tree_sitter_graph::Variables;
 
···
     let mut parser = Parser::new();
     parser.set_language(tree_sitter_python::language()).unwrap();
     let tree = parser.parse(python_source, None).unwrap();
-    let mut ctx = Context::new();
-    let file = File::from_str(tree_sitter_python::language(), &mut ctx, dsl_source)
-        .expect("Cannot parse file");
-    let mut functions = Functions::stdlib(&mut ctx);
+    let file =
+        File::from_str(tree_sitter_python::language(), dsl_source).expect("Cannot parse file");
+    let mut functions = Functions::stdlib();
     let mut globals = Variables::new();
     globals
-        .add(ctx.add_identifier("filename"), "test.py".into())
+        .add("filename".into(), "test.py".into())
         .map_err(|_| ExecutionError::DuplicateVariable("filename".into()))?;
-    let graph = file.execute_lazy(&mut ctx, &tree, python_source, &mut functions, &globals)?;
-    let result = graph.display_with(&ctx).to_string();
+    let graph = file.execute_lazy(&tree, python_source, &mut functions, &globals)?;
+    let result = graph.pretty_print().to_string();
     Ok(result)
 }
 

tests/it/parser.rs

···
 use tree_sitter::CaptureQuantifier::*;
 
 use tree_sitter_graph::ast::*;
-use tree_sitter_graph::Context;
+use tree_sitter_graph::Identifier;
 use tree_sitter_graph::Location;
 
 #[test]
 fn can_parse_blocks() {
-    let mut ctx = Context::new();
     let source = r#"
         (function_definition
           name: (identifier) @cap1) @cap2
···
           set @cap2.var1 = loc1
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), &mut ctx, source)
-        .expect("Cannot parse file");
+    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
 
-    let loc1 = ctx.add_identifier("loc1");
-    let precedence = ctx.add_identifier("precedence");
-    let pop = ctx.add_identifier("pop");
-    let prop1 = ctx.add_identifier("prop1");
-    let push = ctx.add_identifier("push");
-    let cap2 = ctx.add_identifier("cap2");
-    let var1 = ctx.add_identifier("var1");
+    let loc1 = Identifier::from("loc1");
+    let precedence = Identifier::from("precedence");
+    let pop = Identifier::from("pop");
+    let prop1 = Identifier::from("prop1");
+    let push = Identifier::from("push");
+    let cap2 = Identifier::from("cap2");
+    let var1 = Identifier::from("var1");
 
     let statements = file
         .stanzas
···
         vec![vec![
             CreateGraphNode {
                 node: UnscopedVariable {
-                    name: loc1,
+                    name: loc1.clone(),
                     location: Location { row: 4, column: 15 }
                 }
                 .into(),
···
                     scope: Box::new(
                         Capture {
                             quantifier: One,
-                            name: cap2,
+                            name: cap2.clone(),
                             file_capture_index: 1,
                             stanza_capture_index: 1,
                             location: Location { row: 5, column: 15 }
                         }
                         .into()
                     ),
-                    name: prop1,
+                    name: prop1.clone(),
                     location: Location { row: 5, column: 21 }
                 }
                 .into(),
···
                     scope: Box::new(
                         Capture {
                             quantifier: One,
-                            name: cap2,
+                            name: cap2.clone(),
                             file_capture_index: 1,
                             stanza_capture_index: 1,
                             location: Location { row: 6, column: 15 }
                         }
                         .into()
                     ),
-                    name: prop1,
+                    name: prop1.clone(),
                     location: Location { row: 6, column: 21 }
                 }
                 .into(),
                 sink: UnscopedVariable {
-                    name: loc1,
+                    name: loc1.clone(),
                     location: Location { row: 6, column: 30 },
                 }
                 .into(),
···
                     scope: Box::new(
                         Capture {
                             quantifier: One,
-                            name: cap2,
+                            name: cap2.clone(),
                             file_capture_index: 1,
                             stanza_capture_index: 1,
                             location: Location { row: 7, column: 16 }
                         }
                         .into()
                     ),
-                    name: prop1,
+                    name: prop1.clone(),
                     location: Location { row: 7, column: 22 },
                 }
                 .into(),
                 sink: UnscopedVariable {
-                    name: loc1.into(),
+                    name: loc1.clone(),
                     location: Location { row: 7, column: 31 },
                 }
                 .into(),
···
                     scope: Box::new(
                         Capture {
                             quantifier: One,
-                            name: cap2,
+                            name: cap2.clone(),
                             file_capture_index: 1,
                             stanza_capture_index: 1,
                             location: Location { row: 8, column: 16 }
                         }
                         .into()
                     ),
-                    name: prop1,
+                    name: prop1.clone(),
                     location: Location { row: 8, column: 22 },
                 }
                 .into(),
                 attributes: vec![
                     Attribute {
-                        name: push,
+                        name: push.clone(),
                         value: String::from("str2").into(),
                     },
                     Attribute {
-                        name: pop,
-                        value: Expression::TrueLiteral
+                        name: pop.clone(),
+                        value: Expression::TrueLiteral,
                     },
                 ],
                 location: Location { row: 8, column: 10 },
···
                     scope: Box::new(
                         Capture {
                             quantifier: One,
-                            name: cap2,
+                            name: cap2.clone(),
                             file_capture_index: 1,
                             stanza_capture_index: 1,
                             location: Location { row: 9, column: 14 }
                         }
                         .into()
                     ),
-                    name: var1,
+                    name: var1.clone(),
                     location: Location { row: 9, column: 20 },
                 }
                 .into(),
                 value: UnscopedVariable {
-                    name: loc1,
+                    name: loc1.clone(),
                     location: Location { row: 9, column: 27 },
                 }
                 .into(),
···
                     scope: Box::new(
                         Capture {
                             quantifier: One,
-                            name: cap2,
+                            name: cap2.clone(),
                             file_capture_index: 1,
                             stanza_capture_index: 1,
                             location: Location {
···
                         }
                         .into()
                     ),
-                    name: var1,
+                    name: var1.clone(),
                     location: Location {
                         row: 10,
                         column: 20
···
                 }
                 .into(),
                 value: UnscopedVariable {
-                    name: loc1,
+                    name: loc1.clone(),
                     location: Location {
                         row: 10,
                         column: 27
···
 
 #[test]
 fn can_parse_literals() {
-    let mut ctx = Context::new();
     let source = r#"
         (identifier)
         {
···
           let t = #true
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), &mut ctx, source)
-        .expect("Cannot parse file");
+    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
 
-    let f = ctx.add_identifier("f");
-    let n = ctx.add_identifier("n");
-    let t = ctx.add_identifier("t");
+    let f = Identifier::from("f");
+    let n = Identifier::from("n");
+    let t = Identifier::from("t");
 
     let statements = file
         .stanzas
···
         vec![vec![
             DeclareImmutable {
                 variable: UnscopedVariable {
-                    name: f,
+                    name: f.clone(),
                     location: Location { row: 3, column: 14 }
                 }
                 .into(),
···
             .into(),
             DeclareImmutable {
                 variable: UnscopedVariable {
-                    name: n,
+                    name: n.clone(),
                     location: Location { row: 4, column: 14 }
                 }
                 .into(),
···
             .into(),
             DeclareImmutable {
                 variable: UnscopedVariable {
-                    name: t,
+                    name: t.clone(),
                     location: Location { row: 5, column: 14 }
                 }
                 .into(),
···
 
 #[test]
 fn can_parse_strings() {
-    let mut ctx = Context::new();
     let source = r#"
         (identifier)
         {
           let loc1 = "\"abc,\ndef\\"
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), &mut ctx, source)
-        .expect("Cannot parse file");
+    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
 
-    let loc1 = ctx.add_identifier("loc1");
+    let loc1 = Identifier::from("loc1");
 
     let statements = file
         .stanzas
···
         statements,
         vec![vec![DeclareImmutable {
             variable: UnscopedVariable {
-                name: loc1,
+                name: loc1.clone(),
                 location: Location { row: 3, column: 14 }
             }
             .into(),
···
 
 #[test]
 fn can_parse_lists() {
-    let mut ctx = Context::new();
     let source = r#"
         (identifier)
         {
···
           let list3 = ["hello", "world",]
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), &mut ctx, source)
-        .expect("Cannot parse file");
+    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
 
-    let list1 = ctx.add_identifier("list1");
-    let list2 = ctx.add_identifier("list2");
-    let list3 = ctx.add_identifier("list3");
+    let list1 = Identifier::from("list1");
+    let list2 = Identifier::from("list2");
+    let list3 = Identifier::from("list3");
 
     let statements = file
         .stanzas
···
         vec![vec![
             DeclareImmutable {
                 variable: UnscopedVariable {
-                    name: list1,
+                    name: list1.clone(),
                     location: Location { row: 3, column: 14 }
                 }
                 .into(),
···
             .into(),
             DeclareImmutable {
                 variable: UnscopedVariable {
-                    name: list2,
+                    name: list2.clone(),
                     location: Location { row: 4, column: 14 }
                 }
                 .into(),
···
             .into(),
             DeclareImmutable {
                 variable: UnscopedVariable {
-                    name: list3,
+                    name: list3.clone(),
                     location: Location { row: 5, column: 14 }
                 }
                 .into(),
···
 
 #[test]
 fn can_parse_sets() {
-    let mut ctx = Context::new();
     let source = r#"
         (identifier)
         {
···
           let set3 = {"hello", "world",}
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), &mut ctx, source)
-        .expect("Cannot parse file");
+    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
 
-    let set1 = ctx.add_identifier("set1");
-    let set2 = ctx.add_identifier("set2");
-    let set3 = ctx.add_identifier("set3");
+    let set1 = Identifier::from("set1");
+    let set2 = Identifier::from("set2");
+    let set3 = Identifier::from("set3");
 
     let statements = file
         .stanzas
···
         vec![vec![
             DeclareImmutable {
                 variable: UnscopedVariable {
-                    name: set1,
+                    name: set1.clone(),
                     location: Location { row: 3, column: 14 }
                 }
                 .into(),
···
             .into(),
             DeclareImmutable {
                 variable: UnscopedVariable {
-                    name: set2,
+                    name: set2.clone(),
                     location: Location { row: 4, column: 14 }
                 }
                 .into(),
···
             .into(),
             DeclareImmutable {
                 variable: UnscopedVariable {
-                    name: set3,
+                    name: set3.clone(),
                     location: Location { row: 5, column: 14 }
                 }
                 .into(),
···
 
 #[test]
 fn can_parse_print() {
-    let mut ctx = Context::new();
     let source = r#"
         (identifier)
         {
           print "x =", 5
         }    
     "#;
-    let file = File::from_str(tree_sitter_python::language(), &mut ctx, source)
-        .expect("Cannot parse file");
+    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
 
     let statements = file
         .stanzas
···
 
 #[test]
 fn cannot_parse_nullable_regex() {
-    let mut ctx = Context::new();
     let source = r#"
         (module) @root
         {
···
           node n
         }
     "#;
-    if let Ok(_) = File::from_str(tree_sitter_python::language(), &mut ctx, source) {
+    if let Ok(_) = File::from_str(tree_sitter_python::language(), source) {
         panic!("Parse succeeded unexpectedly");
     }
 }
 
 #[test]
 fn can_parse_star_capture() {
-    let mut ctx = Context::new();
     let source = r#"
         (module (_)* @stmts)
         {
           print @stmts
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), &mut ctx, source)
-        .expect("Cannot parse file");
+    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
 
-    let stmts = ctx.add_identifier("stmts");
+    let stmts = Identifier::from("stmts");
 
     let statements = file
         .stanzas
···
 
 #[test]
 fn can_parse_star_multiple_capture() {
-    let mut ctx = Context::new();
     let source = r#"
         (module (_) @stmt * @stmts)
         {
···
           print @stmts
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), &mut ctx, source)
-        .expect("Cannot parse file");
+    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
 
-    let stmt = ctx.add_identifier("stmt");
-    let stmts = ctx.add_identifier("stmts");
+    let stmt = Identifier::from("stmt");
+    let stmts = Identifier::from("stmts");
 
     let statements = file
         .stanzas
···
 
 #[test]
 fn can_parse_plus_capture() {
-    let mut ctx = Context::new();
     let source = r#"
         (module (_)+ @stmts)
         {
           print @stmts
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), &mut ctx, source)
-        .expect("Cannot parse file");
+    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
 
-    let stmts = ctx.add_identifier("stmts");
+    let stmts = Identifier::from("stmts");
 
     let statements = file
         .stanzas
···
 
 #[test]
 fn can_parse_optional_capture() {
-    let mut ctx = Context::new();
     let source = r#"
         (module (_)? @stmt)
         {
           print @stmt
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), &mut ctx, source)
-        .expect("Cannot parse file");
+    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
 
-    let stmt = ctx.add_identifier("stmt");
+    let stmt = Identifier::from("stmt");
 
     let statements = file
         .stanzas
···
 
 #[test]
 fn can_parse_parent_optional_capture() {
-    let mut ctx = Context::new();
     let source = r#"
         (module (_) @stmt) ?
         {
           print @stmt
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), &mut ctx, source)
-        .expect("Cannot parse file");
+    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
 
-    let stmt = ctx.add_identifier("stmt");
+    let stmt = Identifier::from("stmt");
 
     let statements = file
         .stanzas
···
 
 #[test]
 fn can_parse_alternative_capture() {
-    let mut ctx = Context::new();
     let source = r#"
         (module [(_) (_) @stmt])
         {
           print @stmt
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), &mut ctx, source)
-        .expect("Cannot parse file");
+    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
 
-    let stmt = ctx.add_identifier("stmt");
+    let stmt = Identifier::from("stmt");
 
     let statements = file
         .stanzas
···
 
 #[test]
 fn can_parse_nested_plus_and_optional_capture() {
-    let mut ctx = Context::new();
     let source = r#"
         (module (_)+ @stmt) ?
         {
           print @stmt
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), &mut ctx, source)
-        .expect("Cannot parse file");
+    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
 
-    let stmt = ctx.add_identifier("stmt");
+    let stmt = Identifier::from("stmt");
 
     let statements = file
         .stanzas
···
 
 #[test]
 fn can_parse_if() {
-    let mut ctx = Context::new();
     let source = r#"
         (module (pass_statement)? @x)
         {
···
           }
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), &mut ctx, source)
-        .expect("Cannot parse file");
+    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
 
-    let x = ctx.add_identifier("x");
+    let x = Identifier::from("x");
 
     let statements = file
         .stanzas
···
 
 #[test]
 fn can_parse_if_elif() {
-    let mut ctx = Context::new();
     let source = r#"
         (module (pass_statement)? @x)
         {
···
           }
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), &mut ctx, source)
-        .expect("Cannot parse file");
+    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
 
-    let x = ctx.add_identifier("x");
+    let x = Identifier::from("x");
 
     let statements = file
         .stanzas
···
                     conditions: vec![Condition::None {
                         value: Capture {
                             quantifier: ZeroOrOne,
-                            name: x,
+                            name: x.clone(),
                             file_capture_index: 0,
                             stanza_capture_index: 0,
                             location: Location { row: 3, column: 18 },
···
                     conditions: vec![Condition::Some {
                         value: Capture {
                             quantifier: ZeroOrOne,
-                            name: x,
+                            name: x.clone(),
                             file_capture_index: 0,
                             stanza_capture_index: 0,
                             location: Location { row: 5, column: 22 },
···
 
 #[test]
 fn can_parse_if_else() {
-    let mut ctx = Context::new();
     let source = r#"
         (module (pass_statement)? @x)
         {
···
           }
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), &mut ctx, source)
-        .expect("Cannot parse file");
+    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
 
-    let x = ctx.add_identifier("x");
+    let x = Identifier::from("x");
 
     let statements = file
         .stanzas
···
 
 #[test]
 fn cannot_parse_if_some_list_capture() {
-    let mut ctx = Context::new();
     let source = r#"
         (module (_)+ @xs) @root
         {
···
           }
         }
     "#;
-    if let Ok(_) = File::from_str(tree_sitter_python::language(), &mut ctx, source) {
+    if let Ok(_) = File::from_str(tree_sitter_python::language(), source) {
         panic!("Parse succeeded unexpectedly");
     }
 }
 
 #[test]
 fn can_parse_for_in() {
-    let mut ctx = Context::new();
     let source = r#"
         (module (_)* @xs)
         {
···
           }
         }
     "#;
-    let file = File::from_str(tree_sitter_python::language(), &mut ctx, source)
-        .expect("Cannot parse file");
+    let file = File::from_str(tree_sitter_python::language(), source).expect("Cannot parse file");
 
-    let xs = ctx.add_identifier("xs");
-    let x = ctx.add_identifier("x");
+    let xs = Identifier::from("xs");
+    let x = Identifier::from("x");
 
     let statements = file
         .stanzas
···
         statements,
         vec![vec![ForIn {
             variable: UnscopedVariable {
-                name: x,
+                name: x.clone(),
                 location: Location { row: 3, column: 14 }
             },
             value: Capture {
                 quantifier: ZeroOrMore,
-                name: xs,
+                name: xs.clone(),
                 file_capture_index: 0,
                 stanza_capture_index: 0,
                 location: Location { row: 3, column: 19 },
···
             .into(),
             statements: vec![Print {
                 values: vec![UnscopedVariable {
-                    name: x,
+                    name: x.clone(),
                     location: Location { row: 4, column: 18 },
                 }
                 .into()],
···
 
 #[test]
 fn cannot_parse_for_in_optional_capture() {
-    let mut ctx = Context::new();
     let source = r#"
         (module (_)? @xs) @root
         {
···
           }
         }
     "#;
-    if let Ok(_) = File::from_str(tree_sitter_python::language(), &mut ctx, source) {
+    if let Ok(_) = File::from_str(tree_sitter_python::language(), source) {
         panic!("Parse succeeded unexpectedly");
     }
 }
 
 #[test]
 fn cannot_parse_scan_of_nonlocal_call_expression() {
-    let mut ctx = Context::new();
     let source = r#"
       (function_definition
       name: (identifier) @name)
···
         }
       }
     "#;
-    if let Ok(_) = File::from_str(tree_sitter_python::language(), &mut ctx, source) {
+    if let Ok(_) = File::from_str(tree_sitter_python::language(), source) {
         panic!("Parse succeeded unexpectedly");
     }
 }
 
 #[test]
 fn cannot_parse_scan_of_nonlocal_variable() {
-    let mut ctx = Context::new();
     let source = r#"
       (function_definition
       name: (identifier) @name)
···
         }
       }
     "#;
-    if let Ok(_) = File::from_str(tree_sitter_python::language(), &mut ctx, source) {
+    if let Ok(_) = File::from_str(tree_sitter_python::language(), source) {
         panic!("Parse succeeded unexpectedly");
     }
 }