feat: add support for parsing async_sequence<T> type (#775)

* feat: add support for parsing `async iterable<T>` type

* it can be return type of operations

* Update to async_sequence

* Update README.md

* revert the unconsume caused by LL(1) violation

* revert usages of `async`

* remove async_sequence return

The grammar isn't wrong but it's not valid. It's covered in invalid/idl instead.

* update validation message

---------

Co-authored-by: Kagami Sascha Rosylight <[email protected]>

Author: lucacasonato

README.md

@@ -186,6 +186,7 @@ properties:
 * `sourceName`: the source name you passed to `parse()`.
 * `level`: `"error"` by default, can be `"warning"` for some validations for e.g. potential future deprecations.
 * `ruleName`: Only for validations. Currently the followings are supported:
+   * `async-iterable-idl-to-js`: `async_iterable` types cannot be returned from the IDL to JS.
    * `attr-invalid-type`: Attributes cannot have sequences, records, nor dictionaries.
    * `dict-arg-default`: Optional dictionary type arguments must have a default value of `{}`.
    * `dict-arg-optional`: Dictionary type arguments must be optional if the type does not include a required field.
@@ -236,7 +237,7 @@ attached to a field called `idlType`:
 Where the fields are as follows:
 
 * `type`: String indicating where this type is used. Can be `null` if not applicable.
-* `generic`: String indicating the generic type (e.g. "Promise", "sequence").
+* `generic`: String indicating the generic type (e.g. "Promise", "sequence", "async_sequence").
 * `idlType`: String indicating the type name, or array of subtypes if the type is
   generic or a union.
 * `nullable`: `true` if the type is nullable.

lib/productions/attribute.js

@@ -75,7 +75,9 @@ export class Attribute extends Base {
     yield* this.extAttrs.validate(defs);
     yield* this.idlType.validate(defs);
 
-    if (["sequence", "record"].includes(this.idlType.generic)) {
+    if (
+      ["async_sequence", "sequence", "record"].includes(this.idlType.generic)
+    ) {
       const message = `Attributes cannot accept ${this.idlType.generic} types.`;
       yield validationError(
         this.tokens.name,

lib/productions/callback.js

@@ -5,6 +5,7 @@ import {
   unescape,
   autoParenter,
 } from "./helpers.js";
+import { validationError } from "../error.js";
 
 export class CallbackFunction extends Base {
   /**
@@ -44,6 +45,18 @@ export class CallbackFunction extends Base {
 
   *validate(defs) {
     yield* this.extAttrs.validate(defs);
+    for (const arg of this.arguments) {
+      yield* arg.validate(defs);
+      if (arg.idlType.generic === "async_sequence") {
+        const message = `async_sequence types cannot be returned as a callback argument.`;
+        yield validationError(
+          arg.tokens.name,
+          arg,
+          "async-sequence-idl-to-js",
+          message,
+        );
+      }
+    }
     yield* this.idlType.validate(defs);
   }
 

lib/productions/operation.js

@@ -68,6 +68,15 @@ export class Operation extends Base {
       yield validationError(this.tokens.open, this, "incomplete-op", message);
     }
     if (this.idlType) {
+      if (this.idlType.generic === "async_sequence") {
+        const message = `async_sequence types cannot be returned by an operation.`;
+        yield validationError(
+          this.idlType.tokens.base,
+          this,
+          "async-sequence-idl-to-js",
+          message,
+        );
+      }
       yield* this.idlType.validate(defs);
     }
     for (const argument of this.arguments) {

lib/productions/type.js

@@ -20,6 +20,7 @@ function generic_type(tokeniser, typeName) {
     "FrozenArray",
     "ObservableArray",
     "Promise",
+    "async_sequence",
     "sequence",
     "record",
   );
@@ -42,6 +43,7 @@ function generic_type(tokeniser, typeName) {
       ret.subtype.push(subtype);
       break;
     }
+    case "async_sequence":
     case "sequence":
     case "FrozenArray":
     case "ObservableArray": {

lib/tokeniser.js

@@ -73,6 +73,7 @@ const nonRegexTerminals = [
   "ObservableArray",
   "Promise",
   "async_iterable",
+  "async_sequence",
   "bigint",
   "boolean",
   "byte",

test/invalid/baseline/async-sequence-const.txt

@@ -0,0 +1,3 @@
+Syntax error at line 3 in async-sequence-const.webidl, since `interface AsyncSequence`:
+  const async_sequence<long, short
+        ^ Const lacks a type

test/invalid/baseline/async-sequence-idl-to-js.txt

@@ -0,0 +1,9 @@
+(attr-invalid-type) Validation error at line 3 in async-sequence-idl-to-js.webidl, inside `interface asyncIterableAsAttribute -> attribute invalid`:
+  attribute async_sequence<short> invalid;
+                                  ^ Attributes cannot accept async_sequence types.
+(async-sequence-idl-to-js) Validation error at line 5 in async-sequence-idl-to-js.webidl, inside `interface asyncIterableAsAttribute -> operation invalidOp`:
+  async_sequence<DOMString> invalidOp
+  ^ async_sequence types cannot be returned by an operation.
+(async-sequence-idl-to-js) Validation error at line 8 in async-sequence-idl-to-js.webidl, inside `callback DoSomething -> argument bool`:
+ (async_sequence<DOMString> bool);
+                            ^ async_sequence types cannot be returned as a callback argument.

test/invalid/baseline/async-sequence-two-params.txt

@@ -0,0 +1,3 @@
+Syntax error at line 3 in async-sequence-two-params.webidl, since `interface AsyncSequence`:
+  async_sequence<long, short> foo(
+                     ^ Missing closing bracket after async_sequence

test/invalid/idl/async-sequence-const.webidl

@@ -0,0 +1,4 @@
+[Exposed=Window]
+interface AsyncSequence {
+  const async_sequence<long, short>  ASYNC_SEQUENCE = 0;
+};