JS Interop Facade generation polish.

test/js_interop_test.ts

 /// <reference path="../typings/mocha/mocha.d.ts"/>
 import {expectTranslate} from './test_support';
 
 // TODO(jacobr): merge these tests back in with the other tests. These tests are
 // only separate because we expected at one point to integrate with TS2Dart
 // instead of refactoring TS2Dart to only output facades.
 describe('variables', () => {
   it('should print variable declaration', () => {
     expectTranslate('var a:number;').to.equal(`@JS()
 external num get a;
@@ skipping 261 matching lines @@
       expectTranslate('class X<T> { Z(): X<T> {} }').to.equal(`@JS()
 class X<T> {
   // @Ignore
   X.fakeConstructor$();
   external X<T> Z();
 }`);
     });
     it('merge overrides', () => {
       expectTranslate(`
 class X {
-  createElement(tagName: "img"): HTMLImageElement;
-  createElement(tagName: "video"): HTMLVideoElement;
-  createElement(tagName: string): HTMLElement;
+  createElement<T>(tagName: "img"): T;
+  createElement<T>(tagName: "video"): T;
+  createElement<T>(tagName: string): T;
+}`).to.equal(`@JS()
+class X {
+  // @Ignore
+  X.fakeConstructor$();
+  /*external T createElement<T>('img' tagName);*/
+  /*external T createElement<T>('video' tagName);*/
+  /*external T createElement<T>(String tagName);*/
+  external dynamic/*=T*/ createElement/*<T>*/(
+      String /*'img'|'video'|String*/ tagName);
+}`);
+
+      expectTranslate(`
+class X {
+  createElement<T>(tagName: "img"): T;
+  createElement<T>(tagName: "video"): T;
+  createElement<V>(tagName: string): V;
+}`).to.equal(`@JS()
+class X {
+  // @Ignore
+  X.fakeConstructor$();
+  /*external T createElement<T>('img' tagName);*/
+  /*external T createElement<T>('video' tagName);*/
+  /*external V createElement<V>(String tagName);*/
+  external dynamic /*T|V*/ createElement/*<T, V>*/(
+      String /*'img'|'video'|String*/ tagName);
+}`);
+
+      expectTranslate(`
+class X {
+  createElement<T extends HTMLImageElement>(tagName: "img"): T;
+  createElement<T extends HTMLVideoElement>(tagName: "video"): T;
+  createElement<T extends Element>(tagName: string): T;
 }`).to.equal(`import "dart:html";
 
 @JS()
 class X {
   // @Ignore
   X.fakeConstructor$();
-  /*external ImageElement createElement("img" tagName);*/
-  /*external VideoElement createElement("video" tagName);*/
-  /*external HtmlElement createElement(String tagName);*/
-  external dynamic /*ImageElement|VideoElement|HtmlElement*/ createElement(
-      String tagName);
+  /*external T createElement<T extends ImageElement>('img' tagName);*/
+  /*external T createElement<T extends VideoElement>('video' tagName);*/
+  /*external T createElement<T extends Element>(String tagName);*/
+  external dynamic/*=T*/ createElement/*<T>*/(
+      String /*'img'|'video'|String*/ tagName);
 }`);
+
+      expectTranslate(`export interface ScaleLinear<O> {
+    (value: number): Output;
+    domain(): Array<O>;
+}
+
+export function scaleLinear(): ScaleLinear<number>;
+export function scaleLinear<O>(): ScaleLinear<O>;`)
+          .to.equal(`@anonymous
+@JS()
+abstract class ScaleLinear<O> {
+  external Output call(num value);
+  external List<O> domain();
+}
+
+/*external ScaleLinear<num> scaleLinear();*/
+/*external ScaleLinear<O> scaleLinear<O>();*/
+@JS()
+external ScaleLinear /*ScaleLinear<num>|ScaleLinear<O>*/ scaleLinear/*<O>*/();`);
+
       expectTranslate(`
 class X {
   F(a:string):num;
   F(a:string, b: string|num):string;
   F(a2:string, b: string, c: num):string;
 }`).to.equal(`@JS()
 class X {
   // @Ignore
   X.fakeConstructor$();
   /*external num F(String a);*/
@@ skipping 43 matching lines @@
       expectTranslate(`
 interface SampleAudioNode {
   addEventListener(type: "ended", listener: (ev: Event) => any, useCapture?: boolean): void;
   addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
 }`).to.equal(`import "dart:html";
 import "package:func/func.dart";
 
 @anonymous
 @JS()
 abstract class SampleAudioNode {
-  /*external void addEventListener("ended" type, dynamic listener(Event ev), [bool useCapture]);*/
+  /*external void addEventListener('ended' type, dynamic listener(Event ev), [bool useCapture]);*/
   /*external void addEventListener(String type, EventListener|EventListenerObject listener, [bool useCapture]);*/
-  external void addEventListener(String type,
+  external void addEventListener(String /*'ended'|String*/ type,
       dynamic /*Func1<Event, dynamic>|EventListener|EventListenerObject*/ listener,
       [bool useCapture]);
 }`);
 
       expectTranslate(`
 interface ListenObject {
     someDummyMethod(evt: string): void;
 }
 
 interface ExampleListener {
     (evt: string): void;
 }
 
 interface DummySample {
-  addEventListener(type: "ended", listener: ListenObject): void;
+  addEventListener(type: 'ended', listener: ListenObject): void;
   addEventListener(type: string, listener: ExampleListener): void;
 }`).to.equal(`@anonymous
 @JS()
 abstract class ListenObject {
   external void someDummyMethod(String evt);
 }
 
 typedef void ExampleListener(String evt);
 
 @anonymous
 @JS()
 abstract class DummySample {
-  /*external void addEventListener("ended" type, ListenObject listener);*/
+  /*external void addEventListener('ended' type, ListenObject listener);*/
   /*external void addEventListener(String type, ExampleListener listener);*/
-  external void addEventListener(
-      String type, dynamic /*ListenObject|ExampleListener*/ listener);
+  external void addEventListener(String /*'ended'|String*/ type,
+      dynamic /*ListenObject|ExampleListener*/ listener);
 }`);
 
       expectTranslate(`
 interface ListenAny {
     (evt: any): void;
 }
 
 interface ExampleListener {
     (evt: string): void;
 }
 
 interface DummySample {
-  addEventListener(type: "ended", listener: ListenAny): void;
+  addEventListener(type: 'ended', listener: ListenAny): void;
   addEventListener(type: string, listener: ExampleListener): void;
 }`).to.equal(`typedef void ListenAny(dynamic evt);
 typedef void ExampleListener(String evt);
 
 @anonymous
 @JS()
 abstract class DummySample {
-  /*external void addEventListener("ended" type, ListenAny listener);*/
+  /*external void addEventListener('ended' type, ListenAny listener);*/
   /*external void addEventListener(String type, ExampleListener listener);*/
-  external void addEventListener(
-      String type, Function /*ListenAny|ExampleListener*/ listener);
+  external void addEventListener(String /*'ended'|String*/ type,
+      Function /*ListenAny|ExampleListener*/ listener);
 }`);
 
     });
     it('dot dot dot', () => {
       expectTranslate(`
 function buildName(firstName: string, ...restOfName: string[]): string;
 `).to.equal(`@JS()
 external String buildName(String firstName,
     [String restOfName1,
     String restOfName2,
     String restOfName3,
     String restOfName4,
     String restOfName5]);`);
       expectTranslate(`
 function log(...args);`)
           .to.equal(`@JS()
 external log([args1, args2, args3, args4, args5]);`);
     });
     it('interface constructors', () => {
       expectTranslate(`
 interface C {
   oncached: (ev: Event) => any;
 }
 declare var C: {new(): C; CHECKING: number; }`)
           .to.equal(`import "package:func/func.dart";
 import "dart:html";
 
-@JS()
+@JS("C")
 abstract class C {
   external Func1<Event, dynamic> get oncached;
   external set oncached(Func1<Event, dynamic> v);
   external factory C();
   external static num get CHECKING;
   external static set CHECKING(num v);
 }`);
     });
     it('property bag interfaces', () => {
       expectTranslate(`
@@ skipping 49 matching lines @@
   external B get d;
   external set d(B v);
   external dynamic get e;
   external set e(dynamic v);
   external factory Y({B d, dynamic e, A a, num b, X c});
 }`);
     });
     it('callable', () => {
       expectTranslate('interface X<T> { (a:T):T; Y():T; }').to.equal(`@anonymous
 @JS()
-abstract class X<T> implements Function {
+abstract class X<T> {
   external T call(T a);
   external T Y();
 }`);
     });
 
     it('supports constructors', () => {
       expectTranslate('class X { constructor() { } }').to.equal(`@JS()
 class X {
   // @Ignore
   X.fakeConstructor$();
@@ skipping 302 matching lines @@
 // End module m2
 @JS()
 external register(A x);`);
   });
 
   describe('type alias', () => {
     it('replace with simple type', () => {
       expectTranslate(`
 type MyNumber = number;
 export function add(x: MyNumber, y: MyNumber): MyNumber;
-        `).to.equal(`@JS()
+        `).to.equal(`/*type MyNumber = number;*/
+@JS()
 external num add(num x, num y);`);
     });
   });
 
   it('union types', () => {
+    // TODO(jacobr): we should resolve that listener1 and listener2 are both functions.
+
     // TODO(jacobr): ideally the draw method should specify that arg el has type
     // HtmlElement instead of dynamic.
     expectTranslate(`
 type listener1 = ()=>boolean;
 type listener2 = (e:string)=>boolean;
 function addEventListener(listener: listener1|listener2);`)
-        .to.equal(`import "package:func/func.dart";
-
+        .to.equal(`typedef bool listener1();
+typedef bool listener2(String e);
 @JS()
-external addEventListener(
-    Function /*Func0<bool>|Func1<String, bool>*/ listener);`);
+external addEventListener(dynamic /*listener1|listener2*/ listener);`);
 
     expectTranslate('function draw(el: HTMLCanvasElement|HTMLImageElement):void;')
         .to.equal(`import "dart:html";
 
 @JS()
 external void draw(dynamic /*CanvasElement|ImageElement*/ el);`);
   });
+
+  it('callback this type', () => {
+    expectTranslate(`
+function addEventListener(type: string, listener: (this: Element, event: Event) => void);`)
+        .to.equal(`import "dart:html";
+
+@JS()
+external addEventListener(
+    String type, void listener(/*Element this*/ Event event));`);
+    expectTranslate(`
+function addEventListener(type: 'load', listener: (this: HTMLImageElement, event: Event) => void);
+function addEventListener(type: string, listener: (this: Element, event: Event) => void);
+`).to.equal(`import "dart:html";
+import "package:func/func.dart";
+
+/*external addEventListener('load' type, void listener(ImageElement JS$this, Event event));*/
+/*external addEventListener(
+    String type, void listener(Element JS$this, Event event));*/
+@JS()
+external addEventListener(
+    String /*'load'|String*/ type, void listener(/*Element this*/ Event event));`);
+  });
 });