fixes #27586, prefer downwards context type in generic inference

fixes #27625, Object constraints were not tracked in inference
fixes #27933, pin return type from downwards inference

We now prefer to pick the bound (lower or upper) that had some information on, and it also improves inference error messages somewhat (still a ways to go).

The way this works is we now have a type representing an unknown type: ?. We use ? when performing downward inference steps, instead of `dynamic`. This allows more accurate tracking of type constraints.

For example: given:

    var x = await Future.wait([a, b]);

Future.wait<T>'s argument type is Iterable<Future<T>>. Since we didn't know T, we previously pushed down Iterable<Future<dynamic>>. The dynamic caused loss of information. Now we push down Iterable<Future<?>>, allowing us to infer the right type there.

[email protected], [email protected]

Review-Url: https://codereview.chromium.org/2456803004 .

Author: Jennifer Messerly

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

@@ -933,6 +933,10 @@ class TypeParameterMember extends Member implements TypeParameterElement {
   @override
   TypeParameterType get type => _type;
 
+  @override
+  bool operator ==(Object other) =>
+      other is TypeParameterMember && baseElement == other.baseElement;
+
   @override
   /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
       visitor.visitTypeParameterElement(this);

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

@@ -2660,9 +2660,47 @@ class TypeParameterTypeImpl extends TypeImpl implements TypeParameterType {
   @override
   int get hashCode => element.hashCode;
 
+  /**
+   * Append a textual representation of this type to the given [buffer]. The set
+   * of [visitedTypes] is used to prevent infinite recursion.
+   */
+  void appendTo(StringBuffer buffer, Set<TypeImpl> visitedTypes) {
+    super.appendTo(buffer, visitedTypes);
+    TypeParameterElement e = element;
+    if (e is TypeParameterMember &&
+        e.bound != e.baseElement.bound &&
+        !_appendingBounds) {
+      buffer.write(' extends ');
+      // If we're appending bounds already, we don't want to do it recursively.
+      _appendingBounds = true;
+      try {
+        (e.bound as TypeImpl).appendTo(buffer, visitedTypes);
+      } finally {
+        _appendingBounds = false;
+      }
+    }
+  }
+
   @override
-  bool operator ==(Object object) =>
-      object is TypeParameterTypeImpl && (element == object.element);
+  bool operator ==(Object other) {
+    if (other is TypeParameterTypeImpl && element == other.element) {
+      if (_comparingBounds) {
+        // If we're comparing bounds already, then we only need type variable
+        // equality.
+        return true;
+      }
+      _comparingBounds = true;
+      try {
+        return bound == other.bound;
+      } finally {
+        _comparingBounds = false;
+      }
+    }
+    return false;
+  }
+
+  static bool _comparingBounds = false;
+  static bool _appendingBounds = false;
 
   @override
   bool isMoreSpecificThan(DartType s,

pkg/analyzer/lib/src/error/codes.dart

@@ -4771,7 +4771,7 @@ class StrongModeCode extends ErrorCode {
   static const StrongModeCode COULD_NOT_INFER = const StrongModeCode(
       ErrorType.COMPILE_TIME_ERROR,
       'COULD_NOT_INFER',
-      "Couldn't infer type parameter '{0}'; '{1}' must be of type '{2}'.");
+      "Couldn't infer type parameter '{0}'.{1}");
 
   static const StrongModeCode INFERRED_TYPE = const StrongModeCode(
       ErrorType.HINT, 'INFERRED_TYPE', _inferredTypeMessage);