Merge js-string-builtins into wasm-3.0 (#1943)

* Initial commit

* Initial setup and overview

* Update proposal

  * Adopts builtin modules approach
  * Adds section of polyfilling
  * Adds section on feature detection
  * Adds cast/test builtins
  * Adds future extension ideas for
    - binding memory
    - utf8/wtf8
    - evolving the type signatures

* Address review feedback

* Rename concatenate to concat

* Editorial changes

  - Eliminate usage of 'builtin module' in description. This is not essential to the proposal and
    causes confusion around a similarly named JS proposal, which had different goals.
  - Clarify some minor points.
  - Make JS-API changes to WebIDL comprehensive.
  - Reword feature detection section to actually propose change to WebAssembly.validate method

* Tighten up definitions of function builtins

  - Function builtin behaviors is defined using 'create a host function'
  - Clarify behavior around monkey patching using standard language
  - Clarify edge cases around nullability
  - Clarify edge cases around unsigned/signed integers
  - Restrict 'substring' behavior to normal cases
  - Use wasm helpers for when wasm instructions are needed

* Rework support for WTF-8

The existing WTF-8 operation in this proposal violated one of the goals of the
proposal: "don't create substantial new functionality" by introducing WTF-8
transcoding support to the web platform without prior precedent. The WTF-8
operation is removed because of this.

The naming for WTF-16 operations is reworked to refer to 'charCodes' instead
as that is what the JS String interface uses.

We could support UTF-8 transcoding by referring to the TextEncoder/TextDecoder
interfaces, so this commit adds support for that.

* Review comments

* Update substring range checking

* Fix mutability of array i8

Fixes #19.

* Add streaming-related functions

Fixes #19

* Clarify behavior of flags and function names

Fixes #17.

* Fix link to type-imports prposal in js-string-builtins/Overview.md

* Clarify feature detection scheme

Explain that users should validate modules that deliberately produce link errors to test for support for particular builtins.

* Add test for js-string-builtins

This commit adds a basic suite of tests for the js-string-builtins.

This is done by defining a polyfill module matching the overview,
and then comparing the host provided builtins against the polyfill
on representative inputs.

* Fix type signature of 'concat'

Fixes #24.

* Add section on string constants, including Struct.from

* Rework to use imported string constants idea

* Fixup typos

* Add missing start parameter to measureStringAsUTF8 overview

* Update Overview.md

* Many small improvements

- Syntax highlighting
- Added links
- Code font
- Consistency
- Grammer fixes

* Update proposals/js-string-builtins/Overview.md

* Fix nullability for string constants

* Expand section on string constants

* Revert unintentional change to builtins field

* Add note about empty imports object

* Initial outline of builtin support

* Expand specification of builtins

* Remove unneeded modification to embedding spec

* Initial string constants support

* Fix module constructor to handle options

* Don't freeze internal instantiation of builtins and string constants

* Move UTF-8 support to a future proposal

* Remove DS_Store

* Remove DS_Store

* Mark up options appropriately

* Make UnwrapString an abstract-op and use it to implement cast

* Consistently use "steps" instead of "algorithm" for builtins

* Add test

* Add stubs for the rest of the operations

* Add fromCharCode

* Switch to using the Call abstract op, and add fromCodePoint

* Add length

* Add charCodeAt and codePointAt

* Add concat

* Add substring

* Use angle quotes appropriately

* Add basic support for fromCharCodeArray

Needs more detail to properly integrate with GC array ops.

* Make fromCharCodeArray slightly less formal

This avoids having to refer to actual Wasm instructions,
since after all this is a host function.

* Add intoCharCodeArray

* Add equals and compare

* Review fixes for builtin steps

* Tweak wording for trapping in builtins

* Fix spec to separate builtin name used for imports and compile options

* Add note about patching the String builtins

* Add more tests

* Don't validate that every builtin set option is valid

* Fix null-handling for `equals` in test and polyfill

Equals specifically allows null inputs. Update the JS API tests
and the polyfill to match.

* Editorial: replace Type AO with new ECMA-262 type test convention

* actually remove Type

* support per-component polyfill fallbacks

* spec rework

* typo

* Editorial: Align with Web IDL specification

* [js-api] Fix incorrect return statement in 'validate builtin set names'

* [js-api] Remove copy-pasted if statements

* Revert changes to conf and README to prepare for merging

* [tests] Remove tentative from js-string tests

* Expand JS builtin functypes

* Add change history entry

* [js-api] Improve formatting

---------

Co-authored-by: Deepti Gandluri <dtig@users.noreply.github.com>
Co-authored-by: Martin Kustermann <kustermann@google.com>
Co-authored-by: Thomas Lively <tlively@google.com>
Co-authored-by: Ömer Sinan Ağacan <omeragacan@gmail.com>
Co-authored-by: Thomas Steiner <tomac@google.com>
Co-authored-by: Adam Klein <adamk@chromium.org>
Co-authored-by: Michael Ficarra <m.ficarra@f5.com>
Co-authored-by: Guy Bedford <guybedford@gmail.com>
Co-authored-by: autokagami <saschanaz+autokagami@outlook.com>

Author: 10 people

document/js-api/index.bs

@@ -88,25 +88,25 @@ additional APIs that are implemented by Web user agents but are outside the scop
 <pre class="idl">
 [Exposed=(Window,Worker)]
 partial namespace WebAssembly {
-  Promise&lt;Module> compileStreaming(Promise&lt;Response> source);
+  Promise&lt;Module> compileStreaming(Promise&lt;Response> source, optional WebAssemblyCompileOptions options);
   Promise&lt;WebAssemblyInstantiatedSource> instantiateStreaming(
-      Promise&lt;Response> source, optional object importObject);
+      Promise&lt;Response> source, optional object importObject, optional WebAssemblyCompileOptions options);
 };
 </pre>
 
 <div algorithm>
-The <dfn method for="WebAssembly">compileStreaming(|source|)</dfn> method, when invoked, returns the result of [=compile a potential WebAssembly response|compiling a potential WebAssembly response=] with |source|.
+The <dfn method for="WebAssembly">compileStreaming(|source|, |options|)</dfn> method, when invoked, returns the result of [=compile a potential WebAssembly response|compiling a potential WebAssembly response=] with |source| using |options|.
 </div>
 
 <div algorithm>
-The <dfn method for="WebAssembly">instantiateStreaming(|source|, |importObject|)</dfn> method, when invoked, performs the following steps:
+The <dfn method for="WebAssembly">instantiateStreaming(|source|, |importObject|, |options|)</dfn> method, when invoked, performs the following steps:
 
-    1. Let |promiseOfModule| be the result of [=compile a potential WebAssembly response|compiling a potential WebAssembly response=] with |source|.
+    1. Let |promiseOfModule| be the result of [=compile a potential WebAssembly response|compiling a potential WebAssembly response=] with |source| using |options|.
     1. Return the result of [=instantiate a promise of a module|instantiating the promise of a module=] |promiseOfModule| with imports |importObject|.
 </div>
 
 <div algorithm>
-To <dfn>compile a potential WebAssembly response</dfn> with a promise of a {{Response}} |source|, perform the following steps:
+To <dfn>compile a potential WebAssembly response</dfn> with a promise of a {{Response}} |source| and {{WebAssemblyCompileOptions}} |options|, perform the following steps:
 
 Note: This algorithm accepts a {{Response}} object, or a
     promise for one, and compiles and instantiates the resulting bytes of the response. This compilation
@@ -135,7 +135,7 @@ Note: This algorithm accepts a {{Response}} object, or a
 
         1. [=Upon fulfillment=] of |bodyPromise| with value |bodyArrayBuffer|:
             1. Let |stableBytes| be a [=get a copy of the buffer source|copy of the bytes held by the buffer=] |bodyArrayBuffer|.
-            1. [=Asynchronously compile a WebAssembly module|Asynchronously compile the WebAssembly module=] |stableBytes| using the [=networking task source=] and [=resolve=] |returnValue| with the result.
+            1. [=Asynchronously compile a WebAssembly module|Asynchronously compile the WebAssembly module=] |stableBytes| using the [=networking task source=] and |options| and [=resolve=] |returnValue| with the result.
         1. [=Upon rejection=] of |bodyPromise| with reason |reason|:
             1. [=Reject=] |returnValue| with |reason|.
      1. [=Upon rejection=] of |source| with reason |reason|: