Type annotations instead of closure comments.

lib/src/js/nodes.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;
 
-abstract class NodeVisitor<T> {
+abstract class NodeVisitor<T> implements TypeRefVisitor<T> {
   T visitProgram(Program node);
 
   T visitBlock(Block node);
   T visitExpressionStatement(ExpressionStatement node);
   T visitEmptyStatement(EmptyStatement node);
   T visitIf(If node);
   T visitFor(For node);
   T visitForIn(ForIn node);
   T visitForOf(ForOf node);
   T visitWhile(While node);
@@ skipping 70 matching lines @@
   T visitInterpolatedStatement(InterpolatedStatement node);
   T visitInterpolatedMethod(InterpolatedMethod node);
   T visitInterpolatedIdentifier(InterpolatedIdentifier node);
 
   T visitArrayBindingPattern(ArrayBindingPattern node);
   T visitObjectBindingPattern(ObjectBindingPattern node);
   T visitDestructuredVariable(DestructuredVariable node);
   T visitSimpleBindingPattern(SimpleBindingPattern node);
 }
 
+abstract class TypeRefVisitor<T> {
+  T visitQualifiedTypeRef(QualifiedTypeRef node);
+  T visitGenericTypeRef(GenericTypeRef node);
+  T visitUnionTypeRef(UnionTypeRef node);
+  T visitRecordTypeRef(RecordTypeRef node);
+  T visitOptionalTypeRef(OptionalTypeRef node);
+  T visitFunctionTypeRef(FunctionTypeRef node);
+  T visitAnyTypeRef(AnyTypeRef node);
+  T visitUnknownTypeRef(UnknownTypeRef node);
+  T visitArrayTypeRef(ArrayTypeRef node);
+}
+
 class BaseVisitor<T> implements NodeVisitor<T> {
   T visitNode(Node node) {
     node.visitChildren(this);
     return null;
   }
 
   T visitProgram(Program node) => visitNode(node);
 
   T visitStatement(Statement node) => visitModuleItem(node);
   T visitLoop(Loop node) => visitStatement(node);
@@ skipping 108 matching lines @@
   T visitAwait(Await node) => visitExpression(node);
   T visitDartYield(DartYield node) => visitStatement(node);
 
   T visitBindingPattern(BindingPattern node) => visitNode(node);
   T visitArrayBindingPattern(ArrayBindingPattern node)
       => visitBindingPattern(node);
   T visitObjectBindingPattern(ObjectBindingPattern node)
       => visitBindingPattern(node);
   T visitDestructuredVariable(DestructuredVariable node) => visitNode(node);
   T visitSimpleBindingPattern(SimpleBindingPattern node) => visitNode(node);
+
+  T visitTypeRef(TypeRef node) => visitNode(node);
+  T visitQualifiedTypeRef(QualifiedTypeRef node) => visitTypeRef(node);
+  T visitGenericTypeRef(GenericTypeRef node) => visitTypeRef(node);
+  T visitOptionalTypeRef(OptionalTypeRef node) => visitTypeRef(node);
+  T visitRecordTypeRef(RecordTypeRef node) => visitTypeRef(node);
+  T visitUnionTypeRef(UnionTypeRef node) => visitTypeRef(node);
+  T visitFunctionTypeRef(FunctionTypeRef node) => visitTypeRef(node);
+  T visitAnyTypeRef(AnyTypeRef node) => visitTypeRef(node);
+  T visitUnknownTypeRef(UnknownTypeRef node) => visitTypeRef(node);
+  T visitArrayTypeRef(ArrayTypeRef node) => visitTypeRef(node);
 }
 
 abstract class Node {
   /// Sets the source location of this node. For performance reasons, we allow
   /// setting this after construction.
   Object sourceInformation;
 
   ClosureAnnotation _closureAnnotation;
   /// Closure annotation of this node.
   ClosureAnnotation get closureAnnotation => _closureAnnotation;
@@ skipping 540 matching lines @@
 }
 
 abstract class VariableBinding extends Expression {
 }
 
 class DestructuredVariable extends Expression implements Parameter {
   /// [LiteralString] or [Identifier].
   final Expression name;
   final BindingPattern structure;
   final Expression defaultValue;
-  DestructuredVariable({this.name, this.structure, this.defaultValue}) {
+  final TypeRef type;
+  DestructuredVariable({this.name, this.structure, this.defaultValue, this.type}) {
     assert(name != null || structure != null);
   }
 
   accept(NodeVisitor visitor) => visitor.visitDestructuredVariable(this);
   void visitChildren(NodeVisitor visitor) {
     name?.accept(visitor);
     structure?.accept(visitor);
     defaultValue?.accept(visitor);
   }
 
@@ skipping 232 matching lines @@
 
   Postfix _clone() => new Postfix(op, argument);
 
   void visitChildren(NodeVisitor visitor) {
     argument.accept(visitor);
   }
 
   int get precedenceLevel => UNARY;
 }
 
-abstract class Parameter implements Expression, VariableBinding {}
+abstract class Parameter implements Expression, VariableBinding {
+  TypeRef get type;
+}
 
 class Identifier extends Expression implements Parameter, VariableBinding {
   final String name;
   final bool allowRename;
+  final TypeRef type;
 
-  Identifier(this.name, {this.allowRename: true}) {
-    assert(_identifierRE.hasMatch(name));
+  Identifier(this.name, {this.allowRename: true, this.type}) {
+    if (!_identifierRE.hasMatch(name)) {
+      throw new ArgumentError.value(name, "name", "not a valid identifier");
+    }
   }
   static RegExp _identifierRE = new RegExp(r'^[A-Za-z_$][A-Za-z_$0-9]*$');
 
   Identifier _clone() =>
       new Identifier(name, allowRename: allowRename);
   accept(NodeVisitor visitor) => visitor.visitIdentifier(this);
   int get precedenceLevel => PRIMARY;
   void visitChildren(NodeVisitor visitor) {}
 }
 
 // This is an expression for convenience in the AST.
 class RestParameter extends Expression implements Parameter {
   final Identifier parameter;
+  TypeRef get type => null;
 
   RestParameter(this.parameter);
 
   RestParameter _clone() => new RestParameter(parameter);
   accept(NodeVisitor visitor) => visitor.visitRestParameter(this);
   void visitChildren(NodeVisitor visitor) {
     parameter.accept(visitor);
   }
   int get precedenceLevel => PRIMARY;
 }
@@ skipping 44 matching lines @@
     name.accept(visitor);
     function.accept(visitor);
   }
   NamedFunction _clone() => new NamedFunction(name, function);
 
   int get precedenceLevel => PRIMARY_LOW_PRECEDENCE;
 }
 
 abstract class FunctionExpression extends Expression {
   List<Parameter> get params;
+
   get body; // Expression or block
+  /// Type parameters passed to this generic function, if any. `null` otherwise.
+  // TODO(ochafik): Support type bounds.
+  List<Identifier> get typeParams;
+  /// Return type of this function, if any. `null` otherwise.
+  TypeRef get returnType;
 }
 
 class Fun extends FunctionExpression {
   final List<Parameter> params;
   final Block body;
+  @override final List<Identifier> typeParams;
+  @override final TypeRef returnType;
   /** Whether this is a JS generator (`function*`) that may contain `yield`. */
   final bool isGenerator;
 
   final AsyncModifier asyncModifier;
 
   Fun(this.params, this.body, {this.isGenerator: false,
-      this.asyncModifier: const AsyncModifier.sync()});
+      this.asyncModifier: const AsyncModifier.sync(),
+      this.typeParams, this.returnType});
 
   accept(NodeVisitor visitor) => visitor.visitFun(this);
 
   void visitChildren(NodeVisitor visitor) {
     for (Parameter param in params) param.accept(visitor);
     body.accept(visitor);
   }
 
   Fun _clone() => new Fun(params, body,
       isGenerator: isGenerator, asyncModifier: asyncModifier);
 
   int get precedenceLevel => PRIMARY_LOW_PRECEDENCE;
 }
 
 class ArrowFun extends FunctionExpression {
   final List<Parameter> params;
   final body; // Expression or Block
+  @override final List<Identifier> typeParams;
+  @override final TypeRef returnType;
 
-  ArrowFun(this.params, this.body);
+  ArrowFun(this.params, this.body, {this.typeParams, this.returnType});
 
   accept(NodeVisitor visitor) => visitor.visitArrowFun(this);
 
   void visitChildren(NodeVisitor visitor) {
     for (Parameter param in params) param.accept(visitor);
     body.accept(visitor);
   }
 
   int get precedenceLevel => PRIMARY_LOW_PRECEDENCE;
 
@@ skipping 266 matching lines @@
 
   accept(NodeVisitor visitor) => visitor.visitClassDeclaration(this);
   visitChildren(NodeVisitor visitor) => classExpr.accept(visitor);
   ClassDeclaration _clone() => new ClassDeclaration(classExpr);
 }
 
 class ClassExpression extends Expression {
   final Identifier name;
   final Expression heritage; // Can be null.
   final List<Method> methods;
+  /// Type parameters of this class, if any. `null` otherwise.
+  // TODO(ochafik): Support type bounds.
+  final List<Identifier> typeParams;
+  /// Field declarations of this class (TypeScript / ES6_TYPED).
+  final List<VariableDeclarationList> fields;
 
-  ClassExpression(this.name, this.heritage, this.methods);
+  ClassExpression(this.name, this.heritage, this.methods,
+      {this.typeParams, this.fields});
 
   accept(NodeVisitor visitor) => visitor.visitClassExpression(this);
 
   void visitChildren(NodeVisitor visitor) {
     name.accept(visitor);
     if (heritage != null) heritage.accept(visitor);
     for (Method element in methods) element.accept(visitor);
+    if (fields != null) {
+      for (var field in fields) {
+        field.accept(visitor);
+      }
+    }
+    if (typeParams != null) {
+      for (var typeParam in typeParams) {
+        typeParam.accept(visitor);
+      }
+    }
   }
 
-  ClassExpression _clone() => new ClassExpression(name, heritage, methods);
+  ClassExpression _clone() => new ClassExpression(
+      name, heritage, methods, typeParams: typeParams, fields: fields);
 
   int get precedenceLevel => PRIMARY_LOW_PRECEDENCE;
 }
 
 class Method extends Property {
   final bool isGetter;
   final bool isSetter;
   final bool isStatic;
 
   Method(Expression name, Fun function,
@@ skipping 44 matching lines @@
   InterpolatedLiteral(this.nameOrPosition);
 
   accept(NodeVisitor visitor) => visitor.visitInterpolatedLiteral(this);
   void visitChildren(NodeVisitor visitor) {}
   InterpolatedLiteral _clone() => new InterpolatedLiteral(nameOrPosition);
 }
 
 class InterpolatedParameter extends Expression with InterpolatedNode
     implements Identifier {
   final nameOrPosition;
+  TypeRef get type => null;
 
   String get name { throw "InterpolatedParameter.name must not be invoked"; }
   bool get allowRename => false;
 
   InterpolatedParameter(this.nameOrPosition);
 
   accept(NodeVisitor visitor) => visitor.visitInterpolatedParameter(this);
   void visitChildren(NodeVisitor visitor) {}
   InterpolatedParameter _clone() => new InterpolatedParameter(nameOrPosition);
 
@@ skipping 39 matching lines @@
   bool get isGetter => _unsupported;
   bool get isSetter => _unsupported;
   bool get isStatic => _unsupported;
   Fun get function => _unsupported;
   get _unsupported => throw '$runtimeType does not support this member.';
 }
 
 class InterpolatedIdentifier extends Expression with InterpolatedNode
     implements Identifier {
   final nameOrPosition;
+  TypeRef get type => null;
 
   InterpolatedIdentifier(this.nameOrPosition);
 
   accept(NodeVisitor visitor) =>
       visitor.visitInterpolatedIdentifier(this);
   void visitChildren(NodeVisitor visitor) {}
   InterpolatedIdentifier _clone() => new InterpolatedIdentifier(nameOrPosition);
 
   int get precedenceLevel => PRIMARY;
   String get name => throw '$runtimeType does not support this member.';
@@ skipping 182 matching lines @@
 
   final List<ModuleItem> body;
   Module(this.body, {this.name});
 
   accept(NodeVisitor visitor) => visitor.visitModule(this);
   void visitChildren(NodeVisitor visitor) {
     for (ModuleItem item in body) item.accept(visitor);
   }
   Module _clone() => new Module(body);
 }