Add support for generic function type syntax, part 1

pkg/analyzer/test/src/dart/ast/utilities_test.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.test.src.dart.ast.utilities_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 178 matching lines @@
   void test_binary_notEqual_invalidRight() {
     Object value = _getConstantValue("2 != a");
     expect(value, ConstantEvaluator.NOT_A_CONSTANT);
   }
 
   void test_binary_notEqual_string() {
     Object value = _getConstantValue("'a' != 'b'");
     expect(value, true);
   }
 
-  void test_binary_plus_string() {
-    Object value = _getConstantValue("'hello ' + 'world'");
-    expect(value, 'hello world');
-  }
-
   void test_binary_plus_double() {
     Object value = _getConstantValue("2.3 + 3.2");
     expect(value, 2.3 + 3.2);
   }
 
-  void test_binary_plus_integer() {
-    Object value = _getConstantValue("2 + 3");
-    expect(value, 5);
-  }
-
-  void test_binary_plus_string_int() {
-    Object value = _getConstantValue("5 + 'world'");
+  void test_binary_plus_double_string() {
+    Object value = _getConstantValue("'world' + 5.5");
     expect(value, ConstantEvaluator.NOT_A_CONSTANT);
   }
 
   void test_binary_plus_int_string() {
     Object value = _getConstantValue("'world' + 5");
     expect(value, ConstantEvaluator.NOT_A_CONSTANT);
   }
 
-  void test_binary_plus_double_string() {
-    Object value = _getConstantValue("'world' + 5.5");
-    expect(value, ConstantEvaluator.NOT_A_CONSTANT);
+  void test_binary_plus_integer() {
+    Object value = _getConstantValue("2 + 3");
+    expect(value, 5);
+  }
+
+  void test_binary_plus_string() {
+    Object value = _getConstantValue("'hello ' + 'world'");
+    expect(value, 'hello world');
   }
 
   void test_binary_plus_string_double() {
     Object value = _getConstantValue("5.5 + 'world'");
     expect(value, ConstantEvaluator.NOT_A_CONSTANT);
   }
 
+  void test_binary_plus_string_int() {
+    Object value = _getConstantValue("5 + 'world'");
+    expect(value, ConstantEvaluator.NOT_A_CONSTANT);
+  }
+
   void test_binary_remainder_double() {
     Object value = _getConstantValue("3.2 % 2.3");
     expect(value, 3.2 % 2.3);
   }
 
   void test_binary_remainder_integer() {
     Object value = _getConstantValue("8 % 3");
     expect(value, 2);
   }
 
@@ skipping 121 matching lines @@
 }
 
 @reflectiveTest
 class NodeLocator2Test extends ParserTestCase {
   void test_onlyStartOffset() {
     String code = ' int vv; ';
     //             012345678
     CompilationUnit unit = ParserTestCase.parseCompilationUnit(code);
     TopLevelVariableDeclaration declaration = unit.declarations[0];
     VariableDeclarationList variableList = declaration.variables;
-    Identifier typeName = variableList.type.name;
+    Identifier typeName = (variableList.type as TypeName).name;
     SimpleIdentifier varName = variableList.variables[0].name;
     expect(new NodeLocator2(0).searchWithin(unit), same(unit));
     expect(new NodeLocator2(1).searchWithin(unit), same(typeName));
     expect(new NodeLocator2(2).searchWithin(unit), same(typeName));
     expect(new NodeLocator2(3).searchWithin(unit), same(typeName));
     expect(new NodeLocator2(4).searchWithin(unit), same(variableList));
     expect(new NodeLocator2(5).searchWithin(unit), same(varName));
     expect(new NodeLocator2(6).searchWithin(unit), same(varName));
     expect(new NodeLocator2(7).searchWithin(unit), same(declaration));
     expect(new NodeLocator2(8).searchWithin(unit), same(unit));
     expect(new NodeLocator2(9).searchWithin(unit), isNull);
     expect(new NodeLocator2(100).searchWithin(unit), isNull);
   }
 
   void test_startEndOffset() {
     String code = ' int vv; ';
     //             012345678
     CompilationUnit unit = ParserTestCase.parseCompilationUnit(code);
     TopLevelVariableDeclaration declaration = unit.declarations[0];
     VariableDeclarationList variableList = declaration.variables;
-    Identifier typeName = variableList.type.name;
+    Identifier typeName = (variableList.type as TypeName).name;
     SimpleIdentifier varName = variableList.variables[0].name;
     expect(new NodeLocator2(-1, 2).searchWithin(unit), isNull);
     expect(new NodeLocator2(0, 2).searchWithin(unit), same(unit));
     expect(new NodeLocator2(1, 2).searchWithin(unit), same(typeName));
     expect(new NodeLocator2(1, 3).searchWithin(unit), same(typeName));
     expect(new NodeLocator2(1, 4).searchWithin(unit), same(variableList));
     expect(new NodeLocator2(5, 6).searchWithin(unit), same(varName));
     expect(new NodeLocator2(5, 7).searchWithin(unit), same(declaration));
     expect(new NodeLocator2(5, 8).searchWithin(unit), same(unit));
     expect(new NodeLocator2(5, 100).searchWithin(unit), isNull);
@@ skipping 282 matching lines @@
     MethodElement propagatedElement = ElementFactory.methodElement(
         "m", ElementFactory.classElement2("C").type);
     fromNode.propagatedElement = propagatedElement;
     MethodElement staticElement = ElementFactory.methodElement(
         "m", ElementFactory.classElement2("C").type);
     fromNode.staticElement = staticElement;
     FunctionExpressionInvocation toNode = AstTestFactory
         .functionExpressionInvocation(AstTestFactory.identifier3("f"));
     ClassElement elementT = ElementFactory.classElement2('T');
     fromNode.typeArguments = AstTestFactory
-        .typeArgumentList(<TypeName>[AstTestFactory.typeName(elementT)]);
+        .typeArgumentList(<TypeAnnotation>[AstTestFactory.typeName(elementT)]);
     toNode.typeArguments = AstTestFactory
-        .typeArgumentList(<TypeName>[AstTestFactory.typeName4('T')]);
+        .typeArgumentList(<TypeAnnotation>[AstTestFactory.typeName4('T')]);
 
     _copyAndVerifyInvocation(fromNode, toNode);
 
     expect(toNode.propagatedElement, same(propagatedElement));
     expect(toNode.staticElement, same(staticElement));
   }
 
   void test_visitImportDirective() {
     ImportDirective fromNode =
         AstTestFactory.importDirective3("dart:uri", null);
@@ skipping 112 matching lines @@
     ResolutionCopier.copyResolutionData(fromNode, toNode);
     expect(toNode.propagatedType, same(propagatedType));
     expect(toNode.staticType, same(staticType));
   }
 
   void test_visitMethodInvocation() {
     MethodInvocation fromNode = AstTestFactory.methodInvocation2("m");
     MethodInvocation toNode = AstTestFactory.methodInvocation2("m");
     ClassElement elementT = ElementFactory.classElement2('T');
     fromNode.typeArguments = AstTestFactory
-        .typeArgumentList(<TypeName>[AstTestFactory.typeName(elementT)]);
+        .typeArgumentList(<TypeAnnotation>[AstTestFactory.typeName(elementT)]);
     toNode.typeArguments = AstTestFactory
-        .typeArgumentList(<TypeName>[AstTestFactory.typeName4('T')]);
+        .typeArgumentList(<TypeAnnotation>[AstTestFactory.typeName4('T')]);
     _copyAndVerifyInvocation(fromNode, toNode);
   }
 
   void test_visitNamedExpression() {
     NamedExpression fromNode =
         AstTestFactory.namedExpression2("n", AstTestFactory.integer(0));
     DartType propagatedType = ElementFactory.classElement2("C").type;
     fromNode.propagatedType = propagatedType;
     DartType staticType = ElementFactory.classElement2("C").type;
     fromNode.staticType = staticType;
@@ skipping 276 matching lines @@
     DartType propagatedInvokeType = ElementFactory.classElement2("C").type;
     fromNode.propagatedInvokeType = propagatedInvokeType;
     DartType staticInvokeType = ElementFactory.classElement2("C").type;
     fromNode.staticInvokeType = staticInvokeType;
 
     ResolutionCopier.copyResolutionData(fromNode, toNode);
     expect(toNode.propagatedType, same(propagatedType));
     expect(toNode.staticType, same(staticType));
     expect(toNode.propagatedInvokeType, same(propagatedInvokeType));
     expect(toNode.staticInvokeType, same(staticInvokeType));
-    List<TypeName> fromTypeArguments = toNode.typeArguments.arguments;
-    List<TypeName> toTypeArguments = fromNode.typeArguments.arguments;
+    List<TypeAnnotation> fromTypeArguments = toNode.typeArguments.arguments;
+    List<TypeAnnotation> toTypeArguments = fromNode.typeArguments.arguments;
     if (fromTypeArguments != null) {
       for (int i = 0; i < fromTypeArguments.length; i++) {
-        TypeName toArgument = fromTypeArguments[i];
-        TypeName fromArgument = toTypeArguments[i];
+        TypeAnnotation toArgument = fromTypeArguments[i];
+        TypeAnnotation fromArgument = toTypeArguments[i];
         expect(toArgument.type, same(fromArgument.type));
       }
     }
   }
 }
 
 @reflectiveTest
 class ToSourceVisitor2Test extends EngineTestCase {
   void test_visitAdjacentStrings() {
     _assertSource(
@@ skipping 4644 matching lines @@
   /**
    * Assert that a `ToSourceVisitor` will produce the [expectedSource] when
    * visiting the given [node].
    */
   void _assertSource(String expectedSource, AstNode node) {
     PrintStringWriter writer = new PrintStringWriter();
     node.accept(new ToSourceVisitor(writer));
     expect(writer.toString(), expectedSource);
   }
 }