Emit iterable arguments for ES2015+ (#699)

* fix compiler error

* emit iterable arguments

* apply renamings

Author: saschanaz

baselines/dom.iterable.generated.d.ts

@@ -2,13 +2,22 @@
 /// DOM Iterable APIs
 /////////////////////////////
 
+interface AudioParam {
+    setValueCurveAtTime(values: Iterable<number>, startTime: number, duration: number): AudioParam;
+}
+
 interface AudioParamMap extends ReadonlyMap<string, AudioParam> {
 }
 
 interface AudioTrackList {
     [Symbol.iterator](): IterableIterator<AudioTrack>;
 }
 
+interface BaseAudioContext {
+    createIIRFilter(feedforward: Iterable<number>, feedback: Iterable<number>): IIRFilterNode;
+    createPeriodicWave(real: Iterable<number>, imag: Iterable<number>, constraints?: PeriodicWaveConstraints): PeriodicWave;
+}
+
 interface CSSRuleList {
     [Symbol.iterator](): IterableIterator<CSSRule>;
 }
@@ -17,6 +26,14 @@ interface CSSStyleDeclaration {
     [Symbol.iterator](): IterableIterator<string>;
 }
 
+interface Cache {
+    addAll(requests: Iterable<RequestInfo>): Promise<void>;
+}
+
+interface CanvasPathDrawingStyles {
+    setLineDash(segments: Iterable<number>): void;
+}
+
 interface ClientRectList {
     [Symbol.iterator](): IterableIterator<ClientRect>;
 }
@@ -96,6 +113,15 @@ interface Headers {
     values(): IterableIterator<string>;
 }
 
+interface IDBObjectStore {
+    /**
+     * Creates a new index in store with the given name, keyPath and options and returns a new IDBIndex. If the keyPath and options define constraints that cannot be satisfied with the data already in store the upgrade transaction will abort with a "ConstraintError" DOMException.
+     * 
+     * Throws an "InvalidStateError" DOMException if not called within an upgrade transaction.
+     */
+    createIndex(name: string, keyPath: string | Iterable<string>, options?: IDBIndexParameters): IDBIndex;
+}
+
 interface MediaKeyStatusMap {
     [Symbol.iterator](): IterableIterator<[BufferSource, MediaKeyStatus]>;
     entries(): IterableIterator<[BufferSource, MediaKeyStatus]>;
@@ -115,6 +141,10 @@ interface NamedNodeMap {
     [Symbol.iterator](): IterableIterator<Attr>;
 }
 
+interface Navigator {
+    requestMediaKeySystemAccess(keySystem: string, supportedConfigurations: Iterable<MediaKeySystemConfiguration>): Promise<MediaKeySystemAccess>;
+}
+
 interface NodeList {
     [Symbol.iterator](): IterableIterator<Node>;
     /**
@@ -155,6 +185,10 @@ interface PluginArray {
     [Symbol.iterator](): IterableIterator<Plugin>;
 }
 
+interface RTCRtpTransceiver {
+    setCodecPreferences(codecs: Iterable<RTCRtpCodecCapability>): void;
+}
+
 interface RTCStatsReport extends ReadonlyMap<string, any> {
 }
 
@@ -222,6 +256,36 @@ interface URLSearchParams {
     values(): IterableIterator<string>;
 }
 
+interface VRDisplay {
+    requestPresent(layers: Iterable<VRLayer>): Promise<void>;
+}
+
 interface VideoTrackList {
     [Symbol.iterator](): IterableIterator<VideoTrack>;
 }
+
+interface WEBGL_draw_buffers {
+    drawBuffersWEBGL(buffers: Iterable<GLenum>): void;
+}
+
+interface WebAuthentication {
+    makeCredential(accountInformation: Account, cryptoParameters: Iterable<ScopedCredentialParameters>, attestationChallenge: Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | ArrayBuffer | null, options?: ScopedCredentialOptions): Promise<ScopedCredentialInfo>;
+}
+
+interface WebGLRenderingContextBase {
+    uniform1fv(location: WebGLUniformLocation | null, v: Iterable<GLfloat>): void;
+    uniform2fv(location: WebGLUniformLocation | null, v: Iterable<GLfloat>): void;
+    uniform3fv(location: WebGLUniformLocation | null, v: Iterable<GLfloat>): void;
+    uniform4fv(location: WebGLUniformLocation | null, v: Iterable<GLfloat>): void;
+    uniform1iv(location: WebGLUniformLocation | null, v: Iterable<GLint>): void;
+    uniform2iv(location: WebGLUniformLocation | null, v: Iterable<GLint>): void;
+    uniform3iv(location: WebGLUniformLocation | null, v: Iterable<GLint>): void;
+    uniform4iv(location: WebGLUniformLocation | null, v: Iterable<GLint>): void;
+    uniformMatrix2fv(location: WebGLUniformLocation | null, transpose: GLboolean, value: Iterable<GLfloat>): void;
+    uniformMatrix3fv(location: WebGLUniformLocation | null, transpose: GLboolean, value: Iterable<GLfloat>): void;
+    uniformMatrix4fv(location: WebGLUniformLocation | null, transpose: GLboolean, value: Iterable<GLfloat>): void;
+    vertexAttrib1fv(index: GLuint, values: Iterable<GLfloat>): void;
+    vertexAttrib2fv(index: GLuint, values: Iterable<GLfloat>): void;
+    vertexAttrib3fv(index: GLuint, values: Iterable<GLfloat>): void;
+    vertexAttrib4fv(index: GLuint, values: Iterable<GLfloat>): void;
+}

src/emitter.ts

@@ -325,6 +325,9 @@ export function emitWebIdl(webidl: Browser.WebIdl, flavor: Flavor) {
     }
 
     function convertDomTypeToTsTypeSimple(objDomType: string): string {
+        if (objDomType === "sequence" && flavor === Flavor.ES6Iterators) {
+            return "Iterable";
+        }
         if (baseTypeConversionMap.has(objDomType)) {
             return baseTypeConversionMap.get(objDomType)!;
         }
@@ -1207,8 +1210,8 @@ export function emitWebIdl(webidl: Browser.WebIdl, flavor: Flavor) {
             });
         }
 
-        function getIteratorExtends(iterator: Browser.Iterator | undefined, subtypes: string[]) {
-            if (!iterator) {
+        function getIteratorExtends(iterator?: Browser.Iterator, subtypes?: string[]) {
+            if (!iterator || !subtypes) {
                 return "";
             }
             const base = iterator.kind === "maplike" ? `Map<${subtypes[0]}, ${subtypes[1]}>` :
@@ -1220,17 +1223,60 @@ export function emitWebIdl(webidl: Browser.WebIdl, flavor: Flavor) {
             return `extends ${result} `;
         }
 
+        function hasSequenceArgument(s: Browser.Signature) {
+            function typeIncludesSequence(type: string | Browser.Typed[]): boolean {
+                if (Array.isArray(type)) {
+                    return type.some(t => typeIncludesSequence(t.type))
+                }
+                return type === "sequence" || !!sequenceTypedefMap[type];
+            }
+            return !!s.param && s.param.some(p => typeIncludesSequence(p.type));
+        }
+
+        function replaceTypedefsInSignatures(signatures: Browser.Signature[]): Browser.Signature[] {
+            return signatures.map(s => {
+                const params = s.param!.map(p => {
+                    const typedef = typeof p.type === "string" ? sequenceTypedefMap[p.type] : undefined;
+                    if (!typedef) {
+                        return p;
+                    }
+                    return { ...p, type: typedef.type };
+                })
+                return { ...s, param: params };
+            });
+        }
+
+        const sequenceTypedefs = !webidl.typedefs ? [] :
+            webidl.typedefs.typedef
+                .filter(typedef => Array.isArray(typedef.type))
+                .map(typedef => ({ ...typedef, type: (typedef.type as Browser.Typed[]).filter(t => t.type === "sequence") }))
+                .filter(typedef => typedef.type.length)
+        const sequenceTypedefMap = arrayToMap(sequenceTypedefs, t => t["new-type"], t => t);
+
         const subtypes = getIteratorSubtypes();
-        if (subtypes) {
+        const methodsWithSequence: Browser.Method[] =
+            mapToArray(i.methods ? i.methods.method : {})
+                .filter(m => m.signature && !m["override-signatures"])
+                .map(m => ({
+                    ...m, 
+                    signature: replaceTypedefsInSignatures(m.signature.filter(hasSequenceArgument))
+                }))
+                .filter(m => m.signature.length)
+                .sort();
+
+        if (subtypes || methodsWithSequence.length) {
             const iteratorExtends = getIteratorExtends(i.iterator, subtypes);
             const name = extendConflictsBaseTypes[i.name] ? `${i.name}Base` : i.name;
             printer.printLine("");
             printer.printLine(`interface ${name} ${iteratorExtends}{`);
             printer.increaseIndent();
-            if (!iteratorExtends) {
+
+            methodsWithSequence.forEach(m => emitMethod("", m, new Set()));
+
+            if (subtypes && !iteratorExtends) {
                 printer.printLine(`[Symbol.iterator](): IterableIterator<${stringifySingleOrTupleTypes(subtypes)}>;`);
             }
-            if (i.iterator && i.iterator.kind === "iterable") {
+            if (i.iterator && i.iterator.kind === "iterable" && subtypes) {
                 emitIterableDeclarationMethods(i, subtypes);
             }
             printer.decreaseIndent();