Rework how tests are run (bytecodealliance#211)

This commit reorganizes how tests are run with a few goals in mind:

* Currently it's difficult to run just one test, you typically have to
  run everything and that can take some time.
* The error messages for failing tests aren't always immediately clear
  what test failed where.

This commit moves the `src/tests.rs` module to a `tests/all.rs`
integration test that is now run without a test harness. Test discovery
happens manually and rayon is used for parallelism. Test filters via CLI
arguments are supported and match on the filename of the test to run.

A few fixes to validation were applied along the way, along with
enabling a few more directories from the upstream spec tests. For now,
though, there's still a number of holes in the reference types
validation.

Author: alexcrichton

Cargo.toml

@@ -16,6 +16,7 @@ anyhow = "1.0"
 criterion = "0.3"
 getopts = "0.2"
 wast = "15.0.0"
+rayon = "1.3"
 
 [badges]
 travis-ci = { repository = "bytecodealliance/wasmparser.rs" }
@@ -29,3 +30,7 @@ deterministic = []
 [[bench]]
 name = "benchmark"
 harness = false
+
+[[test]]
+name = "all"
+harness = false

src/module_resources.rs

@@ -295,6 +295,8 @@ pub trait WasmModuleResources {
     fn global_at(&self, at: u32) -> Option<&Self::GlobalType>;
     /// Returns the function signature ID at given index.
     fn func_type_id_at(&self, at: u32) -> Option<u32>;
+    /// Returns the element type at the given index.
+    fn element_type_at(&self, at: u32) -> Option<crate::Type>;
 
     /// Returns the number of elements.
     fn element_count(&self) -> u32;

src/operators_validator.rs

@@ -1982,14 +1982,19 @@ impl OperatorValidator {
                 if table > 0 {
                     self.check_reference_types_enabled()?;
                 }
-                if resources.table_at(table).is_none() {
-                    bail_op_err!("unknown table {}: table index out of bounds", table);
-                }
-                if segment >= resources.element_count() {
-                    bail_op_err!(
-                        "unknown element segment {}: segment index out of bounds",
+                let table = match resources.table_at(table) {
+                    Some(table) => table,
+                    None => bail_op_err!("unknown table {}: table index out of bounds", table),
+                };
+                let segment_ty = match resources.element_type_at(segment) {
+                    Some(ty) => ty,
+                    None => bail_op_err!(
+                        "unknown elem segment {}: segment index out of bounds",
                         segment
-                    );
+                    ),
+                };
+                if !is_subtype_supertype(segment_ty, table.element_type().to_parser_type()) {
+                    return Err(OperatorValidatorError::new("type mismatch"));
                 }
                 self.check_operands_3(Type::I32, Type::I32, Type::I32)?;
                 self.func_state.change_frame(3)?;
@@ -1998,7 +2003,7 @@ impl OperatorValidator {
                 self.check_bulk_memory_enabled()?;
                 if segment >= resources.element_count() {
                     bail_op_err!(
-                        "unknown element segment {}: segment index out of bounds",
+                        "unknown elem segment {}: segment index out of bounds",
                         segment
                     );
                 }
@@ -2011,10 +2016,16 @@ impl OperatorValidator {
                 if src_table > 0 || dst_table > 0 {
                     self.check_reference_types_enabled()?;
                 }
-                if resources.table_at(src_table).is_none()
-                    || resources.table_at(dst_table).is_none()
-                {
-                    return Err(OperatorValidatorError::new("table index out of bounds"));
+                let (src, dst) =
+                    match (resources.table_at(src_table), resources.table_at(dst_table)) {
+                        (Some(a), Some(b)) => (a, b),
+                        _ => return Err(OperatorValidatorError::new("table index out of bounds")),
+                    };
+                if !is_subtype_supertype(
+                    src.element_type().to_parser_type(),
+                    dst.element_type().to_parser_type(),
+                ) {
+                    return Err(OperatorValidatorError::new("type mismatch"));
                 }
                 self.check_operands_3(Type::I32, Type::I32, Type::I32)?;
                 self.func_state.change_frame(3)?;