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

pkg/analyzer/lib/src/generated/resolver.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.resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
@@ skipping 354 matching lines @@
    * checks expressed using an is expression.
    *
    * @param node the is expression to check
    * @return `true` if and only if a hint code is generated on the passed node
    * See [HintCode.TYPE_CHECK_IS_NOT_NULL], [HintCode.TYPE_CHECK_IS_NULL],
    * [HintCode.UNNECESSARY_TYPE_CHECK_TRUE], and
    * [HintCode.UNNECESSARY_TYPE_CHECK_FALSE].
    */
   bool _checkAllTypeChecks(IsExpression node) {
     Expression expression = node.expression;
-    TypeAnnotation typeName = node.type;
+    TypeName typeName = node.type;
     DartType lhsType = expression.staticType;
     DartType rhsType = typeName.type;
     if (lhsType == null || rhsType == null) {
       return false;
     }
-    String rhsNameStr = typeName is TypeName ? typeName.name.name : null;
+    String rhsNameStr = typeName.name.name;
     // if x is dynamic
     if (rhsType.isDynamic && rhsNameStr == Keyword.DYNAMIC.syntax) {
       if (node.notOperator == null) {
         // the is case
         _errorReporter.reportErrorForNode(
             HintCode.UNNECESSARY_TYPE_CHECK_TRUE, node);
       } else {
         // the is not case
         _errorReporter.reportErrorForNode(
             HintCode.UNNECESSARY_TYPE_CHECK_FALSE, node);
@@ skipping 485 matching lines @@
    * `null`, avoiding these implicit returns is considered a best practice.
    *
    * Note: for async functions/methods, this hint only applies when the
    * function has a return type that Future<Null> is not assignable to.
    *
    * @param node the binary expression to check
    * @param body the function body
    * @return `true` if and only if a hint code is generated on the passed node
    * See [HintCode.MISSING_RETURN].
    */
-  void _checkForMissingReturn(TypeAnnotation returnType, FunctionBody body) {
+  void _checkForMissingReturn(TypeName returnType, FunctionBody body) {
     // Check that the method or function has a return type, and a function body
     if (returnType == null || body == null) {
       return;
     }
     // Check that the body is a BlockFunctionBody
     if (body is BlockFunctionBody) {
       // Generators are never required to have a return statement.
       if (body.isGenerator) {
         return;
       }
@@ skipping 942 matching lines @@
    * `x is! int`.
    *
    * @param node the is expression to check
    * @return `true` if and only if a hint code is generated on the passed node
    * See [HintCode.IS_DOUBLE],
    * [HintCode.IS_INT],
    * [HintCode.IS_NOT_DOUBLE], and
    * [HintCode.IS_NOT_INT].
    */
   bool _checkForIsDoubleHints(IsExpression node) {
-    DartType type = node.type.type;
+    TypeName typeName = node.type;
+    DartType type = typeName.type;
     Element element = type?.element;
     if (element != null) {
       String typeNameStr = element.name;
       LibraryElement libraryElement = element.library;
       //      if (typeNameStr.equals(INT_TYPE_NAME) && libraryElement != null
       //          && libraryElement.isDartCore()) {
       //        if (node.getNotOperator() == null) {
       //          errorReporter.reportError(HintCode.IS_INT, node);
       //        } else {
       //          errorReporter.reportError(HintCode.IS_NOT_INT, node);
@@ skipping 1151 matching lines @@
 
   @override
   bool visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     if (_nodeExits(node.function)) {
       return true;
     }
     return node.argumentList.accept(this);
   }
 
   @override
-  bool visitGenericFunctionType(GenericFunctionType node) => false;
-
-  @override
   bool visitIdentifier(Identifier node) => false;
 
   @override
   bool visitIfStatement(IfStatement node) {
     Expression conditionExpression = node.condition;
     Statement thenStatement = node.thenStatement;
     Statement elseStatement = node.elseStatement;
     if (_nodeExits(conditionExpression)) {
       return true;
     }
@@ skipping 3052 matching lines @@
     return null;
   }
 
   @override
   void visitFunctionTypeAliasInScope(FunctionTypeAlias node) {
     super.visitFunctionTypeAliasInScope(node);
     safelyVisitComment(node.documentationComment);
   }
 
   @override
-  Object visitGenericFunctionType(GenericFunctionType node) => null;
-
-  @override
   Object visitHideCombinator(HideCombinator node) => null;
 
   @override
   Object visitIfStatement(IfStatement node) {
     Expression condition = node.condition;
     condition?.accept(this);
     Map<VariableElement, DartType> thenOverrides =
         const <VariableElement, DartType>{};
     Statement thenStatement = node.thenStatement;
     if (thenStatement != null) {
@@ skipping 1913 matching lines @@
     for (Match match in matches) {
       int offset = commentToken.offset + match.start + match.group(1).length;
       int length = match.group(2).length;
       _errorReporter.reportErrorForOffset(
           TodoCode.TODO, offset, length, [match.group(2)]);
     }
   }
 }
 
 /**
- * Helper for resolving types.
+ * Helper for resolving [TypeName]s.
  *
  * The client must set [nameScope] before calling [resolveTypeName].
  */
 class TypeNameResolver {
   final TypeSystem typeSystem;
   final DartType dynamicType;
   final DartType undefinedType;
   final LibraryElement definingLibrary;
   final Source source;
   final AnalysisErrorListener errorListener;
@@ skipping 258 matching lines @@
         } else {
           reportErrorForNode(
               StaticWarningCode.NOT_A_TYPE, typeName, [typeName.name]);
         }
       }
       typeName.staticType = dynamicType;
       node.type = dynamicType;
       return;
     }
     if (argumentList != null) {
-      NodeList<TypeAnnotation> arguments = argumentList.arguments;
+      NodeList<TypeName> arguments = argumentList.arguments;
       int argumentCount = arguments.length;
       List<DartType> parameters = typeSystem.typeFormalsAsTypes(type);
       int parameterCount = parameters.length;
       List<DartType> typeArguments = new List<DartType>(parameterCount);
       if (argumentCount == parameterCount) {
         for (int i = 0; i < parameterCount; i++) {
-          DartType argumentType = _getType(arguments[i]);
+          TypeName argumentTypeName = arguments[i];
+          DartType argumentType = _getType(argumentTypeName);
           if (argumentType == null) {
             argumentType = dynamicType;
           }
           typeArguments[i] = argumentType;
         }
       } else {
         reportErrorForNode(_getInvalidTypeParametersErrorCode(node), node,
             [typeName.name, parameterCount, argumentCount]);
         for (int i = 0; i < parameterCount; i++) {
           typeArguments[i] = dynamicType;
         }
       }
       type = typeSystem.instantiateType(type, typeArguments);
     } else {
       type = typeSystem.instantiateToBounds(type);
     }
     typeName.staticType = type;
     node.type = type;
   }
 
   /**
-   * The number of type arguments in the given [typeName] does not match the
-   * number of parameters in the corresponding class element. Return the error
-   * code that should be used to report this error.
+   * The number of type arguments in the given type name does not match the number of parameters in
+   * the corresponding class element. Return the error code that should be used to report this
+   * error.
+   *
+   * @param node the type name with the wrong number of type arguments
+   * @return the error code that should be used to report that the wrong number of type arguments
+   *         were provided
    */
-  ErrorCode _getInvalidTypeParametersErrorCode(TypeName typeName) {
-    AstNode parent = typeName.parent;
+  ErrorCode _getInvalidTypeParametersErrorCode(TypeName node) {
+    AstNode parent = node.parent;
     if (parent is ConstructorName) {
       parent = parent.parent;
       if (parent is InstanceCreationExpression) {
         if (parent.isConst) {
           return CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS;
         } else {
           return StaticWarningCode.NEW_WITH_INVALID_TYPE_PARAMETERS;
         }
       }
     }
     return StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS;
   }
 
   /**
-   * Checks if the given [typeName] is the target in a redirected constructor.
+   * Checks if the given type name is the target in a redirected constructor.
+   *
+   * @param typeName the type name to analyze
+   * @return some [RedirectingConstructorKind] if the given type name is used as the type in a
+   *         redirected constructor, or `null` otherwise
    */
   RedirectingConstructorKind _getRedirectingConstructorKind(TypeName typeName) {
     AstNode parent = typeName.parent;
     if (parent is ConstructorName) {
       AstNode grandParent = parent.parent;
       if (grandParent is ConstructorDeclaration) {
         if (identical(grandParent.redirectedConstructor, parent)) {
           if (grandParent.constKeyword != null) {
             return RedirectingConstructorKind.CONST;
           }
           return RedirectingConstructorKind.NORMAL;
         }
       }
     }
     return null;
   }
 
   /**
-   * Return the type represented by the given type [annotation].
+   * Return the type represented by the given type name.
+   *
+   * @param typeName the type name representing the type to be returned
+   * @return the type represented by the type name
    */
-  DartType _getType(TypeAnnotation annotation) {
-    DartType type = annotation.type;
+  DartType _getType(TypeName typeName) {
+    DartType type = typeName.type;
     if (type == null) {
       return undefinedType;
     }
     return type;
   }
 
   /**
    * Returns the simple identifier of the given (may be qualified) type name.
    *
    * @param typeName the (may be qualified) qualified type name
@@ skipping 23 matching lines @@
         if (type != null) {
           return null;
         }
         type = element.type;
       }
     }
     return type;
   }
 
   /**
-   * Checks if the given [typeName] is used as the type in an as expression.
+   * Checks if the given type name is used as the type in an as expression.
+   *
+   * @param typeName the type name to analyzer
+   * @return `true` if the given type name is used as the type in an as expression
    */
   bool _isTypeNameInAsExpression(TypeName typeName) {
     AstNode parent = typeName.parent;
     if (parent is AsExpression) {
       return identical(parent.type, typeName);
     }
     return false;
   }
 
   /**
-   * Checks if the given [typeName] is used as the exception type in a catch
-   * clause.
+   * Checks if the given type name is used as the exception type in a catch clause.
+   *
+   * @param typeName the type name to analyzer
+   * @return `true` if the given type name is used as the exception type in a catch clause
    */
   bool _isTypeNameInCatchClause(TypeName typeName) {
     AstNode parent = typeName.parent;
     if (parent is CatchClause) {
       return identical(parent.exceptionType, typeName);
     }
     return false;
   }
 
   /**
-   * Checks if the given [typeName] is used as the type in an instance creation
-   * expression.
+   * Checks if the given type name is used as the type in an instance creation expression.
+   *
+   * @param typeName the type name to analyzer
+   * @return `true` if the given type name is used as the type in an instance creation
+   *         expression
    */
   bool _isTypeNameInInstanceCreationExpression(TypeName typeName) {
     AstNode parent = typeName.parent;
     if (parent is ConstructorName &&
         parent.parent is InstanceCreationExpression) {
       return parent != null && identical(parent.type, typeName);
     }
     return false;
   }
 
   /**
-   * Checks if the given [typeName] is used as the type in an is expression.
+   * Checks if the given type name is used as the type in an is expression.
+   *
+   * @param typeName the type name to analyzer
+   * @return `true` if the given type name is used as the type in an is expression
    */
   bool _isTypeNameInIsExpression(TypeName typeName) {
     AstNode parent = typeName.parent;
     if (parent is IsExpression) {
       return identical(parent.type, typeName);
     }
     return false;
   }
 
   /**
-   * Checks if the given [typeName] used in a type argument list.
+   * Checks if the given type name used in a type argument list.
+   *
+   * @param typeName the type name to analyzer
+   * @return `true` if the given type name is in a type argument list
    */
   bool _isTypeNameInTypeArgumentList(TypeName typeName) =>
       typeName.parent is TypeArgumentList;
 
   /**
    * Records the new Element for a TypeName's Identifier.
    *
    * A null may be passed in to indicate that the element can't be resolved.
    * (During a re-run of a task, it's important to clear any previous value
    * of the element.)
    */
   void _setElement(Identifier typeName, Element element) {
     if (typeName is SimpleIdentifier) {
       typeName.staticElement = element;
     } else if (typeName is PrefixedIdentifier) {
       typeName.identifier.staticElement = element;
       SimpleIdentifier prefix = typeName.prefix;
       prefix.staticElement = nameScope.lookup(prefix, definingLibrary);
     }
   }
 
   /**
-   * Return `true` if the name of the given [typeName] is an built-in identifier.
+   * @return `true` if the name of the given [TypeName] is an built-in identifier.
    */
-  static bool _isBuiltInIdentifier(TypeName typeName) {
-    Token token = typeName.name.beginToken;
+  static bool _isBuiltInIdentifier(TypeName node) {
+    Token token = node.name.beginToken;
     return token.type == TokenType.KEYWORD;
   }
 
   /**
-   * @return `true` if given [typeName] is used as a type annotation.
+   * @return `true` if given [TypeName] is used as a type annotation.
    */
-  static bool _isTypeAnnotation(TypeName typeName) {
-    AstNode parent = typeName.parent;
+  static bool _isTypeAnnotation(TypeName node) {
+    AstNode parent = node.parent;
     if (parent is VariableDeclarationList) {
-      return identical(parent.type, typeName);
+      return identical(parent.type, node);
     } else if (parent is FieldFormalParameter) {
-      return identical(parent.type, typeName);
+      return identical(parent.type, node);
     } else if (parent is SimpleFormalParameter) {
-      return identical(parent.type, typeName);
+      return identical(parent.type, node);
     }
     return false;
   }
 }
 
 /**
  * Instances of the class `TypeOverrideManager` manage the ability to override the type of an
  * element within a given context.
  */
 class TypeOverrideManager {
@@ skipping 247 matching lines @@
       } else if (unitMember is ClassTypeAlias) {
         _resolveTypeParameters(unitMember.typeParameters,
             () => new TypeParameterScope(libraryScope, unitMember.element));
       } else if (unitMember is FunctionTypeAlias) {
         _resolveTypeParameters(unitMember.typeParameters,
             () => new FunctionTypeScope(libraryScope, unitMember.element));
       }
     }
   }
 
-  void _resolveTypeName(TypeAnnotation type) {
-    if (type is TypeName) {
-      type.typeArguments?.arguments?.forEach(_resolveTypeName);
-      typeNameResolver.resolveTypeName(type);
-      // TODO(scheglov) report error when don't apply type bounds for type bounds
-    } else {
-      // TODO(brianwilkerson) Add resolution of GenericFunctionType
-      throw new ArgumentError('Cannot resolve a ${type.runtimeType}');
-    }
+  void _resolveTypeName(TypeName typeName) {
+    typeName.typeArguments?.arguments?.forEach(_resolveTypeName);
+    typeNameResolver.resolveTypeName(typeName);
+    // TODO(scheglov) report error when don't apply type bounds for type bounds
   }
 
   void _resolveTypeParameters(
       TypeParameterList typeParameters, Scope createTypeParametersScope()) {
     if (typeParameters != null) {
       Scope typeParametersScope = null;
       for (TypeParameter typeParameter in typeParameters.typeParameters) {
-        TypeAnnotation bound = typeParameter.bound;
+        TypeName bound = typeParameter.bound;
         if (bound != null) {
           Element typeParameterElement = typeParameter.name.staticElement;
           if (typeParameterElement is TypeParameterElementImpl) {
             if (LibraryElementImpl.hasResolutionCapability(
                 library, LibraryResolutionCapability.resolvedTypeNames)) {
-              if (bound is TypeName) {
-                bound.type = typeParameterElement.bound;
-              } else {
-                // TODO(brianwilkerson) Add resolution of GenericFunctionType
-                throw new ArgumentError(
-                    'Cannot resolve a ${bound.runtimeType}');
-              }
+              bound.type = typeParameterElement.bound;
             } else {
               libraryScope ??= new LibraryScope(library);
               typeParametersScope ??= createTypeParametersScope();
               typeNameResolver ??= new TypeNameResolver(
                   new TypeSystemImpl(typeProvider),
                   typeProvider,
                   library,
                   source,
                   errorListener);
               typeNameResolver.nameScope = typeParametersScope;
@@ skipping 657 matching lines @@
    * True if we're analyzing in strong mode.
    */
   bool _strongMode;
 
   /**
    * Type type system in use for this resolver pass.
    */
   TypeSystem _typeSystem;
 
   /**
-   * The helper to resolve types.
+   * The helper to resolve [TypeName]s.
    */
   TypeNameResolver _typeNameResolver;
 
   final TypeResolverMode mode;
 
   /**
    * Is `true` when we are visiting all nodes in [TypeResolverMode.local] mode.
    */
   bool _localModeVisitAll = false;
 
@@ skipping 61 matching lines @@
   }
 
   @override
   Object visitCatchClause(CatchClause node) {
     super.visitCatchClause(node);
     SimpleIdentifier exception = node.exceptionParameter;
     if (exception != null) {
       // If an 'on' clause is provided the type of the exception parameter is
       // the type in the 'on' clause. Otherwise, the type of the exception
       // parameter is 'Object'.
-      TypeAnnotation exceptionTypeName = node.exceptionType;
+      TypeName exceptionTypeName = node.exceptionType;
       DartType exceptionType;
       if (exceptionTypeName == null) {
         exceptionType = typeProvider.dynamicType;
       } else {
         exceptionType = _typeNameResolver._getType(exceptionTypeName);
       }
       _recordType(exception, exceptionType);
       Element element = exception.staticElement;
       if (element is VariableElementImpl) {
         element.declaredType = exceptionType;
@@ skipping 118 matching lines @@
       AnalysisEngine.instance.logger.logError(buffer.toString(),
           new CaughtException(new AnalysisException(), null));
     }
     return null;
   }
 
   @override
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     super.visitDeclaredIdentifier(node);
     DartType declaredType;
-    TypeAnnotation typeName = node.type;
+    TypeName typeName = node.type;
     if (typeName == null) {
       declaredType = _dynamicType;
     } else {
       declaredType = _typeNameResolver._getType(typeName);
     }
     LocalVariableElementImpl element = node.element as LocalVariableElementImpl;
     element.declaredType = declaredType;
     return null;
   }
 
   @override
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     super.visitFieldFormalParameter(node);
     Element element = node.identifier.staticElement;
     if (element is ParameterElementImpl) {
       FormalParameterList parameterList = node.parameters;
       if (parameterList == null) {
         DartType type;
-        TypeAnnotation typeName = node.type;
+        TypeName typeName = node.type;
         if (typeName == null) {
           element.hasImplicitType = true;
           if (element is FieldFormalParameterElement) {
             FieldElement fieldElement =
                 (element as FieldFormalParameterElement).field;
             type = fieldElement?.type;
           }
         } else {
           type = _typeNameResolver._getType(typeName);
         }
@@ skipping 202 matching lines @@
     }
 
     // The mode in which we visit all nodes.
     return super.visitNode(node);
   }
 
   @override
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     super.visitSimpleFormalParameter(node);
     DartType declaredType;
-    TypeAnnotation typeName = node.type;
+    TypeName typeName = node.type;
     if (typeName == null) {
       declaredType = _dynamicType;
     } else {
       declaredType = _typeNameResolver._getType(typeName);
     }
     Element element = node.identifier.staticElement;
     if (element is ParameterElementImpl) {
       element.declaredType = declaredType;
     } else {
       // TODO(brianwilkerson) Report the internal error.
@@ skipping 18 matching lines @@
   @override
   Object visitTypeParameter(TypeParameter node) {
     super.visitTypeParameter(node);
     AstNode parent2 = node.parent?.parent;
     if (parent2 is ClassDeclaration ||
         parent2 is ClassTypeAlias ||
         parent2 is FunctionTypeAlias) {
       // Bounds of parameters of classes and function type aliases are
       // already resolved.
     } else {
-      TypeAnnotation bound = node.bound;
+      TypeName bound = node.bound;
       if (bound != null) {
         TypeParameterElementImpl typeParameter =
             node.name.staticElement as TypeParameterElementImpl;
         if (typeParameter != null) {
           typeParameter.bound = bound.type;
         }
       }
     }
     return null;
   }
 
   @override
   Object visitVariableDeclaration(VariableDeclaration node) {
     super.visitVariableDeclaration(node);
     var variableList = node.parent as VariableDeclarationList;
     // When the library is resynthesized, the types of field elements are
     // already set - statically or inferred. We don't want to overwrite them.
     if (variableList.parent is FieldDeclaration &&
         LibraryElementImpl.hasResolutionCapability(
             definingLibrary, LibraryResolutionCapability.resolvedTypeNames)) {
       return null;
     }
     // Resolve the type.
     DartType declaredType;
-    TypeAnnotation typeName = variableList.type;
+    TypeName typeName = variableList.type;
     if (typeName == null) {
       declaredType = _dynamicType;
     } else {
       declaredType = _typeNameResolver._getType(typeName);
     }
     Element element = node.name.staticElement;
     if (element is VariableElementImpl) {
       element.declaredType = declaredType;
     }
     return null;
   }
 
   /**
-   * Given the [returnType] of a function, compute the return type of the
+   * Given a type name representing the return type of a function, compute the return type of the
    * function.
+   *
+   * @param returnType the type name representing the return type of the function
+   * @return the return type that was computed
    */
-  DartType _computeReturnType(TypeAnnotation returnType) {
+  DartType _computeReturnType(TypeName returnType) {
     if (returnType == null) {
       return _dynamicType;
     } else {
       return returnType.type;
     }
   }
 
   /**
    * Return the class element that represents the class whose name was provided.
    *
@@ skipping 61 matching lines @@
   Object _recordType(Expression expression, DartType type) {
     if (type == null) {
       expression.staticType = _dynamicType;
     } else {
       expression.staticType = type;
     }
     return null;
   }
 
   /**
-   * Resolve the types in the given [withClause] and [implementsClause] and
-   * associate those types with the given [classElement].
+   * Resolve the types in the given with and implements clauses and associate those types with the
+   * given class element.
+   *
+   * @param classElement the class element with which the mixin and interface types are to be
+   *          associated
+   * @param withClause the with clause to be resolved
+   * @param implementsClause the implements clause to be resolved
    */
   void _resolve(ClassElementImpl classElement, WithClause withClause,
       ImplementsClause implementsClause) {
     if (withClause != null) {
       List<InterfaceType> mixinTypes = _resolveTypes(
           withClause.mixinTypes,
           CompileTimeErrorCode.MIXIN_OF_NON_CLASS,
           CompileTimeErrorCode.MIXIN_OF_ENUM,
           CompileTimeErrorCode.MIXIN_OF_NON_CLASS);
       if (classElement != null) {
@@ skipping 88 matching lines @@
       InterfaceType type =
           _resolveType(typeName, nonTypeError, enumTypeError, dynamicTypeError);
       if (type != null) {
         types.add(type);
       }
     }
     return types;
   }
 
   /**
-   * Given a parameter [element], create a function type based on the given
-   * [returnType] and [parameterList] and associate the created type with the
-   * element.
+   * Given a parameter element, create a function type based on the given return type and parameter
+   * list and associate the created type with the element.
+   *
+   * @param element the parameter element whose type is to be set
+   * @param returnType the (possibly `null`) return type of the function
+   * @param parameterList the list of parameters to the function
    */
   void _setFunctionTypedParameterType(ParameterElementImpl element,
-      TypeAnnotation returnType, FormalParameterList parameterList) {
+      TypeName returnType, FormalParameterList parameterList) {
     List<ParameterElement> parameters = _getElements(parameterList);
     FunctionElementImpl functionElement = new FunctionElementImpl.forNode(null);
     functionElement.isSynthetic = true;
     functionElement.shareParameters(parameters);
     functionElement.declaredReturnType = _computeReturnType(returnType);
     functionElement.enclosingElement = element;
     functionElement.shareTypeParameters(element.typeParameters);
     element.type = new FunctionTypeImpl(functionElement);
     functionElement.type = element.type;
   }
@@ skipping 537 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }