Added logic to handle methods that return Promises (dart-archive#52)

* Added logic to handle methods that return Promises

* Moved external methods that return Promises to private classes and exposed them through extension methods

* Emitted opaque Dart class for Promises

Author: derekxu16

lib/base.ts

@@ -260,6 +260,10 @@ export function isTypeNode(node: ts.Node): boolean {
   }
 }
 
+export function isPromise(type: ts.TypeNode): boolean {
+  return type && ts.isTypeReferenceNode(type) && ident(type.typeName) === 'Promise';
+}
+
 export function isCallable(decl: ClassLike): boolean {
   let members = decl.members as ReadonlyArray<ts.ClassElement>;
   return members.some((member) => {
@@ -473,7 +477,7 @@ export class TranspilerBase {
   /**
    * Returns whether any parameters were actually emitted.
    */
-  visitParameterList(nodes: ts.ParameterDeclaration[]): boolean {
+  visitParameterList(nodes: ts.ParameterDeclaration[], namesOnly: boolean): boolean {
     let emittedParameters = false;
     for (let i = 0; i < nodes.length; ++i) {
       let param = nodes[i];
@@ -489,7 +493,11 @@ export class TranspilerBase {
       if (emittedParameters) {
         this.emitNoSpace(',');
       }
-      this.visit(param);
+      if (namesOnly) {
+        this.emit(ident(param.name));
+      } else {
+        this.visit(param);
+      }
       emittedParameters = true;
     }
     return emittedParameters;
@@ -556,7 +564,7 @@ export class TranspilerBase {
     }
   }
 
-  visitParameters(parameters: ts.NodeArray<ts.ParameterDeclaration>) {
+  visitParameters(parameters: ts.NodeArray<ts.ParameterDeclaration>, {namesOnly = false}) {
     this.emitNoSpace('(');
     let firstInitParamIdx = 0;
     for (; firstInitParamIdx < parameters.length; firstInitParamIdx++) {
@@ -572,15 +580,19 @@ export class TranspilerBase {
     let hasValidParameters = false;
     if (firstInitParamIdx !== 0) {
       let requiredParams = parameters.slice(0, firstInitParamIdx);
-      hasValidParameters = this.visitParameterList(requiredParams);
+      hasValidParameters = this.visitParameterList(requiredParams, namesOnly);
     }
 
     if (firstInitParamIdx !== parameters.length) {
       if (hasValidParameters) this.emitNoSpace(',');
       let positionalOptional = parameters.slice(firstInitParamIdx, parameters.length);
-      this.emit('[');
-      this.visitParameterList(positionalOptional);
-      this.emitNoSpace(']');
+      if (!namesOnly) {
+        this.emit('[');
+      }
+      this.visitParameterList(positionalOptional, namesOnly);
+      if (!namesOnly) {
+        this.emitNoSpace(']');
+      }
     }
 
     this.emitNoSpace(')');

lib/declaration.ts

@@ -19,8 +19,9 @@ export function isFunctionLikeProperty(
 
 export default class DeclarationTranspiler extends base.TranspilerBase {
   private tc: ts.TypeChecker;
-
   private extendsClass = false;
+  private containsPromises = false;
+  private promiseMethods: Set<ts.FunctionLikeDeclaration> = new Set();
 
   static NUM_FAKE_REST_PARAMETERS = 5;
 
@@ -446,7 +447,7 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
             // instead.
             this.visit(fnType.type);
             this.visit(paramDecl.name);
-            this.visitParameters(fnType.parameters);
+            this.visitParameters(fnType.parameters, {namesOnly: false});
             break;
           }
         }
@@ -500,6 +501,11 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
       case ts.SyntaxKind.SourceFile:
         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`);
+        }
         break;
       case ts.SyntaxKind.ModuleBlock: {
         let block = <ts.ModuleBlock>node;
@@ -540,7 +546,7 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
         this.emit('external');
         this.visit(fn.type);
         this.emit('call');
-        this.visitParameters(fn.parameters);
+        this.visitParameters(fn.parameters, {namesOnly: false});
         this.emitNoSpace(';');
       } break;
       case ts.SyntaxKind.IndexSignature:
@@ -641,7 +647,7 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
         }
         this.visitDeclarationMetadata(ctorDecl);
         this.fc.visitTypeName(classDecl.name);
-        this.visitParameters(ctorDecl.parameters);
+        this.visitParameters(ctorDecl.parameters, {namesOnly: false});
         this.emitNoSpace(';');
         if (isAnonymous) {
           this.exitCodeComment();
@@ -681,6 +687,16 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
         break;
       case ts.SyntaxKind.MethodSignature:
         let methodSignatureDecl = <ts.FunctionLikeDeclaration>node;
+        if (base.isPromise(methodSignatureDecl.type)) {
+          if (this.promiseMethods.has(methodSignatureDecl)) {
+            break;
+          }
+          if (!this.containsPromises) {
+            this.containsPromises = true;
+          }
+          this.promiseMethods.add(methodSignatureDecl);
+          break;
+        }
         this.visitDeclarationMetadata(methodSignatureDecl);
         this.visitFunctionLike(methodSignatureDecl);
         break;
@@ -759,7 +775,7 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
       }
       // Dart does not even allow the parens of an empty param list on getter
       if (accessor !== 'get') {
-        this.visitParameters(fn.parameters);
+        this.visitParameters(fn.parameters, {namesOnly: false});
       } else {
         if (fn.parameters && fn.parameters.length > 0) {
           this.reportError(fn, 'getter should not accept parameters');
@@ -858,7 +874,12 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
                 (<ts.ConstructorDeclaration>ctor).parameters.forEach(synthesizePropertyParam));
 
     this.visitClassBody(decl, name);
-    this.emit('}\n\n');
+    this.emit('}\n');
+    if (this.promiseMethods.size) {
+      this.emitMethodsAsExtensions(name, this.promiseMethods);
+      this.promiseMethods.clear();
+    }
+    this.emit('\n');
   }
 
   private visitDeclarationMetadata(decl: ts.Declaration) {
@@ -906,7 +927,42 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
       this.exitTypeArguments();
       this.emitNoSpace('>');
     }
-    this.visitParameters(signature.parameters);
+    this.visitParameters(signature.parameters, {namesOnly: false});
     this.emitNoSpace(';');
   }
+
+  private emitMethodsAsExtensions(
+      className: ts.Identifier, methods: Set<ts.FunctionLikeDeclaration>) {
+    // Emit private class containing external methods
+    this.emit(`@JS('${base.ident(className)}')`);
+    this.emit(`abstract class _`);
+    this.fc.visitTypeName(className);
+    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('{');
+    for (const declaration of methods) {
+      if (!base.isPromise(declaration.type)) {
+        continue;
+      }
+      this.emit('Future');
+      this.emit(base.ident(declaration.name));
+      this.visitParameters(declaration.parameters, {namesOnly: false});
+      this.emit('{');
+      this.emit('final Object t = this;');
+      this.emit('final _');
+      this.fc.visitTypeName(className);
+      this.emit('tt = t;\n');
+      this.emit(`return promiseToFuture(tt.${base.ident(declaration.name)}`);
+      this.visitParameters(declaration.parameters, {namesOnly: true});
+      this.emit(');}\n');
+    }
+    this.emit('}\n');
+  }
 }

lib/main.ts

@@ -534,7 +534,8 @@ class Output {
     let buffer = this.insideCodeComment ? this.codeCommentResult : this.result;
     if (buffer.length > 0) {
       let lastChar = buffer.slice(-1);
-      if (lastChar !== ' ' && lastChar !== '(' && lastChar !== '<' && lastChar !== '[') {
+      if (lastChar !== ' ' && lastChar !== '(' && lastChar !== '<' && lastChar !== '[' &&
+          lastChar !== '_') {
         // Avoid emitting a space in obvious cases where a space is not required
         // to make the output slightly prettier in cases where the DartFormatter
         // cannot run such as within a comment where code we emit is not quite

test/declaration_test.ts

@@ -256,6 +256,32 @@ class X {
   X.fakeConstructor$();
   external 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;
+
+@anonymous
+@JS()
+abstract class MyMath {}
+
+@JS('MyMath')
+abstract class _MyMath {
+  Promise<num> randomInRange(num start, num end);
+}
+
+extension on MyMath {
+  Future randomInRange(num start, num end) {
+    final Object t = this;
+    final _MyMath tt = t;
+    return promiseToFuture(tt.randomInRange(start, end));
+  }
+}
+
+@JS()
+abstract class Promise<T> {}`);
     });
     it('supports abstract methods', () => {
       expectTranslate('abstract class X { abstract x(); }').to.equal(`@JS()

test/facade_converter_test.ts

@@ -7,7 +7,6 @@ function getSources(str: string): {[k: string]: string} {
           map(x: number): string { return String(x); }
           static get(m: any, k: string): number { return m[k]; }
         }
-        export class Promise {}
     `,
   };
   srcs[FAKE_MAIN] = str;