anchor.diff:      return currentType;
     }
   
  +  @override
  +  DartType resolveToBound(DartType type) {
  +    return instantiateToBounds(type);
  +  }
  +
     /**
      * Tries to promote from the first type from the second type, and returns the
      * promoted type if it succeeds, otherwise null.
  
positive.code: import 'package:analyzer/dart/ast/token.dart' show Keyword, TokenType;
  import 'package:analyzer/dart/element/element.dart';
  import 'package:analyzer/dart/element/type.dart';
  import 'package:analyzer/error/listener.dart' show ErrorReporter;
  import 'package:analyzer/src/dart/element/element.dart';
  import 'package:analyzer/src/dart/element/member.dart' show TypeParameterMember;
  
negative.code:    * bound in a type system specific manner.
     */
    DartType _interfaceLeastUpperBound(InterfaceType type1, InterfaceType type2);
  
    /**
     * Starting from the given [type], search its class hierarchy for types of the
     * form Future<R>, and return a list of the resulting R's.
     */
    List<DartType> _searchTypeHierarchyForFutureTypeParameters(DartType type) {
      List<DartType> result = <DartType>[];
      HashSet<ClassElement> visitedClasses = new HashSet<ClassElement>();
      void recurse(InterfaceTypeImpl type) {
        if (type.isDartAsyncFuture && type.typeArguments.isNotEmpty) {
          result.add(type.typeArguments[0]);
        }
        if (visitedClasses.add(type.element)) {
          if (type.superclass != null) {
            recurse(type.superclass);
          }
          for (InterfaceType interface in type.interfaces) {
            recurse(interface);
          }
          visitedClasses.remove(type.element);
        }
      }
  
      recurse(type);
      return result;
    }
  
    /**
     * Given two [DartType]s [type1] and [type2] at least one of which is a
  