Implement override-based type inference for instance methods.

pkg/front_end/lib/src/fasta/type_inference/type_schema_environment.dart

 // Copyright (c) 2017, 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.md file.
 
 import 'dart:math' as math;
 
 import 'package:front_end/src/fasta/type_inference/type_constraint_gatherer.dart';
 import 'package:front_end/src/fasta/type_inference/type_schema.dart';
 import 'package:front_end/src/fasta/type_inference/type_schema_elimination.dart';
 import 'package:kernel/ast.dart';
 import 'package:kernel/class_hierarchy.dart';
 import 'package:kernel/core_types.dart';
 import 'package:kernel/type_algebra.dart';
 import 'package:kernel/type_environment.dart';
 
+// TODO(paulberry): try to push this functionality into kernel.
+FunctionType substituteTypeParams(
+    FunctionType type,
+    Map<TypeParameter, DartType> substitutionMap,
+    List<TypeParameter> newTypeParameters) {
+  var substitution = Substitution.fromMap(substitutionMap);
+  return new FunctionType(
+      type.positionalParameters.map(substitution.substituteType).toList(),
+      substitution.substituteType(type.returnType),
+      namedParameters: type.namedParameters
+          .map((named) => new NamedType(
+              named.name, substitution.substituteType(named.type)))
+          .toList(),
+      typeParameters: newTypeParameters,

[Siggi Cherem (dart-lang), 2017/06/21 20:19:08]

Just making sure I follow the change here. Before you had substitutionMap.keys,
was that basically using the old type-parameters instead of the new ones?

[Paul Berry, 2017/06/21 20:54:47]

That's right.  It was a bug which happened to be benign, because prior to this
CL, the only caller of this function didn't actually depend on the type
parameters being correct.  But now that I'm using this function to actually set
an inferred type, it actually matters that the type parameters are correct :)

+      requiredParameterCount: type.requiredParameterCount);
+}
+
 /// A constraint on a type parameter that we're inferring.
 class TypeConstraint {
   /// The lower bound of the type being constrained.  This bound must be a
   /// subtype of the type being constrained.
   DartType lower;
 
   /// The upper bound of the type being constrained.  The type being constrained
   /// must be a subtype of this bound.
   DartType upper;
 
@@ skipping 741 matching lines @@
           Substitution.fromMap({type2.parameter: objectType}).substituteType(
               type2.parameter.bound));
     } else {
       // We should only be called when at least one of the types is a
       // TypeParameterType
       assert(false);
       return const DynamicType();
     }
   }
 }