[Devtools] Doctyped Object.js

third_party/WebKit/Source/devtools/front_end/common/Object.js

Index: third_party/WebKit/Source/devtools/front_end/common/Object.js
diff --git a/third_party/WebKit/Source/devtools/front_end/common/Object.js b/third_party/WebKit/Source/devtools/front_end/common/Object.js
index 6f5d793c827a6d14ee94043e1b8a9248b4074a63..9dced11c512b8212e86a17426a33dd1a16c7810e 100644
--- a/third_party/WebKit/Source/devtools/front_end/common/Object.js
+++ b/third_party/WebKit/Source/devtools/front_end/common/Object.js
@@ -27,6 +27,10 @@
  * @unrestricted
  */
 Common.Object = class {
+  constructor() {
+    /** @type {(!Map<symbol, !Array<!Common.Object._listenerCallbackTuple>>|undefined)} */

[dgozman, 2017/01/09 21:46:18]

Should be symbol|Emitable

[allada, 2017/01/09 23:01:54]

Done.

+    this._listeners;
+  }
   /**
    * @override
    * @param {symbol} eventType
@@ -39,9 +43,10 @@ Common.Object = class {
       console.assert(false);
 
     if (!this._listeners)
-      this._listeners = new Map();
+      this._listeners = /** @type {!Map<symbol, !Array<!Common.Object._listenerCallbackTuple>>} */ (new Map());

[dgozman, 2017/01/09 21:46:18]

Let's not type here - should be enough in the constructor?

[allada, 2017/01/09 23:01:54]

Done.

+
     if (!this._listeners.has(eventType))
-      this._listeners.set(eventType, []);
+      this._listeners.set(eventType, /** @type {!Array<!Common.Object._listenerCallbackTuple>} */ ([]));
     this._listeners.get(eventType).push({thisObject: thisObject, listener: listener});
     return new Common.EventTarget.EventDescriptor(this, eventType, thisObject, listener);
   }
@@ -73,7 +78,7 @@ Common.Object = class {
    * @return {boolean}
    */
   hasEventListeners(eventType) {
-    return this._listeners && this._listeners.has(eventType);
+    return !!(this._listeners && this._listeners.has(eventType));
   }
 
   /**
@@ -92,16 +97,16 @@ Common.Object = class {
   }
 
   /**
-   * @template T
    * @override
-   * @param {function(new:T, ...)} eventType
+   * @param {function(new:Common.Emitable, ...)} eventType

[allada, 2017/01/04 22:03:54]

Nice little trick here to enforce T to be a Common.Emitable :-)

[luoe, 2017/01/09 19:07:00]

Acknowledged.

    * @param {function(!T)} listener
    * @param {!Object=} thisObject
    * @return {!Common.EventTarget.TypedEventDescriptor}
+   * @template T
    */
   on(eventType, listener, thisObject) {
     if (!this._listeners)
-      this._listeners = new Map();
+      this._listeners = /** @type {!Map<symbol, !Array<!Common.Object._listenerCallbackTuple>>} */ (new Map());
     if (!this._listeners.has(eventType))
       this._listeners.set(eventType, []);

[luoe, 2017/01/09 19:07:00]

This looks like the same case as line 49.  Should they both be typed?

[dgozman, 2017/01/09 21:46:18]

I'd say we should not type them both. In fact, looks like closure didn't catch
us using Common.Emitable as a symbol. Does it make sense to even type things
now?

[allada, 2017/01/09 23:01:54]

Done.

     this._listeners.get(eventType).push({thisObject: thisObject, listener: listener});
@@ -109,10 +114,9 @@ Common.Object = class {
   }
 
   /**
-   * @template T
    * @override
-   * @param {function(new:T, ...)} eventType
-   * @param {function(!T)} listener
+   * @param {function(new:Common.Emitable, ...)} eventType
+   * @param {function(!Common.Emitable)} listener
    * @param {!Object=} thisObject
    */
   off(eventType, listener, thisObject) {
@@ -128,9 +132,8 @@ Common.Object = class {
   }
 
   /**
-   * @template T
    * @override
-   * @param {!T} event
+   * @param {!Common.Emitable} event
    */
   emit(event) {
     var eventType = event.constructor;
@@ -143,6 +146,17 @@ Common.Object = class {
 };
 
 /**
+ * @interface
+ */
+Common.Emitable = function() {};

[luoe, 2017/01/09 19:07:00]

Nit: Since emitter is spelled with 2 "t"s, I think this should be changed
"Emittable".

[allada, 2017/01/09 23:01:54]

Done.

+
+/**
+ * @typedef {!{thisObject: (!Object|undefined), listener: function(!Common.Emitable)}}
+ */
+Common.Object._listenerCallbackTuple;
+
+/**
+ * @implements {Common.Emitable}
  * @unrestricted
  */
 Common.Event = class {
@@ -160,15 +174,72 @@ Common.Event = class {
 Common.EventTarget = function() {};
 
 /**
- * @param {!Array<!Common.EventTarget.EventDescriptor|!Common.EventTarget.TypedEventDescriptor>} eventList
+ * @record
+ * @template T
+ */
+Common.EventTarget.EventDescriptorStruct = class {
+  constructor() {
+    /** @type {!Common.EventTarget} */
+    this.eventTarget;
+    /** @type {!T} */
+    this.eventType;
+    /** @type {(!Object|undefined)} */
+    this.receiver;
+    /** @type {function(!Common.Emitable)} */
+    this.method;
+  }
+};
+
+/**
+ * @implements {Common.EventTarget.EventDescriptorStruct<symbol>}
+ * @unrestricted
+ */
+Common.EventTarget.EventDescriptor = class {
+  /**
+   * @param {!Common.EventTarget} eventTarget
+   * @param {symbol} eventType
+   * @param {(!Object|undefined)} receiver
+   * @param {function(!Common.Event)} method
+   */
+  constructor(eventTarget, eventType, receiver, method) {
+    this.eventTarget = eventTarget;
+    this.eventType = eventType;
+    this.receiver = receiver;
+    this.method = method;
+  }
+};
+
+/**
+ * @implements {Common.EventTarget.EventDescriptorStruct<function(new:Common.Emitable)>}
+ * @unrestricted
+ */
+Common.EventTarget.TypedEventDescriptor = class {
+  /**
+   * @param {!Common.EventTarget} eventTarget
+   * @param {function(new:Common.Emitable, ...)} eventType
+   * @param {(!Object|undefined)} receiver
+   * @param {function(!Common.Emitable)} method
+   */
+  constructor(eventTarget, eventType, receiver, method) {
+    this.eventTarget = eventTarget;
+    this.eventType = eventType;
+    this.receiver = receiver;
+    this.method = method;
+  }
+};
+
+/**
+ * @param {!Array<!Common.EventTarget.EventDescriptorStruct>} eventList
  */
 Common.EventTarget.removeEventListeners = function(eventList) {
   for (var i = 0; i < eventList.length; ++i) {
-    var eventInfo = eventList[i];
-    if (eventInfo instanceof Common.EventTarget.EventDescriptor)
+    if (eventList[i] instanceof Common.EventTarget.EventDescriptor) {
+      var eventInfo = /** @type {!Common.EventTarget.EventDescriptor} */ (eventList[i]);
       eventInfo.eventTarget.removeEventListener(eventInfo.eventType, eventInfo.method, eventInfo.receiver);
-    else
+    } else {
+      var eventInfo = /** @type {!Common.EventTarget.TypedEventDescriptor} */ (eventList[i]);
       eventInfo.eventTarget.off(eventInfo.eventType, eventInfo.method, eventInfo.receiver);
+    }
   }
   // Do not hold references on unused event descriptors.
   eventList.splice(0, eventList.length);
@@ -203,62 +274,23 @@ Common.EventTarget.prototype = {
   dispatchEventToListeners(eventType, eventData) {},
 
   /**
-   * @template T
-   * @param {function(new:T, ...)} eventType
+   * @param {function(new:Common.Emitable, ...)} eventType
    * @param {function(!T)} listener
    * @param {!Object=} thisObject
    * @return {!Common.EventTarget.TypedEventDescriptor}
+   * @template T
    */
   on(eventType, listener, thisObject) {},
 
   /**
-   * @template T
-   * @param {function(new:T, ...)} eventType
-   * @param {function(!T)} listener
+   * @param {function(new:Common.Emitable, ...)} eventType
+   * @param {function(!Common.Emitable)} listener
    * @param {!Object=} thisObject
    */
   off(eventType, listener, thisObject) {},
 
   /**
-   * @template T
-   * @param {!T} event
+   * @param {!Common.Emitable} event
    */
   emit(event) {},
 };
-
-/**
- * @unrestricted
- */
-Common.EventTarget.EventDescriptor = class {
-  /**
-   * @param {!Common.EventTarget} eventTarget
-   * @param {symbol} eventType
-   * @param {(!Object|undefined)} receiver
-   * @param {function(?):?} method
-   */
-  constructor(eventTarget, eventType, receiver, method) {
-    this.eventTarget = eventTarget;
-    this.eventType = eventType;
-    this.receiver = receiver;
-    this.method = method;
-  }
-};
-
-/**
- * @template T
- * @unrestricted
- */
-Common.EventTarget.TypedEventDescriptor = class {
-  /**
-   * @param {!Common.EventTarget} eventTarget
-   * @param {function(new:T, ...)} eventType
-   * @param {(!Object|undefined)} receiver
-   * @param {function(!T)} method
-   */
-  constructor(eventTarget, eventType, receiver, method) {
-    this.eventTarget = eventTarget;
-    this.eventType = eventType;
-    this.receiver = receiver;
-    this.method = method;
-  }
-};