From c89121ebdcaeb5279b2828875da7a5ba5a7ce239 Mon Sep 17 00:00:00 2001
From: Kagami Sascha Rosylight <saschanaz@outlook.com>
Date: Wed, 5 Jun 2019 12:24:31 +0900
Subject: [PATCH 1/6] Revert "Restore FileReaderProgressEvent (#704)"

This reverts commit 17d343ac99794aff02ee8bb2fe43ca579bbfdfee.
---
 baselines/dom.generated.d.ts       | 30 ++++++++++++------------------
 baselines/webworker.generated.d.ts | 28 ++++++++++++----------------
 inputfiles/addedTypes.json         | 15 ---------------
 inputfiles/overridingTypes.json    | 12 ++++++------
 4 files changed, 30 insertions(+), 55 deletions(-)

diff --git a/baselines/dom.generated.d.ts b/baselines/dom.generated.d.ts
index 7b1cfbc32..6c7f4e5ad 100644
--- a/baselines/dom.generated.d.ts
+++ b/baselines/dom.generated.d.ts
@@ -4558,7 +4558,6 @@ interface Document extends Node, NonElementParentNode, DocumentOrShadowRoot, Par
     createEvent(eventInterface: "ErrorEvent"): ErrorEvent;
     createEvent(eventInterface: "Event"): Event;
     createEvent(eventInterface: "Events"): Event;
-    createEvent(eventInterface: "FileReaderProgressEvent"): FileReaderProgressEvent;
     createEvent(eventInterface: "FocusEvent"): FocusEvent;
     createEvent(eventInterface: "FocusNavigationEvent"): FocusNavigationEvent;
     createEvent(eventInterface: "GamepadEvent"): GamepadEvent;
@@ -4808,7 +4807,6 @@ interface DocumentEvent {
     createEvent(eventInterface: "ErrorEvent"): ErrorEvent;
     createEvent(eventInterface: "Event"): Event;
     createEvent(eventInterface: "Events"): Event;
-    createEvent(eventInterface: "FileReaderProgressEvent"): FileReaderProgressEvent;
     createEvent(eventInterface: "FocusEvent"): FocusEvent;
     createEvent(eventInterface: "FocusNavigationEvent"): FocusNavigationEvent;
     createEvent(eventInterface: "GamepadEvent"): GamepadEvent;
@@ -5370,23 +5368,23 @@ declare var FileList: {
 };
 
 interface FileReaderEventMap {
-    "abort": FileReaderProgressEvent;
-    "error": FileReaderProgressEvent;
-    "load": FileReaderProgressEvent;
-    "loadend": FileReaderProgressEvent;
-    "loadstart": FileReaderProgressEvent;
-    "progress": FileReaderProgressEvent;
+    "abort": ProgressEvent;
+    "error": ProgressEvent;
+    "load": ProgressEvent;
+    "loadend": ProgressEvent;
+    "loadstart": ProgressEvent;
+    "progress": ProgressEvent;
 }
 
 /** Lets web applications asynchronously read the contents of files (or raw data buffers) stored on the user's computer, using File or Blob objects to specify the file or data to read. */
 interface FileReader extends EventTarget {
     readonly error: DOMException | null;
-    onabort: ((this: FileReader, ev: FileReaderProgressEvent) => any) | null;
-    onerror: ((this: FileReader, ev: FileReaderProgressEvent) => any) | null;
-    onload: ((this: FileReader, ev: FileReaderProgressEvent) => any) | null;
-    onloadend: ((this: FileReader, ev: FileReaderProgressEvent) => any) | null;
-    onloadstart: ((this: FileReader, ev: FileReaderProgressEvent) => any) | null;
-    onprogress: ((this: FileReader, ev: FileReaderProgressEvent) => any) | null;
+    onabort: ((this: FileReader, ev: ProgressEvent) => any) | null;
+    onerror: ((this: FileReader, ev: ProgressEvent) => any) | null;
+    onload: ((this: FileReader, ev: ProgressEvent) => any) | null;
+    onloadend: ((this: FileReader, ev: ProgressEvent) => any) | null;
+    onloadstart: ((this: FileReader, ev: ProgressEvent) => any) | null;
+    onprogress: ((this: FileReader, ev: ProgressEvent) => any) | null;
     readonly readyState: number;
     readonly result: string | ArrayBuffer | null;
     abort(): void;
@@ -5411,10 +5409,6 @@ declare var FileReader: {
     readonly LOADING: number;
 };
 
-interface FileReaderProgressEvent extends ProgressEvent {
-    readonly target: FileReader | null;
-}
-
 /** Focus-related events like focus, blur, focusin, or focusout. */
 interface FocusEvent extends UIEvent {
     readonly relatedTarget: EventTarget;
diff --git a/baselines/webworker.generated.d.ts b/baselines/webworker.generated.d.ts
index 8115f73c6..93bb1da00 100644
--- a/baselines/webworker.generated.d.ts
+++ b/baselines/webworker.generated.d.ts
@@ -1525,23 +1525,23 @@ declare var FileList: {
 };
 
 interface FileReaderEventMap {
-    "abort": FileReaderProgressEvent;
-    "error": FileReaderProgressEvent;
-    "load": FileReaderProgressEvent;
-    "loadend": FileReaderProgressEvent;
-    "loadstart": FileReaderProgressEvent;
-    "progress": FileReaderProgressEvent;
+    "abort": ProgressEvent;
+    "error": ProgressEvent;
+    "load": ProgressEvent;
+    "loadend": ProgressEvent;
+    "loadstart": ProgressEvent;
+    "progress": ProgressEvent;
 }
 
 /** Lets web applications asynchronously read the contents of files (or raw data buffers) stored on the user's computer, using File or Blob objects to specify the file or data to read. */
 interface FileReader extends EventTarget {
     readonly error: DOMException | null;
-    onabort: ((this: FileReader, ev: FileReaderProgressEvent) => any) | null;
-    onerror: ((this: FileReader, ev: FileReaderProgressEvent) => any) | null;
-    onload: ((this: FileReader, ev: FileReaderProgressEvent) => any) | null;
-    onloadend: ((this: FileReader, ev: FileReaderProgressEvent) => any) | null;
-    onloadstart: ((this: FileReader, ev: FileReaderProgressEvent) => any) | null;
-    onprogress: ((this: FileReader, ev: FileReaderProgressEvent) => any) | null;
+    onabort: ((this: FileReader, ev: ProgressEvent) => any) | null;
+    onerror: ((this: FileReader, ev: ProgressEvent) => any) | null;
+    onload: ((this: FileReader, ev: ProgressEvent) => any) | null;
+    onloadend: ((this: FileReader, ev: ProgressEvent) => any) | null;
+    onloadstart: ((this: FileReader, ev: ProgressEvent) => any) | null;
+    onprogress: ((this: FileReader, ev: ProgressEvent) => any) | null;
     readonly readyState: number;
     readonly result: string | ArrayBuffer | null;
     abort(): void;
@@ -1566,10 +1566,6 @@ declare var FileReader: {
     readonly LOADING: number;
 };
 
-interface FileReaderProgressEvent extends ProgressEvent {
-    readonly target: FileReader | null;
-}
-
 /** Allows to read File or Blob objects in a synchronous way. */
 interface FileReaderSync {
     readAsArrayBuffer(blob: Blob): ArrayBuffer;
diff --git a/inputfiles/addedTypes.json b/inputfiles/addedTypes.json
index 40fa45518..fd9152279 100644
--- a/inputfiles/addedTypes.json
+++ b/inputfiles/addedTypes.json
@@ -2174,21 +2174,6 @@
                         }
                     }
                 }
-            },
-            "FileReaderProgressEvent": {
-                "name": "FileReaderProgressEvent",
-                "extends": "ProgressEvent",
-                "no-interface-object": 1,
-                "properties": {
-                    "property": {
-                        "target": {
-                            "name": "target",
-                            "read-only": 1,
-                            "nullable": 1,
-                            "type": "FileReader"
-                        }
-                    }
-                }
             }
         }
     },
diff --git a/inputfiles/overridingTypes.json b/inputfiles/overridingTypes.json
index 031b09522..fc5bfe508 100644
--- a/inputfiles/overridingTypes.json
+++ b/inputfiles/overridingTypes.json
@@ -1862,27 +1862,27 @@
                     "event": [
                         {
                             "name": "loadstart",
-                            "type": "FileReaderProgressEvent"
+                            "type": "ProgressEvent"
                         },
                         {
                             "name": "progress",
-                            "type": "FileReaderProgressEvent"
+                            "type": "ProgressEvent"
                         },
                         {
                             "name": "load",
-                            "type": "FileReaderProgressEvent"
+                            "type": "ProgressEvent"
                         },
                         {
                             "name": "abort",
-                            "type": "FileReaderProgressEvent"
+                            "type": "ProgressEvent"
                         },
                         {
                             "name": "error",
-                            "type": "FileReaderProgressEvent"
+                            "type": "ProgressEvent"
                         },
                         {
                             "name": "loadend",
-                            "type": "FileReaderProgressEvent"
+                            "type": "ProgressEvent"
                         }
                     ]
                 }

From c157267b765b766c8dc67e73d2311af12eb48c01 Mon Sep 17 00:00:00 2001
From: Kagami Sascha Rosylight <saschanaz@outlook.com>
Date: Wed, 5 Jun 2019 12:43:57 +0900
Subject: [PATCH 2/6] Parameterize ProgressEvent

---
 baselines/dom.generated.d.ts       | 27 ++++++++++++++-------------
 baselines/webworker.generated.d.ts | 27 ++++++++++++++-------------
 inputfiles/addedTypes.json         | 13 +++++++++++++
 inputfiles/overridingTypes.json    | 18 ++++++++++++------
 src/emitter.ts                     |  7 ++++++-
 src/types.d.ts                     |  2 ++
 6 files changed, 61 insertions(+), 33 deletions(-)

diff --git a/baselines/dom.generated.d.ts b/baselines/dom.generated.d.ts
index 6c7f4e5ad..91ff28abc 100644
--- a/baselines/dom.generated.d.ts
+++ b/baselines/dom.generated.d.ts
@@ -5368,23 +5368,23 @@ declare var FileList: {
 };
 
 interface FileReaderEventMap {
-    "abort": ProgressEvent;
-    "error": ProgressEvent;
-    "load": ProgressEvent;
-    "loadend": ProgressEvent;
-    "loadstart": ProgressEvent;
-    "progress": ProgressEvent;
+    "abort": ProgressEvent<FileReader>;
+    "error": ProgressEvent<FileReader>;
+    "load": ProgressEvent<FileReader>;
+    "loadend": ProgressEvent<FileReader>;
+    "loadstart": ProgressEvent<FileReader>;
+    "progress": ProgressEvent<FileReader>;
 }
 
 /** Lets web applications asynchronously read the contents of files (or raw data buffers) stored on the user's computer, using File or Blob objects to specify the file or data to read. */
 interface FileReader extends EventTarget {
     readonly error: DOMException | null;
-    onabort: ((this: FileReader, ev: ProgressEvent) => any) | null;
-    onerror: ((this: FileReader, ev: ProgressEvent) => any) | null;
-    onload: ((this: FileReader, ev: ProgressEvent) => any) | null;
-    onloadend: ((this: FileReader, ev: ProgressEvent) => any) | null;
-    onloadstart: ((this: FileReader, ev: ProgressEvent) => any) | null;
-    onprogress: ((this: FileReader, ev: ProgressEvent) => any) | null;
+    onabort: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
+    onerror: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
+    onload: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
+    onloadend: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
+    onloadstart: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
+    onprogress: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
     readonly readyState: number;
     readonly result: string | ArrayBuffer | null;
     abort(): void;
@@ -11759,9 +11759,10 @@ declare var ProcessingInstruction: {
 };
 
 /** Events measuring progress of an underlying process, like an HTTP request (for an XMLHttpRequest, or the loading of the underlying resource of an <img>, <audio>, <video>, <style> or <link>). */
-interface ProgressEvent extends Event {
+interface ProgressEvent<T extends EventTarget = EventTarget> extends Event {
     readonly lengthComputable: boolean;
     readonly loaded: number;
+    readonly target: T | null;
     readonly total: number;
 }
 
diff --git a/baselines/webworker.generated.d.ts b/baselines/webworker.generated.d.ts
index 93bb1da00..0e468b363 100644
--- a/baselines/webworker.generated.d.ts
+++ b/baselines/webworker.generated.d.ts
@@ -1525,23 +1525,23 @@ declare var FileList: {
 };
 
 interface FileReaderEventMap {
-    "abort": ProgressEvent;
-    "error": ProgressEvent;
-    "load": ProgressEvent;
-    "loadend": ProgressEvent;
-    "loadstart": ProgressEvent;
-    "progress": ProgressEvent;
+    "abort": ProgressEvent<FileReader>;
+    "error": ProgressEvent<FileReader>;
+    "load": ProgressEvent<FileReader>;
+    "loadend": ProgressEvent<FileReader>;
+    "loadstart": ProgressEvent<FileReader>;
+    "progress": ProgressEvent<FileReader>;
 }
 
 /** Lets web applications asynchronously read the contents of files (or raw data buffers) stored on the user's computer, using File or Blob objects to specify the file or data to read. */
 interface FileReader extends EventTarget {
     readonly error: DOMException | null;
-    onabort: ((this: FileReader, ev: ProgressEvent) => any) | null;
-    onerror: ((this: FileReader, ev: ProgressEvent) => any) | null;
-    onload: ((this: FileReader, ev: ProgressEvent) => any) | null;
-    onloadend: ((this: FileReader, ev: ProgressEvent) => any) | null;
-    onloadstart: ((this: FileReader, ev: ProgressEvent) => any) | null;
-    onprogress: ((this: FileReader, ev: ProgressEvent) => any) | null;
+    onabort: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
+    onerror: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
+    onload: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
+    onloadend: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
+    onloadstart: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
+    onprogress: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
     readonly readyState: number;
     readonly result: string | ArrayBuffer | null;
     abort(): void;
@@ -2583,9 +2583,10 @@ declare var Permissions: {
 };
 
 /** Events measuring progress of an underlying process, like an HTTP request (for an XMLHttpRequest, or the loading of the underlying resource of an <img>, <audio>, <video>, <style> or <link>). */
-interface ProgressEvent extends Event {
+interface ProgressEvent<T extends EventTarget = EventTarget> extends Event {
     readonly lengthComputable: boolean;
     readonly loaded: number;
+    readonly target: T | null;
     readonly total: number;
 }
 
diff --git a/inputfiles/addedTypes.json b/inputfiles/addedTypes.json
index fd9152279..0f1b6d182 100644
--- a/inputfiles/addedTypes.json
+++ b/inputfiles/addedTypes.json
@@ -2174,6 +2174,19 @@
                         }
                     }
                 }
+            },
+            "ProgressEvent": {
+                "generic": "T extends EventTarget = EventTarget",
+                "properties": {
+                    "property": {
+                        "target": {
+                            "name": "target",
+                            "read-only": 1,
+                            "nullable": 1,
+                            "override-type": "T"
+                        }
+                    }
+                }
             }
         }
     },
diff --git a/inputfiles/overridingTypes.json b/inputfiles/overridingTypes.json
index fc5bfe508..a594b12be 100644
--- a/inputfiles/overridingTypes.json
+++ b/inputfiles/overridingTypes.json
@@ -1862,27 +1862,33 @@
                     "event": [
                         {
                             "name": "loadstart",
-                            "type": "ProgressEvent"
+                            "type": "ProgressEvent",
+                            "generic": "FileReader"
                         },
                         {
                             "name": "progress",
-                            "type": "ProgressEvent"
+                            "type": "ProgressEvent",
+                            "generic": "FileReader"
                         },
                         {
                             "name": "load",
-                            "type": "ProgressEvent"
+                            "type": "ProgressEvent",
+                            "generic": "FileReader"
                         },
                         {
                             "name": "abort",
-                            "type": "ProgressEvent"
+                            "type": "ProgressEvent",
+                            "generic": "FileReader"
                         },
                         {
                             "name": "error",
-                            "type": "ProgressEvent"
+                            "type": "ProgressEvent",
+                            "generic": "FileReader"
                         },
                         {
                             "name": "loadend",
-                            "type": "ProgressEvent"
+                            "type": "ProgressEvent",
+                            "generic": "FileReader"
                         }
                     ]
                 }
diff --git a/src/emitter.ts b/src/emitter.ts
index 066a62f9d..5414ed67f 100644
--- a/src/emitter.ts
+++ b/src/emitter.ts
@@ -248,7 +248,8 @@ export function emitWebIdl(webidl: Browser.WebIdl, flavor: Flavor) {
         if (i.events) {
             const event = i.events.event.find(e => e.name === eName);
             if (event && event.type) {
-                return event.type;
+                const generic = event.generic ? `<${event.generic}>` : "";
+                return event.type + generic;
             }
         }
         if (i["attributeless-events"]) {
@@ -830,6 +831,10 @@ export function emitWebIdl(webidl: Browser.WebIdl, flavor: Flavor) {
 
         printer.print(`interface ${processInterfaceType(i, processedIName)}`);
 
+        if (i.generic) {
+            printer.print(`<${i.generic}>`)
+        }
+
         const finalExtends = distinct([i.extends || "Object"].concat(i.implements || [])
             .filter(i => i !== "Object")
             .map(processIName));
diff --git a/src/types.d.ts b/src/types.d.ts
index 018326ccb..cc86437c1 100644
--- a/src/types.d.ts
+++ b/src/types.d.ts
@@ -66,6 +66,7 @@ export interface Property extends Typed {
 export interface Event {
     name: string;
     type: string;
+    generic?: string;
     dispatch?: string;
     "skips-window"?: string;
     bubbles?: 1;
@@ -150,6 +151,7 @@ export interface TypeParameter {
 
 export interface Interface {
     name: string;
+    generic?: string;
     extends: string;
     comment?: string;
     constants?: {

From 8a8bb00cf786a755741eac8e1d05d54b375a0cfe Mon Sep 17 00:00:00 2001
From: Kagami Sascha Rosylight <saschanaz@outlook.com>
Date: Wed, 5 Jun 2019 13:17:32 +0900
Subject: [PATCH 3/6] use generic for existing types

---
 inputfiles/addedTypes.json | 10 ++++++----
 inputfiles/comments.json   |  2 +-
 src/emitter.ts             |  9 +++++++--
 3 files changed, 14 insertions(+), 7 deletions(-)

diff --git a/inputfiles/addedTypes.json b/inputfiles/addedTypes.json
index 0f1b6d182..5cebc7f25 100644
--- a/inputfiles/addedTypes.json
+++ b/inputfiles/addedTypes.json
@@ -599,8 +599,9 @@
                     }
                 }
             },
-            "NodeListOf<TNode extends Node>": {
-                "name": "NodeListOf<TNode extends Node>",
+            "NodeListOf": {
+                "name": "NodeListOf",
+                "generic": "TNode extends Node",
                 "exposed": "Window",
                 "extends": "NodeList",
                 "properties": {
@@ -634,8 +635,9 @@
                     ]
                 }
             },
-            "HTMLCollectionOf<T extends Element>": {
-                "name": "HTMLCollectionOf<T extends Element>",
+            "HTMLCollectionOf": {
+                "name": "HTMLCollectionOf",
+                "generic": "T extends Element",
                 "exposed": "Window",
                 "extends": "HTMLCollection",
                 "methods": {
diff --git a/inputfiles/comments.json b/inputfiles/comments.json
index 227279498..4fcf6ef5d 100644
--- a/inputfiles/comments.json
+++ b/inputfiles/comments.json
@@ -177,7 +177,7 @@
                     }
                 }
             },
-            "NodeListOf<TNode extends Node>": {
+            "NodeListOf": {
                 "methods": {
                     "method": {
                         "forEach": {
diff --git a/src/emitter.ts b/src/emitter.ts
index 5414ed67f..d9ffcb690 100644
--- a/src/emitter.ts
+++ b/src/emitter.ts
@@ -226,6 +226,10 @@ export function emitWebIdl(webidl: Browser.WebIdl, flavor: Flavor) {
             return ehParents;
         }
 
+        if (!i.name) {
+            throw new Error("Unexpected nameless object: " + JSON.stringify(i));
+        }
+
         const iExtends = i.extends && i.extends.replace(/<.*>$/, '');
         const parentWithEventHandler = allInterfacesMap[iExtends] && getParentEventHandler(allInterfacesMap[iExtends]) || [];
         const mixinsWithEventHandler = flatMap(i.implements || [], i => getParentEventHandler(allInterfacesMap[i]));
@@ -695,7 +699,7 @@ export function emitWebIdl(webidl: Browser.WebIdl, flavor: Flavor) {
         const value = subtype[subtype.length - 1];
         const key = subtype.length > 1 ? subtype[0] :
             i.iterator.kind === "iterable" ? "number" : value;
-        const name = i.name.replace(/ extends \w+/, "");
+        const name = i.name + (i.generic ? `<${i.generic.split(" ")[0]}>` : "");
         printer.printLine(`forEach(callbackfn: (value: ${value}, key: ${key}, parent: ${name}) => void, thisArg?: any): void;`);
     }
 
@@ -1229,8 +1233,9 @@ export function emitWebIdl(webidl: Browser.WebIdl, flavor: Flavor) {
         if (subtypes) {
             const iteratorExtends = getIteratorExtends(i.iterator, subtypes);
             const name = extendConflictsBaseTypes[i.name] ? `${i.name}Base` : i.name;
+            const generic = i.generic ? `<${i.generic}>` : "";
             printer.printLine("");
-            printer.printLine(`interface ${name} ${iteratorExtends}{`);
+            printer.printLine(`interface ${name}${generic} ${iteratorExtends}{`);
             printer.increaseIndent();
             if (!iteratorExtends) {
                 printer.printLine(`[Symbol.iterator](): IterableIterator<${stringifySingleOrTupleTypes(subtypes)}>;`);

From e4a944d2b46ecd9968769b77a16740b5793ed284 Mon Sep 17 00:00:00 2001
From: Kagami Sascha Rosylight <saschanaz@outlook.com>
Date: Mon, 10 Jun 2019 20:20:35 +0900
Subject: [PATCH 4/6] emit parameterized ProgressEvent

---
 baselines/dom.generated.d.ts       | 30 +++++++++++++++---------------
 baselines/webworker.generated.d.ts | 14 +++++++-------
 inputfiles/overridingTypes.json    | 18 ++++++------------
 src/emitter.ts                     | 12 +++++++++---
 src/types.d.ts                     |  1 +
 src/widlprocess.ts                 |  1 +
 6 files changed, 39 insertions(+), 37 deletions(-)

diff --git a/baselines/dom.generated.d.ts b/baselines/dom.generated.d.ts
index 91ff28abc..265ff3e49 100644
--- a/baselines/dom.generated.d.ts
+++ b/baselines/dom.generated.d.ts
@@ -1953,7 +1953,7 @@ interface ApplicationCacheEventMap {
     "error": Event;
     "noupdate": Event;
     "obsolete": Event;
-    "progress": ProgressEvent;
+    "progress": ProgressEvent<ApplicationCache>;
     "updateready": Event;
 }
 
@@ -1971,7 +1971,7 @@ interface ApplicationCache extends EventTarget {
     /** @deprecated */
     onobsolete: ((this: ApplicationCache, ev: Event) => any) | null;
     /** @deprecated */
-    onprogress: ((this: ApplicationCache, ev: ProgressEvent) => any) | null;
+    onprogress: ((this: ApplicationCache, ev: ProgressEvent<ApplicationCache>) => any) | null;
     /** @deprecated */
     onupdateready: ((this: ApplicationCache, ev: Event) => any) | null;
     /** @deprecated */
@@ -4286,7 +4286,7 @@ interface DocumentEventMap extends GlobalEventHandlersEventMap, DocumentAndEleme
     "fullscreenerror": Event;
     "pointerlockchange": Event;
     "pointerlockerror": Event;
-    "readystatechange": ProgressEvent;
+    "readystatechange": ProgressEvent<Document>;
     "visibilitychange": Event;
 }
 
@@ -4445,7 +4445,7 @@ interface Document extends Node, NonElementParentNode, DocumentOrShadowRoot, Par
      * Fires when the state of the object has changed.
      * @param ev The event
      */
-    onreadystatechange: ((this: Document, ev: ProgressEvent) => any) | null;
+    onreadystatechange: ((this: Document, ev: ProgressEvent<Document>) => any) | null;
     onvisibilitychange: ((this: Document, ev: Event) => any) | null;
     /**
      * Returns document's origin.
@@ -17241,9 +17241,9 @@ interface WindowEventMap extends GlobalEventHandlersEventMap, WindowEventHandler
     "play": Event;
     "playing": Event;
     "popstate": PopStateEvent;
-    "progress": ProgressEvent;
+    "progress": ProgressEvent<Window>;
     "ratechange": Event;
-    "readystatechange": ProgressEvent;
+    "readystatechange": ProgressEvent<Window>;
     "reset": Event;
     "resize": UIEvent;
     "scroll": Event;
@@ -17327,7 +17327,7 @@ interface Window extends EventTarget, WindowTimers, WindowSessionStorage, Window
     onmspointerup: ((this: Window, ev: Event) => any) | null;
     /** @deprecated */
     onorientationchange: ((this: Window, ev: Event) => any) | null;
-    onreadystatechange: ((this: Window, ev: ProgressEvent) => any) | null;
+    onreadystatechange: ((this: Window, ev: ProgressEvent<Window>) => any) | null;
     onvrdisplayactivate: ((this: Window, ev: Event) => any) | null;
     onvrdisplayblur: ((this: Window, ev: Event) => any) | null;
     onvrdisplayconnect: ((this: Window, ev: Event) => any) | null;
@@ -17679,13 +17679,13 @@ declare var XMLHttpRequest: {
 };
 
 interface XMLHttpRequestEventTargetEventMap {
-    "abort": ProgressEvent;
-    "error": ProgressEvent;
-    "load": ProgressEvent;
-    "loadend": ProgressEvent;
-    "loadstart": ProgressEvent;
-    "progress": ProgressEvent;
-    "timeout": ProgressEvent;
+    "abort": ProgressEvent<XMLHttpRequestEventTarget>;
+    "error": ProgressEvent<XMLHttpRequestEventTarget>;
+    "load": ProgressEvent<XMLHttpRequestEventTarget>;
+    "loadend": ProgressEvent<XMLHttpRequestEventTarget>;
+    "loadstart": ProgressEvent<XMLHttpRequestEventTarget>;
+    "progress": ProgressEvent<XMLHttpRequestEventTarget>;
+    "timeout": ProgressEvent<XMLHttpRequestEventTarget>;
 }
 
 interface XMLHttpRequestEventTarget extends EventTarget {
@@ -18323,7 +18323,7 @@ declare var onmspointerover: ((this: Window, ev: Event) => any) | null;
 declare var onmspointerup: ((this: Window, ev: Event) => any) | null;
 /** @deprecated */
 declare var onorientationchange: ((this: Window, ev: Event) => any) | null;
-declare var onreadystatechange: ((this: Window, ev: ProgressEvent) => any) | null;
+declare var onreadystatechange: ((this: Window, ev: ProgressEvent<Window>) => any) | null;
 declare var onvrdisplayactivate: ((this: Window, ev: Event) => any) | null;
 declare var onvrdisplayblur: ((this: Window, ev: Event) => any) | null;
 declare var onvrdisplayconnect: ((this: Window, ev: Event) => any) | null;
diff --git a/baselines/webworker.generated.d.ts b/baselines/webworker.generated.d.ts
index 0e468b363..c208bdccb 100644
--- a/baselines/webworker.generated.d.ts
+++ b/baselines/webworker.generated.d.ts
@@ -4510,13 +4510,13 @@ declare var XMLHttpRequest: {
 };
 
 interface XMLHttpRequestEventTargetEventMap {
-    "abort": ProgressEvent;
-    "error": ProgressEvent;
-    "load": ProgressEvent;
-    "loadend": ProgressEvent;
-    "loadstart": ProgressEvent;
-    "progress": ProgressEvent;
-    "timeout": ProgressEvent;
+    "abort": ProgressEvent<XMLHttpRequestEventTarget>;
+    "error": ProgressEvent<XMLHttpRequestEventTarget>;
+    "load": ProgressEvent<XMLHttpRequestEventTarget>;
+    "loadend": ProgressEvent<XMLHttpRequestEventTarget>;
+    "loadstart": ProgressEvent<XMLHttpRequestEventTarget>;
+    "progress": ProgressEvent<XMLHttpRequestEventTarget>;
+    "timeout": ProgressEvent<XMLHttpRequestEventTarget>;
 }
 
 interface XMLHttpRequestEventTarget extends EventTarget {
diff --git a/inputfiles/overridingTypes.json b/inputfiles/overridingTypes.json
index a594b12be..fc5bfe508 100644
--- a/inputfiles/overridingTypes.json
+++ b/inputfiles/overridingTypes.json
@@ -1862,33 +1862,27 @@
                     "event": [
                         {
                             "name": "loadstart",
-                            "type": "ProgressEvent",
-                            "generic": "FileReader"
+                            "type": "ProgressEvent"
                         },
                         {
                             "name": "progress",
-                            "type": "ProgressEvent",
-                            "generic": "FileReader"
+                            "type": "ProgressEvent"
                         },
                         {
                             "name": "load",
-                            "type": "ProgressEvent",
-                            "generic": "FileReader"
+                            "type": "ProgressEvent"
                         },
                         {
                             "name": "abort",
-                            "type": "ProgressEvent",
-                            "generic": "FileReader"
+                            "type": "ProgressEvent"
                         },
                         {
                             "name": "error",
-                            "type": "ProgressEvent",
-                            "generic": "FileReader"
+                            "type": "ProgressEvent"
                         },
                         {
                             "name": "loadend",
-                            "type": "ProgressEvent",
-                            "generic": "FileReader"
+                            "type": "ProgressEvent"
                         }
                     ]
                 }
diff --git a/src/emitter.ts b/src/emitter.ts
index d9ffcb690..04aad60b1 100644
--- a/src/emitter.ts
+++ b/src/emitter.ts
@@ -249,11 +249,17 @@ export function emitWebIdl(webidl: Browser.WebIdl, flavor: Flavor) {
     }
 
     function getEventTypeInInterface(eName: string, i: Browser.Interface) {
+        function getGenericEventType(baseName: string) {
+            if (baseName === "ProgressEvent" && !i.mixin) {
+                return `${baseName}<${i.name}>`;
+            }
+            return baseName;
+        }
+
         if (i.events) {
             const event = i.events.event.find(e => e.name === eName);
             if (event && event.type) {
-                const generic = event.generic ? `<${event.generic}>` : "";
-                return event.type + generic;
+                return getGenericEventType(event.type);
             }
         }
         if (i["attributeless-events"]) {
@@ -262,7 +268,7 @@ export function emitWebIdl(webidl: Browser.WebIdl, flavor: Flavor) {
                 return event.type;
             }
         }
-        return eNameToEType[eName] || "Event";
+        return getGenericEventType(eNameToEType[eName]) || "Event";
     }
 
     /// Determine if interface1 depends on interface2
diff --git a/src/types.d.ts b/src/types.d.ts
index cc86437c1..9863c1835 100644
--- a/src/types.d.ts
+++ b/src/types.d.ts
@@ -151,6 +151,7 @@ export interface TypeParameter {
 
 export interface Interface {
     name: string;
+    mixin?: boolean;
     generic?: string;
     extends: string;
     comment?: string;
diff --git a/src/widlprocess.ts b/src/widlprocess.ts
index dda75c7af..06a8f93ee 100644
--- a/src/widlprocess.ts
+++ b/src/widlprocess.ts
@@ -91,6 +91,7 @@ function convertInterface(i: webidl2.InterfaceType, commentMap: Record<string, s
 
 function convertInterfaceMixin(i: webidl2.InterfaceMixinType, commentMap: Record<string, string>) {
     const result = convertInterfaceCommon(i, commentMap);
+    result.mixin = true;
     result['no-interface-object'] = 1;
     return result;
 }

From 4f338acaa29e41b1ddd071387a389f067a4104c9 Mon Sep 17 00:00:00 2001
From: Kagami Sascha Rosylight <saschanaz@outlook.com>
Date: Wed, 12 Jun 2019 16:25:27 +0900
Subject: [PATCH 5/6] use existing `type-parameters` field

---
 inputfiles/addedTypes.json | 22 +++++++++++++++++++---
 src/emitter.ts             | 34 ++++++++++++++++------------------
 src/types.d.ts             |  2 --
 3 files changed, 35 insertions(+), 23 deletions(-)

diff --git a/inputfiles/addedTypes.json b/inputfiles/addedTypes.json
index 5cebc7f25..9b3fac023 100644
--- a/inputfiles/addedTypes.json
+++ b/inputfiles/addedTypes.json
@@ -601,7 +601,12 @@
             },
             "NodeListOf": {
                 "name": "NodeListOf",
-                "generic": "TNode extends Node",
+                "type-parameters": [
+                    {
+                        "name": "TNode",
+                        "extends": "Node"
+                    }
+                ],
                 "exposed": "Window",
                 "extends": "NodeList",
                 "properties": {
@@ -637,7 +642,12 @@
             },
             "HTMLCollectionOf": {
                 "name": "HTMLCollectionOf",
-                "generic": "T extends Element",
+                "type-parameters": [
+                    {
+                        "name": "T",
+                        "extends": "Element"
+                    }
+                ],
                 "exposed": "Window",
                 "extends": "HTMLCollection",
                 "methods": {
@@ -2178,7 +2188,13 @@
                 }
             },
             "ProgressEvent": {
-                "generic": "T extends EventTarget = EventTarget",
+                "type-parameters": [
+                    {
+                        "name": "T",
+                        "extends": "EventTarget",
+                        "default": "EventTarget"
+                    }
+                ],
                 "properties": {
                     "property": {
                         "target": {
diff --git a/src/emitter.ts b/src/emitter.ts
index 04aad60b1..e0031b444 100644
--- a/src/emitter.ts
+++ b/src/emitter.ts
@@ -402,14 +402,17 @@ export function emitWebIdl(webidl: Browser.WebIdl, flavor: Flavor) {
             expectedParamType.every((pt, idx) => convertDomTypeToTsType(m.signature[0].param![idx]) === pt);
     }
 
-    function processInterfaceType(i: Browser.Interface | Browser.Dictionary | Browser.CallbackFunction, name: string) {
+    function getNameWithTypeParameter(i: Browser.Interface | Browser.Dictionary | Browser.CallbackFunction, name: string) {
         function typeParameterWithDefault(type: Browser.TypeParameter) {
-            return `${type.name}`
-                + (type.extends ? ` extends ${type.extends}` : ``)
-                + (type.default ? ` = ${type.default}` : ``)
+            return type.name
+                + (type.extends ? ` extends ${type.extends}` : "")
+                + (type.default ? ` = ${type.default}` : "");
         }
 
-        return i["type-parameters"] ? name + "<" + i["type-parameters"]!.map(typeParameterWithDefault).join(", ") + ">" : name;
+        if (!i["type-parameters"]) {
+            return name;
+        }
+        return `${name}<${i["type-parameters"]!.map(typeParameterWithDefault).join(", ")}>`;
     }
 
     /// Emit overloads for the createElement method
@@ -541,7 +544,7 @@ export function emitWebIdl(webidl: Browser.WebIdl, flavor: Flavor) {
     }
 
     function emitCallBackFunction(cb: Browser.CallbackFunction) {
-        printer.printLine(`interface ${processInterfaceType(cb, cb.name)} {`);
+        printer.printLine(`interface ${getNameWithTypeParameter(cb, cb.name)} {`);
         printer.increaseIndent();
         emitSignatures(cb, "", "", printer.printLine);
         printer.decreaseIndent();
@@ -705,7 +708,7 @@ export function emitWebIdl(webidl: Browser.WebIdl, flavor: Flavor) {
         const value = subtype[subtype.length - 1];
         const key = subtype.length > 1 ? subtype[0] :
             i.iterator.kind === "iterable" ? "number" : value;
-        const name = i.name + (i.generic ? `<${i.generic.split(" ")[0]}>` : "");
+        const name = i["type-parameters"] ? `${i.name}<${i["type-parameters"]!.map(p => p.name).join(", ")}>` : i.name;
         printer.printLine(`forEach(callbackfn: (value: ${value}, key: ${key}, parent: ${name}) => void, thisArg?: any): void;`);
     }
 
@@ -832,18 +835,14 @@ export function emitWebIdl(webidl: Browser.WebIdl, flavor: Flavor) {
         const processedIName = processIName(i.name);
 
         if (processedIName !== i.name) {
-            printer.printLineToStack(`interface ${processInterfaceType(i, i.name)} extends ${processedIName} {`);
+            printer.printLineToStack(`interface ${getNameWithTypeParameter(i, i.name)} extends ${processedIName} {`);
         }
 
         if (i.comment) {
             printer.printLine(`/** ${i.comment} */`);
         }
 
-        printer.print(`interface ${processInterfaceType(i, processedIName)}`);
-
-        if (i.generic) {
-            printer.print(`<${i.generic}>`)
-        }
+        printer.print(`interface ${getNameWithTypeParameter(i, processedIName)}`);
 
         const finalExtends = distinct([i.extends || "Object"].concat(i.implements || [])
             .filter(i => i !== "Object")
@@ -1059,10 +1058,10 @@ export function emitWebIdl(webidl: Browser.WebIdl, flavor: Flavor) {
 
     function emitDictionary(dict: Browser.Dictionary) {
         if (!dict.extends || dict.extends === "Object") {
-            printer.printLine(`interface ${processInterfaceType(dict, dict.name)} {`);
+            printer.printLine(`interface ${getNameWithTypeParameter(dict, dict.name)} {`);
         }
         else {
-            printer.printLine(`interface ${processInterfaceType(dict, dict.name)} extends ${dict.extends} {`);
+            printer.printLine(`interface ${getNameWithTypeParameter(dict, dict.name)} extends ${dict.extends} {`);
         }
         printer.increaseIndent();
         if (dict.members) {
@@ -1238,10 +1237,9 @@ export function emitWebIdl(webidl: Browser.WebIdl, flavor: Flavor) {
         const subtypes = getIteratorSubtypes();
         if (subtypes) {
             const iteratorExtends = getIteratorExtends(i.iterator, subtypes);
-            const name = extendConflictsBaseTypes[i.name] ? `${i.name}Base` : i.name;
-            const generic = i.generic ? `<${i.generic}>` : "";
+            const name = getNameWithTypeParameter(i, extendConflictsBaseTypes[i.name] ? `${i.name}Base` : i.name);
             printer.printLine("");
-            printer.printLine(`interface ${name}${generic} ${iteratorExtends}{`);
+            printer.printLine(`interface ${name} ${iteratorExtends}{`);
             printer.increaseIndent();
             if (!iteratorExtends) {
                 printer.printLine(`[Symbol.iterator](): IterableIterator<${stringifySingleOrTupleTypes(subtypes)}>;`);
diff --git a/src/types.d.ts b/src/types.d.ts
index 9863c1835..ed3c118b8 100644
--- a/src/types.d.ts
+++ b/src/types.d.ts
@@ -66,7 +66,6 @@ export interface Property extends Typed {
 export interface Event {
     name: string;
     type: string;
-    generic?: string;
     dispatch?: string;
     "skips-window"?: string;
     bubbles?: 1;
@@ -152,7 +151,6 @@ export interface TypeParameter {
 export interface Interface {
     name: string;
     mixin?: boolean;
-    generic?: string;
     extends: string;
     comment?: string;
     constants?: {

From 8c699e72530642bfb3903decfa768adfb97db6c3 Mon Sep 17 00:00:00 2001
From: Kagami Sascha Rosylight <saschanaz@outlook.com>
Date: Wed, 12 Jun 2019 16:30:52 +0900
Subject: [PATCH 6/6] ensure attributeless events get type param in the future

---
 src/emitter.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/emitter.ts b/src/emitter.ts
index e0031b444..46558c1fa 100644
--- a/src/emitter.ts
+++ b/src/emitter.ts
@@ -265,7 +265,7 @@ export function emitWebIdl(webidl: Browser.WebIdl, flavor: Flavor) {
         if (i["attributeless-events"]) {
             const event = i["attributeless-events"].event.find(e => e.name === eName);
             if (event && event.type) {
-                return event.type;
+                return getGenericEventType(event.type);
             }
         }
         return getGenericEventType(eNameToEType[eName]) || "Event";