Add @external-id

Author: lukewagner

design/mvp/Binary.md

@@ -391,14 +391,15 @@ in the explainer.)
 ```ebnf
 import         ::= in:<importname'> ed:<externdesc>                     => (import in ed)
 export         ::= en:<exportname'> si:<sortidx> ed?:<externdesc>?      => (export en si ed?)
-importname'    ::= 0x00 len:<u32> in:<importname>                       => in      (if len = |in|)
-                 | 0x01 len:<u32> in:<importname>                       => in      (if len = |in|)
-                 | 0x02 len:<u32> in:<importname> opts:vec(<nameopt>)   => in opts (if len = |in|) 🏷️/🔗
-exportname'    ::= 0x00 len:<u32> in:<exportname>                       => in      (if len = |in|)
-                 | 0x01 len:<u32> in:<exportname>                       => in      (if len = |in|)
-                 | 0x02 len:<u32> in:<importname> opts:vec(<nameopt>)   => in opts (if len = |in|) 🏷️/🔗
-nameopt        ::= 0x00 len:<u32> n:<interfacename>                     => (implements i) 🏷️
-                 | 0x01 len:<u32> vs:<semversuffix>                     => (versionsuffix vs) 🔗
+importname'    ::= 0x00 len:<u32> in:<importname>                       => in                 (if len = |in|)
+                 | 0x01 len:<u32> in:<importname>                       => in                 (if len = |in|)
+                 | 0x02 len:<u32> in:<importname> at*:vec(<attribute>)  => in at*             (if len = |in|) 🏷️/🔗
+exportname'    ::= 0x00 len:<u32> en:<exportname>                       => en                 (if len = |en|)
+                 | 0x01 len:<u32> en:<exportname>                       => en                 (if len = |en|)
+                 | 0x02 len:<u32> en:<importname> at*:vec(<attribute>)  => en at*             (if len = |en|) 🏷️/🔗
+attribute      ::= 0x00 len:<u32> in:<interfacename>                    => (implements in)    (if len = |in|) 🏷️
+                 | 0x01 len:<u32> vs:<semversuffix>                     => (versionsuffix vs) (if len = |vs|) 🔗
+                 | 0x02 n:<name>                                        => (externalid n) 🏷️
 ```
 
 Notes:
@@ -422,9 +423,12 @@ Notes:
   preceding `resource` import or export, respectively, in the same scope
   (component, component type or instance type).
 * 🏷️ Validation requires that `implements`-annotated imports or exports are
-  `instance`-typed.
-* 🏷️ Validation requires that `implements`-annotated imports or exports have a
-  `<plainname>` name.
+  `instance`-typed and have a `<plainname>` name.
+* 🏷️/🔗 Validation requires that a `vec(<attribute>)` contains each kind of
+  `attribute` at most once.
+* 🏷️/🔗 Even though `componenttype` and `instancetype` structurally contain a
+  `vec(<attribute>)`, this list is entirely ignored when validating the types
+  of components and instances.
 * Validation of `[constructor]` names requires a `func` type whose result type
   is either `(own $R)` or `(result (own $R) E?)` where `$R` is a resource type
   labeled `r`.

design/mvp/Explainer.md

@@ -2549,11 +2549,14 @@ 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 "<importname>" bind-id(<externdesc>))
-                | (import "<importname>" <versionsuffix> bind-id(<externdesc>)) 🔗
-export        ::= (export <id>? "<exportname>" <sortidx> <externdesc>?)
-                | (export <id>? "<exportname>" <versionsuffix> <sortidx> <externdesc>?) 🔗
+import        ::= (import "<importname>" <attribute>* bind-id(<externdesc>))
+export        ::= (export <id>? "<exportname>" <attribute>* <sortidx> <externdesc>?)
+attribute     ::= <versionsuffix> 🔗
+                | <implements> 🏷️
+                | <externalid> 🏷️
 versionsuffix ::= (versionsuffix "<semversuffix>") 🔗
+implements    ::= (implements "<interfacename>") 🏷️
+externalid    ::= (external-id <name>) 🏷️
 ```
 
 All import names must be [strongly-unique]. Separately, all export

design/mvp/WIT.md

@@ -1011,6 +1011,7 @@ token ::= whitespace
         | keyword
         | integer
         | identifier
+        | string
 ```
 
 Whitespace and comments are ignored when parsing structures defined elsewhere
@@ -1107,6 +1108,14 @@ sequence of digits:
 integer ::= [0-9]+
 ```
 
+### Strings
+
+WIT string literals use the same text format as the Core WebAssembly text
+format's [`string`] literal, which is a quoted sequence of Unicode Scalar Values
+like `"a"`, `"☃︎"`, `"\7f"` and `"\u{7fff}"`.
+
+[`string`]: https://webassembly.github.io/spec/core/text/values.html#text-string
+
 ## Top-level items
 
 A `wit` document is a sequence of items specified at the top level. These items
@@ -1422,22 +1431,36 @@ world-item ::= gate 'world' id '{' world-items* '}'
 
 world-items ::= gate world-definition
 
-world-definition ::= export-item
-                   | import-item
+world-definition ::= external-id? export-item
+                   | external-id? import-item
                    | use-item
                    | typedef-item
                    | include-item
 
-export-item ::= 'export' id ':' extern-type
+export-item ::= external-id? 'export' id ':' extern-type
               | 'export' use-path ';'
-import-item ::= 'import' id ':' extern-type
+import-item ::= external-id? 'import' id ':' extern-type
               | 'import' use-path ';'
 
+external-id ::= '@external-id' '(' string ')' 🏷️
+
 extern-type ::= func-type ';'
               | 'interface' '{' interface-items* '}'
               | use-path ';' 🏷️
 ```
 
+🏷️ The optional `external-id` attribute allows ... For example:
+
+```wit
+world my-world {
+  @external-id("foo/0")
+  import foo: func() -> string;
+
+  @external-id("HOME_DIRECTORY")
+  import bar: func() -> string;
+}
+```
+
 🏷️ The third case of `extern-type` allows a named interface to be imported or
 exported with a custom [plain name]. For example:
 
@@ -1449,6 +1472,18 @@ world my-world {
 }
 ```
 
+When using both together ... For example:
+
+```wit
+world my-world {
+    @external-id("asdf")
+    import primary: wasi:keyvalue/store;
+
+    @external-id("asdf")
+    import secondary: wasi:keyvalue/store;
+}
+```
+
 Here, `primary` and `secondary` are two distinct imports that both have the
 instance type of the `wasi:keyvalue/store` interface. The plain name of the
 import is the `id` before the colon (e.g., `primary`), not the interface name.
@@ -1510,9 +1545,9 @@ interface-item ::= gate 'interface' id '{' interface-items* '}'
 
 interface-items ::= gate interface-definition
 
-interface-definition ::= typedef-item
-                       | use-item
-                       | func-item
+interface-definition ::= use-item
+                       | external-id? typedef-item
+                       | external-id? func-item
 
 typedef-item ::= resource-item
                | variant-items
@@ -1536,6 +1571,22 @@ named-type-list ::= ϵ
 named-type ::= id ':' ty
 ```
 
+🏷️ The optional `external-id` attribute allows ... For example:
+
+```wit
+interface my-interface {
+  @external-id("foo/0")
+  foo: func() -> string;
+
+  @external-id("GlobalScope.Bar")
+  resource bar {
+    @external-id("Bar.Baz/1")
+    baz: func() -> string;
+  }
+}
+```
+
+
 The optional `async` prefix in a WIT function type indicates that the callee
 may block and thus the caller should use the async ABI and asynchronous
 source-language bindings (e.g., `async` functions in JS, Python, C# or Rust) if
@@ -2164,6 +2215,7 @@ annotation defined in [Explainer.md](Explainer.md#import-and-export-definitions)
 interface the instance implements. Note though that each copy implements a
 unique version of the interface in question. For example, the following WIT:
 
+TODO: extend
 ```wit
 package local:demo;