Revert "Add support for generic function type syntax, part 1" (TBR)

pkg/analyzer/lib/src/task/strong/checker.dart

 // Copyright (c) 2015, 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.
 
 // TODO(jmesserly): this was ported from package:dev_compiler, and needs to be
 // refactored to fit into analyzer.
 library analyzer.src.task.strong.checker;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 199 matching lines @@
 
     if (_isDynamicCall(node, ft)) {
       // If f is Function and this is a method invocation, we should have
       // gotten an analyzer error, so no need to issue another error.
       _recordDynamicInvoke(node, node.function);
     } else {
       checkArgumentList(node.argumentList, ft);
     }
   }
 
-  DartType getType(TypeAnnotation type) {
-    return type?.type ?? DynamicTypeImpl.instance;
+  DartType getType(TypeName name) {
+    return (name == null) ? DynamicTypeImpl.instance : name.type;
   }
 
   void reset() {
     _failure = false;
   }
 
   @override
   void visitAsExpression(AsExpression node) {
     // We could do the same check as the IsExpression below, but that is
     // potentially too conservative.  Instead, at runtime, we must fail hard
@@ skipping 253 matching lines @@
   @override
   void visitIsExpression(IsExpression node) {
     _checkRuntimeTypeCheck(node, node.type);
     node.visitChildren(this);
   }
 
   @override
   void visitListLiteral(ListLiteral node) {
     DartType type = DynamicTypeImpl.instance;
     if (node.typeArguments != null) {
-      NodeList<TypeAnnotation> targs = node.typeArguments.arguments;
+      NodeList<TypeName> targs = node.typeArguments.arguments;
       if (targs.length > 0) {
         type = targs[0].type;
       }
     } else {
       DartType staticType = node.staticType;
       if (staticType is InterfaceType) {
         List<DartType> targs = staticType.typeArguments;
         if (targs != null && targs.length > 0) {
           type = targs[0];
         }
       }
     }
     NodeList<Expression> elements = node.elements;
     for (int i = 0; i < elements.length; i++) {
       checkArgument(elements[i], type);
     }
     super.visitListLiteral(node);
   }
 
   @override
   void visitMapLiteral(MapLiteral node) {
     DartType ktype = DynamicTypeImpl.instance;
     DartType vtype = DynamicTypeImpl.instance;
     if (node.typeArguments != null) {
-      NodeList<TypeAnnotation> targs = node.typeArguments.arguments;
+      NodeList<TypeName> targs = node.typeArguments.arguments;
       if (targs.length > 0) {
         ktype = targs[0].type;
       }
       if (targs.length > 1) {
         vtype = targs[1].type;
       }
     } else {
       DartType staticType = node.staticType;
       if (staticType is InterfaceType) {
         List<DartType> targs = staticType.typeArguments;
@@ skipping 119 matching lines @@
       _recordMessage(
           node,
           StaticTypeWarningCode.NON_NULLABLE_FIELD_NOT_INITIALIZED,
           [node.name, variableElement?.type]);
     }
     return super.visitVariableDeclaration(node);
   }
 
   @override
   void visitVariableDeclarationList(VariableDeclarationList node) {
-    TypeAnnotation type = node.type;
+    TypeName type = node.type;
     if (type == null) {
       // No checks are needed when the type is var. Although internally the
       // typing rules may have inferred a more precise type for the variable
       // based on the initializer.
     } else {
       for (VariableDeclaration variable in node.variables) {
         var initializer = variable.initializer;
         if (initializer != null) {
           checkAssignment(initializer, type.type);
         }
@@ skipping 198 matching lines @@
     if (type == null) {
       // We have a type mismatch: the async/async*/sync* modifier does
       // not match the return or yield type.  We should have already gotten an
       // analyzer error in this case.
       return;
     }
     // TODO(vsm): Enforce void or dynamic (to void?) when expression is null.
     if (expression != null) checkAssignment(expression, type);
   }
 
-  void _checkRuntimeTypeCheck(AstNode node, TypeAnnotation annotation) {
-    var type = getType(annotation);
+  void _checkRuntimeTypeCheck(AstNode node, TypeName typeName) {
+    var type = getType(typeName);
     if (!rules.isGroundType(type)) {
       _recordMessage(node, StrongModeCode.NON_GROUND_TYPE_CHECK_INFO, [type]);
     }
   }
 
   void _checkUnary(Expression operand, Token op, MethodElement element) {
     bool isIncrementAssign =
         op.type == TokenType.PLUS_PLUS || op.type == TokenType.MINUS_MINUS;
     if (op.isUserDefinableOperator || isIncrementAssign) {
       if (element == null) {
@@ skipping 609 matching lines @@
     var visited = new Set<InterfaceType>();
     do {
       visited.add(current);
       current.mixins.reversed.forEach(
           (m) => _checkIndividualOverridesFromClass(node, m, seen, true));
       _checkIndividualOverridesFromClass(node, current.superclass, seen, true);
       current = current.superclass;
     } while (!current.isObject && !visited.contains(current));
   }
 }