Reapply "Add support for generic function type syntax, part 1"

pkg/analyzer/test/generated/parser_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.generated.parser_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/ast/visitor.dart';
@@ skipping 3804 matching lines @@
     List<ClassMember> members = classDecl.members;
     expect(members, hasLength(1));
     FieldDeclaration fieldDecl = members[0] as FieldDeclaration;
     // one field
     VariableDeclarationList fieldList = fieldDecl.fields;
     List<VariableDeclaration> fields = fieldList.variables;
     expect(fields, hasLength(1));
     VariableDeclaration field = fields[0];
     expect(field.name.name, 'f');
     // validate the type
-    TypeArgumentList typeArguments = fieldList.type.typeArguments;
+    TypeArgumentList typeArguments = (fieldList.type as TypeName).typeArguments;
     expect(typeArguments.arguments, hasLength(1));
     // synthetic '>'
     Token token = typeArguments.endToken;
     expect(token.type, TokenType.GT);
     expect(token.isSynthetic, isTrue);
   }
 
   void test_incompleteTypeParameters() {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit(
         r'''
@@ skipping 26 matching lines @@
       ParserErrorCode.MISSING_STATEMENT
     ]);
     ClassDeclaration declaration = unit.declarations[0] as ClassDeclaration;
     MethodDeclaration method = declaration.members[0] as MethodDeclaration;
     BlockFunctionBody body = method.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[1] as IfStatement;
     IsExpression expression = ifStatement.condition as IsExpression;
     expect(expression.expression, isNotNull);
     expect(expression.isOperator, isNotNull);
     expect(expression.notOperator, isNotNull);
-    TypeName type = expression.type;
+    TypeAnnotation type = expression.type;
     expect(type, isNotNull);
-    expect(type.name.isSynthetic, isTrue);
+    expect(type is TypeName && type.name.isSynthetic, isTrue);
     EngineTestCase.assertInstanceOf((obj) => obj is EmptyStatement,
         EmptyStatement, ifStatement.thenStatement);
   }
 
   void test_keywordInPlaceOfIdentifier() {
     // TODO(brianwilkerson) We could do better with this.
     ParserTestCase.parseCompilationUnit("do() {}", [
       ParserErrorCode.EXPECTED_EXECUTABLE,
       ParserErrorCode.UNEXPECTED_TOKEN
     ]);
@@ skipping 2150 matching lines @@
     createParser('/*=T*/ m/*<T>*/() {}');
     ClassMember member = parser.parseClassMember('C');
     expectNotNullIfNoErrors(member);
     listener.assertNoErrors();
     expect(member, new isInstanceOf<MethodDeclaration>());
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, isNull);
     expect(method.propertyKeyword, isNull);
-    expect(method.returnType.name.name, 'T');
+    expect((method.returnType as TypeName).name.name, 'T');
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
     expect(method.typeParameters, isNotNull);
     expect(method.parameters, isNotNull);
     expect(method.body, isNotNull);
   }
 
   void test_parseClassMember_method_generic_comment_returnType_bound() {
     enableGenericMethodComments = true;
     createParser('num/*=T*/ m/*<T extends num>*/() {}');
     ClassMember member = parser.parseClassMember('C');
     expectNotNullIfNoErrors(member);
     listener.assertNoErrors();
     expect(member, new isInstanceOf<MethodDeclaration>());
     MethodDeclaration method = member;
     expect(method.documentationComment, isNull);
     expect(method.externalKeyword, isNull);
     expect(method.modifierKeyword, isNull);
     expect(method.propertyKeyword, isNull);
-    expect(method.returnType.name.name, 'T');
+    expect((method.returnType as TypeName).name.name, 'T');
     expect(method.name, isNotNull);
     expect(method.operatorKeyword, isNull);
     expect(method.typeParameters, isNotNull);
     TypeParameter tp = method.typeParameters.typeParameters[0];
     expect(tp.name.name, 'T');
     expect(tp.extendsKeyword, isNotNull);
-    expect(tp.bound.name.name, 'num');
+    expect((tp.bound as TypeName).name.name, 'num');
     expect(method.parameters, isNotNull);
     expect(method.body, isNotNull);
   }
 
   void test_parseClassMember_method_generic_comment_void() {
     enableGenericMethodComments = true;
     createParser('void m/*<T>*/() {}');
     ClassMember member = parser.parseClassMember('C');
     expectNotNullIfNoErrors(member);
     listener.assertNoErrors();
@@ skipping 4060 matching lines @@
     expectNotNullIfNoErrors(expression);
     listener.assertNoErrors();
     expect(expression.keyword, token);
     ConstructorName name = expression.constructorName;
     expect(name, isNotNull);
     TypeName type = name.type;
     expect(type, isNotNull);
     expect(name.period, isNull);
     expect(name.name, isNull);
     expect(expression.argumentList, isNotNull);
-    NodeList<TypeName> arguments = type.typeArguments.arguments;
+    NodeList<TypeAnnotation> arguments = type.typeArguments.arguments;
     expect(arguments, hasLength(1));
-    expect(arguments[0].question, isNotNull);
+    expect((arguments[0] as TypeName).question, isNotNull);
   }
 
   void test_parseLibraryDirective() {
     createParser('library l;');
     LibraryDirective directive =
         parser.parseLibraryDirective(emptyCommentAndMetadata());
     expectNotNullIfNoErrors(directive);
     listener.assertNoErrors();
     expect(directive.libraryKeyword, isNotNull);
     expect(directive.name, isNotNull);
@@ skipping 2900 matching lines @@
     expect(declarationList.variables, hasLength(1));
   }
 
   void test_parseVariableDeclarationListAfterMetadata_final_typeComment() {
     enableGenericMethodComments = true;
     createParser('final/*=T*/ x');
     VariableDeclarationList declarationList = parser
         .parseVariableDeclarationListAfterMetadata(emptyCommentAndMetadata());
     expectNotNullIfNoErrors(declarationList);
     listener.assertNoErrors();
-    expect(declarationList.type.name.name, 'T');
+    expect((declarationList.type as TypeName).name.name, 'T');
     expect(declarationList.isFinal, true);
   }
 
   void test_parseVariableDeclarationListAfterMetadata_type_multiple() {
     createParser('A a, b, c');
     VariableDeclarationList declarationList = parser
         .parseVariableDeclarationListAfterMetadata(emptyCommentAndMetadata());
     expectNotNullIfNoErrors(declarationList);
     listener.assertNoErrors();
     expect(declarationList.keyword, isNull);
@@ skipping 34 matching lines @@
     expect(declarationList.variables, hasLength(1));
   }
 
   void test_parseVariableDeclarationListAfterMetadata_var_typeComment() {
     enableGenericMethodComments = true;
     createParser('var/*=T*/ x');
     VariableDeclarationList declarationList = parser
         .parseVariableDeclarationListAfterMetadata(emptyCommentAndMetadata());
     expectNotNullIfNoErrors(declarationList);
     listener.assertNoErrors();
-    expect(declarationList.type.name.name, 'T');
+    expect((declarationList.type as TypeName).name.name, 'T');
     expect(declarationList.keyword, isNull);
   }
 
   void test_parseVariableDeclarationListAfterType_type() {
     TypeName type =
         astFactory.typeName(astFactory.simpleIdentifier(null), null);
     createParser('a');
     VariableDeclarationList declarationList =
         parser.parseVariableDeclarationListAfterType(
             emptyCommentAndMetadata(), null, type);
@@ skipping 319 matching lines @@
   CompilationUnit _parseDirectives(String source,
       [List<ErrorCode> errorCodes = const <ErrorCode>[]]) {
     createParser(source);
     CompilationUnit unit = parser.parseDirectives2();
     expect(unit, isNotNull);
     expect(unit.declarations, hasLength(0));
     listener.assertErrorsWithCodes(errorCodes);
     return unit;
   }
 }