Replace unwrap with expect

Author: Hendrik van Antwerpen

stack-graphs/src/cycles.rs

@@ -208,22 +208,22 @@ impl<A: Appendable + Clone> AppendingCycleDetector<A> {
             while let Some(appendage) = prefix_appendages.pop_front(appendables) {
                 prefix_path
                     .resolve_to(graph, partials, appendage.start_node(ctx))
-                    .unwrap();
+                    .expect("resolving cycle prefix path failed");
                 appendage
                     .append_to(graph, partials, ctx, &mut prefix_path)
-                    .unwrap();
+                    .expect("appending cycle prefix path failed");
             }
 
             // build cyclic path
             let cyclic_path = maybe_cyclic_path
                 .unwrap_or_else(|| PartialPath::from_node(graph, partials, end_node));
             prefix_path
                 .resolve_to(graph, partials, cyclic_path.start_node)
-                .unwrap();
+                .expect("resolving cyclic path failed");
             prefix_path.ensure_no_overlapping_variables(partials, &cyclic_path);
             prefix_path
                 .concatenate(graph, partials, &cyclic_path)
-                .unwrap();
+                .expect("concatenating cyclic path failed ");
             if !prefix_path.is_productive(graph, partials) {
                 return Err(PathResolutionError::DisallowedCycle);
             }

stack-graphs/src/partial.rs

@@ -2555,12 +2555,16 @@ impl Node {
             }
             Node::JumpTo(_) => {}
             Node::PopScopedSymbol(node) => {
-                let symbol = symbol_stack.pop_front(partials).unwrap();
+                let symbol = symbol_stack
+                    .pop_front(partials)
+                    .expect("missing symbol for pop scoped symbol node in precondition");
                 debug_assert_eq!(symbol.symbol, node.symbol);
                 *scope_stack = symbol.scopes.into_option().unwrap();
             }
             Node::PopSymbol(node) => {
-                let symbol = symbol_stack.pop_front(partials).unwrap();
+                let symbol = symbol_stack
+                    .pop_front(partials)
+                    .expect("missing symbol for pop symbol node in precondition");
                 debug_assert_eq!(symbol.symbol, node.symbol);
             }
             Node::PushScopedSymbol(_) => {}
@@ -2603,11 +2607,15 @@ impl Node {
             Self::PopScopedSymbol(_) => {}
             Self::PopSymbol(_) => {}
             Self::PushScopedSymbol(node) => {
-                let symbol = symbol_stack.pop_front(partials).unwrap();
+                let symbol = symbol_stack
+                    .pop_front(partials)
+                    .expect("missing symbol for push scoped symbol node in postcondition");
                 debug_assert_eq!(symbol.symbol, node.symbol);
             }
             Self::PushSymbol(node) => {
-                let symbol = symbol_stack.pop_front(partials).unwrap();
+                let symbol = symbol_stack
+                    .pop_front(partials)
+                    .expect("missing symbol for push symbol node in postcondition");
                 debug_assert_eq!(symbol.symbol, node.symbol);
             }
             Self::Root(_) => {}