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

pkg/analyzer/lib/src/generated/error_verifier.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.generated.error_verifier;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 750 matching lines @@
       _hiddenElements.declare(functionElement);
     }
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       SimpleIdentifier identifier = node.name;
       String methodName = "";
       if (identifier != null) {
         methodName = identifier.name;
       }
       _enclosingFunction = functionElement;
-      TypeName returnType = node.returnType;
+      TypeAnnotation returnType = node.returnType;
       if (node.isSetter || node.isGetter) {
         _checkForMismatchedAccessorTypes(node, methodName);
         if (node.isSetter) {
           FunctionExpression functionExpression = node.functionExpression;
           if (functionExpression != null) {
             _checkForWrongNumberOfParametersForSetter(
                 identifier, functionExpression.parameters);
           }
           _checkForNonVoidReturnTypeForSetter(returnType);
         }
@@ skipping 73 matching lines @@
               [node.identifier]);
         }
       }
       return super.visitFunctionTypedFormalParameter(node);
     } finally {
       _isInFunctionTypedFormalParameter = old;
     }
   }
 
   @override
+  Object visitGenericFunctionType(GenericFunctionType node) {
+    throw new StateError(
+        'Support for generic function types is not yet implemented');
+//    return super.visitGenericFunctionType(node);
+  }
+
+  @override
+  Object visitGenericTypeAlias(GenericTypeAlias node) {
+    throw new StateError(
+        'Support for generic type aliases is not yet implemented');
+//    return super.visitGenericTypeAlias(node);
+  }
+
+  @override
   Object visitIfStatement(IfStatement node) {
     _checkForNonBoolCondition(node.condition);
     return super.visitIfStatement(node);
   }
 
   @override
   Object visitImplementsClause(ImplementsClause node) {
     node.interfaces.forEach(_checkForImplicitDynamicType);
     return super.visitImplementsClause(node);
   }
@@ skipping 49 matching lines @@
     _checkForTypeAnnotationDeferredClass(node.type);
     _checkForTypeAnnotationGenericFunctionParameter(node.type);
     return super.visitIsExpression(node);
   }
 
   @override
   Object visitListLiteral(ListLiteral node) {
     TypeArgumentList typeArguments = node.typeArguments;
     if (typeArguments != null) {
       if (!_options.strongMode && node.constKeyword != null) {
-        NodeList<TypeName> arguments = typeArguments.arguments;
+        NodeList<TypeAnnotation> arguments = typeArguments.arguments;
         if (arguments.isNotEmpty) {
           _checkForInvalidTypeArgumentInConstTypedLiteral(arguments,
               CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_LIST);
         }
       }
       _checkForExpectedOneListTypeArgument(node, typeArguments);
     }
     _checkForImplicitDynamicTypedLiteral(node);
     _checkForListElementTypeNotAssignable(node);
     return super.visitListLiteral(node);
   }
 
   @override
   Object visitMapLiteral(MapLiteral node) {
     TypeArgumentList typeArguments = node.typeArguments;
     if (typeArguments != null) {
-      NodeList<TypeName> arguments = typeArguments.arguments;
+      NodeList<TypeAnnotation> arguments = typeArguments.arguments;
       if (!_options.strongMode && arguments.isNotEmpty) {
         if (node.constKeyword != null) {
           _checkForInvalidTypeArgumentInConstTypedLiteral(arguments,
               CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_MAP);
         }
       }
       _checkExpectedTwoMapTypeArguments(typeArguments);
     }
     _checkForImplicitDynamicTypedLiteral(node);
     _checkForMapTypeNotAssignable(node);
     _checkForNonConstMapAsExpressionStatement(node);
     return super.visitMapLiteral(node);
   }
 
   @override
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement previousFunction = _enclosingFunction;
     try {
       _isInStaticMethod = node.isStatic;
       _enclosingFunction = node.element;
       SimpleIdentifier identifier = node.name;
       String methodName = "";
       if (identifier != null) {
         methodName = identifier.name;
       }
-      TypeName returnTypeName = node.returnType;
+      TypeAnnotation returnType = node.returnType;
       if (node.isSetter || node.isGetter) {
         _checkForMismatchedAccessorTypes(node, methodName);
       }
       if (node.isGetter) {
         _checkForVoidReturnType(node);
         _checkForConflictingStaticGetterAndInstanceSetter(node);
       } else if (node.isSetter) {
         _checkForInvalidModifierOnBody(
             node.body, CompileTimeErrorCode.INVALID_MODIFIER_ON_SETTER);
         _checkForWrongNumberOfParametersForSetter(node.name, node.parameters);
-        _checkForNonVoidReturnTypeForSetter(returnTypeName);
+        _checkForNonVoidReturnTypeForSetter(returnType);
         _checkForConflictingStaticSetterAndInstanceMember(node);
       } else if (node.isOperator) {
         _checkForOptionalParameterInOperator(node);
         _checkForWrongNumberOfParametersForOperator(node);
         _checkForNonVoidReturnTypeForOperator(node);
       }
       _checkForConcreteClassWithAbstractMember(node);
       _checkForAllInvalidOverrideErrorCodesForMethod(node);
-      _checkForTypeAnnotationDeferredClass(returnTypeName);
-      _checkForIllegalReturnType(returnTypeName);
-      _checkForImplicitDynamicReturn(node.name, node.element);
+      _checkForTypeAnnotationDeferredClass(returnType);
+      _checkForIllegalReturnType(returnType);
+      _checkForImplicitDynamicReturn(node, node.element);
       _checkForMustCallSuper(node);
       return super.visitMethodDeclaration(node);
     } finally {
       _enclosingFunction = previousFunction;
       _isInStaticMethod = false;
     }
   }
 
   @override
   Object visitMethodInvocation(MethodInvocation node) {
@@ skipping 170 matching lines @@
   }
 
   @override
   Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     _checkForFinalNotInitialized(node.variables);
     return super.visitTopLevelVariableDeclaration(node);
   }
 
   @override
   Object visitTypeArgumentList(TypeArgumentList node) {
-    NodeList<TypeName> list = node.arguments;
-    for (TypeName typeName in list) {
-      _checkForTypeAnnotationDeferredClass(typeName);
+    NodeList<TypeAnnotation> list = node.arguments;
+    for (TypeAnnotation type in list) {
+      _checkForTypeAnnotationDeferredClass(type);
     }
     return super.visitTypeArgumentList(node);
   }
 
   @override
   Object visitTypeName(TypeName node) {
     _checkForTypeArgumentNotMatchingBounds(node);
     _checkForTypeParameterReferencedByStatic(node);
     return super.visitTypeName(node);
   }
@@ skipping 2010 matching lines @@
    */
   void _checkForConstWithNonConst(InstanceCreationExpression expression) {
     ConstructorElement constructorElement = expression.staticElement;
     if (constructorElement != null && !constructorElement.isConst) {
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.CONST_WITH_NON_CONST, expression);
     }
   }
 
   /**
-   * Verify that the given [typeName] does not reference any type parameters.
+   * Verify that the given [type] does not reference any type parameters.
    *
    * See [CompileTimeErrorCode.CONST_WITH_TYPE_PARAMETERS].
    */
-  void _checkForConstWithTypeParameters(TypeName typeName) {
+  void _checkForConstWithTypeParameters(TypeAnnotation type) {
     // something wrong with AST
-    if (typeName == null) {
+    if (type is! TypeName) {
       return;
     }
+    TypeName typeName = type;
     Identifier name = typeName.name;
     if (name == null) {
       return;
     }
     // should not be a type parameter
     if (name.staticElement is TypeParameterElement) {
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.CONST_WITH_TYPE_PARAMETERS, name);
     }
     // check type arguments
     TypeArgumentList typeArguments = typeName.typeArguments;
     if (typeArguments != null) {
-      for (TypeName argument in typeArguments.arguments) {
+      for (TypeAnnotation argument in typeArguments.arguments) {
         _checkForConstWithTypeParameters(argument);
       }
     }
   }
 
   /**
    * Verify that if the given 'const' instance creation [expression] is being
    * invoked on the resolved constructor. The [constructorName] is the
    * constructor name, always non-`null`. The [typeName] is the name of the type
    * defining the constructor, always non-`null`.
@@ skipping 544 matching lines @@
         _checkForFinalNotInitialized(classMember.fields);
       }
     }
   }
 
   /**
    * If the current function is async, async*, or sync*, verify that its
    * declared return type is assignable to Future, Stream, or Iterable,
    * respectively.  If not, report the error using [returnType].
    */
-  void _checkForIllegalReturnType(TypeName returnType) {
+  void _checkForIllegalReturnType(TypeAnnotation returnType) {
     if (returnType == null) {
       // No declared return type, so the return type must be dynamic, which is
       // assignable to everything.
       return;
     }
     if (_enclosingFunction.isAsynchronous) {
       if (_enclosingFunction.isGenerator) {
         _checkForIllegalReturnTypeCode(
             returnType,
             _typeProvider.streamDynamicType,
@@ skipping 12 matching lines @@
     }
   }
 
   /**
    * If the current function is async, async*, or sync*, verify that its
    * declared return type is assignable to Future, Stream, or Iterable,
    * respectively. This is called by [_checkForIllegalReturnType] to check if
    * the declared [returnTypeName] is assignable to the required [expectedType]
    * and if not report [errorCode].
    */
-  void _checkForIllegalReturnTypeCode(TypeName returnTypeName,
+  void _checkForIllegalReturnTypeCode(TypeAnnotation returnTypeName,
       DartType expectedType, StaticTypeWarningCode errorCode) {
     DartType returnType = _enclosingFunction.returnType;
     if (_options.strongMode) {
       //
       // When checking an async/sync*/async* method, we know the exact type
       // that will be returned (e.g. Future, Iterable, or Stream).
       //
       // For example an `async` function body will return a `Future<T>` for
       // some `T` (possibly `dynamic`).
       //
@@ skipping 126 matching lines @@
       return;
     }
     if (element != null &&
         element.hasImplicitReturnType &&
         element.returnType.isDynamic) {
       _errorReporter.reportErrorForNode(StrongModeCode.IMPLICIT_DYNAMIC_RETURN,
           functionName, [element.displayName]);
     }
   }
 
-  void _checkForImplicitDynamicType(TypeName node) {
+  void _checkForImplicitDynamicType(TypeAnnotation node) {
     if (_options.implicitDynamic ||
         node == null ||
-        node.typeArguments != null) {
+        (node is TypeName && node.typeArguments != null)) {
       return;
     }
     DartType type = node.type;
     if (type is ParameterizedType &&
         type.typeArguments.isNotEmpty &&
         type.typeArguments.any((t) => t.isDynamic)) {
       _errorReporter.reportErrorForNode(
           StrongModeCode.IMPLICIT_DYNAMIC_TYPE, node, [type]);
     }
   }
@@ skipping 447 matching lines @@
     }
   }
 
   /**
    * Checks to ensure that the given list of type [arguments] does not have a
    * type parameter as a type argument. The [errorCode] is either
    * [CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_LIST] or
    * [CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_MAP].
    */
   void _checkForInvalidTypeArgumentInConstTypedLiteral(
-      NodeList<TypeName> arguments, ErrorCode errorCode) {
-    for (TypeName typeName in arguments) {
-      if (typeName.type is TypeParameterType) {
-        _errorReporter.reportErrorForNode(errorCode, typeName, [typeName.name]);
+      NodeList<TypeAnnotation> arguments, ErrorCode errorCode) {
+    for (TypeAnnotation type in arguments) {
+      if (type is TypeName && type.type is TypeParameterType) {
+        _errorReporter.reportErrorForNode(errorCode, type, [type.name]);
       }
     }
   }
 
   /**
    * Verify that the elements given list [literal] are subtypes of the list's
    * static type.
    *
    * See [CompileTimeErrorCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE], and
    * [StaticWarningCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE].
@@ skipping 660 matching lines @@
    *
    * See [StaticWarningCode.NON_VOID_RETURN_FOR_OPERATOR].
    */
   void _checkForNonVoidReturnTypeForOperator(MethodDeclaration declaration) {
     // check that []= operator
     SimpleIdentifier name = declaration.name;
     if (name.name != "[]=") {
       return;
     }
     // check return type
-    TypeName typeName = declaration.returnType;
-    if (typeName != null) {
-      DartType type = typeName.type;
+    TypeAnnotation annotation = declaration.returnType;
+    if (annotation != null) {
+      DartType type = annotation.type;
       if (type != null && !type.isVoid) {
         _errorReporter.reportErrorForNode(
-            StaticWarningCode.NON_VOID_RETURN_FOR_OPERATOR, typeName);
+            StaticWarningCode.NON_VOID_RETURN_FOR_OPERATOR, annotation);
       }
     }
   }
 
   /**
    * Verify the [typeName], used as the return type of a setter, is valid
    * (either `null` or the type 'void').
    *
    * See [StaticWarningCode.NON_VOID_RETURN_FOR_SETTER].
    */
-  void _checkForNonVoidReturnTypeForSetter(TypeName typeName) {
+  void _checkForNonVoidReturnTypeForSetter(TypeAnnotation typeName) {
     if (typeName != null) {
       DartType type = typeName.type;
       if (type != null && !type.isVoid) {
         _errorReporter.reportErrorForNode(
             StaticWarningCode.NON_VOID_RETURN_FOR_SETTER, typeName);
       }
     }
   }
 
   /**
@@ skipping 401 matching lines @@
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF, alias);
     }
   }
 
   /**
    * Verify that the given type [name] is not a deferred type.
    *
    * See [StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS].
    */
-  void _checkForTypeAnnotationDeferredClass(TypeName name) {
-    if (name != null && name.isDeferred) {
+  void _checkForTypeAnnotationDeferredClass(TypeAnnotation type) {
+    if (type is TypeName && type.isDeferred) {
       _errorReporter.reportErrorForNode(
-          StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS, name, [name.name]);
+          StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS, type, [type.name]);
     }
   }
 
   /**
    * Verify that the given type [name] is not a type parameter in a generic
    * method.
    *
    * See [StaticWarningCode.TYPE_ANNOTATION_GENERIC_FUNCTION_PARAMETER].
    */
-  void _checkForTypeAnnotationGenericFunctionParameter(TypeName typeName) {
-    if (typeName == null) {
-      return;
-    }
-    Identifier name = typeName.name;
-    if (name is SimpleIdentifier) {
-      Element element = name.staticElement;
-      if (element is TypeParameterElement &&
-          element.enclosingElement is ExecutableElement) {
-        _errorReporter.reportErrorForNode(
-            StaticWarningCode.TYPE_ANNOTATION_GENERIC_FUNCTION_PARAMETER,
-            name,
-            [name.name]);
+  void _checkForTypeAnnotationGenericFunctionParameter(TypeAnnotation type) {
+    if (type is TypeName) {
+      Identifier name = type.name;
+      if (name is SimpleIdentifier) {
+        Element element = name.staticElement;
+        if (element is TypeParameterElement &&
+            element.enclosingElement is ExecutableElement) {
+          _errorReporter.reportErrorForNode(
+              StaticWarningCode.TYPE_ANNOTATION_GENERIC_FUNCTION_PARAMETER,
+              name,
+              [name.name]);
+        }
       }
     }
   }
 
   /**
    * Verify that the type arguments in the given [typeName] are all within
    * their bounds.
    *
    * See [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS].
    */
   void _checkForTypeArgumentNotMatchingBounds(TypeName typeName) {
     if (typeName.typeArguments == null) {
       return;
     }
     // prepare Type
     DartType type = typeName.type;
     if (type == null) {
       return;
     }
     Element element = type.element;
     if (element is ClassElement) {
       // prepare type parameters
       List<TypeParameterElement> parameterElements = element.typeParameters;
       List<DartType> parameterTypes = element.type.typeArguments;
       List<DartType> arguments = (type as ParameterizedType).typeArguments;
       // iterate over each bounded type parameter and corresponding argument
-      NodeList<TypeName> typeNameArgList = typeName.typeArguments.arguments;
+      NodeList<TypeAnnotation> argumentNodes = typeName.typeArguments.arguments;
       int loopThroughIndex =
-          math.min(typeNameArgList.length, parameterElements.length);
+          math.min(argumentNodes.length, parameterElements.length);
       bool shouldSubstitute =
           arguments.length != 0 && arguments.length == parameterTypes.length;
       for (int i = 0; i < loopThroughIndex; i++) {
-        TypeName argTypeName = typeNameArgList[i];
-        DartType argType = argTypeName.type;
+        TypeAnnotation argumentNode = argumentNodes[i];
+        DartType argType = argumentNode.type;
         DartType boundType = parameterElements[i].bound;
         if (argType != null && boundType != null) {
           if (shouldSubstitute) {
             boundType = boundType.substitute2(arguments, parameterTypes);
           }
           if (!_typeSystem.isSubtypeOf(argType, boundType)) {
             ErrorCode errorCode;
             if (_isInConstInstanceCreation) {
               errorCode =
                   CompileTimeErrorCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS;
             } else {
               errorCode =
                   StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS;
             }
             _errorReporter.reportTypeErrorForNode(
-                errorCode, argTypeName, [argType, boundType]);
+                errorCode, argumentNode, [argType, boundType]);
           }
         }
       }
     }
   }
 
   /**
    * Check whether the given type [name] is a type parameter being used to
    * define a static member.
    *
@@ skipping 189 matching lines @@
 //        // (Either here or in ErrorVerifier.checkForAllFinalInitializedErrorCodes)
 //        }
   }
 
   /**
    * Verify that the given [getter] does not have a return type of 'void'.
    *
    * See [StaticWarningCode.VOID_RETURN_FOR_GETTER].
    */
   void _checkForVoidReturnType(MethodDeclaration getter) {
-    TypeName returnType = getter.returnType;
-    if (returnType == null || returnType.name.name != "void") {
-      return;
+    TypeAnnotation returnType = getter.returnType;
+    if (returnType is TypeName && returnType.name.name == "void") {
+      _errorReporter.reportErrorForNode(
+          StaticWarningCode.VOID_RETURN_FOR_GETTER, returnType);
     }
-    _errorReporter.reportErrorForNode(
-        StaticWarningCode.VOID_RETURN_FOR_GETTER, returnType);
   }
 
   /**
    * Verify the given operator-method [declaration], has correct number of
    * parameters.
    *
    * This method assumes that the method declaration was tested to be an
    * operator declaration before being called.
    *
    * See [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR].
@@ skipping 187 matching lines @@
    * Verify that the given [typeArguments] are all within their bounds, as
    * defined by the given [element].
    *
    * See [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS].
    */
   void _checkTypeArguments(Element element, TypeArgumentList typeArguments,
       [DartType targetType]) {
     if (element == null || typeArguments == null) {
       return;
     }
-    void reportError(
-        TypeName argument, DartType argumentType, DartType parameterType) {
+    void reportError(TypeAnnotation argument, DartType argumentType,
+        DartType parameterType) {
       _errorReporter.reportTypeErrorForNode(
           StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS,
           argument,
           [argumentType, parameterType]);
     }
 
     if (element is FunctionTypedElement) {
       _checkTypeArgumentsAgainstBounds(
           element.typeParameters, typeArguments, targetType, reportError);
     } else if (element is ClassElement) {
       _checkTypeArgumentsAgainstBounds(
           element.typeParameters, typeArguments, targetType, reportError);
     } else if (element is ParameterElement || element is LocalVariableElement) {
       // TODO(brianwilkerson) Implement this case
     } else {
       print('Unhandled element type: ${element.runtimeType}');
     }
   }
 
   void _checkTypeArgumentsAgainstBounds(
       List<TypeParameterElement> typeParameters,
       TypeArgumentList typeArgumentList,
       DartType targetType,
-      void reportError(
-          TypeName argument, DartType argumentType, DartType parameterType)) {
-    NodeList<TypeName> typeArguments = typeArgumentList.arguments;
+      void reportError(TypeAnnotation argument, DartType argumentType,
+          DartType parameterType)) {
+    NodeList<TypeAnnotation> typeArguments = typeArgumentList.arguments;
     int argumentsLength = typeArguments.length;
     int maxIndex = math.min(typeParameters.length, argumentsLength);
 
     bool shouldSubstitute =
         argumentsLength != 0 && argumentsLength == typeParameters.length;
     List<DartType> argumentTypes = shouldSubstitute
-        ? typeArguments.map((TypeName typeName) => typeName.type).toList()
+        ? typeArguments.map((TypeAnnotation type) => type.type).toList()
         : null;
     List<DartType> parameterTypes = shouldSubstitute
         ? typeParameters
             .map((TypeParameterElement element) => element.type)
             .toList()
         : null;
     List<DartType> targetTypeParameterTypes = null;
     for (int i = 0; i < maxIndex; i++) {
-      TypeName argTypeName = typeArguments[i];
-      DartType argType = argTypeName.type;
+      TypeAnnotation argument = typeArguments[i];
+      DartType argType = argument.type;
       DartType boundType = typeParameters[i].bound;
       if (argType != null && boundType != null) {
         if (targetType is ParameterizedType) {
           if (targetTypeParameterTypes == null) {
             targetTypeParameterTypes = targetType.typeParameters
                 .map((TypeParameterElement element) => element.type)
                 .toList();
           }
           boundType = boundType.substitute2(
               targetType.typeArguments, targetTypeParameterTypes);
         }
         if (shouldSubstitute) {
           boundType = boundType.substitute2(argumentTypes, parameterTypes);
         }
         if (!_typeSystem.isSubtypeOf(argType, boundType)) {
-          reportError(argTypeName, argType, boundType);
+          reportError(argument, argType, boundType);
         }
       }
     }
   }
 
   DartType _computeReturnTypeForMethod(Expression returnExpression) {
     // This method should never be called for generators, since generators are
     // never allowed to contain return statements with expressions.
     assert(!_inGenerator);
     if (returnExpression == null) {
@@ skipping 842 matching lines @@
 class _InvocationCollector extends RecursiveAstVisitor {
   final List<String> superCalls = <String>[];
 
   @override
   visitMethodInvocation(MethodInvocation node) {
     if (node.target is SuperExpression) {
       superCalls.add(node.methodName.name);
     }
   }
 }