Add support for the new function-type syntax.

pkg/compiler/lib/src/tree/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.
 
 import 'dart:collection' show IterableMixin;
 
 import '../common.dart';
 import '../elements/elements.dart' show MetadataAnnotation;
 import '../resolution/secret_tree_element.dart'
     show NullTreeElementMixin, StoredTreeElementMixin;
@@ skipping 33 matching lines @@
   R visitDoWhile(DoWhile node) => visitLoop(node);
   R visitEmptyStatement(EmptyStatement node) => visitStatement(node);
   R visitEnum(Enum node) => visitNode(node);
   R visitExport(Export node) => visitLibraryDependency(node);
   R visitExpression(Expression node) => visitNode(node);
   R visitExpressionStatement(ExpressionStatement node) => visitStatement(node);
   R visitFor(For node) => visitLoop(node);
   R visitForIn(ForIn node) => visitLoop(node);
   R visitFunctionDeclaration(FunctionDeclaration node) => visitStatement(node);
   R visitFunctionExpression(FunctionExpression node) => visitExpression(node);
+  R visitFunctionTypeAnnotation(FunctionTypeAnnotation node) {
+    return visitTypeAnnotation(node);
+  }
+
   R visitGotoStatement(GotoStatement node) => visitStatement(node);
   R visitIdentifier(Identifier node) => visitExpression(node);
   R visitImport(Import node) => visitLibraryDependency(node);
   R visitIf(If node) => visitStatement(node);
   R visitLabel(Label node) => visitNode(node);
   R visitLabeledStatement(LabeledStatement node) => visitStatement(node);
   R visitLibraryDependency(LibraryDependency node) => visitLibraryTag(node);
   R visitLibraryName(LibraryName node) => visitLibraryTag(node);
   R visitLibraryTag(LibraryTag node) => visitNode(node);
   R visitLiteral(Literal node) => visitExpression(node);
@@ skipping 11 matching lines @@
   R visitMetadata(Metadata node) => visitNode(node);
   R visitMixinApplication(MixinApplication node) => visitNode(node);
   R visitModifiers(Modifiers node) => visitNode(node);
   R visitNamedArgument(NamedArgument node) => visitExpression(node);
   R visitNamedMixinApplication(NamedMixinApplication node) {
     return visitMixinApplication(node);
   }
 
   R visitNewExpression(NewExpression node) => visitExpression(node);
   R visitNodeList(NodeList node) => visitNode(node);
+  R visitNominalTypeAnnotation(NominalTypeAnnotation node) {
+    return visitTypeAnnotation(node);
+  }
+
   R visitOperator(Operator node) => visitIdentifier(node);
   R visitParenthesizedExpression(ParenthesizedExpression node) {
     return visitExpression(node);
   }
 
   R visitPart(Part node) => visitLibraryTag(node);
   R visitPartOf(PartOf node) => visitNode(node);
   R visitPostfix(Postfix node) => visitNodeList(node);
   R visitPrefix(Prefix node) => visitNodeList(node);
   R visitRedirectingFactoryBody(RedirectingFactoryBody node) {
@@ skipping 77 matching lines @@
   R visitFor(For node, A arg) => visitLoop(node, arg);
   R visitForIn(ForIn node, A arg) => visitLoop(node, arg);
   R visitFunctionDeclaration(FunctionDeclaration node, A arg) {
     return visitStatement(node, arg);
   }
 
   R visitFunctionExpression(FunctionExpression node, A arg) {
     return visitExpression(node, arg);
   }
 
+  R visitFunctionTypeAnnotation(FunctionTypeAnnotation node, A arg) {
+    return visitTypeAnnotation(node, arg);
+  }
+
   R visitGotoStatement(GotoStatement node, A arg) {
     return visitStatement(node, arg);
   }
 
   R visitIdentifier(Identifier node, A arg) {
     return visitExpression(node, arg);
   }
 
   R visitImport(Import node, A arg) {
     return visitLibraryDependency(node, arg);
@@ skipping 29 matching lines @@
   R visitMetadata(Metadata node, A arg) => visitNode(node, arg);
   R visitMixinApplication(MixinApplication node, A arg) => visitNode(node, arg);
   R visitModifiers(Modifiers node, A arg) => visitNode(node, arg);
   R visitNamedArgument(NamedArgument node, A arg) => visitExpression(node, arg);
   R visitNamedMixinApplication(NamedMixinApplication node, A arg) {
     return visitMixinApplication(node, arg);
   }
 
   R visitNewExpression(NewExpression node, A arg) => visitExpression(node, arg);
   R visitNodeList(NodeList node, A arg) => visitNode(node, arg);
+  R visitNominalTypeAnnotation(NominalTypeAnnotation node, A arg) {
+    visitTypeAnnotation(node, arg);
+  }
+
   R visitOperator(Operator node, A arg) => visitIdentifier(node, arg);
   R visitParenthesizedExpression(ParenthesizedExpression node, A arg) {
     return visitExpression(node, arg);
   }
 
   R visitPart(Part node, A arg) => visitLibraryTag(node, arg);
   R visitPartOf(PartOf node, A arg) => visitNode(node, arg);
   R visitPostfix(Postfix node, A arg) => visitNodeList(node, arg);
   R visitPrefix(Prefix node, A arg) => visitNodeList(node, arg);
   R visitRedirectingFactoryBody(RedirectingFactoryBody node, A arg) {
@@ skipping 15 matching lines @@
   }
 
   R visitSwitchCase(SwitchCase node, A arg) => visitNode(node, arg);
   R visitSwitchStatement(SwitchStatement node, A arg) {
     return visitStatement(node, arg);
   }
 
   R visitLiteralSymbol(LiteralSymbol node, A arg) => visitExpression(node, arg);
   R visitThrow(Throw node, A arg) => visitExpression(node, arg);
   R visitTryStatement(TryStatement node, A arg) => visitStatement(node, arg);
+  R visitTypedef(Typedef node, A arg) => visitNode(node, arg);
   R visitTypeAnnotation(TypeAnnotation node, A arg) => visitNode(node, arg);
-  R visitTypedef(Typedef node, A arg) => visitNode(node, arg);
   R visitTypeVariable(TypeVariable node, A arg) => visitNode(node, arg);
   R visitVariableDefinitions(VariableDefinitions node, A arg) {
     return visitStatement(node, arg);
   }
 
   R visitWhile(While node, A arg) => visitLoop(node, arg);
   R visitYield(Yield node, A arg) => visitStatement(node, arg);
 }
 
 Token firstBeginToken(Node first, Node second) {
@@ skipping 78 matching lines @@
   ErrorExpression asErrorExpression() => null;
   Export asExport() => null;
   Expression asExpression() => null;
   ExpressionStatement asExpressionStatement() => null;
   For asFor() => null;
   SyncForIn asSyncForIn() => null;
   AsyncForIn asAsyncForIn() => null;
   ForIn asForIn() => null;
   FunctionDeclaration asFunctionDeclaration() => null;
   FunctionExpression asFunctionExpression() => null;
+  FunctionTypeAnnotation asFunctionTypeAnnotation() => null;
   Identifier asIdentifier() => null;
   If asIf() => null;
   Import asImport() => null;
   Label asLabel() => null;
   LabeledStatement asLabeledStatement() => null;
   LibraryName asLibraryName() => null;
   LibraryDependency asLibraryDependency() => null;
   LiteralBool asLiteralBool() => null;
   LiteralDouble asLiteralDouble() => null;
   LiteralInt asLiteralInt() => null;
   LiteralList asLiteralList() => null;
   LiteralMap asLiteralMap() => null;
   LiteralMapEntry asLiteralMapEntry() => null;
   LiteralNull asLiteralNull() => null;
   LiteralString asLiteralString() => null;
   LiteralSymbol asLiteralSymbol() => null;
   Metadata asMetadata() => null;
   MixinApplication asMixinApplication() => null;
   Modifiers asModifiers() => null;
   NamedArgument asNamedArgument() => null;
   NamedMixinApplication asNamedMixinApplication() => null;
   NewExpression asNewExpression() => null;
   NodeList asNodeList() => null;
+  NominalTypeAnnotation asNominalTypeAnnotation() => null;
   Operator asOperator() => null;
   ParenthesizedExpression asParenthesizedExpression() => null;
   Part asPart() => null;
   PartOf asPartOf() => null;
   RedirectingFactoryBody asRedirectingFactoryBody() => null;
   Rethrow asRethrow() => null;
   Return asReturn() => null;
   Send asSend() => null;
   SendSet asSendSet() => null;
   Statement asStatement() => null;
   StringInterpolation asStringInterpolation() => null;
   StringInterpolationPart asStringInterpolationPart() => null;
   StringJuxtaposition asStringJuxtaposition() => null;
   StringNode asStringNode() => null;
   SwitchCase asSwitchCase() => null;
   SwitchStatement asSwitchStatement() => null;
   Throw asThrow() => null;
   TryStatement asTryStatement() => null;
-  TypeAnnotation asTypeAnnotation() => null;
   TypeVariable asTypeVariable() => null;
   Typedef asTypedef() => null;
   VariableDefinitions asVariableDefinitions() => null;
   While asWhile() => null;
   Yield asYield() => null;
 
   bool isValidBreakTarget() => false;
   bool isValidContinueTarget() => false;
   bool isThis() => false;
   bool isSuper() => false;
@@ skipping 64 matching lines @@
       token = name.getEndToken();
     }
     assert(token != null);
     return token;
   }
 
   Token getEndToken() => endToken;
 }
 
 class MixinApplication extends Node {
-  final TypeAnnotation superclass;
+  final NominalTypeAnnotation superclass;
   final NodeList mixins;
 
   MixinApplication(this.superclass, this.mixins);
 
   MixinApplication asMixinApplication() => this;
 
   accept(Visitor visitor) => visitor.visitMixinApplication(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitMixinApplication(this, arg);
 
   visitChildren(Visitor visitor) {
     if (superclass != null) superclass.accept(visitor);
     if (mixins != null) mixins.accept(visitor);
   }
 
   visitChildren1(Visitor1 visitor, arg) {
     if (superclass != null) superclass.accept1(visitor, arg);
     if (mixins != null) mixins.accept1(visitor, arg);
   }
 
   Token getBeginToken() => superclass.getBeginToken();
   Token getEndToken() => mixins.getEndToken();
 }
 
-// TODO(kasperl): Let this share some structure with the typedef for function
-// type aliases?
 class NamedMixinApplication extends Node implements MixinApplication {
   final Identifier name;
   final NodeList typeParameters;
 
   final Modifiers modifiers;
   final MixinApplication mixinApplication;
   final NodeList interfaces;
 
   final Token classKeyword;
   final Token endToken;
 
   NamedMixinApplication(this.name, this.typeParameters, this.modifiers,
       this.mixinApplication, this.interfaces, this.classKeyword, this.endToken);
 
-  TypeAnnotation get superclass => mixinApplication.superclass;
+  NominalTypeAnnotation get superclass => mixinApplication.superclass;
   NodeList get mixins => mixinApplication.mixins;
 
   MixinApplication asMixinApplication() => this;
   NamedMixinApplication asNamedMixinApplication() => this;
 
   accept(Visitor visitor) => visitor.visitNamedMixinApplication(this);
 
   accept1(Visitor1 visitor, arg) {
     return visitor.visitNamedMixinApplication(this, arg);
   }
@@ skipping 1172 matching lines @@
   accept1(Visitor1 visitor, arg) => visitor.visitRethrow(this, arg);
 
   visitChildren(Visitor visitor) {}
 
   visitChildren1(Visitor1 visitor, arg) {}
 
   Token getBeginToken() => throwToken;
   Token getEndToken() => endToken;
 }
 
-class TypeAnnotation extends Node {
+abstract class TypeAnnotation extends Node {
+}
+
+class NominalTypeAnnotation extends TypeAnnotation {
   final Expression typeName;
   final NodeList typeArguments;
 
-  TypeAnnotation(Expression this.typeName, NodeList this.typeArguments);
+  NominalTypeAnnotation(this.typeName, this.typeArguments);
 
-  TypeAnnotation asTypeAnnotation() => this;
+  NominalTypeAnnotation asNominalTypeAnnotation() => this;
 
-  accept(Visitor visitor) => visitor.visitTypeAnnotation(this);
+  accept(Visitor visitor) => visitor.visitNominalTypeAnnotation(this);
 
-  accept1(Visitor1 visitor, arg) => visitor.visitTypeAnnotation(this, arg);
+  accept1(Visitor1 visitor, arg) {
+    return visitor.visitNominalTypeAnnotation(this, arg);
+  }
 
   visitChildren(Visitor visitor) {
     typeName.accept(visitor);
     if (typeArguments != null) typeArguments.accept(visitor);
   }
 
   visitChildren1(Visitor1 visitor, arg) {
     typeName.accept1(visitor, arg);
     if (typeArguments != null) typeArguments.accept1(visitor, arg);
   }
@@ skipping 75 matching lines @@
   }
 
   Token getBeginToken() {
     var token = firstBeginToken(modifiers, type);
     if (token == null) {
       token = definitions.getBeginToken();
     }
     return token;
   }
 
-  Token getEndToken() => definitions.getEndToken();
+  Token getEndToken() {
+    var result = definitions.getEndToken();
+    if (result != null) return result;
+    assert(definitions.nodes.length == 1);
+    assert(definitions.nodes.last == null);
+    return type.getEndToken();
+  }
 }
 
 abstract class Loop extends Statement {
   Expression get condition;
   final Statement body;
 
   Loop(this.body);
 
   bool isValidContinueTarget() => true;
 }
@@ skipping 1007 matching lines @@
   visitChildren(Visitor visitor) => identifiers.accept(visitor);
 
   visitChildren1(Visitor1 visitor, arg) => identifiers.accept1(visitor, arg);
 
   Token getBeginToken() => keywordToken;
 
   Token getEndToken() => identifiers.getEndToken();
 }
 
 class Typedef extends Node {
+  final bool isGeneralizedTypeAlias;
+
+  /// Parameters to the template.
+  ///
+  /// For example, `T` and `S` are template parameters in the following
+  /// typedef: `typedef F<S, T> = Function(S, T)`, or, in the inlined syntax,
+  /// `typedef F<S, T>(S x, T y)`.
+  final NodeList templateParameters;
+
   final TypeAnnotation returnType;
   final Identifier name;
+  /// The generic type parameters to the function type.
+  ///
+  /// For example `A` and `B` (but not `T`) are type parameters in
+  /// `typedef F<T> = Function<A, B>(A, B, T)`;
   final NodeList typeParameters;
   final NodeList formals;
 
   final Token typedefKeyword;
   final Token endToken;
 
-  Typedef(this.returnType, this.name, this.typeParameters, this.formals,
-      this.typedefKeyword, this.endToken);
+  Typedef(this.isGeneralizedTypeAlias, this.templateParameters, this.returnType,
+      this.name, this.typeParameters, this.formals, this.typedefKeyword,
+      this.endToken);
 
   Typedef asTypedef() => this;
 
   accept(Visitor visitor) => visitor.visitTypedef(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitTypedef(this, arg);
 
   visitChildren(Visitor visitor) {
+    if (templateParameters != null) templateParameters.accept(visitor);
     if (returnType != null) returnType.accept(visitor);
     name.accept(visitor);
     if (typeParameters != null) typeParameters.accept(visitor);
     formals.accept(visitor);
   }
 
   visitChildren1(Visitor1 visitor, arg) {
+    if (templateParameters != null) templateParameters.accept1(visitor, arg);
     if (returnType != null) returnType.accept1(visitor, arg);
     name.accept1(visitor, arg);
     if (typeParameters != null) typeParameters.accept1(visitor, arg);
     formals.accept1(visitor, arg);
   }
 
   Token getBeginToken() => typedefKeyword;
 
   Token getEndToken() => endToken;
 }
 
+class FunctionTypeAnnotation extends TypeAnnotation {
+  final TypeAnnotation returnType;
+  final Token functionToken;
+  final NodeList typeParameters;
+  final NodeList formals;
+
+  FunctionTypeAnnotation(
+      this.returnType, this.functionToken, this.typeParameters, this.formals);
+
+  FunctionTypeAnnotation asFunctionTypeAnnotation() => this;
+
+  accept(Visitor visitor) => visitor.visitFunctionTypeAnnotation(this);
+
+  accept1(Visitor1 visitor, arg) {
+    return visitor.visitFunctionTypeAnnotation(this, arg);
+  }
+
+  visitChildren(Visitor visitor) {
+    if (returnType != null) returnType.accept(visitor);
+    if (typeParameters != null) typeParameters.accept(visitor);
+    formals.accept(visitor);
+  }
+
+  visitChildren1(Visitor1 visitor, arg) {
+    if (returnType != null) returnType.accept1(visitor, arg);
+    if (typeParameters != null) typeParameters.accept1(visitor, arg);
+    formals.accept1(visitor, arg);
+  }
+
+  Token getBeginToken() {
+    if (returnType != null) return returnType.getBeginToken();
+    return functionToken;
+  }
+
+  Token getEndToken() => formals.getEndToken();
+}
+
 class TryStatement extends Statement {
   final Block tryBlock;
   final NodeList catchBlocks;
   final Block finallyBlock;
 
   final Token tryKeyword;
   final Token finallyKeyword;
 
   TryStatement(this.tryBlock, this.catchBlocks, this.finallyBlock,
       this.tryKeyword, this.finallyKeyword);
@@ skipping 226 matching lines @@
   get getOrSet => null;
   get isRedirectingFactory => false;
   bool get hasBody => false;
   bool get hasEmptyBody => false;
 
   // VariableDefinitions.
   get metadata => null;
   get type => null;
 
   // Typedef.
+  get isGeneralizedTypeAlias => null;
+  get templateParameters => null;
   get typeParameters => null;
   get formals => null;
   get typedefKeyword => null;
 }