Redo #28580: instantiate bounds to bounds.

One thing to be careful of here is that function type bounds may be
left unbounded. However, their parameters and return type cannot refer
to a type parameter for resolve-to-bounds to work.

There are also a large number of ways that this can loop infinitely, and
a number of new guards had to be added (as well as some test cases) to
catch them all.

Change-Id: I14322f5f71d1f7b73b27a870553e5c588b2c7e2e
Reviewed-on: https://dart-review.googlesource.com/52062
Commit-Queue: Mike Fairhurst <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>

Author: MichaelRFairhurst

pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart

@@ -675,7 +675,7 @@ class LibraryAnalyzer {
     // TODO(scheglov) remove EnumMemberBuilder class
 
     new TypeParameterBoundsResolver(
-            _typeProvider, _libraryElement, source, errorListener)
+            _context.typeSystem, _libraryElement, source, errorListener)
         .resolveTypeBounds(unit);
 
     unit.accept(new TypeResolverVisitor(

pkg/analyzer/lib/src/dart/element/type.dart

@@ -16,6 +16,8 @@ import 'package:analyzer/src/generated/engine.dart'
 import 'package:analyzer/src/generated/type_system.dart';
 import 'package:analyzer/src/generated/utilities_collection.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
+import 'package:analyzer/src/summary/resynthesize.dart'
+    show RecursiveInstantiateToBounds;
 
 /**
  * Type of callbacks used by [DeferredFunctionTypeImpl].
@@ -1691,7 +1693,11 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
   @override
   List<DartType> get typeArguments {
     if (_typeArguments == null) {
-      _typeArguments = _typeArgumentsComputer();
+      try {
+        _typeArguments = _typeArgumentsComputer();
+      } on RecursiveInstantiateToBounds {
+        _hasTypeParameterReferenceInBound = true;
+      }
       _typeArgumentsComputer = null;
     }
     return _typeArguments;
@@ -2596,6 +2602,11 @@ abstract class TypeImpl implements DartType {
    */
   final String name;
 
+  /**
+   * The cached value for [hasTypeParameterReferenceInBound].
+   */
+  bool _hasTypeParameterReferenceInBound;
+
   /**
    * Initialize a newly created type to be declared by the given [element] and
    * to have the given [name].
@@ -2608,6 +2619,46 @@ abstract class TypeImpl implements DartType {
   @override
   Element get element => _element;
 
+  /**
+   * Return `true` if the type is parameterized and has a type parameter with
+   * the bound that references a type parameter.
+   */
+  bool get hasTypeParameterReferenceInBound {
+    if (_hasTypeParameterReferenceInBound == null) {
+      bool hasTypeParameterReference(DartType type) {
+        if (type == this) {
+          // Cycle detection -- and cycles should be considered unboundable.
+          return true;
+        } else if (type is TypeImpl &&
+            type._hasTypeParameterReferenceInBound == true) {
+          return true;
+        } else if (type is TypeParameterType) {
+          return true;
+        } else if (type is FunctionType) {
+          return (type as TypeImpl).hasTypeParameterReferenceInBound;
+        } else if (type is ParameterizedType) {
+          return type.typeArguments.any(hasTypeParameterReference);
+        } else {
+          return false;
+        }
+      }
+
+      Element element = this.element;
+      if (element is FunctionTypedElement) {
+        _hasTypeParameterReferenceInBound = element.parameters.any(
+                (parameter) => hasTypeParameterReference(parameter.type)) ||
+            (element.returnType != null &&
+                hasTypeParameterReference(element.returnType));
+      } else if (element is TypeParameterizedElement) {
+        _hasTypeParameterReferenceInBound = element.typeParameters
+            .any((parameter) => hasTypeParameterReference(parameter.bound));
+      } else {
+        _hasTypeParameterReferenceInBound = false;
+      }
+    }
+    return _hasTypeParameterReferenceInBound;
+  }
+
   @override
   bool get isBottom => false;
 

pkg/analyzer/lib/src/generated/error_verifier.dart

@@ -7277,19 +7277,10 @@ class _UninstantiatedBoundChecker extends RecursiveAstVisitor {
       return;
     }
 
-    var element = node.type.element;
-    if (element is TypeParameterizedElement &&
-        element.typeParameters.any((p) => p.bound != null)) {
+    final type = node.type;
+    if (type is TypeImpl && type.hasTypeParameterReferenceInBound) {
       _errorReporter.reportErrorForNode(
-          StrongModeCode.NOT_INSTANTIATED_BOUND, node, [node.type]);
-    }
-
-    var enclosingElement = element?.enclosingElement;
-    if (element is GenericFunctionTypeElement &&
-        enclosingElement is GenericTypeAliasElement &&
-        enclosingElement.typeParameters.any((p) => p.bound != null)) {
-      _errorReporter.reportErrorForNode(
-          StrongModeCode.NOT_INSTANTIATED_BOUND, node, [node.type]);
+          StrongModeCode.NOT_INSTANTIATED_BOUND, node, [type]);
     }
   }
 }

pkg/analyzer/lib/src/generated/resolver.dart

@@ -8885,7 +8885,7 @@ class TypeOverrideManager_TypeOverrideScope {
  * type aliases.
  */
 class TypeParameterBoundsResolver {
-  final TypeProvider typeProvider;
+  final TypeSystem typeSystem;
   final LibraryElement library;
   final Source source;
   final AnalysisErrorListener errorListener;
@@ -8894,7 +8894,7 @@ class TypeParameterBoundsResolver {
   TypeNameResolver typeNameResolver = null;
 
   TypeParameterBoundsResolver(
-      this.typeProvider, this.library, this.source, this.errorListener);
+      this.typeSystem, this.library, this.source, this.errorListener);
 
   /**
    * Resolve bounds of type parameters of classes, class and function type
@@ -8964,12 +8964,8 @@ class TypeParameterBoundsResolver {
             } else {
               libraryScope ??= new LibraryScope(library);
               typeParametersScope ??= createTypeParametersScope();
-              typeNameResolver ??= new TypeNameResolver(
-                  new TypeSystemImpl(typeProvider),
-                  typeProvider,
-                  library,
-                  source,
-                  errorListener);
+              typeNameResolver ??= new TypeNameResolver(typeSystem,
+                  typeSystem.typeProvider, library, source, errorListener);
               typeNameResolver.nameScope = typeParametersScope;
               _resolveTypeName(bound);
               typeParameterElement.bound = bound.type;

pkg/analyzer/lib/src/generated/type_system.dart

@@ -358,10 +358,15 @@ class StrongTypeSystemImpl extends TypeSystem {
       }
     }
 
-    List<TypeParameterType> getFreeParameters(DartType type) {
+    List<TypeParameterType> getFreeParameters(DartType rootType) {
       List<TypeParameterType> parameters = null;
+      Set<DartType> visitedTypes = new HashSet<DartType>();
 
       void appendParameters(DartType type) {
+        if (visitedTypes.contains(type)) {
+          return;
+        }
+        visitedTypes.add(type);
         if (type is TypeParameterType && all.contains(type)) {
           parameters ??= <TypeParameterType>[];
           parameters.add(type);
@@ -370,7 +375,7 @@ class StrongTypeSystemImpl extends TypeSystem {
         }
       }
 
-      appendParameters(type);
+      appendParameters(rootType);
       return parameters;
     }
 

pkg/analyzer/lib/src/summary/resynthesize.dart

@@ -858,6 +858,8 @@ class _LibraryResynthesizerContext extends LibraryResynthesizerContextMixin
   }
 }
 
+class RecursiveInstantiateToBounds {}
+
 /// Specialization of [ReferenceInfo] for resynthesis from linked summaries.
 class _ReferenceInfo extends ReferenceInfo {
   /**
@@ -983,14 +985,27 @@ class _ReferenceInfo extends ReferenceInfo {
       InterfaceTypeImpl type =
           new InterfaceTypeImpl.elementWithNameAndArgs(element, name, () {
         if (typeArguments == null) {
-          if (libraryResynthesizer.summaryResynthesizer.strongMode &&
-              instantiateToBoundsAllowed) {
-            InterfaceType instantiatedToBounds = libraryResynthesizer
-                .summaryResynthesizer.context.typeSystem
-                .instantiateToBounds(element.type) as InterfaceType;
-            return instantiatedToBounds.typeArguments;
+          if (!_isBeingInstantiatedToBounds) {
+            _isBeingInstantiatedToBounds = true;
+            _isRecursiveWhileInstantiateToBounds = false;
+            try {
+              if (libraryResynthesizer.summaryResynthesizer.strongMode) {
+                InterfaceType instantiatedToBounds = libraryResynthesizer
+                    .summaryResynthesizer.context.typeSystem
+                    .instantiateToBounds(element.type) as InterfaceType;
+                if (_isRecursiveWhileInstantiateToBounds) {
+                  throw new RecursiveInstantiateToBounds();
+                }
+                return instantiatedToBounds.typeArguments;
+              } else {
+                return _dynamicTypeArguments;
+              }
+            } finally {
+              _isBeingInstantiatedToBounds = false;
+            }
           } else {
-            return _dynamicTypeArguments;
+            _isRecursiveWhileInstantiateToBounds = true;
+            typeArguments = _dynamicTypeArguments;
           }
         }
         return typeArguments;
@@ -1352,6 +1367,7 @@ class _UnitResynthesizer extends UnitResynthesizer with UnitResynthesizerMixin {
       if (declaredType && !referenceInfo.isDeclarableType) {
         return DynamicTypeImpl.instance;
       }
+
       return referenceInfo.buildType(
           instantiateToBoundsAllowed,
           type.typeArguments.length,

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

@@ -4927,7 +4927,7 @@ class ResolveTopLevelUnitTypeBoundsTask extends SourceBasedAnalysisTask {
     //
     RecordingErrorListener errorListener = new RecordingErrorListener();
     new TypeParameterBoundsResolver(
-            typeProvider, library, unitElement.source, errorListener)
+            context.typeSystem, library, unitElement.source, errorListener)
         .resolveTypeBounds(unit);
     //
     // Record outputs.

pkg/analyzer/test/generated/strong_mode_driver_test.dart

@@ -65,6 +65,18 @@ class StrongModeStaticTypeAnalyzer2Test_Driver
   test_genericMethod_functionTypedParameter_tearoff() {
     return super.test_genericMethod_functionTypedParameter_tearoff();
   }
+
+  @override
+  test_notInstantiatedBound_class_error_recursion() {
+    // overridden because not failing
+    return super.test_notInstantiatedBound_class_error_recursion();
+  }
+
+  @override
+  test_notInstantiatedBound_class_error_recursion_less_direct() {
+    // overridden because not failing
+    return super.test_notInstantiatedBound_class_error_recursion_less_direct();
+  }
 }
 
 @reflectiveTest