Implement stable resolution of generic types without type arguments to their bounds.

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/token.dart';
@@ skipping 7468 matching lines @@
       }
     }
     return resolvedParameters;
   }
 }
 
 /**
  * The abstract class `ScopedVisitor` maintains name and label scopes as an AST structure is
  * being visited.
  */
+/**
+ * The abstract class `ScopedVisitor` maintains name and label scopes as an AST structure is
+ * being visited.
+ */
 abstract class ScopedVisitor extends UnifyingAstVisitor<Object> {
   /**
    * The element for the library containing the compilation unit being visited.
    */
   final LibraryElement definingLibrary;
 
   /**
    * The source representing the compilation unit being visited.
    */
   final Source source;
@@ skipping 860 matching lines @@
 /**
  * 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 ErrorReporter errorReporter;
+  final Source source;
+  final AnalysisErrorListener errorListener;
 
   Scope nameScope;
 
   TypeNameResolver(this.typeSystem, TypeProvider typeProvider,
-      this.definingLibrary, this.errorReporter)
+      this.definingLibrary, this.source, this.errorListener)
       : dynamicType = typeProvider.dynamicType,
         undefinedType = typeProvider.undefinedType;
 
   /**
+   * Report an error with the given error code and arguments.
+   *
+   * @param errorCode the error code of the error to be reported
+   * @param node the node specifying the location of the error
+   * @param arguments the arguments to the error, used to compose the error message
+   */
+  void reportErrorForNode(ErrorCode errorCode, AstNode node,
+      [List<Object> arguments]) {
+    errorListener.onError(new AnalysisError(
+        source, node.offset, node.length, errorCode, arguments));
+  }
+
+  /**
    * Resolve the given [TypeName] - set its element and static type. Only the
    * given [node] is resolved, all its children must be already resolved.
    *
    * The client must set [nameScope] before calling [resolveTypeName].
    */
   void resolveTypeName(TypeName node) {
     Identifier typeName = node.name;
     _setElement(typeName, null); // Clear old Elements from previous run.
     TypeArgumentList argumentList = node.typeArguments;
     Element element = nameScope.lookup(typeName, definingLibrary);
@@ skipping 38 matching lines @@
           PrefixedIdentifier prefixedIdentifier =
               typeName as PrefixedIdentifier;
           SimpleIdentifier prefix = prefixedIdentifier.prefix;
           element = nameScope.lookup(prefix, definingLibrary);
           if (element is PrefixElement) {
             AstNode grandParent = parent.parent;
             if (grandParent is InstanceCreationExpression &&
                 grandParent.isConst) {
               // If, if this is a const expression, then generate a
               // CompileTimeErrorCode.CONST_WITH_NON_TYPE error.
-              errorReporter.reportErrorForNode(
+              reportErrorForNode(
                   CompileTimeErrorCode.CONST_WITH_NON_TYPE,
                   prefixedIdentifier.identifier,
                   [prefixedIdentifier.identifier.name]);
             } else {
               // Else, if this expression is a new expression, report a
               // NEW_WITH_NON_TYPE warning.
-              errorReporter.reportErrorForNode(
+              reportErrorForNode(
                   StaticWarningCode.NEW_WITH_NON_TYPE,
                   prefixedIdentifier.identifier,
                   [prefixedIdentifier.identifier.name]);
             }
             _setElement(prefix, element);
             return;
           } else if (element != null) {
             //
             // Rewrite the constructor name. The parser, when it sees a
             // constructor named "a.b", cannot tell whether "a" is a prefix and
@@ skipping 12 matching lines @@
     // check element
     bool elementValid = element is! MultiplyDefinedElement;
     if (elementValid &&
         element is! ClassElement &&
         _isTypeNameInInstanceCreationExpression(node)) {
       SimpleIdentifier typeNameSimple = _getTypeSimpleIdentifier(typeName);
       InstanceCreationExpression creation =
           node.parent.parent as InstanceCreationExpression;
       if (creation.isConst) {
         if (element == null) {
-          errorReporter.reportErrorForNode(
+          reportErrorForNode(
               CompileTimeErrorCode.UNDEFINED_CLASS, typeNameSimple, [typeName]);
         } else {
-          errorReporter.reportErrorForNode(
-              CompileTimeErrorCode.CONST_WITH_NON_TYPE,
-              typeNameSimple,
-              [typeName]);
+          reportErrorForNode(CompileTimeErrorCode.CONST_WITH_NON_TYPE,
+              typeNameSimple, [typeName]);
         }
         elementValid = false;
       } else {
         if (element != null) {
-          errorReporter.reportErrorForNode(
+          reportErrorForNode(
               StaticWarningCode.NEW_WITH_NON_TYPE, typeNameSimple, [typeName]);
           elementValid = false;
         }
       }
     }
     if (elementValid && element == null) {
       // We couldn't resolve the type name.
       // TODO(jwren) Consider moving the check for
       // CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE from the
       // ErrorVerifier, so that we don't have two errors on a built in
       // identifier being used as a class name.
       // See CompileTimeErrorCodeTest.test_builtInIdentifierAsType().
       SimpleIdentifier typeNameSimple = _getTypeSimpleIdentifier(typeName);
       RedirectingConstructorKind redirectingConstructorKind;
       if (_isBuiltInIdentifier(node) && _isTypeAnnotation(node)) {
-        errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE,
-            typeName,
-            [typeName.name]);
+        reportErrorForNode(CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE,
+            typeName, [typeName.name]);
       } else if (typeNameSimple.name == "boolean") {
-        errorReporter.reportErrorForNode(
+        reportErrorForNode(
             StaticWarningCode.UNDEFINED_CLASS_BOOLEAN, typeNameSimple, []);
       } else if (_isTypeNameInCatchClause(node)) {
-        errorReporter.reportErrorForNode(
-            StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE,
-            typeName,
+        reportErrorForNode(StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE, typeName,
             [typeName.name]);
       } else if (_isTypeNameInAsExpression(node)) {
-        errorReporter.reportErrorForNode(
+        reportErrorForNode(
             StaticWarningCode.CAST_TO_NON_TYPE, typeName, [typeName.name]);
       } else if (_isTypeNameInIsExpression(node)) {
-        errorReporter.reportErrorForNode(
-            StaticWarningCode.TYPE_TEST_WITH_UNDEFINED_NAME,
-            typeName,
-            [typeName.name]);
+        reportErrorForNode(StaticWarningCode.TYPE_TEST_WITH_UNDEFINED_NAME,
+            typeName, [typeName.name]);
       } else if ((redirectingConstructorKind =
               _getRedirectingConstructorKind(node)) !=
           null) {
         ErrorCode errorCode =
             (redirectingConstructorKind == RedirectingConstructorKind.CONST
                 ? CompileTimeErrorCode.REDIRECT_TO_NON_CLASS
                 : StaticWarningCode.REDIRECT_TO_NON_CLASS);
-        errorReporter.reportErrorForNode(errorCode, typeName, [typeName.name]);
+        reportErrorForNode(errorCode, typeName, [typeName.name]);
       } else if (_isTypeNameInTypeArgumentList(node)) {
-        errorReporter.reportErrorForNode(
-            StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT,
-            typeName,
-            [typeName.name]);
+        reportErrorForNode(StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT,
+            typeName, [typeName.name]);
       } else {
-        errorReporter.reportErrorForNode(
+        reportErrorForNode(
             StaticWarningCode.UNDEFINED_CLASS, typeName, [typeName.name]);
       }
       elementValid = false;
     }
     if (!elementValid) {
       if (element is MultiplyDefinedElement) {
         _setElement(typeName, element);
       }
       typeName.staticType = undefinedType;
       node.type = undefinedType;
@@ skipping 17 matching lines @@
     } else if (element is MultiplyDefinedElement) {
       List<Element> elements = element.conflictingElements;
       type = _getTypeWhenMultiplyDefined(elements);
       if (type != null) {
         node.type = type;
       }
     } else {
       // The name does not represent a type.
       RedirectingConstructorKind redirectingConstructorKind;
       if (_isTypeNameInCatchClause(node)) {
-        errorReporter.reportErrorForNode(
-            StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE,
-            typeName,
+        reportErrorForNode(StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE, typeName,
             [typeName.name]);
       } else if (_isTypeNameInAsExpression(node)) {
-        errorReporter.reportErrorForNode(
+        reportErrorForNode(
             StaticWarningCode.CAST_TO_NON_TYPE, typeName, [typeName.name]);
       } else if (_isTypeNameInIsExpression(node)) {
-        errorReporter.reportErrorForNode(
-            StaticWarningCode.TYPE_TEST_WITH_NON_TYPE,
-            typeName,
+        reportErrorForNode(StaticWarningCode.TYPE_TEST_WITH_NON_TYPE, typeName,
             [typeName.name]);
       } else if ((redirectingConstructorKind =
               _getRedirectingConstructorKind(node)) !=
           null) {
         ErrorCode errorCode =
             (redirectingConstructorKind == RedirectingConstructorKind.CONST
                 ? CompileTimeErrorCode.REDIRECT_TO_NON_CLASS
                 : StaticWarningCode.REDIRECT_TO_NON_CLASS);
-        errorReporter.reportErrorForNode(errorCode, typeName, [typeName.name]);
+        reportErrorForNode(errorCode, typeName, [typeName.name]);
       } else if (_isTypeNameInTypeArgumentList(node)) {
-        errorReporter.reportErrorForNode(
-            StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT,
-            typeName,
-            [typeName.name]);
+        reportErrorForNode(StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT,
+            typeName, [typeName.name]);
       } else {
         AstNode parent = typeName.parent;
         while (parent is TypeName) {
           parent = parent.parent;
         }
         if (parent is ExtendsClause ||
             parent is ImplementsClause ||
             parent is WithClause ||
             parent is ClassTypeAlias) {
           // Ignored. The error will be reported elsewhere.
         } else {
-          errorReporter.reportErrorForNode(
+          reportErrorForNode(
               StaticWarningCode.NOT_A_TYPE, typeName, [typeName.name]);
         }
       }
       typeName.staticType = dynamicType;
       node.type = dynamicType;
       return;
     }
     if (argumentList != null) {
       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++) {
           TypeName argumentTypeName = arguments[i];
           DartType argumentType = _getType(argumentTypeName);
           if (argumentType == null) {
             argumentType = dynamicType;
           }
           typeArguments[i] = argumentType;
         }
       } else {
-        errorReporter.reportErrorForNode(
-            _getInvalidTypeParametersErrorCode(node),
-            node,
+        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;
@@ skipping 429 matching lines @@
    *
    * @param element the element whose type might have been overridden
    * @param type the overridden type of the given element
    */
   void setType(VariableElement element, DartType type) {
     _overridenTypes[element] = type;
   }
 }
 
 /**
+ * This class resolves bounds of type parameters of classes, class and function
+ * type aliases.
+ */
+class TypeParameterBoundsResolver {
+  final TypeProvider typeProvider;
+  final LibraryElement library;
+  final Source source;
+  final AnalysisErrorListener errorListener;
+
+  Scope libraryScope = null;
+  TypeNameResolver typeNameResolver = null;
+
+  TypeParameterBoundsResolver(
+      this.typeProvider, this.library, this.source, this.errorListener);
+
+  /**
+   * Resolve bounds of type parameters of classes, class and function type
+   * aliases.
+   */
+  void resolveTypeBounds(CompilationUnit unit) {
+    for (CompilationUnitMember unitMember in unit.declarations) {
+      if (unitMember is ClassDeclaration) {
+        _resolveTypeParameters(unitMember.typeParameters,
+            () => new TypeParameterScope(libraryScope, unitMember.element));
+      } 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(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) {
+        TypeName bound = typeParameter.bound;
+        if (bound != null) {
+          libraryScope ??= new LibraryScope(library, errorListener);
+          typeParametersScope ??= createTypeParametersScope();
+          typeNameResolver ??= new TypeNameResolver(new TypeSystemImpl(),
+              typeProvider, library, source, errorListener);
+          typeNameResolver.nameScope = typeParametersScope;
+          _resolveTypeName(bound);
+          Element typeParameterElement = typeParameter.name.staticElement;
+          if (typeParameterElement is TypeParameterElementImpl) {
+            typeParameterElement.bound = bound.type;
+          }
+        }
+      }
+    }
+  }
+}
+
+/**
  * Instances of the class `TypePromotionManager` manage the ability to promote types of local
  * variables and formal parameters from their declared types based on control flow.
  */
 class TypePromotionManager {
   /**
    * The current promotion scope, or `null` if no scope has been entered.
    */
   TypePromotionManager_TypePromoteScope currentScope;
 
   /**
@@ skipping 600 matching lines @@
   TypeResolverVisitor(LibraryElement definingLibrary, Source source,
       TypeProvider typeProvider, AnalysisErrorListener errorListener,
       {Scope nameScope})
       : super(definingLibrary, source, typeProvider, errorListener,
             nameScope: nameScope) {
     _dynamicType = typeProvider.dynamicType;
     _undefinedType = typeProvider.undefinedType;
     _strongMode = definingLibrary.context.analysisOptions.strongMode;
     _typeSystem = TypeSystem.create(definingLibrary.context);
     _typeNameResolver = new TypeNameResolver(
-        _typeSystem, typeProvider, definingLibrary, errorReporter);
+        _typeSystem, typeProvider, definingLibrary, source, errorListener);
   }
 
   @override
   Object visitAnnotation(Annotation node) {
     //
     // Visit annotations, if the annotation is @proxy, on a class, and "proxy"
     // resolves to the proxy annotation in dart.core, then resolve the
     // ElementAnnotation.
     //
     // Element resolution is done in the ElementResolver, and this work will be
@@ skipping 321 matching lines @@
   Object visitTypeName(TypeName node) {
     super.visitTypeName(node);
     _typeNameResolver.nameScope = this.nameScope;
     _typeNameResolver.resolveTypeName(node);
     return null;
   }
 
   @override
   Object visitTypeParameter(TypeParameter node) {
     super.visitTypeParameter(node);
-    TypeName bound = node.bound;
-    if (bound != null) {
-      TypeParameterElementImpl typeParameter =
-          node.name.staticElement as TypeParameterElementImpl;
-      if (typeParameter != null) {
-        typeParameter.bound = bound.type;
+    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 {
+      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);
     DartType declaredType;
     TypeName typeName = (node.parent as VariableDeclarationList).type;
@@ skipping 786 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }