Added support for Promise class properties (dart-archive#60)

* Added support for Promise class properties

Emitted extension getters and setters to expose them as Futures in the
generated facade

Refactored emission of getters and setters

Author: derekxu16

lib/declaration.ts

@@ -5,6 +5,21 @@ import {FacadeConverter} from './facade_converter';
 import {Transpiler} from './main';
 import {MergedMember, MergedParameter, MergedType, MergedTypeParameters} from './merge';
 
+const PRIVATE_CLASS_INSTANCE_IN_EXTENSIONS = 'tt';
+
+const enum emitPropertyMode {
+  getter,
+  setter
+}
+type emitPropertyOptions = {
+  mode: emitPropertyMode,
+  declaration: ts.PropertyDeclaration|ts.PropertySignature|ts.VariableDeclaration|
+             ts.ParameterDeclaration,
+  emitJsAnnotation: boolean,
+  isExternal: boolean,
+  emitBody?: (declaration: ts.PropertyDeclaration|ts.PropertySignature) => void
+};
+
 export function isFunctionLikeProperty(
     decl: ts.VariableDeclaration|ts.ParameterDeclaration|ts.PropertyDeclaration|
     ts.PropertySignature,
@@ -22,7 +37,7 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
   private extendsClass = false;
   private visitPromises = false;
   private containsPromises = false;
-  private promiseMethods: ts.SignatureDeclaration[] = [];
+  private promiseMembers: ts.SignatureDeclaration[] = [];
 
   static NUM_FAKE_REST_PARAMETERS = 5;
 
@@ -128,13 +143,13 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
     }
   }
 
-  private visitName(name: ts.Node) {
+  private visitName(name: ts.PropertyName|ts.BindingName) {
     if (base.getEnclosingClass(name) != null) {
       this.visit(name);
       return;
     }
     // Have to rewrite names in this case as we could have conflicts
-    // due to needing to support multiple JS modules in a single JS module
+    // due to needing to support multiple JS modules in a single Dart module
     if (!ts.isIdentifier(name)) {
       throw 'Internal error: unexpected function name kind:' + name.kind;
     }
@@ -327,16 +342,17 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
 
     orderedGroups.forEach((group: Array<ts.SignatureDeclaration>) => {
       const first = group[0];
-      // If the methods in this group return Promises and this.visitPromises is false, skip
-      // visiting these methods and add them to this.promiseMethods. If the methods in this group
-      // return Promises and this.visitPromises is true, it means that this function is being called
-      // from emitMethodsAsExtensions and the methods should now be visited.
+      // If the members in this group are Promise properties or Promise-returning methods and
+      // this.visitPromises is false, skip visiting these members and add them to
+      // this.promiseMembers. If the members in this group are/return Promises and
+      // this.visitPromises is true, it means that this function is being called from
+      // emitMembersAsExtensions and the members should now be visited.
       if (!this.visitPromises && base.isPromise(first.type)) {
         if (!this.containsPromises) {
           this.containsPromises = true;
         }
         group.forEach((declaration: ts.SignatureDeclaration) => {
-          this.promiseMethods.push(declaration);
+          this.promiseMembers.push(declaration);
         });
         return;
       }
@@ -529,7 +545,12 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
         this.visitMergingOverloads(sourceFile.statements);
         if (this.containsPromises) {
           this.addImport('package:js/js_util.dart', 'promiseToFuture');
-          this.emit(`@JS() abstract class Promise<T> {}\n`);
+          // TODO(derekx): Move this definition of the Promise class to a package
+          this.emit(`@JS()
+                     abstract class Promise<T> {
+                       external factory Promise(void executor(void resolve(T result), Function reject));
+                       external Promise then(void onFulfilled(T result), [Function onRejected]);
+                     }\n`);
         }
         break;
       case ts.SyntaxKind.ModuleBlock: {
@@ -540,26 +561,25 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
         // We have to handle variable declaration lists differently in the case
         // of JS interop because Dart does not support external variables.
         let varDeclList = <ts.VariableDeclarationList>node;
-        this.visitList(varDeclList.declarations, ';');
+        this.visitList(varDeclList.declarations, ' ');
       } break;
       case ts.SyntaxKind.VariableDeclaration: {
         // We have to handle variable declarations differently in the case of JS
         // interop because Dart does not support external variables.
         let varDecl = <ts.VariableDeclaration>node;
-        this.maybeEmitJsAnnotation(varDecl);
-        this.emit('external');
-        this.visit(varDecl.type);
-        this.emit('get');
-        this.visitName(varDecl.name);
+        this.emitProperty({
+          mode: emitPropertyMode.getter,
+          declaration: varDecl,
+          emitJsAnnotation: true,
+          isExternal: true
+        });
         if (!this.hasNodeFlag(varDecl, ts.NodeFlags.Const)) {
-          this.emitNoSpace(';');
-          this.maybeEmitJsAnnotation(varDecl);
-          this.emit('external');
-          this.emit('set');
-          this.visitName(varDecl.name);
-          this.emitNoSpace('(');
-          this.visit(varDecl.type);
-          this.emit('v)');
+          this.emitProperty({
+            mode: emitPropertyMode.setter,
+            declaration: varDecl,
+            emitJsAnnotation: true,
+            isExternal: true
+          });
         }
       } break;
       case ts.SyntaxKind.StringLiteral: {
@@ -651,9 +671,9 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
       case ts.SyntaxKind.ExpressionWithTypeArguments: {
         let exprWithTypeArgs = <ts.ExpressionWithTypeArguments>node;
         let expr = exprWithTypeArgs.expression;
-        if (expr.kind === ts.SyntaxKind.Identifier || expr.kind === ts.SyntaxKind.QualifiedName ||
-            expr.kind === ts.SyntaxKind.PropertyAccessExpression) {
-          this.fc.visitTypeName(expr as (ts.EntityName | ts.PropertyAccessExpression));
+        if (ts.isIdentifier(expr) || ts.isQualifiedName(expr) ||
+            ts.isPropertyAccessExpression(expr)) {
+          this.fc.visitTypeName(expr);
         } else {
           this.visit(expr);
         }
@@ -743,7 +763,6 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
       case ts.SyntaxKind.VariableStatement:
         let variableStmt = <ts.VariableStatement>node;
         this.visit(variableStmt.declarationList);
-        this.emitNoSpace(';');
         break;
       case ts.SyntaxKind.SwitchStatement:
       case ts.SyntaxKind.ArrayLiteralExpression:
@@ -771,7 +790,7 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
         if (name.kind !== ts.SyntaxKind.Identifier) {
           this.reportError(name, 'Unexpected name kind:' + name.kind);
         }
-        this.fc.visitTypeName(<ts.Identifier>name);
+        this.fc.visitTypeName(name);
       }
 
       if (fn.typeParameters) {
@@ -815,30 +834,26 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
       decl: ts.PropertyDeclaration|ts.ParameterDeclaration, isParameter?: boolean) {
     const hasValidName =
         !ts.isStringLiteral(decl.name) || base.isValidDartIdentifier(decl.name.text);
-    const isStatic = base.isStatic(decl);
 
     // TODO(derekx): Properties with names that contain special characters are currently ignored by
     // commenting them out. Determine a way to rename these properties in the future.
     this.maybeWrapInCodeComment({shouldWrap: !hasValidName, newLine: true}, () => {
-      this.emit('external');
-      if (isStatic) this.emit('static');
-      this.visit(decl.type);
-      this.emit('get');
-      this.visitName(decl.name);
-      this.emitNoSpace(';');
+      this.emitProperty({
+        mode: emitPropertyMode.getter,
+        declaration: decl,
+        emitJsAnnotation: false,
+        isExternal: true
+      });
     });
 
     if (!base.isReadonly(decl)) {
       this.maybeWrapInCodeComment({shouldWrap: !hasValidName, newLine: true}, () => {
-        this.emit('external');
-        if (isStatic) this.emit('static');
-        this.emit('set');
-        this.visitName(decl.name);
-        this.emitNoSpace('(');
-        this.visit(decl.type);
-        this.emit('v');
-        this.emitNoSpace(')');
-        this.emitNoSpace(';');
+        this.emitProperty({
+          mode: emitPropertyMode.setter,
+          declaration: decl,
+          emitJsAnnotation: false,
+          isExternal: true
+        });
       });
     }
   }
@@ -881,15 +896,15 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
 
     this.visitClassBody(decl, name);
     this.emit('}\n');
-    if (this.promiseMethods.length) {
+    if (this.promiseMembers.length) {
       const visitName = () => {
         this.visitClassLikeName(name, typeParameters, ts.createNodeArray(), false);
       };
       const visitNameOfExtensions = () => {
         this.visitClassLikeName(name, typeParameters, ts.createNodeArray(), true);
       };
-      this.emitMethodsAsExtensions(name, visitName, visitNameOfExtensions, this.promiseMethods);
-      this.promiseMethods = [];
+      this.emitMembersAsExtensions(name, visitName, visitNameOfExtensions, this.promiseMembers);
+      this.promiseMembers = [];
     }
     this.emit('\n');
   }
@@ -963,48 +978,106 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
     this.emitNoSpace(';');
   }
 
-  private emitMethodsAsExtensions(
-      className: ts.Identifier, visitName: () => void, visitNameOfExtensions: () => void,
+  private emitProperty({mode, declaration, emitJsAnnotation, isExternal, emitBody}:
+                           emitPropertyOptions) {
+    const {name, type} = declaration;
+
+    if (emitJsAnnotation) {
+      this.maybeEmitJsAnnotation(declaration);
+    }
+    if (isExternal) {
+      this.emit('external');
+    }
+    if (base.isStatic(declaration)) {
+      this.emit('static');
+    }
+    if (mode === emitPropertyMode.getter) {
+      this.visit(type);
+      this.emit('get');
+      this.visitName(name);
+    } else if (mode === emitPropertyMode.setter) {
+      this.emit('set');
+      this.visitName(name);
+      this.emitNoSpace('(');
+      this.visit(type);
+      this.emit('v)');
+    }
+    if (emitBody && !ts.isVariableDeclaration(declaration) && !ts.isParameter(declaration)) {
+      this.emit('{');
+      emitBody(declaration);
+      this.emit('}');
+    } else {
+      this.emitNoSpace(';');
+    }
+  }
+
+  private emitCastThisToPrivateClass(visitClassName: () => void) {
+    this.emit('final Object t = this;');
+    this.emit('final _');
+    visitClassName();
+    this.emit('tt = t;\n');
+  }
+
+  private emitMembersAsExtensions(
+      className: ts.Identifier, visitClassName: () => void, visitNameOfExtensions: () => void,
       methods: ts.SignatureDeclaration[]) {
     this.visitPromises = true;
+    this.fc.emitPromisesAsFutures = false;
     // Emit private class containing external methods
     this.emit(`@JS('${base.ident(className)}')`);
     this.emit(`abstract class _`);
-    visitName();
+    visitClassName();
     this.emit('{');
     const mergedMembers = this.visitMergingOverloads(ts.createNodeArray(Array.from(methods)));
     this.emit('}\n');
+    this.fc.emitPromisesAsFutures = true;
 
     // Emit extensions on public class to expose methods
     this.emit('extension');
     visitNameOfExtensions();
     this.emit('on');
-    visitName();
+    visitClassName();
     this.emit('{');
     for (const merged of mergedMembers) {
       const declaration = merged.mergedDeclaration;
-      if (!base.isPromise(declaration.type)) {
-        continue;
-      }
-      this.emit('Future');
-      if (ts.isTypeReferenceNode(declaration.type)) {
-        this.maybeVisitTypeArguments(declaration.type);
+      if (ts.isPropertyDeclaration(declaration) || ts.isPropertySignature(declaration)) {
+        this.emitProperty({
+          mode: emitPropertyMode.getter,
+          declaration,
+          emitJsAnnotation: false,
+          isExternal: false,
+          emitBody: () => {
+            this.emitCastThisToPrivateClass(visitClassName);
+            this.emitExtensionGetterBody(declaration);
+          }
+        });
+        if (!base.isReadonly(declaration)) {
+          this.emitProperty({
+            mode: emitPropertyMode.setter,
+            declaration,
+            emitJsAnnotation: false,
+            isExternal: false,
+            emitBody: () => {
+              this.emitCastThisToPrivateClass(visitClassName);
+              this.emitExtensionSetterBody(declaration);
+            }
+          });
+        }
+      } else if (ts.isMethodDeclaration(declaration) || ts.isMethodSignature(declaration)) {
+        this.visit(declaration.type);
+        this.visitName(declaration.name);
+        this.visitParameters(declaration.parameters, {namesOnly: false});
+        this.emit('{');
+        this.emitCastThisToPrivateClass(visitClassName);
+        this.emitExtensionMethodBody(merged);
+        this.emit('}\n');
       }
-      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.emitExtensionBody(merged);
-      this.emit('}\n');
     }
     this.emit('}\n');
     this.visitPromises = false;
   }
 
-  private emitExtensionBody({constituents, mergedDeclaration}: MergedMember) {
+  private emitExtensionMethodBody({constituents, mergedDeclaration}: MergedMember) {
     // Determine all valid arties of this method by going through the overloaded signatures
     const arities: Set<number> = new Set();
     for (const constituent of constituents) {
@@ -1031,15 +1104,42 @@ export default class DeclarationTranspiler extends base.TranspilerBase {
           this.emit('== null');
         }
         this.emit(') {');
-        this.emit(`return promiseToFuture(tt.${base.ident(mergedDeclaration.name)}`);
+        this.emit('return promiseToFuture(');
+        this.emit(PRIVATE_CLASS_INSTANCE_IN_EXTENSIONS);
+        this.emit('.');
+        this.visitName(mergedDeclaration.name);
         this.visitParameters(ts.createNodeArray(suppliedParameters), {namesOnly: true});
         this.emit('); }\n');
       } else {
         // No parameters were omitted, no null checks are necessary for this call
-        this.emit(`return promiseToFuture(tt.${base.ident(mergedDeclaration.name)}`);
+        this.emit('return promiseToFuture(');
+        this.emit(PRIVATE_CLASS_INSTANCE_IN_EXTENSIONS);
+        this.emit('.');
+        this.visitName(mergedDeclaration.name);
         this.visitParameters(ts.createNodeArray(mergedDeclaration.parameters), {namesOnly: true});
         this.emit(');\n');
       }
     }
   }
+
+  private emitExtensionGetterBody(declaration: ts.PropertyDeclaration|ts.PropertySignature) {
+    this.emit('return promiseToFuture(');
+    this.emit(PRIVATE_CLASS_INSTANCE_IN_EXTENSIONS);
+    this.emit('.');
+    this.visitName(declaration.name);
+    this.emit(');');
+  }
+
+  private emitExtensionSetterBody(declaration: ts.PropertyDeclaration|ts.PropertySignature) {
+    this.emit(PRIVATE_CLASS_INSTANCE_IN_EXTENSIONS);
+    this.emit('.');
+    this.visitName(declaration.name);
+    this.emit('=');
+    // To emit the call to the Promise constructor, we need to temporarily disable
+    // this.fc.emitPromisesAsFutures
+    this.fc.emitPromisesAsFutures = false;
+    this.visit(declaration.type);
+    this.fc.emitPromisesAsFutures = true;
+    this.emit('(allowInterop((resolve, reject) { v.then(resolve, onError: reject); }));');
+  }
 }