Type annotations instead of closure comments.

lib/src/js/printer.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of js_ast;
 
 
 class JavaScriptPrintingOptions {
   final bool shouldCompressOutput;
   final bool minifyLocalVariables;
   final bool preferSemicolonToNewlineInMinifiedOutput;
+  final bool shouldEmitTypes;
   final bool allowSingleLineIfStatements;
 
   /// True to allow keywords in properties, such as `obj.var` or `obj.function`
   /// Modern JS engines support this.
   final bool allowKeywordsInProperties;
 
   JavaScriptPrintingOptions(
       {this.shouldCompressOutput: false,
        this.minifyLocalVariables: false,
        this.preferSemicolonToNewlineInMinifiedOutput: false,
+       this.shouldEmitTypes: false,
        this.allowKeywordsInProperties: false,
        this.allowSingleLineIfStatements: false});
 }
 
 
 /// An environment in which JavaScript printing is done.  Provides emitting of
 /// text and pre- and post-visit callbacks.
 abstract class JavaScriptPrintingContext {
   /// Signals an error.  This should happen only for serious internal errors.
   void error(String message) { throw message; }
@@ skipping 12 matching lines @@
 class SimpleJavaScriptPrintingContext extends JavaScriptPrintingContext {
   final StringBuffer buffer = new StringBuffer();
 
   void emit(String string) {
     buffer.write(string);
   }
 
   String getText() => buffer.toString();
 }
 
-
-class Printer implements NodeVisitor {
+// TODO(ochafik): Inline the body of [TypeScriptTypePrinter] here if/when it no
+// longer needs to share utils with [ClosureTypePrinter].
+class Printer extends TypeScriptTypePrinter implements NodeVisitor {
   final JavaScriptPrintingOptions options;
   final JavaScriptPrintingContext context;
   final bool shouldCompressOutput;
   final DanglingElseVisitor danglingElseVisitor;
   final LocalNamer localNamer;
 
   bool inForInit = false;
   bool atStatementBegin = false;
   bool inNewTarget = false;
   bool pendingSemicolon = false;
@@ skipping 468 matching lines @@
   void functionOut(Fun fun, Node name) {
     out("function");
     if (fun.isGenerator) out("*");
     if (name != null) {
       out(" ");
       // Name must be a [Decl]. Therefore only test for primary expressions.
       visitNestedExpression(name, PRIMARY,
                             newInForInit: false, newAtStatementBegin: false);
     }
     localNamer.enterScope(fun);
+    outTypeParams(fun.typeParams);
     out("(");
     if (fun.params != null) {
       visitCommaSeparated(fun.params, PRIMARY,
                           newInForInit: false, newAtStatementBegin: false);
     }
     out(")");
+    outTypeAnnotation(fun.returnType);
     switch (fun.asyncModifier) {
       case const AsyncModifier.sync():
         break;
       case const AsyncModifier.async():
         out(' async');
         break;
       case const AsyncModifier.syncStar():
         out(' sync*');
         break;
       case const AsyncModifier.asyncStar():
@@ skipping 34 matching lines @@
       out(")");
     } else {
       inForInit = newInForInit;
       atStatementBegin = newAtStatementBegin;
       visit(node);
     }
   }
 
   visitVariableDeclarationList(VariableDeclarationList list) {
     outClosureAnnotation(list);
-    out(list.keyword);
-    out(" ");
+    // Note: keyword can be null for non-static field declarations.
+    if (list.keyword != null) {
+      out(list.keyword);
+      out(" ");
+    }
     visitCommaSeparated(list.declarations, ASSIGNMENT,
                         newInForInit: inForInit, newAtStatementBegin: false);
   }
 
   visitArrayBindingPattern(ArrayBindingPattern node) {
     out("[");
     visitCommaSeparated(node.variables, EXPRESSION,
                         newInForInit: false, newAtStatementBegin: false);
     out("]");
   }
@@ skipping 16 matching lines @@
         visit(name);
       }
     }
     if (node.structure != null) {
       if (hasName) {
         out(":");
         spaceOut();
       }
       visit(node.structure);
     }
+    outTypeAnnotation(node.type);
     if (node.defaultValue != null) {
       spaceOut();
       out("=");
       spaceOut();
       visitNestedExpression(node.defaultValue, EXPRESSION,
                             newInForInit: false, newAtStatementBegin: false);
     }
   }
 
   visitSimpleBindingPattern(SimpleBindingPattern node) {
@@ skipping 210 matching lines @@
   visitThis(This node) {
     out("this");
   }
 
   visitSuper(Super node) {
     out("super");
   }
 
   visitIdentifier(Identifier node) {
     out(localNamer.getName(node));
+    outTypeAnnotation(node.type);
   }
 
   visitRestParameter(RestParameter node) {
     out('...');
     visitIdentifier(node.parameter);
   }
 
   bool isDigit(int charCode) {
     return charCodes.$0 <= charCode && charCode <= charCodes.$9;
   }
@@ skipping 45 matching lines @@
   visitNamedFunction(NamedFunction namedFunction) {
     functionOut(namedFunction.function, namedFunction.name);
   }
 
   visitFun(Fun fun) {
     functionOut(fun, null);
   }
 
   visitArrowFun(ArrowFun fun) {
     localNamer.enterScope(fun);
-    if (fun.params.length == 1) {
+    if (fun.params.length == 1 &&
+        (fun.params.single.type == null || !options.shouldEmitTypes)) {
       visitNestedExpression(fun.params.single, SPREAD,
           newInForInit: false, newAtStatementBegin: false);
     } else {
       out("(");
       visitCommaSeparated(fun.params, SPREAD,
           newInForInit: false, newAtStatementBegin: false);
       out(")");
     }
+    outTypeAnnotation(fun.returnType);
     spaceOut();
     out("=>");
     if (fun.body is Expression) {
       spaceOut();
       // Object initializers require parenthesis to disambiguate
       // AssignmentExpression from FunctionBody. See:
       // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-arrow-function-definitions
       var needsParen = fun.body is ObjectInitializer;
       if (needsParen) out("(");
       visitNestedExpression(fun.body, ASSIGNMENT,
@@ skipping 118 matching lines @@
     visit(node.tag);
     visit(node.template);
   }
 
   visitClassDeclaration(ClassDeclaration node) {
     indent();
     visit(node.classExpr);
     lineOut();
   }
 
+  void outTypeParams(Iterable<Identifier> typeParams) {
+    if (typeParams != null && options.shouldEmitTypes && typeParams.isNotEmpty) {
+      out("<");
+      var first = true;
+      for (var typeParam in typeParams) {
+        if (!first) out(", ");
+        first = false;
+        visit(typeParam);
+      }
+      out(">");
+    }
+  }
+
   visitClassExpression(ClassExpression node) {
     out('class ');
     visit(node.name);
+    outTypeParams(node.typeParams);
     if (node.heritage != null) {
       out(' extends ');
       visit(node.heritage);
     }
     spaceOut();
     if (node.methods.isNotEmpty) {
       out('{');
       lineOut();
       indentMore();
+      if (options.shouldEmitTypes && node.fields != null) {
+        for (var field in node.fields) {
+          indent();
+          visit(field);
+          out(";");
+          lineOut();
+        }
+      }
       for (var method in node.methods) {
         indent();
         visit(method);
         lineOut();
       }
       indentLess();
       indent();
       out('}');
     } else {
       out('{}');
@@ skipping 211 matching lines @@
     } else {
       out('/* $comment */');
     }
     visit(node.expression);
   }
 
   void visitAwait(Await node) {
     out("await ");
     visit(node.expression);
   }
+
+  void outTypeAnnotation(TypeRef node) {
+    if (node == null || !options.shouldEmitTypes || node.isUnknown) return;
+
+    if (node is OptionalTypeRef) {
+      out("?: ");
+      visit(node.type);
+    } else {
+      out(": ");
+      visit(node);
+    }
+  }
 }
 
 // Collects all the var declarations in the function.  We need to do this in a
 // separate pass because JS vars are lifted to the top of the function.
 class VarCollector extends BaseVisitor {
   bool nested;
   final Set<String> vars;
   final Set<String> params;
 
   VarCollector() : nested = false,
@@ skipping 299 matching lines @@
     declare(node.name);
     node.function.accept(this);
   }
 
   visitClassExpression(ClassExpression node) {
     declare(node.name);
     if (node.heritage != null) node.heritage.accept(this);
     for (Method element in node.methods) element.accept(this);
   }
 }