Add support for generic function type syntax, part 1

pkg/analyzer/lib/src/dart/ast/utilities.dart

Index: pkg/analyzer/lib/src/dart/ast/utilities.dart
diff --git a/pkg/analyzer/lib/src/dart/ast/utilities.dart b/pkg/analyzer/lib/src/dart/ast/utilities.dart
index d23485ab07f77095e21b933cad898b20a5c2f58f..f615ef3afa2bb05f5dc0aa2958efc5db518df2c4 100644
--- a/pkg/analyzer/lib/src/dart/ast/utilities.dart
+++ b/pkg/analyzer/lib/src/dart/ast/utilities.dart
@@ -551,6 +551,26 @@ class AstCloner implements AstVisitor<AstNode> {
           cloneNode(node.parameters));
 
   @override
+  AstNode visitGenericFunctionType(GenericFunctionType node) =>
+      astFactory.genericFunctionType(
+          cloneNode(node.returnType),
+          cloneToken(node.functionKeyword),
+          cloneNode(node.typeParameters),
+          cloneNode(node.parameters));
+
+  @override
+  AstNode visitGenericTypeAlias(GenericTypeAlias node) =>
+      astFactory.genericTypeAlias(
+          cloneNode(node.documentationComment),
+          cloneNodeList(node.metadata),
+          cloneToken(node.typedefKeyword),
+          cloneNode(node.name),
+          cloneNode(node.typeParameters),
+          cloneToken(node.equals),
+          cloneNode(node.functionType),
+          cloneToken(node.semicolon));
+
+  @override
   HideCombinator visitHideCombinator(HideCombinator node) =>
       astFactory.hideCombinator(
           cloneToken(node.keyword), cloneNodeList(node.hiddenNames));
@@ -1588,6 +1608,28 @@ class AstComparator implements AstVisitor<bool> {
   }
 
   @override
+  bool visitGenericFunctionType(GenericFunctionType node) {
+    GenericFunctionType other = _other as GenericFunctionType;
+    return isEqualNodes(node.returnType, other.returnType) &&
+        isEqualTokens(node.functionKeyword, other.functionKeyword) &&
+        isEqualNodes(node.typeParameters, other.typeParameters) &&
+        isEqualNodes(node.parameters, other.parameters);
+  }
+
+  @override
+  bool visitGenericTypeAlias(GenericTypeAlias node) {
+    GenericTypeAlias other = _other as GenericTypeAlias;
+    return isEqualNodes(
+            node.documentationComment, other.documentationComment) &&
+        _isEqualNodeLists(node.metadata, other.metadata) &&
+        isEqualTokens(node.typedefKeyword, other.typedefKeyword) &&
+        isEqualNodes(node.name, other.name) &&
+        isEqualNodes(node.typeParameters, other.typeParameters) &&
+        isEqualTokens(node.equals, other.equals) &&
+        isEqualNodes(node.functionType, other.functionType);
+  }
+
+  @override
   bool visitHideCombinator(HideCombinator node) {
     HideCombinator other = _other as HideCombinator;
     return isEqualTokens(node.keyword, other.keyword) &&
@@ -3260,6 +3302,26 @@ class IncrementalAstCloner implements AstVisitor<AstNode> {
           _cloneNode(node.parameters));
 
   @override
+  AstNode visitGenericFunctionType(GenericFunctionType node) =>
+      astFactory.genericFunctionType(
+          _cloneNode(node.returnType),
+          _mapToken(node.functionKeyword),
+          _cloneNode(node.typeParameters),
+          _cloneNode(node.parameters));
+
+  @override
+  AstNode visitGenericTypeAlias(GenericTypeAlias node) =>
+      astFactory.genericTypeAlias(
+          _cloneNode(node.documentationComment),
+          _cloneNodeList(node.metadata),
+          _mapToken(node.typedefKeyword),
+          _cloneNode(node.name),
+          _cloneNode(node.typeParameters),
+          _mapToken(node.equals),
+          _cloneNode(node.functionType),
+          _mapToken(node.semicolon));
+
+  @override
   HideCombinator visitHideCombinator(HideCombinator node) =>
       astFactory.hideCombinator(
           _mapToken(node.keyword), _cloneNodeList(node.hiddenNames));
@@ -4107,7 +4169,7 @@ class NodeReplacer implements AstVisitor<bool> {
       node.expression = _newNode as Expression;
       return true;
     } else if (identical(node.type, _oldNode)) {
-      node.type = _newNode as TypeName;
+      node.type = _newNode as TypeAnnotation;
       return true;
     }
     return visitNode(node);
@@ -4215,7 +4277,7 @@ class NodeReplacer implements AstVisitor<bool> {
   @override
   bool visitCatchClause(CatchClause node) {
     if (identical(node.exceptionType, _oldNode)) {
-      node.exceptionType = _newNode as TypeName;
+      node.exceptionType = _newNode as TypeAnnotation;
       return true;
     } else if (identical(node.exceptionParameter, _oldNode)) {
       node.exceptionParameter = _newNode as SimpleIdentifier;
@@ -4393,7 +4455,7 @@ class NodeReplacer implements AstVisitor<bool> {
   @override
   bool visitDeclaredIdentifier(DeclaredIdentifier node) {
     if (identical(node.type, _oldNode)) {
-      node.type = _newNode as TypeName;
+      node.type = _newNode as TypeAnnotation;
       return true;
     } else if (identical(node.identifier, _oldNode)) {
       node.identifier = _newNode as SimpleIdentifier;
@@ -4506,7 +4568,7 @@ class NodeReplacer implements AstVisitor<bool> {
   @override
   bool visitFieldFormalParameter(FieldFormalParameter node) {
     if (identical(node.type, _oldNode)) {
-      node.type = _newNode as TypeName;
+      node.type = _newNode as TypeAnnotation;
       return true;
     } else if (identical(node.parameters, _oldNode)) {
       node.parameters = _newNode as FormalParameterList;
@@ -4564,7 +4626,7 @@ class NodeReplacer implements AstVisitor<bool> {
   @override
   bool visitFunctionDeclaration(FunctionDeclaration node) {
     if (identical(node.returnType, _oldNode)) {
-      node.returnType = _newNode as TypeName;
+      node.returnType = _newNode as TypeAnnotation;
       return true;
     } else if (identical(node.name, _oldNode)) {
       node.name = _newNode as SimpleIdentifier;
@@ -4612,7 +4674,7 @@ class NodeReplacer implements AstVisitor<bool> {
   @override
   bool visitFunctionTypeAlias(FunctionTypeAlias node) {
     if (identical(node.returnType, _oldNode)) {
-      node.returnType = _newNode as TypeName;
+      node.returnType = _newNode as TypeAnnotation;
       return true;
     } else if (identical(node.name, _oldNode)) {
       node.name = _newNode as SimpleIdentifier;
@@ -4630,7 +4692,7 @@ class NodeReplacer implements AstVisitor<bool> {
   @override
   bool visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     if (identical(node.returnType, _oldNode)) {
-      node.returnType = _newNode as TypeName;
+      node.returnType = _newNode as TypeAnnotation;
       return true;
     } else if (identical(node.parameters, _oldNode)) {
       node.parameters = _newNode as FormalParameterList;
@@ -4640,6 +4702,38 @@ class NodeReplacer implements AstVisitor<bool> {
   }
 
   @override
+  bool visitGenericFunctionType(GenericFunctionType node) {
+    if (identical(node.returnType, _oldNode)) {
+      node.returnType = _newNode as TypeAnnotation;
+      return true;
+    } else if (identical(node.typeParameters, _oldNode)) {
+      node.typeParameters = _newNode as TypeParameterList;
+      return true;
+    } else if (identical(node.parameters, _oldNode)) {
+      node.parameters = _newNode as FormalParameterList;
+      return true;
+    }
+    return null;
+  }
+
+  @override
+  bool visitGenericTypeAlias(GenericTypeAlias node) {
+    if (identical(node.name, _oldNode)) {
+      node.name = _newNode as SimpleIdentifier;
+      return true;
+    } else if (identical(node.typeParameters, _oldNode)) {
+      node.typeParameters = _newNode as TypeParameterList;
+      return true;
+    } else if (identical(node.functionType, _oldNode)) {
+      node.functionType = _newNode as GenericFunctionType;
+      return true;
+    } else if (_replaceInList(node.metadata)) {
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
   bool visitHideCombinator(HideCombinator node) {
     if (_replaceInList(node.hiddenNames)) {
       return true;
@@ -4724,7 +4818,7 @@ class NodeReplacer implements AstVisitor<bool> {
       node.expression = _newNode as Expression;
       return true;
     } else if (identical(node.type, _oldNode)) {
-      node.type = _newNode as TypeName;
+      node.type = _newNode as TypeAnnotation;
       return true;
     }
     return visitNode(node);
@@ -4798,7 +4892,7 @@ class NodeReplacer implements AstVisitor<bool> {
   @override
   bool visitMethodDeclaration(MethodDeclaration node) {
     if (identical(node.returnType, _oldNode)) {
-      node.returnType = _newNode as TypeName;
+      node.returnType = _newNode as TypeAnnotation;
       return true;
     } else if (identical(node.name, _oldNode)) {
       node.name = _newNode as SimpleIdentifier;
@@ -4987,7 +5081,7 @@ class NodeReplacer implements AstVisitor<bool> {
   @override
   bool visitSimpleFormalParameter(SimpleFormalParameter node) {
     if (identical(node.type, _oldNode)) {
-      node.type = _newNode as TypeName;
+      node.type = _newNode as TypeAnnotation;
       return true;
     }
     return visitNormalFormalParameter(node);
@@ -5126,7 +5220,7 @@ class NodeReplacer implements AstVisitor<bool> {
       node.name = _newNode as SimpleIdentifier;
       return true;
     } else if (identical(node.bound, _oldNode)) {
-      node.bound = _newNode as TypeName;
+      node.bound = _newNode as TypeAnnotation;
       return true;
     }
     return visitNode(node);
@@ -5163,7 +5257,7 @@ class NodeReplacer implements AstVisitor<bool> {
   @override
   bool visitVariableDeclarationList(VariableDeclarationList node) {
     if (identical(node.type, _oldNode)) {
-      node.type = _newNode as TypeName;
+      node.type = _newNode as TypeAnnotation;
       return true;
     } else if (_replaceInList(node.variables)) {
       return true;
@@ -5865,6 +5959,38 @@ class ResolutionCopier implements AstVisitor<bool> {
   }
 
   @override
+  bool visitGenericFunctionType(GenericFunctionType node) {
+    GenericFunctionType toNode = this._toNode as GenericFunctionType;
+    if (_and(
+        _isEqualNodes(node.returnType, toNode.returnType),
+        _isEqualTokens(node.functionKeyword, toNode.functionKeyword),
+        _isEqualNodes(node.typeParameters, toNode.typeParameters),
+        _isEqualNodes(node.parameters, toNode.parameters))) {
+      // TODO(brianwilkerson) Copy the type information.
+      return true;
+    }
+    return false;
+  }
+
+  @override
+  bool visitGenericTypeAlias(GenericTypeAlias node) {
+    GenericTypeAlias toNode = this._toNode as GenericTypeAlias;
+    if (_and(
+        _isEqualNodes(node.documentationComment, toNode.documentationComment),
+        _isEqualNodeLists(node.metadata, toNode.metadata),
+        _isEqualTokens(node.typedefKeyword, toNode.typedefKeyword),
+        _isEqualNodes(node.name, toNode.name),
+        _isEqualNodes(node.typeParameters, toNode.typeParameters),
+        _isEqualTokens(node.equals, toNode.equals),
+        _isEqualNodes(node.functionType, toNode.functionType),
+        _isEqualTokens(node.semicolon, toNode.semicolon))) {
+      // TODO(brianwilkerson) Copy the type and element information.
+      return true;
+    }
+    return false;
+  }
+
+  @override
   bool visitHideCombinator(HideCombinator node) {
     HideCombinator toNode = this._toNode as HideCombinator;
     return _and(_isEqualTokens(node.keyword, toNode.keyword),
@@ -7395,6 +7521,26 @@ class ToSourceVisitor implements AstVisitor<Object> {
   }
 
   @override
+  Object visitGenericFunctionType(GenericFunctionType node) {
+    _visitNode(node.returnType);
+    _writer.print(' Function ');
+    _visitNode(node.typeParameters);
+    _visitNode(node.parameters);
+    return null;
+  }
+
+  @override
+  Object visitGenericTypeAlias(GenericTypeAlias node) {
+    _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
+    _writer.print("typedef ");
+    _visitNode(node.name);
+    _visitNode(node.typeParameters);
+    _writer.print(" = ");
+    _visitNode(node.functionType);
+    return null;
+  }
+
+  @override
   Object visitHideCombinator(HideCombinator node) {
     _writer.print("hide ");
     _visitNodeListWithSeparator(node.hiddenNames, ", ");
@@ -8682,6 +8828,26 @@ class ToSourceVisitor2 implements AstVisitor<Object> {
   }
 
   @override
+  Object visitGenericFunctionType(GenericFunctionType node) {
+    safelyVisitNode(node.returnType);
+    sink.write(' Function ');
+    safelyVisitNode(node.typeParameters);
+    safelyVisitNode(node.parameters);
+    return null;
+  }
+
+  @override
+  Object visitGenericTypeAlias(GenericTypeAlias node) {
+    safelyVisitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
+    sink.write("typedef ");
+    safelyVisitNode(node.name);
+    safelyVisitNode(node.typeParameters);
+    sink.write(" = ");
+    safelyVisitNode(node.functionType);
+    return null;
+  }
+
+  @override
   Object visitHideCombinator(HideCombinator node) {
     sink.write("hide ");
     safelyVisitNodeListWithSeparator(node.hiddenNames, ", ");