Ensure all edges are created before evaluating edge attributes

src/execution/lazy.rs

···
         let mut locals = VariableMap::new();
         let mut store = LazyStore::new();
         let mut scoped_store = LazyScopedVariables::new();
-        let mut lazy_graph = Vec::new();
+        let mut lazy_graph = LazyGraph::new();
         let mut function_parameters = Vec::new();
         let mut prev_element_debug_info = HashMap::new();
 
···
             prev_element_debug_info: &mut prev_element_debug_info,
             cancellation_flag,
         };
-        for graph_stmt in &lazy_graph {
-            graph_stmt.evaluate(&mut exec)?;
-        }
+        lazy_graph.evaluate(&mut exec)?;
         // make sure any unforced values are now forced, to surface any problems
         // hidden by the fact that the values were unused
         store.evaluate_all(&mut exec)?;
···
     mat: &'a QueryMatch<'a, 'tree>,
     store: &'a mut LazyStore,
     scoped_store: &'a mut LazyScopedVariables,
-    lazy_graph: &'a mut Vec<LazyStatement>,
+    lazy_graph: &'a mut LazyGraph,
     function_parameters: &'a mut Vec<graph::Value>, // re-usable buffer to reduce memory allocations
     prev_element_debug_info: &'a mut HashMap<GraphElementKey, DebugInfo>,
     error_context: StatementContext,
···
         locals: &mut VariableMap<'l, LazyValue>,
         store: &mut LazyStore,
         scoped_store: &mut LazyScopedVariables,
-        lazy_graph: &mut Vec<LazyStatement>,
+        lazy_graph: &mut LazyGraph,
         function_parameters: &mut Vec<graph::Value>,
         prev_element_debug_info: &mut HashMap<GraphElementKey, DebugInfo>,
         inherited_variables: &HashSet<Identifier>,

src/execution/lazy/statements.rs

···
 use super::EvaluationContext;
 use super::GraphElementKey;
 
+/// Lazy graph
+#[derive(Debug)]
+pub(super) struct LazyGraph {
+    edge_statements: Vec<LazyStatement>,
+    attr_statements: Vec<LazyStatement>,
+    print_statements: Vec<LazyStatement>,
+}
+
+impl LazyGraph {
+    pub(super) fn new() -> Self {
+        LazyGraph {
+            edge_statements: Vec::new(),
+            attr_statements: Vec::new(),
+            print_statements: Vec::new(),
+        }
+    }
+
+    pub(super) fn push(&mut self, stmt: LazyStatement) {
+        match stmt {
+            LazyStatement::AddGraphNodeAttribute(_) => self.attr_statements.push(stmt),
+            LazyStatement::CreateEdge(_) => self.edge_statements.push(stmt),
+            LazyStatement::AddEdgeAttribute(_) => self.attr_statements.push(stmt),
+            LazyStatement::Print(_) => self.print_statements.push(stmt),
+        }
+    }
+
+    pub(super) fn evaluate(&self, exec: &mut EvaluationContext) -> Result<(), ExecutionError> {
+        for stmt in &self.edge_statements {
+            stmt.evaluate(exec)?;
+        }
+        for stmt in &self.attr_statements {
+            stmt.evaluate(exec)?;
+        }
+        for stmt in &self.print_statements {
+            stmt.evaluate(exec)?;
+        }
+        Ok(())
+    }
+}
+
 /// Lazy graph statements
 #[derive(Debug)]
 pub(super) enum LazyStatement {

tests/it/lazy_execution.rs

···
         "#},
         indoc! {r#"
           node 0
-            name: "alpha"
-          edge 0 -> 2
+          edge 0 -> 1
           node 1
-          edge 1 -> 0
+            name: "alpha"
+          edge 1 -> 2
           node 2
             name: "beta"
           edge 2 -> 3