Split Parameter and TypeParameter out of Identifier

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> implements TypeRefVisitor<T> {
   T visitProgram(Program node);
 
   T visitBlock(Block node);
@@ skipping 29 matching lines @@
   T visitBinary(Binary node);
   T visitPrefix(Prefix node);
   T visitPostfix(Postfix node);
   T visitSpread(Spread node);
   T visitYield(Yield node);
 
   T visitIdentifier(Identifier node);
   T visitThis(This node);
   T visitSuper(Super node);
   T visitAccess(PropertyAccess node);
-  T visitRestParameter(RestParameter node);
 
   T visitNamedFunction(NamedFunction node);
   T visitFun(Fun node);
   T visitArrowFun(ArrowFun node);
 
   T visitLiteralBool(LiteralBool node);
   T visitLiteralString(LiteralString node);
   T visitLiteralNumber(LiteralNumber node);
   T visitLiteralNull(LiteralNull node);
 
@@ skipping 21 matching lines @@
   T visitCommentExpression(CommentExpression node);
 
   T visitInterpolatedExpression(InterpolatedExpression node);
   T visitInterpolatedLiteral(InterpolatedLiteral node);
   T visitInterpolatedParameter(InterpolatedParameter node);
   T visitInterpolatedSelector(InterpolatedSelector node);
   T visitInterpolatedStatement(InterpolatedStatement node);
   T visitInterpolatedMethod(InterpolatedMethod node);
   T visitInterpolatedIdentifier(InterpolatedIdentifier node);
 
+  T visitParameter(Parameter node);
+  T visitTypeParameter(TypeParameter 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);
@@ skipping 62 matching lines @@
   T visitPrefix(Prefix node) => visitExpression(node);
   T visitPostfix(Postfix node) => visitExpression(node);
   T visitSpread(Spread node) => visitPrefix(node);
   T visitYield(Yield node) => visitExpression(node);
   T visitAccess(PropertyAccess node) => visitExpression(node);
 
   T visitIdentifier(Identifier node) => visitExpression(node);
   T visitThis(This node) => visitExpression(node);
   T visitSuper(Super node) => visitExpression(node);
 
-  T visitRestParameter(RestParameter node) => visitNode(node);
-
   T visitNamedFunction(NamedFunction node) => visitExpression(node);
   T visitFunctionExpression(FunctionExpression node) => visitExpression(node);
   T visitFun(Fun node) => visitFunctionExpression(node);
   T visitArrowFun(ArrowFun node) => visitFunctionExpression(node);
 
   T visitLiteral(Literal node) => visitExpression(node);
 
   T visitLiteralBool(LiteralBool node) => visitLiteral(node);
   T visitLiteralString(LiteralString node) => visitLiteral(node);
   T visitLiteralNumber(LiteralNumber node) => visitLiteral(node);
@@ skipping 35 matching lines @@
   T visitInterpolatedIdentifier(InterpolatedIdentifier node)
       => visitInterpolatedNode(node);
 
   // Ignore comments by default.
   T visitComment(Comment node) => null;
   T visitCommentExpression(CommentExpression node) => null;
 
   T visitAwait(Await node) => visitExpression(node);
   T visitDartYield(DartYield node) => visitStatement(node);
 
+  T visitParameter(Parameter node) => visitNode(node);
+  T visitTypeParameter(TypeParameter node) => visitNode(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);
@@ skipping 440 matching lines @@
 
   accept(NodeVisitor visitor) => visitor.visitDartYield(this);
 
   void visitChildren(NodeVisitor visitor) {
     expression.accept(visitor);
   }
 
   DartYield _clone() => new DartYield(expression, hasStar);
 }
 
-abstract class Expression extends Node {
+abstract class Expression extends Node implements LValue {
   Expression();
 
   factory Expression.binary(List<Expression> exprs, String op) {
     Expression comma = null;
     for (var node in exprs) {
       comma = (comma == null) ? node : new Binary(op, comma, node);
     }
     return comma;
   }
 
@@ skipping 52 matching lines @@
       declaration.accept(visitor);
     }
   }
 
   VariableDeclarationList _clone() =>
       new VariableDeclarationList(keyword, declarations);
 
   int get precedenceLevel => EXPRESSION;
 }
 
+abstract class LValue implements Node {}
+
 class Assignment extends Expression {
-  final Expression leftHandSide;
+  final LValue leftHandSide;
   final String op;         // Null, if the assignment is not compound.
   final Expression value;  // May be null, for [VariableInitialization]s.
 
   Assignment(leftHandSide, value)
       : this.compound(leftHandSide, null, value);
   Assignment.compound(this.leftHandSide, this.op, this.value);
 
   int get precedenceLevel => ASSIGNMENT;
 
   bool get isCompound => op != null;
 
   accept(NodeVisitor visitor) => visitor.visitAssignment(this);
 
   void visitChildren(NodeVisitor visitor) {
     leftHandSide.accept(visitor);
     if (value != null) value.accept(visitor);
   }
 
   Assignment _clone() =>
       new Assignment.compound(leftHandSide, op, value);
 }
 
 class VariableInitialization extends Assignment {
+  final TypeRef type;
   /** [value] may be null. */
-  VariableInitialization(VariableBinding declaration, Expression value)
+  VariableInitialization(VariableBinding declaration, Expression value, {this.type})
       : super(declaration, value);
 
   VariableBinding get declaration => leftHandSide;
 
   accept(NodeVisitor visitor) => visitor.visitVariableInitialization(this);
 
   VariableInitialization _clone() =>
       new VariableInitialization(declaration, value);
 }
 
-abstract class VariableBinding extends Expression {
-}
+abstract class VariableBinding implements LValue {}
 
-class DestructuredVariable extends Expression implements Parameter {
+class DestructuredVariable extends Node implements VariableBinding {
   /// [LiteralString] or [Identifier].
   final Expression name;
   final BindingPattern structure;
   final Expression defaultValue;
   final TypeRef type;
-  DestructuredVariable({this.name, this.structure, this.defaultValue, this.type}) {
+  DestructuredVariable({this.name, this.structure, this.type, this.defaultValue}) {
     assert(name != null || structure != null);
   }
 
   accept(NodeVisitor visitor) => visitor.visitDestructuredVariable(this);
   void visitChildren(NodeVisitor visitor) {
     name?.accept(visitor);
     structure?.accept(visitor);
+    type?.accept(visitor);
     defaultValue?.accept(visitor);
   }
 
-  /// Avoid parenthesis when pretty-printing.
-  @override int get precedenceLevel => PRIMARY;
   @override Node _clone() =>
       new DestructuredVariable(
           name: name, structure: structure, defaultValue: defaultValue);
 }
 
 abstract class BindingPattern extends Expression implements VariableBinding {
   final List<DestructuredVariable> variables;
   BindingPattern(this.variables);
 
   void visitChildren(NodeVisitor visitor) {
@@ skipping 220 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 {
-  TypeRef get type;
+class Parameter extends Node implements VariableBinding {
+  final VariableBinding binding;
+  final TypeRef type;
+  final Expression defaultValue;
+  final bool isRest;
+  Parameter(this.binding, {this.type, this.defaultValue, this.isRest: false});
+
+  accept(NodeVisitor visitor) => visitor.visitParameter(this);
+  void visitChildren(NodeVisitor visitor) {
+    binding?.accept(visitor);
+    defaultValue?.accept(visitor);
+    type?.accept(visitor);
+  }
+  Parameter _clone() => new Parameter(binding, type: type, isRest: isRest);
 }
 
-class Identifier extends Expression implements Parameter, VariableBinding {
+class TypeParameter extends Node {
+  final Identifier name;
+  final TypeRef bound;
+  TypeParameter(this.name, {this.bound});
+
+  accept(NodeVisitor visitor) => visitor.visitTypeParameter(this);
+  void visitChildren(NodeVisitor visitor) {
+    name?.accept(visitor);
+    bound?.accept(visitor);
+  }
+  TypeParameter _clone() => new TypeParameter(name, bound: bound);
+}
+
+class Identifier extends Expression implements VariableBinding {
   final String name;
   final bool allowRename;
-  final TypeRef type;
 
-  Identifier(this.name, {this.allowRename: true, this.type}) {
+  Identifier(this.name, {this.allowRename: true}) {
     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;
-}
-
 class This extends Expression {
   accept(NodeVisitor visitor) => visitor.visitThis(this);
   This _clone() => new This();
   int get precedenceLevel => PRIMARY;
   void visitChildren(NodeVisitor visitor) {}
 
   static bool foundIn(Node node) {
     _thisFinder.found = false;
     node.accept(_thisFinder);
     return _thisFinder.found;
@@ skipping 37 matching lines @@
 
   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;
+  List<TypeParameter> 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 List<TypeParameter> 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.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 List<TypeParameter> typeParams;
   @override final TypeRef returnType;
 
   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);
   }
@@ skipping 271 matching lines @@
   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;
+  final List<TypeParameter> typeParams;
   /// Field declarations of this class (TypeScript / ES6_TYPED).
   final List<VariableDeclarationList> fields;
 
   ClassExpression(this.name, this.heritage, this.methods,
       {this.typeParams, this.fields});
 
   accept(NodeVisitor visitor) => visitor.visitClassExpression(this);
 
   void visitChildren(NodeVisitor visitor) {
     name.accept(visitor);
@@ skipping 68 matching lines @@
   final nameOrPosition;
 
   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 {
+    implements Parameter {
   final nameOrPosition;
+  final bool isRest;
   TypeRef get type => null;
 
-  String get name { throw "InterpolatedParameter.name must not be invoked"; }
+  Identifier get binding { throw "InterpolatedParameter.binding must not be invoked"; }
+  Expression get defaultValue { throw "InterpolatedParameter.defaultValue must not be invoked"; }
   bool get allowRename => false;
 
-  InterpolatedParameter(this.nameOrPosition);
+  InterpolatedParameter(this.nameOrPosition, {this.isRest: false});
 
   accept(NodeVisitor visitor) => visitor.visitInterpolatedParameter(this);
   void visitChildren(NodeVisitor visitor) {}
-  InterpolatedParameter _clone() => new InterpolatedParameter(nameOrPosition);
+  InterpolatedParameter _clone() =>
+      new InterpolatedParameter(nameOrPosition, isRest: isRest);
 
   int get precedenceLevel => PRIMARY;
 }
 
 class InterpolatedSelector extends Expression with InterpolatedNode {
   final nameOrPosition;
 
   InterpolatedSelector(this.nameOrPosition);
 
   accept(NodeVisitor visitor) => visitor.visitInterpolatedSelector(this);
@@ skipping 30 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);
 }