Fix GenericFunctionType parsing tests by making them fail in non-checked mode.

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 13626 matching lines @@
   void test_parseTypeAnnotation_function_returnType_classFunction() {
     createParser('Function v');
     TypeName functionType = parser.parseTypeAnnotation(false);
     expectNotNullIfNoErrors(functionType);
     listener.assertNoErrors();
   }
 
   @failingTest
   void test_parseTypeAnnotation_function_returnType_function() {
     createParser('A Function(B, C) Function(D) v');
-    GenericFunctionType functionType = parser.parseTypeAnnotation(false);
+    // TODO(scheglov) improve the test to verify also the node properties
+    var functionType = parser.parseTypeAnnotation(false) as GenericFunctionType;
     expectNotNullIfNoErrors(functionType);
     listener.assertNoErrors();
   }
 
   @failingTest
   void test_parseTypeAnnotation_function_returnType_noParameters() {
     createParser('List<int> Function()');
     GenericFunctionType functionType = parser.parseTypeAnnotation(false);
     expectNotNullIfNoErrors(functionType);
     listener.assertNoErrors();
@@ skipping 30 matching lines @@
     parameter = parameters[1];
     expect(parameter.identifier, isNotNull);
     expect(parameter.identifier.name, 'i');
     expect(parameter.type, new isInstanceOf<TypeName>());
     expect((parameter.type as TypeName).name.name, 'int');
   }
 
   @failingTest
   void test_parseTypeAnnotation_function_returnType_simple() {
     createParser('A Function(B, C) v');
-    GenericFunctionType functionType = parser.parseTypeAnnotation(false);
+    // TODO(scheglov) improve the test to verify also the node properties
+    var functionType = parser.parseTypeAnnotation(false) as GenericFunctionType;
     expectNotNullIfNoErrors(functionType);
     listener.assertNoErrors();
   }
 
   @failingTest
   void test_parseTypeAnnotation_function_returnType_typeParameters() {
     createParser('List<T> Function<T>()');
     GenericFunctionType functionType = parser.parseTypeAnnotation(false);
     expectNotNullIfNoErrors(functionType);
     listener.assertNoErrors();
@@ skipping 20 matching lines @@
     expect(typeParameters, isNotNull);
     expect(typeParameters.typeParameters, hasLength(1));
     FormalParameterList parameterList = functionType.parameters;
     expect(parameterList, isNotNull);
     expect(parameterList.parameters, hasLength(2));
   }
 
   @failingTest
   void test_parseTypeAnnotation_function_returnType_withArguments() {
     createParser('A<B> Function(C) v');
-    GenericFunctionType functionType = parser.parseTypeAnnotation(false);
+    // TODO(scheglov) improve this test to verify also the node properties
+    var functionType = parser.parseTypeAnnotation(false) as GenericFunctionType;
     expectNotNullIfNoErrors(functionType);
     listener.assertNoErrors();
   }
 
   void test_parseTypeAnnotation_named() {
     createParser('A<B> v');
     TypeName typeName = parser.parseTypeAnnotation(false);
     expectNotNullIfNoErrors(typeName);
     listener.assertNoErrors();
   }
@@ skipping 851 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;
   }
 }