Generic method subtyping.

pkg/analyzer/lib/src/generated/element.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.
 
 library engine.element;
 
 import 'dart:collection';
 import 'dart:math' show min;
 
 import 'package:analyzer/src/generated/utilities_general.dart';
@@ skipping 5058 matching lines @@
     }
     FunctionTypeImpl otherType = object as FunctionTypeImpl;
     if (boundTypeParameters.length != otherType.boundTypeParameters.length) {
       return false;
     }
     // `<T>T -> T` should be equal to `<U>U -> U`
     // To test this, we instantiate both types with the same (unique) type
     // variables, and see if the result is equal.
     if (boundTypeParameters.isNotEmpty) {
       List<DartType> instantiateTypeArgs = new List<DartType>();
-      for (TypeParameterElement e in boundTypeParameters) {
-        instantiateTypeArgs.add(new TypeParameterTypeImpl(
-            new TypeParameterElementImpl(e.name, -1)));
+      List<DartType> variablesThis = new List<DartType>();
+      List<DartType> variablesOther = new List<DartType>();
+      for (int i = 0; i < boundTypeParameters.length; i++) {
+        TypeParameterElement pThis = boundTypeParameters[i];
+        TypeParameterElement pOther = otherType.boundTypeParameters[i];
+        TypeParameterTypeImpl pFresh = new TypeParameterTypeImpl(
+            new TypeParameterElementImpl(pThis.name, -1));
+        instantiateTypeArgs.add(pFresh);
+        variablesThis.add(pThis.type);
+        variablesOther.add(pOther.type);
+        // Check that the bounds are equal after equating the previous
+        // bound variables.
+        if (pThis.bound?.substitute2(instantiateTypeArgs, variablesThis) !=
+            pOther.bound?.substitute2(instantiateTypeArgs, variablesOther)) {
+          return false;
+        }
       }
       // After instantiation, they will no longer have boundTypeParameters,
       // so we will continue below.
       return this.instantiate(instantiateTypeArgs) ==
           otherType.instantiate(instantiateTypeArgs);
     }
 
     return returnType == otherType.returnType &&
         TypeImpl.equalArrays(
             normalParameterTypes, otherType.normalParameterTypes) &&
@@ skipping 11 matching lines @@
       _freeVariablesInFunctionType(this, freeVariables);
 
       Set<String> namesToAvoid = new HashSet<String>();
       for (DartType arg in freeVariables) {
         if (arg is TypeParameterType) {
           namesToAvoid.add(arg.displayName);
         }
       }
 
       List<DartType> instantiateTypeArgs = new List<DartType>();
+      List<DartType> variables = new List<DartType>();
       buffer.write("<");
       for (TypeParameterElement e in boundTypeParameters) {
         if (e != boundTypeParameters[0]) {
           buffer.write(",");
         }
         String name = e.name;
         int counter = 0;
         while (!namesToAvoid.add(name)) {
           // Unicode subscript-zero is U+2080, zero is U+0030. Other digits
           // are sequential from there. Thus +0x2050 will get us the subscript.
           String subscript = new String.fromCharCodes(
               counter.toString().codeUnits.map((n) => n + 0x2050));
 
           name = e.name + subscript;
           counter++;
         }
         TypeParameterTypeImpl t =
             new TypeParameterTypeImpl(new TypeParameterElementImpl(name, -1));
         t.appendTo(buffer);
         instantiateTypeArgs.add(t);
+        variables.add(e.type);
+        if (e.bound != null) {
+          buffer.write(" extends ");
+          TypeImpl renamed =
+              e.bound.substitute2(instantiateTypeArgs, variables);
+          renamed.appendTo(buffer);
+        }
       }
       buffer.write(">");
 
       // Instantiate it and print the resulting type. After instantiation, it
       // will no longer have boundTypeParameters, so we will continue below.
       this.instantiate(instantiateTypeArgs).appendTo(buffer);
       return;
     }
 
     List<DartType> normalParameterTypes = this.normalParameterTypes;
@@ skipping 5647 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }