Update spec test suite submodule (#2485)

* Update spec test suite submodule

* Add support for `assert_{invalid,malformed}_custom` directives
* Shuffle around how `@custom` is printed to improve round-trip-ability
* Disallow multiple `@metadata.branch_hint` annotations on one
  instruction.
* Skip a custom-page-sizes test for now until the test upstream is
  updated.
* Adjust the `name` section emitted during text-to-binary to happen
  after user-specified `@custom` sections to make round-tripping work.

* Fix warnings

Author: alexcrichton

ci/generate-spec-tests.rs

@@ -40,6 +40,11 @@ fn copy_test(src: &Path, dst: &Path) {
         return;
     }
 
+    // FIXME(WebAssembly/custom-page-sizes#58)
+    if src.ends_with("proposals/custom-page-sizes/custom-page-sizes-invalid.wast") {
+        return;
+    }
+
     let directive = match dst.file_name().and_then(|s| s.to_str()) {
         // Disable tests by doing something like:
         // Some("exact-func-import.wast") => "FAIL",

crates/json-from-wast/src/build.rs

@@ -103,6 +103,19 @@ impl<'a> JsonBuilder<'a, '_> {
                     file,
                 }
             }
+            WastDirective::AssertMalformedCustom {
+                span: _,
+                module,
+                message,
+            } => {
+                let line = self.lineno(module.span());
+                let (_name, file) = self.emit_file(module, true)?;
+                crate::Command::AssertMalformedCustom {
+                    line,
+                    text: message.into(),
+                    file,
+                }
+            }
             WastDirective::AssertInvalid {
                 span: _,
                 module,
@@ -116,6 +129,19 @@ impl<'a> JsonBuilder<'a, '_> {
                     file,
                 }
             }
+            WastDirective::AssertInvalidCustom {
+                span: _,
+                module,
+                message,
+            } => {
+                let line = self.lineno(module.span());
+                let (_name, file) = self.emit_file(module, false)?;
+                crate::Command::AssertInvalidCustom {
+                    line,
+                    text: message.into(),
+                    file,
+                }
+            }
             WastDirective::Register {
                 span: _,
                 module,

crates/json-from-wast/src/lib.rs

@@ -97,13 +97,27 @@ pub enum Command<'a> {
         #[serde(borrow)]
         text: Cow<'a, str>,
     },
+    AssertMalformedCustom {
+        line: u32,
+        #[serde(borrow, flatten)]
+        file: WasmFile<'a>,
+        #[serde(borrow)]
+        text: Cow<'a, str>,
+    },
     AssertInvalid {
         line: u32,
         #[serde(borrow, flatten)]
         file: WasmFile<'a>,
         #[serde(borrow)]
         text: Cow<'a, str>,
     },
+    AssertInvalidCustom {
+        line: u32,
+        #[serde(borrow, flatten)]
+        file: WasmFile<'a>,
+        #[serde(borrow)]
+        text: Cow<'a, str>,
+    },
     Register {
         line: u32,
         #[serde(borrow, skip_serializing_if = "Option::is_none")]
@@ -197,7 +211,9 @@ impl Command<'_> {
             | ModuleDefinition { line, .. }
             | ModuleInstance { line, .. }
             | AssertMalformed { line, .. }
+            | AssertMalformedCustom { line, .. }
             | AssertInvalid { line, .. }
+            | AssertInvalidCustom { line, .. }
             | Register { line, .. }
             | AssertUnlinkable { line, .. }
             | AssertUninstantiable { line, .. }

crates/wasmprinter/src/lib.rs

@@ -165,14 +165,7 @@ struct State {
     core: CoreState,
     #[cfg(feature = "component-model")]
     component: ComponentState,
-    custom_section_place: Option<(&'static str, usize)>,
-    // `custom_section_place` stores the text representation of the location where
-    // a custom section should be serialized in the binary format.
-    // The tuple elements are a str (e.g. "after elem") and the line number
-    // where the custom section place was set. `update_custom_section_place` won't
-    // update the custom section place unless the line number changes; this prevents
-    // printing a place "after xxx" where the xxx section doesn't appear in the text format
-    // (e.g. because it was present but empty in the binary format).
+    custom_section_place: Option<&'static str>,
 }
 
 impl State {
@@ -485,8 +478,7 @@ impl Printer<'_, '_> {
                     match encoding {
                         Encoding::Module => {
                             states.push(State::new(Encoding::Module));
-                            states.last_mut().unwrap().custom_section_place =
-                                Some(("before first", self.line));
+                            states.last_mut().unwrap().custom_section_place = Some("before first");
                             if states.len() > 1 {
                                 self.start_group("core module")?;
                             } else {
@@ -546,7 +538,6 @@ impl Printer<'_, '_> {
                         self.result
                             .print_custom_section(c.name(), c.data_offset(), c.data())?;
                     if printed {
-                        self.update_custom_section_line(&mut states);
                         continue;
                     }
 
@@ -589,16 +580,19 @@ impl Printer<'_, '_> {
                         }
                     }
                     assert!(self.nesting == start);
-                    self.update_custom_section_line(&mut states);
                 }
                 Payload::TypeSection(s) => {
+                    if s.count() > 0 {
+                        self.update_custom_section_place(&mut states, "after type");
+                    }
                     self.print_types(states.last_mut().unwrap(), s)?;
-                    self.update_custom_section_place(&mut states, "after type");
                 }
                 Payload::ImportSection(s) => {
                     Self::ensure_module(&states)?;
+                    if s.count() > 0 {
+                        self.update_custom_section_place(&mut states, "after import");
+                    }
                     self.print_imports(states.last_mut().unwrap(), s)?;
-                    self.update_custom_section_place(&mut states, "after import");
                 }
                 Payload::FunctionSection(reader) => {
                     Self::ensure_module(&states)?;
@@ -609,35 +603,47 @@ impl Printer<'_, '_> {
                             MAX_WASM_FUNCTIONS
                         );
                     }
+                    if reader.count() > 0 {
+                        self.update_custom_section_place(&mut states, "after func");
+                    }
                     for ty in reader {
                         states.last_mut().unwrap().core.func_to_type.push(Some(ty?))
                     }
-                    self.update_custom_section_place(&mut states, "after func");
                 }
                 Payload::TableSection(s) => {
                     Self::ensure_module(&states)?;
+                    if s.count() > 0 {
+                        self.update_custom_section_place(&mut states, "after table");
+                    }
                     self.print_tables(states.last_mut().unwrap(), s)?;
-                    self.update_custom_section_place(&mut states, "after table");
                 }
                 Payload::MemorySection(s) => {
                     Self::ensure_module(&states)?;
+                    if s.count() > 0 {
+                        self.update_custom_section_place(&mut states, "after memory");
+                    }
                     self.print_memories(states.last_mut().unwrap(), s)?;
-                    self.update_custom_section_place(&mut states, "after memory");
                 }
                 Payload::TagSection(s) => {
                     Self::ensure_module(&states)?;
+                    if s.count() > 0 {
+                        self.update_custom_section_place(&mut states, "after tag");
+                    }
                     self.print_tags(states.last_mut().unwrap(), s)?;
-                    self.update_custom_section_place(&mut states, "after tag");
                 }
                 Payload::GlobalSection(s) => {
                     Self::ensure_module(&states)?;
+                    if s.count() > 0 {
+                        self.update_custom_section_place(&mut states, "after global");
+                    }
                     self.print_globals(states.last_mut().unwrap(), s)?;
-                    self.update_custom_section_place(&mut states, "after global");
                 }
                 Payload::ExportSection(s) => {
                     Self::ensure_module(&states)?;
+                    if s.count() > 0 {
+                        self.update_custom_section_place(&mut states, "after export");
+                    }
                     self.print_exports(states.last().unwrap(), s)?;
-                    self.update_custom_section_place(&mut states, "after export");
                 }
                 Payload::StartSection { func, range } => {
                     Self::ensure_module(&states)?;
@@ -649,8 +655,10 @@ impl Printer<'_, '_> {
                 }
                 Payload::ElementSection(s) => {
                     Self::ensure_module(&states)?;
+                    if s.count() > 0 {
+                        self.update_custom_section_place(&mut states, "after elem");
+                    }
                     self.print_elems(states.last_mut().unwrap(), s)?;
-                    self.update_custom_section_place(&mut states, "after elem");
                 }
                 Payload::CodeSectionStart { .. } => {
                     Self::ensure_module(&states)?;
@@ -669,8 +677,10 @@ impl Printer<'_, '_> {
                 }
                 Payload::DataSection(s) => {
                     Self::ensure_module(&states)?;
+                    if s.count() > 0 {
+                        self.update_custom_section_place(&mut states, "after data");
+                    }
                     self.print_data(states.last_mut().unwrap(), s)?;
-                    self.update_custom_section_place(&mut states, "after data");
                 }
 
                 #[cfg(feature = "component-model")]
@@ -774,19 +784,8 @@ impl Printer<'_, '_> {
 
     fn update_custom_section_place(&self, states: &mut Vec<State>, place: &'static str) {
         if let Some(last) = states.last_mut() {
-            if let Some((prev, prev_line)) = &mut last.custom_section_place {
-                if *prev_line != self.line {
-                    *prev = place;
-                    *prev_line = self.line;
-                }
-            }
-        }
-    }
-
-    fn update_custom_section_line(&self, states: &mut Vec<State>) {
-        if let Some(last) = states.last_mut() {
-            if let Some((_, prev_line)) = &mut last.custom_section_place {
-                *prev_line = self.line;
+            if let Some(prev) = &mut last.custom_section_place {
+                *prev = place;
             }
         }
     }
@@ -1997,7 +1996,7 @@ impl Printer<'_, '_> {
         self.newline(section.range().start)?;
         self.start_group("@custom ")?;
         self.print_str(section.name())?;
-        if let Some((place, _)) = state.custom_section_place {
+        if let Some(place) = state.custom_section_place {
             write!(self.result, " ({place})")?;
         }
         self.result.write_str(" ")?;

crates/wast/src/core/binary.rs

@@ -188,10 +188,10 @@ pub(crate) fn encode(
 
     e.typed_section(&data);
 
+    e.custom_sections(AfterLast);
     if !names.is_empty() {
         e.wasm.section(&names.to_name_section());
     }
-    e.custom_sections(AfterLast);
     if let Some(dwarf) = &mut dwarf {
         dwarf.emit(&mut e);
     }

crates/wast/src/core/expr.rs

@@ -383,10 +383,16 @@ impl<'a> ExpressionParser<'a> {
             _ => return Err(parser.error("invalid value for branch hint")),
         };
 
-        self.branch_hints.push(BranchHint {
-            instr_index: self.raw_instrs.len(),
-            value,
-        });
+        let instr_index = self.raw_instrs.len();
+        if let Some(prev) = self.branch_hints.last() {
+            if prev.instr_index == instr_index {
+                return Err(
+                    parser.error("@metadata.code.branch_hint annotation: duplicate annotation")
+                );
+            }
+        }
+
+        self.branch_hints.push(BranchHint { instr_index, value });
         Ok(())
     }
 

crates/wast/src/lib.rs

@@ -396,7 +396,9 @@ pub mod kw {
     custom_keyword!(assert_exception);
     custom_keyword!(assert_exhaustion);
     custom_keyword!(assert_invalid);
+    custom_keyword!(assert_invalid_custom);
     custom_keyword!(assert_malformed);
+    custom_keyword!(assert_malformed_custom);
     custom_keyword!(assert_return);
     custom_keyword!(assert_trap);
     custom_keyword!(assert_unlinkable);

crates/wast/src/wast.rs

@@ -94,6 +94,13 @@ pub enum WastDirective<'a> {
         message: &'a str,
     },
 
+    /// Asserts the module has an invalid custom section.
+    AssertInvalidCustom {
+        span: Span,
+        module: QuoteWat<'a>,
+        message: &'a str,
+    },
+
     /// Registers the `module` instance with the given `name` to be available
     /// for importing in future module instances.
     Register {
@@ -149,6 +156,13 @@ pub enum WastDirective<'a> {
 
     /// Waits for the specified thread to exit.
     Wait { span: Span, thread: Id<'a> },
+
+    /// Asserts that a custom section of `module` is malformed.
+    AssertMalformedCustom {
+        span: Span,
+        module: QuoteWat<'a>,
+        message: &'a str,
+    },
 }
 
 impl WastDirective<'_> {
@@ -163,12 +177,14 @@ impl WastDirective<'_> {
             | WastDirective::ModuleDefinition(QuoteWat::QuoteComponent(span, _)) => *span,
             WastDirective::ModuleInstance { span, .. }
             | WastDirective::AssertMalformed { span, .. }
+            | WastDirective::AssertMalformedCustom { span, .. }
             | WastDirective::Register { span, .. }
             | WastDirective::AssertTrap { span, .. }
             | WastDirective::AssertReturn { span, .. }
             | WastDirective::AssertExhaustion { span, .. }
             | WastDirective::AssertUnlinkable { span, .. }
             | WastDirective::AssertInvalid { span, .. }
+            | WastDirective::AssertInvalidCustom { span, .. }
             | WastDirective::AssertException { span, .. }
             | WastDirective::AssertSuspension { span, .. }
             | WastDirective::Wait { span, .. } => *span,
@@ -190,13 +206,27 @@ impl<'a> Parse<'a> for WastDirective<'a> {
                 module: parser.parens(|p| p.parse())?,
                 message: parser.parse()?,
             })
+        } else if l.peek::<kw::assert_malformed_custom>()? {
+            let span = parser.parse::<kw::assert_malformed_custom>()?.0;
+            Ok(WastDirective::AssertMalformedCustom {
+                span,
+                module: parser.parens(|p| p.parse())?,
+                message: parser.parse()?,
+            })
         } else if l.peek::<kw::assert_invalid>()? {
             let span = parser.parse::<kw::assert_invalid>()?.0;
             Ok(WastDirective::AssertInvalid {
                 span,
                 module: parser.parens(|p| p.parse())?,
                 message: parser.parse()?,
             })
+        } else if l.peek::<kw::assert_invalid_custom>()? {
+            let span = parser.parse::<kw::assert_invalid_custom>()?.0;
+            Ok(WastDirective::AssertInvalidCustom {
+                span,
+                module: parser.parens(|p| p.parse())?,
+                message: parser.parse()?,
+            })
         } else if l.peek::<kw::register>()? {
             let span = parser.parse::<kw::register>()?.0;
             Ok(WastDirective::Register {