Fix and clean spec runner.

spec/src/run.rs

@@ -143,6 +143,7 @@ impl ModuleImportResolver for SpecModule {
 struct SpecDriver {
     spec_module: SpecModule,
     instances: HashMap<String, ModuleRef>,
+    last_module: Option<ModuleRef>,
 }
 
 impl SpecDriver {
@@ -150,6 +151,7 @@ impl SpecDriver {
         SpecDriver {
             spec_module: SpecModule::new(),
             instances: HashMap::new(),
+            last_module: None,
         }
     }
 
@@ -157,15 +159,27 @@ impl SpecDriver {
         &mut self.spec_module
     }
 
-    fn add_module(&mut self, name: String, module: ModuleRef) {
+    fn add_module(&mut self, name: Option<String>, module: ModuleRef) {
+        self.last_module = Some(module.clone());
+        if let Some(name) = name {
             self.instances.insert(name, module);
         }
+    }
 
     fn module(&self, name: &str) -> Result<ModuleRef, InterpreterError> {
         self.instances.get(name).cloned().ok_or_else(|| {
             InterpreterError::Instantiation(format!("Module not registered {}", name))
         })
     }
+
+    fn module_or_last(&self, name: Option<&str>) -> Result<ModuleRef, InterpreterError> {
+        match name {
+            Some(name) => self.module(name),
+            None => self.last_module.clone().ok_or_else(|| {
+                InterpreterError::Instantiation("No modules registered".into())
+            }),
+        }
+    }
 }
 
 impl ImportResolver for SpecDriver {
@@ -263,11 +277,8 @@ fn load_module(
         .run_start(spec_driver.spec_module())
         .expect("Run start failed");
 
-    let module_name = name.as_ref()
-        .map(|s| s.as_ref())
-        .unwrap_or("wasm_test")
-        .trim_left_matches('$');
-    spec_driver.add_module(module_name.to_owned(), instance.clone());
+    let module_name = name.clone();
+    spec_driver.add_module(module_name, instance.clone());
 
     instance
 }
@@ -311,10 +322,8 @@ fn run_action(
             ref field,
             ref args,
         } => {
-            let module = module.clone().unwrap_or("wasm_test".into());
-            let module = module.trim_left_matches('$');
-            let module = program.module(&module).expect(&format!(
-                "Expected program to have loaded module {}",
+            let module = program.module_or_last(module.as_ref().map(|x| x.as_ref())).expect(&format!(
+                "Expected program to have loaded module {:?}",
                 module
             ));
             module.invoke_export(
@@ -328,10 +337,8 @@ fn run_action(
             ref field,
             ..
         } => {
-            let module = module.clone().unwrap_or("wasm_test".into());
-            let module = module.trim_left_matches('$');
-            let module = program.module(&module).expect(&format!(
-                "Expected program to have loaded module {}",
+            let module = program.module_or_last(module.as_ref().map(|x| x.as_ref())).expect(&format!(
+                "Expected program to have loaded module {:?}",
                 module
             ));
             let field = jstring_to_rstring(&field);
@@ -418,7 +425,6 @@ pub fn spec(name: &str) {
         serde_json::from_reader(&mut f).expect("Failed to deserialize JSON file");
 
     let mut spec_driver = SpecDriver::new();
-    let mut last_module = None;
     for command in &spec.commands {
         println!("command {:?}", command);
         match command {
@@ -427,7 +433,7 @@ pub fn spec(name: &str) {
                 ref filename,
                 ..
             } => {
-                last_module = Some(load_module(tmpdir.as_ref(), &filename, &name, &mut spec_driver));
+                load_module(tmpdir.as_ref(), &filename, &name, &mut spec_driver);
             }
             &test::Command::AssertReturn {
                 line,
@@ -535,19 +541,16 @@ pub fn spec(name: &str) {
                 Err(e) => println!("assert_uninstantiable - success ({:?})", e),
             },
             &test::Command::Register {
+                line,
                 ref name,
                 ref as_name,
                 ..
             } => {
-                match name {
-                    &Some(ref name) => assert_eq!(name.trim_left_matches('$'), as_name), // we have already registered this module without $ prefix
-                    &None => spec_driver.add_module(
-                        as_name.clone(),
-                        last_module
-                            .take()
-                            .expect("Last module must be set for this command"),
-                    ),
-                }
+                let module = match spec_driver.module_or_last(name.as_ref().map(|x| x.as_ref())) {
+                    Ok(module) => module,
+                    Err(e) => panic!("No such module, at line {} - ({:?})", e, line),
+                };
+                spec_driver.add_module(Some(as_name.clone()), module);
             }
             &test::Command::Action { line, ref action } => {
                 match run_action(&mut spec_driver, action) {