Add support for generic function type syntax, part 1

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

 // Copyright (c) 2014, 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.
 
 library analyzer.src.dart.ast.utilities;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
@@ skipping 533 matching lines @@
           FunctionTypedFormalParameter node) =>
       astFactory.functionTypedFormalParameter(
           cloneNode(node.documentationComment),
           cloneNodeList(node.metadata),
           cloneNode(node.returnType),
           cloneNode(node.identifier),
           cloneNode(node.typeParameters),
           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));
 
   @override
   IfStatement visitIfStatement(IfStatement node) => astFactory.ifStatement(
       cloneToken(node.ifKeyword),
       cloneToken(node.leftParenthesis),
       cloneNode(node.condition),
       cloneToken(node.rightParenthesis),
@@ skipping 1017 matching lines @@
     FunctionTypedFormalParameter other = _other as FunctionTypedFormalParameter;
     return isEqualNodes(
             node.documentationComment, other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
         isEqualNodes(node.returnType, other.returnType) &&
         isEqualNodes(node.identifier, other.identifier) &&
         isEqualNodes(node.parameters, other.parameters);
   }
 
   @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) &&
         _isEqualNodeLists(node.hiddenNames, other.hiddenNames);
   }
 
   @override
   bool visitIfStatement(IfStatement node) {
     IfStatement other = _other as IfStatement;
     return isEqualTokens(node.ifKeyword, other.ifKeyword) &&
@@ skipping 1652 matching lines @@
           FunctionTypedFormalParameter node) =>
       astFactory.functionTypedFormalParameter(
           _cloneNode(node.documentationComment),
           _cloneNodeList(node.metadata),
           _cloneNode(node.returnType),
           _cloneNode(node.identifier),
           _cloneNode(node.typeParameters),
           _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));
 
   @override
   IfStatement visitIfStatement(IfStatement node) => astFactory.ifStatement(
       _mapToken(node.ifKeyword),
       _mapToken(node.leftParenthesis),
       _cloneNode(node.condition),
       _mapToken(node.rightParenthesis),
@@ skipping 827 matching lines @@
     }
     return visitNode(node);
   }
 
   @override
   bool visitAsExpression(AsExpression node) {
     if (identical(node.expression, _oldNode)) {
       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);
   }
 
   @override
   bool visitAssertInitializer(AssertInitializer node) {
     if (identical(node.condition, _oldNode)) {
       node.condition = _newNode as Expression;
       return true;
@@ skipping 87 matching lines @@
       return true;
     } else if (_replaceInList(node.cascadeSections)) {
       return true;
     }
     return visitNode(node);
   }
 
   @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;
       return true;
     } else if (identical(node.stackTraceParameter, _oldNode)) {
       node.stackTraceParameter = _newNode as SimpleIdentifier;
       return true;
     }
     return visitNode(node);
   }
@@ skipping 157 matching lines @@
     if (identical(node.label, _oldNode)) {
       node.label = _newNode as SimpleIdentifier;
       return true;
     }
     return visitNode(node);
   }
 
   @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;
       return true;
     }
     return visitAnnotatedNode(node);
   }
 
   @override
   bool visitDefaultFormalParameter(DefaultFormalParameter node) {
@@ skipping 92 matching lines @@
     if (identical(node.fields, _oldNode)) {
       node.fields = _newNode as VariableDeclarationList;
       return true;
     }
     return visitAnnotatedNode(node);
   }
 
   @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;
       return true;
     }
     return visitNormalFormalParameter(node);
   }
 
   @override
   bool visitForEachStatement(ForEachStatement node) {
@@ skipping 37 matching lines @@
       return true;
     } else if (_replaceInList(node.updaters)) {
       return true;
     }
     return visitNode(node);
   }
 
   @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;
       return true;
     } else if (identical(node.functionExpression, _oldNode)) {
       node.functionExpression = _newNode as FunctionExpression;
       return true;
     }
     return visitAnnotatedNode(node);
   }
@@ skipping 27 matching lines @@
     } else if (identical(node.argumentList, _oldNode)) {
       node.argumentList = _newNode as ArgumentList;
       return true;
     }
     return visitNode(node);
   }
 
   @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;
       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 visitAnnotatedNode(node);
   }
 
   @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;
       return true;
     }
     return visitNormalFormalParameter(node);
   }
 
   @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;
     }
     return visitNode(node);
   }
 
   @override
   bool visitIfStatement(IfStatement node) {
     if (identical(node.condition, _oldNode)) {
@@ skipping 64 matching lines @@
 
   @override
   bool visitInterpolationString(InterpolationString node) => visitNode(node);
 
   @override
   bool visitIsExpression(IsExpression node) {
     if (identical(node.expression, _oldNode)) {
       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);
   }
 
   @override
   bool visitLabel(Label node) {
     if (identical(node.label, _oldNode)) {
       node.label = _newNode as SimpleIdentifier;
       return true;
@@ skipping 53 matching lines @@
     } else if (identical(node.value, _oldNode)) {
       node.value = _newNode as Expression;
       return true;
     }
     return visitNode(node);
   }
 
   @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;
       return true;
     } else if (identical(node.parameters, _oldNode)) {
       node.parameters = _newNode as FormalParameterList;
       return true;
     } else if (identical(node.body, _oldNode)) {
       node.body = _newNode as FunctionBody;
       return true;
@@ skipping 168 matching lines @@
   bool visitShowCombinator(ShowCombinator node) {
     if (_replaceInList(node.shownNames)) {
       return true;
     }
     return visitNode(node);
   }
 
   @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);
   }
 
   @override
   bool visitSimpleIdentifier(SimpleIdentifier node) => visitNode(node);
 
   @override
   bool visitSimpleStringLiteral(SimpleStringLiteral node) => visitNode(node);
@@ skipping 118 matching lines @@
     }
     return visitNode(node);
   }
 
   @override
   bool visitTypeParameter(TypeParameter node) {
     if (identical(node.name, _oldNode)) {
       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);
   }
 
   @override
   bool visitTypeParameterList(TypeParameterList node) {
     if (_replaceInList(node.typeParameters)) {
       return true;
     }
@@ skipping 16 matching lines @@
     } else if (identical(node.initializer, _oldNode)) {
       node.initializer = _newNode as Expression;
       return true;
     }
     return visitAnnotatedNode(node);
   }
 
   @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;
     }
     return visitAnnotatedNode(node);
   }
 
   @override
   bool visitVariableDeclarationStatement(VariableDeclarationStatement node) {
     if (identical(node.variables, _oldNode)) {
@@ skipping 681 matching lines @@
         this._toNode as FunctionTypedFormalParameter;
     return _and(
         _isEqualNodes(node.documentationComment, toNode.documentationComment),
         _isEqualNodeLists(node.metadata, toNode.metadata),
         _isEqualNodes(node.returnType, toNode.returnType),
         _isEqualNodes(node.identifier, toNode.identifier),
         _isEqualNodes(node.parameters, toNode.parameters));
   }
 
   @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),
         _isEqualNodeLists(node.hiddenNames, toNode.hiddenNames));
   }
 
   @override
   bool visitIfStatement(IfStatement node) {
     IfStatement toNode = this._toNode as IfStatement;
     return _and(
@@ skipping 1510 matching lines @@
     _visitNode(node.identifier);
     _visitNode(node.typeParameters);
     _visitNode(node.parameters);
     if (node.question != null) {
       _writer.print('?');
     }
     return null;
   }
 
   @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, ", ");
     return null;
   }
 
   @override
   Object visitIfStatement(IfStatement node) {
     _writer.print("if (");
     _visitNode(node.condition);
@@ skipping 1267 matching lines @@
     safelyVisitNode(node.identifier);
     safelyVisitNode(node.typeParameters);
     safelyVisitNode(node.parameters);
     if (node.question != null) {
       sink.write('?');
     }
     return null;
   }
 
   @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, ", ");
     return null;
   }
 
   @override
   Object visitIfStatement(IfStatement node) {
     sink.write("if (");
     safelyVisitNode(node.condition);
@@ skipping 496 matching lines @@
     if (node.star != null) {
       sink.write("yield* ");
     } else {
       sink.write("yield ");
     }
     safelyVisitNode(node.expression);
     sink.write(";");
     return null;
   }
 }