Fix reference to <core:name> to be <core:text> (because this is the text format, not the AST)

Author: lukewagner

design/mvp/Explainer.md

@@ -236,8 +236,8 @@ The syntax for defining a core module instance is:
 core:instance       ::= (instance <id>? <core:instancexpr>)
 core:instanceexpr   ::= (instantiate <core:moduleidx> <core:instantiatearg>*)
                       | <core:inlineexport>*
-core:instantiatearg ::= (with <core:name> (instance <core:instanceidx>))
-                      | (with <core:name> (instance <core:inlineexport>*))
+core:instantiatearg ::= (with <core:string> (instance <core:instanceidx>))
+                      | (with <core:string> (instance <core:inlineexport>*))
 core:sortidx        ::= (<core:sort> <u32>)
 core:sort           ::= func
                       | table
@@ -247,17 +247,18 @@ core:sort           ::= func
                       | type
                       | module
                       | instance
-core:inlineexport   ::= (export <core:name> <core:sortidx>)
-```
-When instantiating a module via `instantiate`, the two-level imports of the
-core modules are resolved as follows:
-1. The first `core:name` of the import is looked up in the named list of
-   `core:instantiatearg` to select a core module instance. (In the future,
-   other `core:sort`s could be allowed if core wasm adds single-level
-   imports.)
-2. The second `core:name` of the import is looked up in the named list of
-   exports of the core module instance found by the first step to select the
-   imported core definition.
+core:inlineexport   ::= (export <core:string> <core:sortidx>)
+```
+where [`core:string`] is the WebAssembly text format's quoted string literal.
+
+When instantiating a module via `instantiate`, the two-level imports of the core
+modules are resolved as follows:
+1. The first import name is looked up in the named list of `core:instantiatearg`
+   to select a core module instance. (In the future, other `core:sort`s could be
+   allowed if core wasm adds single-level imports.)
+2. The second import name is looked up in the named list of exports of the core
+   module instance found by the first step to select the imported core
+   definition.
 
 Each `core:sort` corresponds 1:1 with a distinct [index space] that contains
 only core definitions of that *sort*. The `u32` field of `core:sortidx`
@@ -294,9 +295,9 @@ instances, but with an expanded component-level definition of `sort`:
 instance       ::= (instance <id>? <instanceexpr>)
 instanceexpr   ::= (instantiate <componentidx> <instantiatearg>*)
                  | <inlineexport>*
-instantiatearg ::= (with <name> <sortidx>)
-                 | (with <name> (instance <inlineexport>*))
-name           ::= <core:name>
+instantiatearg ::= (with <string> <sortidx>)
+                 | (with <string> (instance <inlineexport>*))
+string         ::= <core:string>
 sortidx        ::= (<sort> <u32>)
 sort           ::= core <core:sort>
                  | func
@@ -316,9 +317,9 @@ future include `data`). Thus, component-level `sort` injects the full set
 of `core:sort`, so that they may be referenced (leaving it up to validation
 rules to throw out the core sorts that aren't allowed in various contexts).
 
-The `name` production reuses the `core:name` quoted-string-literal syntax of
-Core WebAssembly (which appears in core module imports and exports and can
-contain any valid UTF-8 string).
+Component-level `string` literals reuse the Core WebAssembly text format's
+quoted-string-literal syntax which includes literals such as `"a"`, `"☃︎"`,
+`"\7f"` and `"\u{7fff}"`.
 
 🪙 The `value` sort refers to a value that is provided and consumed during
 instantiation. How this works is described in the
@@ -338,14 +339,14 @@ instance, the `core export` of a core module instance and a definition of an
 `outer` component (containing the current component):
 ```ebnf
 alias            ::= (alias <aliastarget> (<sort> <id>?))
-aliastarget      ::= export <instanceidx> <name>
-                   | core export <core:instanceidx> <core:name>
+aliastarget      ::= export <instanceidx> <string>
+                   | core export <core:instanceidx> <core:string>
                    | outer <u32> <u32>
 ```
 If present, the `id` of the alias is bound to the new index added by the alias
 and can be used anywhere a normal `id` can be used.
 
-In the case of `export` aliases, validation ensures `name` is an export in the
+In the case of `export` aliases, validation ensures `string` is an export in the
 target instance and has a matching sort.
 
 In the case of `outer` aliases, the `u32` pair serves as a [de Bruijn index],
@@ -395,7 +396,7 @@ sortidx     ::= (<sort> <u32>)          ;; as above
               | <inlinealias>
 Xidx        ::= <u32>                   ;; as above
               | <inlinealias>
-inlinealias ::= (<sort> <u32> <name>+)
+inlinealias ::= (<sort> <u32> <string>+)
 ```
 If `<sort>` refers to a `<core:sort>`, then the `<u32>` of `inlinealias` is a
 `<core:instanceidx>`; otherwise it's an `<instanceidx>`. For example, the
@@ -493,8 +494,8 @@ core:moduledecl  ::= <core:importdecl>
                    | <core:exportdecl>
 core:alias       ::= (alias <core:aliastarget> (<core:sort> <id>?))
 core:aliastarget ::= outer <u32> <u32>
-core:importdecl  ::= (import <core:name> <core:name> <core:importdesc>)
-core:exportdecl  ::= (export <core:name> <core:exportdesc>)
+core:importdecl  ::= (import <core:string> <core:string> <core:importdesc>)
+core:exportdecl  ::= (export <core:string> <core:exportdesc>)
 core:exportdesc  ::= strip-id(<core:importdesc>)
 
 where strip-id(X) parses '(' sort Y ')' when X parses '(' sort <id>? Y ')'
@@ -2350,7 +2351,7 @@ val      ::= false | true
            | <f64canon>
            | nan
            | '<core:stringchar>'
-           | <core:name>
+           | <core:string>
            | (record <val>+)
            | (variant "<label>" <val>?)
            | (list <val>*)
@@ -3237,7 +3238,7 @@ For some use-case-focused, worked examples, see:
 [`core:i64`]: https://webassembly.github.io/spec/core/text/values.html#text-int
 [`core:f64`]: https://webassembly.github.io/spec/core/syntax/values.html#floating-point
 [`core:stringchar`]: https://webassembly.github.io/spec/core/text/values.html#text-string
-[`core:name`]: https://webassembly.github.io/spec/core/syntax/values.html#syntax-name
+[`core:string`]: https://webassembly.github.io/spec/core/text/values.html#text-string
 [`core:module`]: https://webassembly.github.io/spec/core/text/modules.html#text-module
 [`core:type`]: https://webassembly.github.io/spec/core/text/modules.html#types
 [`core:importdesc`]: https://webassembly.github.io/spec/core/text/modules.html#text-importdesc

design/mvp/WIT.md

@@ -1748,10 +1748,9 @@ resource blob;
 %[method]blob.read: func(self: borrow<blob>, n: u32) -> list<u8>;
 %[static]blob.merge: func(lhs: borrow<blob>, rhs: borrow<blob>) -> blob;
 ```
-These `%`-prefixed [`name`s](Explainer.md) embed the resource type name so that
-bindings generators can generate idiomatic syntax for the target language or
-(for languages like C) fall back to an appropriately-prefixed free function
-name.
+These `%`-prefixed strings embed the resource type name so that bindings
+generators can generate idiomatic syntax for the target language or (for
+languages like C) fall back to an appropriately-prefixed free function name.
 
 When a resource type name is used directly (e.g. when `blob` is used as the
 return value of the constructor above), it stands for an "owning" handle
@@ -1910,8 +1909,7 @@ is expanded into:
 resource file
 %[method]file.read: func(self: borrow<file>, n: u32) -> list<u8>;
 ```
-where `%[method]file.read` is the desugared name of a method according to the
-Component Model's definition of [`name`](Explainer.md).
+where `%[method]file.read` is the desugared name of a method.
 
 
 ## Name resolution