Named extension methods so that they get included in the library's export scope (dart-archive#54)

* Named extension methods so that they get included in the library's export scope

* Added type arguments to Futures and cleaned up visitName function

Author: derekxu16

lib/declaration.ts

@@ -502,7 +502,6 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
         let sourceFile = node as ts.SourceFile;
         this.visitMergingOverloads(sourceFile.statements);
         if (this.containsPromises) {
-          this.addImport('dart:async', 'Completer');
           this.addImport('package:js/js_util.dart', 'promiseToFuture');
           this.emit(`@JS() abstract class Promise<T> {}\n`);
         }
@@ -843,17 +842,14 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
       keyword: string, decl: base.ClassLike|ts.TypeLiteralNode, name: ts.Identifier,
       typeParameters: ts.NodeArray<ts.TypeParameterDeclaration>,
       heritageClauses: ts.NodeArray<ts.HeritageClause>) {
+    const visitName = () => {
+      this.visitClassLikeName(name, typeParameters, heritageClauses, false);
+    };
+    const visitNameOfExtensions = () => {
+      this.visitClassLikeName(name, typeParameters, heritageClauses, true);
+    };
     this.emit(keyword);
-    this.fc.visitTypeName(name);
-    if (typeParameters) {
-      this.emit('<');
-      this.enterTypeArguments();
-      this.visitList(typeParameters);
-      this.exitTypeArguments();
-      this.emit('>');
-    }
-
-    this.visitEachIfPresent(heritageClauses);
+    visitName();
     this.emit('{');
 
     this.maybeEmitFakeConstructors(decl);
@@ -876,12 +872,32 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
     this.visitClassBody(decl, name);
     this.emit('}\n');
     if (this.promiseMethods.size) {
-      this.emitMethodsAsExtensions(name, this.promiseMethods);
+      this.emitMethodsAsExtensions(name, visitName, visitNameOfExtensions, this.promiseMethods);
       this.promiseMethods.clear();
     }
     this.emit('\n');
   }
 
+  private visitClassLikeName(
+      name: ts.Identifier, typeParameters: ts.NodeArray<ts.TypeParameterDeclaration>,
+      heritageClauses: ts.NodeArray<ts.HeritageClause>, extension: boolean) {
+    this.fc.visitTypeName(name);
+
+    if (extension) {
+      this.emitNoSpace('Extensions');
+    }
+
+    if (typeParameters) {
+      this.emit('<');
+      this.enterTypeArguments();
+      this.visitList(typeParameters);
+      this.exitTypeArguments();
+      this.emit('>');
+    }
+
+    this.visitEachIfPresent(heritageClauses);
+  }
+
   private visitDeclarationMetadata(decl: ts.Declaration) {
     this.visitEachIfPresent(decl.modifiers);
 
@@ -932,26 +948,32 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
   }
 
   private emitMethodsAsExtensions(
-      className: ts.Identifier, methods: Set<ts.FunctionLikeDeclaration>) {
+      className: ts.Identifier, visitName: () => void, visitNameOfExtensions: () => void,
+      methods: Set<ts.FunctionLikeDeclaration>) {
     // Emit private class containing external methods
     this.emit(`@JS('${base.ident(className)}')`);
     this.emit(`abstract class _`);
-    this.fc.visitTypeName(className);
+    visitName();
     this.emit('{');
     for (const declaration of methods) {
       this.visitFunctionLike(declaration);
     }
     this.emit('}\n');
 
     // Emit extensions on public class to expose methods
-    this.emit('extension on');
-    this.fc.visitTypeName(className);
+    this.emit('extension');
+    visitNameOfExtensions();
+    this.emit('on');
+    visitName();
     this.emit('{');
     for (const declaration of methods) {
       if (!base.isPromise(declaration.type)) {
         continue;
       }
       this.emit('Future');
+      if (ts.isTypeReferenceNode(declaration.type)) {
+        this.maybeVisitTypeArguments(declaration.type);
+      }
       this.emit(base.ident(declaration.name));
       this.visitParameters(declaration.parameters, {namesOnly: false});
       this.emit('{');

test/declaration_test.ts

@@ -260,8 +260,7 @@ class X {
     it('should emit extension methods to return Futures from methods that return Promises', () => {
       expectTranslate(`declare interface MyMath {
         randomInRange(start: number, end: number): Promise<number>;
-      }`).to.equal(`import "dart:async" show Completer;
-import "package:js/js_util.dart" show promiseToFuture;
+      }`).to.equal(`import "package:js/js_util.dart" show promiseToFuture;
 
 @anonymous
 @JS()
@@ -272,14 +271,37 @@ abstract class _MyMath {
   Promise<num> randomInRange(num start, num end);
 }
 
-extension on MyMath {
-  Future randomInRange(num start, num end) {
+extension MyMathExtensions on MyMath {
+  Future<num> randomInRange(num start, num end) {
     final Object t = this;
     final _MyMath tt = t;
     return promiseToFuture(tt.randomInRange(start, end));
   }
 }
 
+@JS()
+abstract class Promise<T> {}`);
+      expectTranslate(`declare interface X<T> {
+        f(a: T): Promise<T>;
+      }`).to.equal(`import "package:js/js_util.dart" show promiseToFuture;
+
+@anonymous
+@JS()
+abstract class X<T> {}
+
+@JS('X')
+abstract class _X<T> {
+  Promise<T> f(T a);
+}
+
+extension XExtensions<T> on X<T> {
+  Future<T> f(T a) {
+    final Object t = this;
+    final _X tt = t;
+    return promiseToFuture(tt.f(a));
+  }
+}
+
 @JS()
 abstract class Promise<T> {}`);
     });