Issue 28580. Relax instantiate to bounds.

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

Index: pkg/analyzer/lib/src/dart/element/type.dart
diff --git a/pkg/analyzer/lib/src/dart/element/type.dart b/pkg/analyzer/lib/src/dart/element/type.dart
index 21a57e4c2ef0049f71f411d4df53c596a9814611..1447f33a43213b29a7b3c509db9dc6160d1b0749 100644
--- a/pkg/analyzer/lib/src/dart/element/type.dart
+++ b/pkg/analyzer/lib/src/dart/element/type.dart
@@ -2470,6 +2470,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].
    */
@@ -2481,6 +2486,33 @@ 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 is TypeParameterType) {
+          return true;

[Leaf, 2017/03/21 04:58:42]

This should only return true for other type parameters from the same scope, not
from outer scopes.  So:

class C<T> {
  S f<S extends List<T>>() {}
  void test() {
    var x = f(); // Not an error, x should have type List<T>
  }
}  

[scheglov, 2017/03/21 05:42:00]

I'm sorry, I must have missed something in the specification, or may be don't
know which specification to read.


The CL is about relaxing rules for type annotations in bounds or type
parameters.
https://github.com/dart-lang/sdk/issues/28580

Do you talk about instantiate to bounds here?
I just don't understand what you mean when give an example with a method
invocation.


I always thought only about type annotations referencing classes and function
type aliases. Are the same rules also applied to function types of method
invocations?

So, do you mean that f() invocation should have an error in this case?

class C<T> {
  S f<K, S extends List<K>>() => null;
  void test() {
    var x = f();
  }
}

Or List<K> in f() declaration?
Or we don't want to put errors in declarations because we might be able to infer
type arguments?

[Leaf, 2017/03/21 13:24:53]

Ignore everything I said, I was thinking about something else entirely.  You're
completely correct, this isn't relevant here, since this only has to do with
types in bounds, and classes can't be nested.

+        } else if (type is ParameterizedType) {
+          return type.typeArguments.any(hasTypeParameterReference);
+        } else {

[Leaf, 2017/03/21 04:58:42]

Are the new function types instances of ParameterizedType or does this need to
account for that?

[scheglov, 2017/03/21 05:42:00]

AFAIK these are also FunctionType(s), so ParameterizedType(s).

+          return false;
+        }
+      }
+
+      Element element = this.element;
+      if (element is TypeParameterizedElement) {
+        _hasTypeParameterReferenceInBound = element.typeParameters
+            .any((parameter) => hasTypeParameterReference(parameter.bound));
+      } else {
+        _hasTypeParameterReferenceInBound = false;
+      }
+    }
+    return _hasTypeParameterReferenceInBound;
+  }
+
   @override
   bool get isBottom => false;