Implement override-based type inference for instance methods.

pkg/front_end/lib/src/fasta/type_inference/type_constraint_gatherer.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 'package:front_end/src/fasta/type_inference/type_schema.dart';
 import 'package:front_end/src/fasta/type_inference/type_schema_environment.dart';
 import 'package:kernel/ast.dart';
 import 'package:kernel/type_algebra.dart';
 
 /// Creates a collection of [TypeConstraint]s corresponding to type parameters,
@@ skipping 74 matching lines @@
       return false;
     }
     if (subtype.positionalParameters.length <
         supertype.positionalParameters.length) {
       return false;
     }
     if (subtype.typeParameters.isNotEmpty ||
         supertype.typeParameters.isNotEmpty) {
       var subtypeSubstitution = <TypeParameter, DartType>{};
       var supertypeSubstitution = <TypeParameter, DartType>{};
+      var freshTypeVariables = <TypeParameter>[];
       if (!_matchTypeFormals(subtype.typeParameters, supertype.typeParameters,
-          subtypeSubstitution, supertypeSubstitution)) {
+          subtypeSubstitution, supertypeSubstitution, freshTypeVariables)) {
         return false;
       }
 
-      // TODO(paulberry): try to push this functionality into kernel.
-      FunctionType substituteTypeParams(
-          FunctionType type, Map<TypeParameter, DartType> substitutionMap) {
-        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: substitutionMap.keys.toList(),
-            requiredParameterCount: type.requiredParameterCount);
-      }
-
-      subtype = substituteTypeParams(subtype, subtypeSubstitution);
-      supertype = substituteTypeParams(supertype, supertypeSubstitution);
+      subtype = substituteTypeParams(
+          subtype, subtypeSubstitution, freshTypeVariables);
+      supertype = substituteTypeParams(
+          supertype, supertypeSubstitution, freshTypeVariables);
     }
 
     // Test the return types.
     if (supertype.returnType is! VoidType &&
         !_isSubtypeMatch(subtype.returnType, supertype.returnType)) {
       return false;
     }
 
     // Test the parameter types.
     for (int i = 0; i < supertype.positionalParameters.length; ++i) {
@@ skipping 209 matching lines @@
   /// bounds are compatible.
   ///
   /// The return value indicates whether a match was found.  If it was, entries
   /// are added to [substitution1] and [substitution2] which substitute a fresh
   /// set of type variables for the type parameters [params1] and [params2],
   /// respectively, allowing further comparison.
   bool _matchTypeFormals(
       List<TypeParameter> params1,
       List<TypeParameter> params2,
       Map<TypeParameter, DartType> substitution1,
-      Map<TypeParameter, DartType> substitution2) {
+      Map<TypeParameter, DartType> substitution2,
+      List<TypeParameter> freshTypeVariables) {
     int count = params1.length;
     if (count != params2.length) return false;
     // TODO(paulberry): in imitation of analyzer, we're checking the bounds as
     // we build up the substitutions.  But I don't think that's correct--I think
     // we should build up both substitutions completely before checking any
     // bounds.  See dartbug.com/29629.
     for (int i = 0; i < count; i++) {
       TypeParameter pFresh = new TypeParameter(params2[i].name);
+      freshTypeVariables.add(pFresh);
       DartType variableFresh = new TypeParameterType(pFresh);
       substitution1[params1[i]] = variableFresh;
       substitution2[params2[i]] = variableFresh;
       DartType bound1 = substitute(params1[i].bound, substitution1);
       DartType bound2 = substitute(params2[i].bound, substitution2);
       pFresh.bound = bound2;
       if (!_isSubtypeMatch(bound2, bound1)) return false;
     }
     return true;
   }
 }
 
 /// Tracks a single constraint on a single type variable.
 ///
 /// This is called "_ProtoConstraint" to distinguish from [TypeConstraint],
 /// which tracks the upper and lower bounds that are together implied by a set
 /// of [_ProtoConstraint]s.
 class _ProtoConstraint {
   final TypeParameter parameter;
 
   final DartType bound;
 
   final bool isUpper;
 
   _ProtoConstraint.lower(this.parameter, this.bound) : isUpper = false;
 
   _ProtoConstraint.upper(this.parameter, this.bound) : isUpper = true;
 }