Add more context on which part of the statement returned an error

src/execution/lazy/statements.rs

···
     }
 
     pub(super) fn evaluate(&self, exec: &mut EvaluationContext) -> Result<(), ExecutionError> {
-        let node = self.node.evaluate_as_graph_node(exec)?;
+        let node = self
+            .node
+            .evaluate_as_graph_node(exec)
+            .with_context(|| "Evaluating target node".to_string().into())?;
         for attribute in &self.attributes {
             let value = attribute.value.evaluate(exec)?;
             let prev_debug_info = exec.prev_element_debug_info.insert(
···
     }
 
     pub(super) fn evaluate(&self, exec: &mut EvaluationContext) -> Result<(), ExecutionError> {
-        let source = self.source.evaluate_as_graph_node(exec)?;
-        let sink = self.sink.evaluate_as_graph_node(exec)?;
+        let source = self
+            .source
+            .evaluate_as_graph_node(exec)
+            .with_context(|| "Evaluating edge source".to_string().into())?;
+        let sink = self
+            .sink
+            .evaluate_as_graph_node(exec)
+            .with_context(|| "Evaluating edge sink".to_string().into())?;
         let prev_debug_info = exec
             .prev_element_debug_info
             .insert(GraphElementKey::Edge(source, sink), self.debug_info.clone());
···
     }
 
     pub(super) fn evaluate(&self, exec: &mut EvaluationContext) -> Result<(), ExecutionError> {
-        let source = self.source.evaluate_as_graph_node(exec)?;
-        let sink = self.sink.evaluate_as_graph_node(exec)?;
+        let source = self
+            .source
+            .evaluate_as_graph_node(exec)
+            .with_context(|| "Evaluating edge source".to_string().into())?;
+        let sink = self
+            .sink
+            .evaluate_as_graph_node(exec)
+            .with_context(|| "Evaluating edge sink".to_string().into())?;
         for attribute in &self.attributes {
             let value = attribute.value.evaluate(exec)?;
             let edge = match exec.graph[source].get_edge_mut(sink) {

src/execution/lazy/values.rs

···
 use std::fmt;
 
 use crate::execution::error::ExecutionError;
+use crate::execution::error::ResultWithExecutionError;
 use crate::graph::GraphNodeRef;
 use crate::graph::SyntaxNodeRef;
 use crate::graph::Value;
···
     }
 
     fn resolve<'a>(&self, exec: &'a mut EvaluationContext) -> Result<LazyValue, ExecutionError> {
-        let scope = self.scope.as_ref().evaluate_as_syntax_node(exec)?;
+        let scope = self
+            .scope
+            .as_ref()
+            .evaluate_as_syntax_node(exec)
+            .with_context(|| format!("Evaluating scope of variable _.{}", self.name).into())?;
         let scoped_store = &exec.scoped_store;
         scoped_store.evaluate(&scope, &self.name, exec)
     }