Record TSG location for edges

Add the TSG location for edge statements in the debug information,
similarly to what already happened for nodes.

src/execution.rs

···
 use tree_sitter::QueryMatch;
 use tree_sitter::Tree;
 
+use crate::ast::CreateEdge;
 use crate::ast::File;
 use crate::ast::Stanza;
+use crate::ast::Variable;
 use crate::execution::error::ExecutionError;
 use crate::functions::Functions;
+use crate::graph::Attributes;
 use crate::graph::Graph;
 use crate::graph::Value;
 use crate::variables::Globals;
···
         }
     }
 }
+
+impl CreateEdge {
+    pub(crate) fn add_debug_attrs(
+        &self,
+        attributes: &mut Attributes,
+        config: &ExecutionConfig,
+    ) -> Result<(), ExecutionError> {
+        if let Some(location_attr) = &config.location_attr {
+            attributes
+                .add(location_attr.clone(), format!("{}", self.location))
+                .map_err(|_| ExecutionError::DuplicateAttribute(location_attr.as_str().into()))?;
+        }
+        Ok(())
+    }
+}
+impl Variable {
+    pub(crate) fn add_debug_attrs(
+        &self,
+        attributes: &mut Attributes,
+        config: &ExecutionConfig,
+    ) -> Result<(), ExecutionError> {
+        if let Some(variable_name_attr) = &config.variable_name_attr {
+            attributes
+                .add(variable_name_attr.clone(), format!("{}", self))
+                .map_err(|_| {
+                    ExecutionError::DuplicateAttribute(variable_name_attr.as_str().into())
+                })?;
+        }
+        if let Some(location_attr) = &config.location_attr {
+            let location = match &self {
+                Variable::Scoped(v) => v.location,
+                Variable::Unscoped(v) => v.location,
+            };
+            attributes
+                .add(location_attr.clone(), format!("{}", location))
+                .map_err(|_| ExecutionError::DuplicateAttribute(location_attr.as_str().into()))?;
+        }
+        Ok(())
+    }
+}

src/execution/lazy.rs

···
 use crate::execution::ExecutionConfig;
 use crate::functions::Functions;
 use crate::graph;
+use crate::graph::Attributes;
 use crate::graph::Graph;
 use crate::graph::Value;
 use crate::variables::Globals;
···
     fn execute_lazy(&self, exec: &mut ExecutionContext) -> Result<(), ExecutionError> {
         let source = self.source.evaluate_lazy(exec)?;
         let sink = self.sink.evaluate_lazy(exec)?;
-        let stmt = LazyCreateEdge::new(source, sink, exec.error_context.clone().into());
+        let mut attributes = Attributes::new();
+        self.add_debug_attrs(&mut attributes, exec.config)?;
+        let stmt = LazyCreateEdge::new(source, sink, attributes, exec.error_context.clone().into());
         exec.lazy_graph.push(stmt.into());
         Ok(())
     }

src/execution/lazy/statements.rs

···
 
 use crate::execution::error::ExecutionError;
 use crate::execution::error::ResultWithExecutionError;
+use crate::graph::Attributes;
 use crate::Identifier;
 
 use super::store::DebugInfo;
···
 pub(super) struct LazyCreateEdge {
     source: LazyValue,
     sink: LazyValue,
+    attributes: Attributes,
     debug_info: DebugInfo,
 }
 
 impl LazyCreateEdge {
-    pub(super) fn new(source: LazyValue, sink: LazyValue, debug_info: DebugInfo) -> Self {
+    pub(super) fn new(
+        source: LazyValue,
+        sink: LazyValue,
+        attributes: Attributes,
+        debug_info: DebugInfo,
+    ) -> Self {
         Self {
             source,
             sink,
+            attributes,
             debug_info,
         }
     }
···
         let prev_debug_info = exec
             .prev_element_debug_info
             .insert(GraphElementKey::Edge(source, sink), self.debug_info.clone());
-        if let Err(_) = exec.graph[source].add_edge(sink) {
-            Err(ExecutionError::DuplicateEdge(format!(
-                "({} -> {}) at {} and {}",
-                source,
-                sink,
-                prev_debug_info.unwrap(),
-                self.debug_info,
-            )))?;
-        }
+        let edge = match exec.graph[source].add_edge(sink) {
+            Ok(edge) => edge,
+            Err(_) => {
+                return Err(ExecutionError::DuplicateEdge(format!(
+                    "({} -> {}) at {} and {}",
+                    source,
+                    sink,
+                    prev_debug_info.unwrap(),
+                    self.debug_info,
+                )))?
+            }
+        };
+        edge.attributes = self.attributes.clone();
         Ok(())
     }
 }

src/execution/strict.rs

···
 use crate::execution::error::StatementContext;
 use crate::execution::CancellationFlag;
 use crate::execution::ExecutionConfig;
-use crate::graph::Attributes;
 use crate::graph::Graph;
 use crate::graph::SyntaxNodeRef;
 use crate::graph::Value;
···
     fn execute(&self, exec: &mut ExecutionContext) -> Result<(), ExecutionError> {
         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, sink, self,
-            )))?;
-        }
+        let edge = match exec.graph[source].add_edge(sink) {
+            Ok(edge) => edge,
+            Err(_) => {
+                return Err(ExecutionError::DuplicateEdge(format!(
+                    "({} -> {}) in {}",
+                    source, sink, self,
+                )))?
+            }
+        };
+        self.add_debug_attrs(&mut edge.attributes, exec.config)?;
         Ok(())
     }
 }
···
                 ExecutionError::UndefinedVariable(format!("{}", self))
             }
         })
-    }
-}
-
-impl Variable {
-    pub(crate) fn add_debug_attrs(
-        &self,
-        attributes: &mut Attributes,
-        config: &ExecutionConfig,
-    ) -> Result<(), ExecutionError> {
-        if let Some(variable_name_attr) = &config.variable_name_attr {
-            attributes
-                .add(variable_name_attr.clone(), format!("{}", self))
-                .map_err(|_| {
-                    ExecutionError::DuplicateAttribute(variable_name_attr.as_str().into())
-                })?;
-        }
-        if let Some(location_attr) = &config.location_attr {
-            let location = match &self {
-                Variable::Scoped(v) => v.location,
-                Variable::Unscoped(v) => v.location,
-            };
-            attributes
-                .add(location_attr.clone(), format!("{}", location))
-                .map_err(|_| ExecutionError::DuplicateAttribute(location_attr.as_str().into()))?;
-        }
-        Ok(())
     }
 }
 

src/graph.rs

···
 }
 
 /// A set of attributes associated with a graph node or edge
+#[derive(Clone, Debug)]
 pub struct Attributes {
     values: HashMap<Identifier, Value>,
 }