Ensure all scoped variables are forced to uncover hidden errors

src/execution/lazy.rs

···
         // 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)?;
+        scoped_store.evaluate_all(&mut exec)?;
 
         Ok(())
     }

src/execution/lazy/store.rs

···
         name: &Identifier,
         exec: &mut EvaluationContext,
     ) -> Result<LazyValue, ExecutionError> {
-        let values = match self.variables.get(name) {
+        let cell = match self.variables.get(name) {
             Some(v) => v,
             None => {
                 return Err(ExecutionError::UndefinedScopedVariable(format!(
···
                 )));
             }
         };
-        match values.replace(ScopedValues::Forcing) {
+        let values = cell.replace(ScopedValues::Forcing);
+        let map = self.force(name, values, exec)?;
+        let result = map
+            .get(&scope)
+            .ok_or(ExecutionError::UndefinedScopedVariable(format!(
+                "{}.{}",
+                scope, name,
+            )))?
+            .clone();
+        cell.replace(ScopedValues::Forced(map));
+        Ok(result)
+    }
+
+    pub(super) fn evaluate_all(&self, exec: &mut EvaluationContext) -> Result<(), ExecutionError> {
+        for (name, cell) in &self.variables {
+            let values = cell.replace(ScopedValues::Forcing);
+            let map = self.force(name, values, exec)?;
+            cell.replace(ScopedValues::Forced(map));
+        }
+        Ok(())
+    }
+
+    fn force(
+        &self,
+        name: &Identifier,
+        values: ScopedValues,
+        exec: &mut EvaluationContext,
+    ) -> Result<HashMap<SyntaxNodeRef, LazyValue>, ExecutionError> {
+        match values {
             ScopedValues::Unforced(pairs) => {
                 let mut map = HashMap::new();
                 let mut debug_infos = HashMap::new();
···
                         _ => {}
                     };
                 }
-                let result = map
-                    .get(&scope)
-                    .ok_or(ExecutionError::UndefinedScopedVariable(format!(
-                        "{}.{}",
-                        scope, name,
-                    )))?
-                    .clone();
-                values.replace(ScopedValues::Forced(map));
-                Ok(result)
+                Ok(map)
             }
             ScopedValues::Forcing => Err(ExecutionError::RecursivelyDefinedScopedVariable(
-                format!("_.{} requested on {}", name, scope),
+                format!("_.{}", name),
             )),
-            ScopedValues::Forced(map) => {
-                let result = map
-                    .get(&scope)
-                    .ok_or(ExecutionError::UndefinedScopedVariable(format!(
-                        "{}.{}",
-                        scope, name,
-                    )))?
-                    .clone();
-                values.replace(ScopedValues::Forced(map));
-                Ok(result)
-            }
+            ScopedValues::Forced(map) => Ok(map),
         }
     }
 }