Rename to version-suffix, tighten rules, add tests (#738)

Resolves #735

Author: lukewagner

design/mvp/Binary.md

@@ -407,7 +407,7 @@ nameattributes ::= 0x00 len:<u32> en:<externname>                       => "en"
                  | 0x01 len:<u32> en:<externname>                       => "en"                 (if len = |en|)
                  | 0x02 len:<u32> en:<externname> a*:vec(<attribute>)   => "en" a*              (if len = |en|) 🏷️/🔗
 attribute      ::= 0x00 len:<u32> in:<interfacename>                    => (implements "in")    (if len = |in|) 🏷️
-                 | 0x01 len:<u32> vs:<semversuffix>                     => (versionsuffix "vs") (if len = |vs|) 🔗
+                 | 0x01 len:<u32> s:<semversuffix>                      => (version-suffix "s") (if len = |vs|) 🔗
                  | 0x02 n:<name>                                        => (external-id n) 🏷️
 ```
 
@@ -469,11 +469,11 @@ Notes:
 * 📡 Validation of `[set]` names requires that the function have either no
   result type or a result type of `(result (error $E)?)` (with no value type).
 * 🔀/📡 Functions with `[get]` or `[set]` names must not be `async`.
-* 🔗 Validation requires that `versionsuffix` is preceded by an `interfaceversion`
-  matching `canonversion` and that the concatenation of the `canonversion` and
-  the `versionsuffix` results in a `valid semver` as defined by
-  [https://semver.org](https://semver.org/). A `versionsuffix` is otherwise
-  ignored for validation except to improve diagnostic messages.
+* 🔗 Validation requires that a `version-suffix` is only present on
+  `instance`-typed imports or exports that have either an `implements`
+  attribute or an `interfacename` name.
+* 🔗 Validation requires that every `interfacename` with an `interfaceversion`
+  satisfies the [canonical interface name] rules.
 
 ## 🪙 Value Definitions
 
@@ -600,6 +600,7 @@ named once.
 [`core:rectype]: https://webassembly.github.io/gc/core/binary/types.html#recursive-types
 
 [Strongly-unique]: Explainer.md#name-uniqueness
+[Canonical Interface Name]: Explainer.md#-canonical-interface-name
 
 [type-imports]: https://github.com/WebAssembly/proposal-type-imports/blob/master/proposals/type-imports/Overview.md
 [module-linking]: https://github.com/WebAssembly/module-linking/blob/main/proposals/module-linking/Explainer.md

design/mvp/Explainer.md

@@ -645,8 +645,8 @@ instancedecl  ::= core-prefix(<core:type>)
                 | <type>
                 | <alias>
                 | <exportdecl>
-importdecl    ::= (import <externnamelit> <attribute>* bind-id(<externtype>))
-exportdecl    ::= (export <externnamelit> <attribute>* bind-id(<externtype>))
+importdecl    ::= (import <externnamelit> <attributes> bind-id(<externtype>))
+exportdecl    ::= (export <externnamelit> <attributes> bind-id(<externtype>))
 externtype    ::= (<sort> (type <idx>) )
                 | core-prefix(<core:moduletype>)
                 | <functype>
@@ -1121,9 +1121,10 @@ and `$C1` is a subtype of `$C2`:
 )
 ```
 
-🏷️/🔗 Note that all `attribute`s on `import`s and `export`s are ignored by type
-checking and so any `external-id`, `implements` or `versionsuffix` attribute can
-be added to any of the `func`s above without changing the result.
+🏷️/🔗 Note that all `attributes` on `import`s and `export`s are ignored by type
+checking and so adding, removing or changing any `external-id` attribute on the
+`func`s above (or any `implements` or `version-suffix` attribute on `instance`
+imports or exports) does not change the result.
 
 When we next consider type imports and exports, there are two distinct
 subcases of `typebound` to consider: `eq` and `sub`.
@@ -2661,17 +2662,15 @@ exported (e.g., `(export $x "x" (func $f))` binds a new identifier `$x`).
 
 Given this, the syntax of imports and exports are defined as follows:
 ```ebnf
-import        ::= (import <externnamelit> <attribute>* bind-id(<externtype>))
-export        ::= (export <id>? <externnamelit> <attribute>* <externidx> <externtype>?)
-attribute     ::= <versionsuffix> 🔗
-                | <implements> 🏷️
-                | <externid> 🏷️
-versionsuffix ::= (versionsuffix <semversuffixlit>) 🔗
+import        ::= (import <externnamelit> <attributes> bind-id(<externtype>))
+export        ::= (export <id>? <externnamelit> <attributes> <externidx> <externtype>?)
+attributes    ::= <implements>? <versionsuffix>? <externid>?
 implements    ::= (implements <interfacenamelit>) 🏷️
+versionsuffix ::= (version-suffix <semversuffixlit>) 🔗
 externid      ::= (external-id <name>) 🏷️
 ```
 Imports and exports both have a *name* (`externnamelit`) and a list of
-*attributes* (`attribute*`). Imports always include a type (`externtype`).
+*attributes* (`attributes`). Imports always include a type (`externtype`).
 Exports always refer to a preceding definition (`externidx`) whose type is used
 by default as the type of the export. However, this "inferred" type can be
 overridden with an optional type ascription (`externtype`) which must be
@@ -2689,10 +2688,19 @@ and exports and instead provide extra semantic information *about* imports and
 exports that hosts or tools can automatically interpret to determine *how* to
 supply imports and call exports. In particular:
 
-🔗 The `versionsuffix` attribute provides the minor/patch/pre-release/build
-information that was stripped from the [Canonical interface name](#-canonical-interface-name)
-so that this information can be used in error messages to reconstruct the full
-original semantic version.
+🔗 The `version-suffix` attribute provides the minor/patch/build information that
+was stripped from the [Canonical interface name](#-canonical-interface-name) so
+that this information can be used in error messages to reconstruct the full
+original semantic version. A `version-suffix` may only be attached to an
+`instance` import or export and applies to the `interfacename` of the
+`implements` attribute, if present, and otherwise to the `interfacename` of the
+import or export itself. For example:
+```wat
+(component
+  (import "wasi:http/types@0.2" (version-suffix ".6") (instance ...))
+  (import "primary" (implements "wasi:keyvalue/store@0.2") (version-suffix ".1") (instance ...))
+)
+```
 
 🏷️ The `implements` attribute indicates that an imported or exported `instance`
 implements a particular WIT interface. This enables a component to semantically
@@ -2780,8 +2788,9 @@ canonversion      ::= [1-9] [0-9]* 🔗
                     | '0.' [1-9] [0-9]* 🔗
                     | '0.0.' [1-9] [0-9]* 🔗
                     | '0.0.0' 🔗
+                    | <version core> '-' <pre-release> 🔗
 semversuffixlit   ::= '"' <semversuffix> '"' 🔗
-semversuffix      ::= [0-9A-Za-z.+-]* 🔗
+semversuffix      ::= [0-9A-Za-z.+-]+ 🔗
 ```
 The names of component imports and exports provide two options:
 * a **plain name** that leaves it up to the developer to "read the docs"
@@ -2824,8 +2833,9 @@ annotations trigger additional type-validation rules (listed in detail in
   parameter from `[method]`) whose type matches the getter's return type, and
   must return either nothing or `(result (error <valtype>)?)`.
 
-The `valid semver` production is as defined by the [Semantic Versioning 2.0]
-spec and is meant to be interpreted according to that specification. The use of
+The `valid semver` production (along with its `version core` and `pre-release`
+sub-productions) is as defined by the [Semantic Versioning 2.0] spec and is
+meant to be interpreted according to that specification. The use of
 `valid semver` in `interfaceversion` is temporary for backward compatibility;
 see [Canonical interface name](#-canonical-interface-name) below (🔗).
 
@@ -2991,12 +3001,19 @@ the `<major>.<minor>.<patch>(-<pre>)(+<build>)` syntax of [Semantic Versioning
   - `0.0.1+sha.5114f85` &rarr; `0.0.1` / `+sha.5114f85`
 
 When a version is canonicalized, any `semversuffix` that was split off of the
-version should be preserved in the `versionsuffix` field of any resulting
-`import`s and `export`s. This gives component runtimes and other tools access to
-the original version for error messages, documentation, and other development
-purposes. Where a `versionsuffix` is present the preceding `interfacename` must
-have a `canonversion`, and the concatenation of the `canonversion` and
-`versionsuffix` must be a `valid semver`.
+version must be preserved in the `version-suffix` attribute of any resulting
+`import`s and `export`s to give component runtimes and other tools access to the
+original version for error messages, documentation, and other development
+purposes. Validation checks this by requiring that the `interfaceversion`
+concatenated with the `version-suffix` (if present) is a `valid semver` and that,
+when a `version-suffix` is present, canonicalizing the concatenated `valid semver`
+splits it into exactly the `interfaceversion` and the `version-suffix`. Thus,
+for example:
+- `a:b/c@1` is invalid (`1` is not a `valid semver`)
+- `a:b/c@1` with `.2.3` and `a:b/c@0.0.1-alpha` with `+sha` are valid
+- `a:b/c@1` with `.2.3-alpha` is invalid (`1.2.3-alpha` is not split)
+- `a:b/c@1.2` with `.3` and `a:b/c@1.2.3` with `+sha` are invalid (`1.2.3` and
+  `1.2.3+sha` are split after `1`)
 
 For compatibility with older versions of this spec, non-canonical
 `interfacename`s (with `interfaceversion`s matching any `valid semver`) are

test/README.md

@@ -6,12 +6,12 @@ This directory contains Component Model reference tests, grouped by functionalit
 
 A single `.wast` test can be run with full backtrace on trap via:
 ```
-WASMTIME_BACKTRACE_DETAILS=1 WAST_STRICT_COMPONENT_INDICES=1 wasmtime wast -W component-model-more-async-builtins -W component-model-threading -W component-model-async-stackful -W component-model-implements -W component-model-fixed-length-lists -W component-model-map the-test.wast
+WASMTIME_BACKTRACE_DETAILS=1 WAST_STRICT_COMPONENT_INDICES=1 wasmtime wast -W component-model-more-async-builtins -W component-model-threading -W component-model-async-stackful -W component-model-implements -W component-model-fixed-length-lists -W component-model-map -W component-model-canonical-names the-test.wast
 ```
 
 Sometimes test land ahead of the implementation and fail for a while. These
 tests are listed in 'nyi.txt' so that they can be filtered out. Thus, a simple
 way to run all the reference tests is:
 ```
-find . -name "*.wast" | grep -vxFf nyi.txt | WAST_STRICT_COMPONENT_INDICES=1 xargs wasmtime wast -W component-model-more-async-builtins -W component-model-threading -W component-model-async-stackful -W component-model-implements -W component-model-fixed-length-lists -W component-model-map
+find . -name "*.wast" | grep -vxFf nyi.txt | WAST_STRICT_COMPONENT_INDICES=1 xargs wasmtime wast -W component-model-more-async-builtins -W component-model-threading -W component-model-async-stackful -W component-model-implements -W component-model-fixed-length-lists -W component-model-map -W component-model-canonical-names
 ```

test/binary/binary.wast

@@ -1319,15 +1319,21 @@
   "\07\03"                                    ;; type section (3 bytes)
   "\01"                                       ;; 1 type
   "\42\00"                                    ;; empty instancetype
-  "\0a\2f"                                    ;; import section (47 bytes)
-  "\02"                                       ;; 2 imports
+  "\0a\41"                                    ;; import section (65 bytes)
+  "\03"                                       ;; 3 imports
   "\02"                                       ;; externname with attributes
   "\02i1"                                     ;; name "i1"
   "\01"                                       ;; 1 attribute:
   "\00"                                       ;; 0x00 implements:
   "\0cmy:dep/iface"                           ;; name "my:dep/iface"
   "\05\00"                                    ;; instance (type 0)
   "\02"                                       ;; externname with attributes
+  "\07a:b/c@1"                                ;; name "a:b/c@1"
+  "\01"                                       ;; 1 attribute:
+  "\01"                                       ;; 0x01 version-suffix:
+  "\04.2.3"                                   ;; ".2.3"
+  "\05\00"                                    ;; instance (type 0)
+  "\02"                                       ;; externname with attributes
   "\02i2"                                     ;; name "i2"
   "\01"                                       ;; 1 attribute:
   "\02"                                       ;; 0x02 external-id: