fix #25944, improve Future.then inference

pkg/analyzer/lib/dart/element/type.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.
 
 /**
  * Defines the type model. The type model is part of the
  * [element model](element.dart) in that most types are defined by Dart code
  * (the types `dynamic` and `void` being the notable exceptions). All types are
  * represented by an instance of a subclass of [DartType].
  *
  * Other than `dynamic` and `void`, all of the types define either the interface
  * defined by a class (an instance of [InterfaceType]) or the type of a function
  * (an instance of [FunctionType]).
  *
  * We make a distinction between the declaration of a class (a [ClassElement])
  * and the type defined by that class (an [InterfaceType]). The biggest reason
  * for the distinction is to allow us to more cleanly represent the distinction
  * between type parameters and type arguments. For example, if we define a class
  * as `class Pair<K, V> {}`, the declarations of `K` and `V` represent type
  * parameters. But if we declare a variable as `Pair<String, int> pair;` the
  * references to `String` and `int` are type arguments.
  */
 library analyzer.dart.element.type;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart' show InterfaceTypeImpl;
-import 'package:analyzer/src/generated/type_system.dart' show TypeSystem;
+import 'package:analyzer/src/generated/type_system.dart'
+    show TypeContext, TypeSystem;
 
 /**
  * The type associated with elements in the element model.
  *
  * Clients may not extend, implement or mix-in this class.
  */
-abstract class DartType {
+abstract class DartType implements TypeContext {

[Leaf, 2016/08/05 22:32:35]

It bothers me a bit that this leaks into the public API, even though it's just a
marker.  It seems like it would work to make FutureUnion type a subclass of
TypeImpl instead.  That's probably a little annoying since there's a bunch of
API surface from DartType that doesn't really apply to TypeContext.  But at
least it keeps it behind the API boundary.

Maybe an alternative would be to provide for this in a more abstract way by
replacing TypeContext here with something more abstract like "PreType" or
"TypeSchema" or "Classifier" or "TypeData" or something.  Then TypeContext could
be a private implementation of this, and if we want to use this trick again we
don't have to change this again?

WDYT?

[Jennifer Messerly, 2016/08/08 21:59:26]

Yeah, making it a subtype of TypeImpl works for me. Let me give that a try.

   /**
    * An empty list of types.
    */
   static const List<DartType> EMPTY_LIST = const <DartType>[];
 
   /**
    * Return the name of this type as it should appear when presented to users in
    * contexts such as error messages.
    */
   String get displayName;
@@ skipping 238 matching lines @@
    *
    * * For all <i>i</i>, 1 <= <i>i</i> <= <i>n</i>, <i>T<sub>i</sub> &hArr;
    *   S<sub>i</sub></i>.
    * * <i>k</i> >= <i>m</i> and <i>y<sub>i</sub></i> in <i>{x<sub>1</sub>,
    *   &hellip;, x<sub>k</sub>}</i>, 1 <= <i>i</i> <= <i>m</i>.
    * * For all <i>y<sub>i</sub></i> in <i>{y<sub>1</sub>, &hellip;,
    *   y<sub>m</sub>}</i>, <i>y<sub>i</sub> = x<sub>j</sub> => Tj &hArr; Si</i>.
    *
    * In addition, the following subtype rules apply:
    *
-   * <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>, []) &rarr; T <: (T<sub>1</sub>,
+   * <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>, `[]`) &rarr; T <: (T<sub>1</sub>,

[Leaf, 2016/08/05 22:32:35]

line length.

[Jennifer Messerly, 2016/08/08 21:59:26]

Done.

    * &hellip;, T<sub>n</sub>) &rarr; T.</i><br>
    * <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>) &rarr; T <: (T<sub>1</sub>,
    * &hellip;, T<sub>n</sub>, {}) &rarr; T.</i><br>
    * <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>, {}) &rarr; T <: (T<sub>1</sub>,
    * &hellip;, T<sub>n</sub>) &rarr; T.</i><br>
    * <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>) &rarr; T <: (T<sub>1</sub>,
    * &hellip;, T<sub>n</sub>, []) &rarr; T.</i>
    *
    * All functions implement the class `Function`. However not all function
    * types are a subtype of `Function`. If an interface type <i>I</i> includes a
@@ skipping 390 matching lines @@
  */
 abstract class TypeParameterType implements DartType {
   /**
    * An empty list of type parameter types.
    */
   static const List<TypeParameterType> EMPTY_LIST = const <TypeParameterType>[];
 
   @override
   TypeParameterElement get element;
 }