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 69 matching lines @@
   T visitInterpolatedSelector(InterpolatedSelector node);
   T visitInterpolatedStatement(InterpolatedStatement node);
   T visitInterpolatedMethod(InterpolatedMethod node);
   T visitInterpolatedIdentifier(InterpolatedIdentifier node);
 
   T visitArrayBindingPattern(ArrayBindingPattern node);
   T visitObjectBindingPattern(ObjectBindingPattern node);
   T visitDestructuredVariable(DestructuredVariable 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 107 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 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 539 matching lines @@
       new VariableInitialization(declaration, value);
 }
 
 abstract class VariableBinding extends Expression {
 }
 
 class DestructuredVariable extends Expression implements Parameter {
   final Identifier 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 221 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
+  /// For TypeScript / Closure's ES6_TYPED.

[Jennifer Messerly, 2016/02/09 01:21:33]

Maybe:

/// Type parameters passed to this generic function, if any.

[ochafik, 2016/02/10 18:12:45]

Done.

+  List<Identifier> get typeArgs;

[Jennifer Messerly, 2016/02/09 01:21:33]

These are type parameters, right? I'd suggest naming it `typeParams`.

(aside: at some point we should probably bring JS_AST up to the style guide, and
not use abbreviations. Not now though. ;) )


I think JS_AST might use FunctionExpression for both arrow functions:

    <T>(x) => x

and for declarations:

    function foo<T>(x : T) : T {
    }

Do they all support type parameters? If not, you may want to move this to a
subclass or to NamedFunction.

That said it might be fine here, depending on what TypeScript/Closure supports.

BTW, does TypeScript/Closure support constraints on the generic, like `T extends
Foo`?
it looks like TypeScript does:
http://www.typescriptlang.org/Handbook#generics-generic-constraints

so it probably shouldn't be an identifier.

[ochafik, 2016/02/10 18:12:45]

Both kinds of generic functions are valid TS / ES6_TYPED (isn't it neat?)
Ouch, indeed... will leave a TODO if that's okay for now... (btw, would it be
worth decoupling Identifier from Parameter, if we introduce a TypeParameter?
Could simplify some of the declaration visitors I think)

+  /// For TypeScript / Closure's ES6_TYPED.

[Jennifer Messerly, 2016/02/09 01:21:33]

/// The return type of the function, if any.

[ochafik, 2016/02/10 18:12:45]

Done.

+  TypeRef get returnType;
 }
 
 class Fun extends FunctionExpression {
   final List<Parameter> params;
   final Block body;
+  final List<Identifier> typeArgs;

[Jennifer Messerly, 2016/02/09 01:21:33]

Not for now, but, what do you think about using @override?

I like it as a signal for "this already has documentation above".

[ochafik, 2016/02/10 18:12:45]

I love @override, so since you mentioned it... done. (we'd need a cleanup pass
in the visitors... and maybe a hint from the analyzer when it's missing, as in
Java?)

+  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.typeArgs, 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
+  final List<Identifier> typeArgs;
+  final TypeRef returnType;
 
-  ArrowFun(this.params, this.body);
+  ArrowFun(this.params, this.body, {this.typeArgs, 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;
+  /// For TypeScript / Closure's ES6_TYPED.

[Jennifer Messerly, 2016/02/09 01:21:33]

(Same comment -- I think we should give this a proper doc comment.)

[ochafik, 2016/02/10 18:12:45]

Done.

+  final List<Identifier> typeArgs;
+  /// For TypeScript / Closure's ES6_TYPED.
+  final List<VariableDeclarationList> fields;
 
-  ClassExpression(this.name, this.heritage, this.methods);
+  ClassExpression(this.name, this.heritage, this.methods,
+      [this.typeArgs = const [], this.fields = const []]);

[Jennifer Messerly, 2016/02/09 01:21:33]

I think it'd be fine to use a normal list. In general, we don't really use
immutable lists in js_ast, instead they're immutable by convention.

(At some point switching to BuiltList is probably a good idea.)

BTW: would this be worth named args? They're easier to version. Positional
optional args are only good if you know you won't ever want to add a named one
:)

[ochafik, 2016/02/10 18:12:45]

Done.

 
   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);
+    for (var field in fields) field.accept(visitor);
+    for (var typeParam in typeArgs) typeParam.accept(visitor);
   }
 
   ClassExpression _clone() => new ClassExpression(name, heritage, methods);
 
   int get precedenceLevel => PRIMARY_LOW_PRECEDENCE;
 }
 
 class Method extends Property {
   final bool isGetter;
   final bool isSetter;
@@ skipping 47 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);
 }