Introduce Substitution class and Supertype class.

test/class_hierarchy_basic.dart

 // Copyright (c) 2016, 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 kernel.class_hierarchy_basic;
 
 import 'package:kernel/class_hierarchy.dart';
 import 'package:kernel/type_algebra.dart';
 import 'package:kernel/ast.dart';
 
 /// A simple implementation of the class hierarchy interface using
 /// hash tables for everything.
 class BasicClassHierarchy implements ClassHierarchy {
   final Map<Class, Set<Class>> superclasses = <Class, Set<Class>>{};
   final Map<Class, Set<Class>> superMixtures = <Class, Set<Class>>{};
   final Map<Class, Set<Class>> supertypes = <Class, Set<Class>>{};
-  final Map<Class, Map<Class, InterfaceType>> supertypeInstantiations =
-      <Class, Map<Class, InterfaceType>>{};
+  final Map<Class, Map<Class, Supertype>> supertypeInstantiations =
+      <Class, Map<Class, Supertype>>{};
   final Map<Class, Map<Name, Member>> gettersAndCalls =
       <Class, Map<Name, Member>>{};
   final Map<Class, Map<Name, Member>> setters = <Class, Map<Name, Member>>{};
   final Map<Class, Map<Name, List<Member>>> interfaceGettersAndCalls =
       <Class, Map<Name, List<Member>>>{};
   final Map<Class, Map<Name, List<Member>>> interfaceSetters =
       <Class, Map<Name, List<Member>>>{};
   final List<Class> classes = <Class>[];
   final Map<Class, int> classIndex = <Class, int>{};
 
@@ skipping 76 matching lines @@
     for (var supertype in node.implementedTypes) {
       buildSuperTypeSets(supertype.classNode);
       supertypes[node].addAll(supertypes[supertype.classNode]);
     }
     classes.add(node);
     classIndex[node] = classes.length - 1;
   }
 
   void buildSuperTypeInstantiations(Class node) {
     if (supertypeInstantiations.containsKey(node)) return;
-    supertypeInstantiations[node] = <Class, InterfaceType>{node: node.thisType};
+    supertypeInstantiations[node] = <Class, Supertype>{
+      node: node.asThisSupertype
+    };
     for (var supertype in node.supers) {
       var superclass = supertype.classNode;
       buildSuperTypeInstantiations(superclass);
-      var substitution = new Map<TypeParameter, DartType>.fromIterables(
+      var substitution = Substitution.fromPairs(
           superclass.typeParameters, supertype.typeArguments);
       supertypeInstantiations[superclass].forEach((key, type) {
-        supertypeInstantiations[node][key] = substitute(type, substitution);
+        supertypeInstantiations[node][key] =
+            substitution.substituteSupertype(type);
       });
     }
   }
 
   void buildDispatchTable(Class node) {
     if (gettersAndCalls.containsKey(node)) return;
     gettersAndCalls[node] = <Name, Member>{};
     setters[node] = <Name, Member>{};
     if (node.supertype != null) {
       buildDispatchTable(node.supertype.classNode);
@@ skipping 23 matching lines @@
       Map<Name, List<Member>> source, Map<Name, List<Member>> destination) {
     for (var name in source.keys) {
       destination.putIfAbsent(name, () => <Member>[]).addAll(source[name]);
     }
   }
 
   void buildInterfaceTable(Class node) {
     if (interfaceGettersAndCalls.containsKey(node)) return;
     interfaceGettersAndCalls[node] = <Name, List<Member>>{};
     interfaceSetters[node] = <Name, List<Member>>{};
-    void inheritFrom(InterfaceType type) {
+    void inheritFrom(Supertype type) {
       if (type == null) return;
       buildInterfaceTable(type.classNode);
       mergeMaps(interfaceGettersAndCalls[type.classNode],
           interfaceGettersAndCalls[node]);
       mergeMaps(interfaceSetters[type.classNode], interfaceSetters[node]);
     }
     inheritFrom(node.supertype);
     inheritFrom(node.mixedInType);
     node.implementedTypes.forEach(inheritFrom);
     // Overwrite map entries with declared members.
@@ skipping 19 matching lines @@
   }
 
   bool isSubmixtureOf(Class subtype, Class supertype) {
     return superMixtures[subtype].contains(supertype);
   }
 
   bool isSubtypeOf(Class subtype, Class supertype) {
     return supertypes[subtype].contains(supertype);
   }
 
-  InterfaceType getClassAsInstanceOf(Class type, Class supertype) {
+  Supertype getClassAsInstanceOf(Class type, Class supertype) {
     return supertypeInstantiations[type][supertype];
   }
 
   Member getDispatchTarget(Class class_, Name name, {bool setter: false}) {
     return setter ? setters[class_][name] : gettersAndCalls[class_][name];
   }
 
   Iterable<Member> getDispatchTargets(Class class_, {bool setters: false}) {
     return setters
         ? this.setters[class_].values
@@ skipping 25 matching lines @@
   int getClassIndex(Class node) {
     return classIndex[node];
   }
 
   List<int> getExpenseHistogram() => <int>[];
   double getCompressionRatio() => 0.0;
   int getSuperTypeHashTableSize() => 0;
 
   noSuchMethod(inv) => super.noSuchMethod(inv);
 }