Introduce Substitution class and Supertype class.

lib/class_hierarchy.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;
 
 import 'ast.dart';
 import 'dart:math';
 import 'dart:typed_data';
 import 'type_algebra.dart';
 
@@ skipping 46 matching lines @@
     return _infoFor[class_].directMixers.isNotEmpty;
   }
 
   /// True if the given class is used in an `implements` clause.
   bool isUsedAsSuperInterface(Class class_) {
     return _infoFor[class_].directImplementers.isNotEmpty;
   }
 
   /// Returns the instantiation of [superclass] that is implemented by [class_],
   /// or `null` if [class_] does not implement [superclass] at all.
-  InterfaceType getClassAsInstanceOf(Class class_, Class superclass) {
-    if (identical(class_, superclass)) return class_.thisType;
+  Supertype getClassAsInstanceOf(Class class_, Class superclass) {
+    if (identical(class_, superclass)) return class_.asThisSupertype;
     _ClassInfo info = _infoFor[class_];
     _ClassInfo superInfo = _infoFor[superclass];
     if (!info.isSubtypeOf(superInfo)) return null;
-    if (superclass.typeParameters.isEmpty) return superclass.rawType;
+    if (superclass.typeParameters.isEmpty) return superclass.asRawSupertype;
     return info.genericSuperTypes[superclass];
   }
 
   /// Returns the instantiation of [superclass] that is implemented by [type],
   /// or `null` if [type] does not implement [superclass] at all.
   InterfaceType getTypeAsInstanceOf(InterfaceType type, Class superclass) {
-    InterfaceType castedType = getClassAsInstanceOf(type.classNode, superclass);
+    Supertype castedType = getClassAsInstanceOf(type.classNode, superclass);
     if (castedType == null) return null;
-    return substituteThisType(castedType, type);
+    return Substitution
+        .fromInterfaceType(type)
+        .substituteType(castedType.asInterfaceType);
   }
 
   /// Returns the instance member that would respond to a dynamic dispatch of
   /// [name] to an instance of [class_], or `null` if no such member exists.
   ///
   /// If [setter] is `false`, the name is dispatched as a getter or call,
   /// and will return a field, getter, method, or operator (or null).
   ///
   /// If [setter] is `true`, the name is dispatched as a setter, roughly
   /// corresponding to `name=` in the Dart specification, but note that the
@@ skipping 256 matching lines @@
   }
 
   List<Member> _buildInterfaceMembers(Class classNode, _ClassInfo info,
       {bool setters}) {
     List<Member> members =
         setters ? info.interfaceSetters : info.interfaceGettersAndCalls;
     if (members != null) return members;
     List<Member> allInheritedMembers = <Member>[];
     List<Member> declared =
         setters ? info.declaredSetters : info.declaredGettersAndCalls;
-    void inheritFrom(InterfaceType type) {
+    void inheritFrom(Supertype type) {
       if (type == null) return;
       List<Member> inherited = _buildInterfaceMembers(
           type.classNode, _infoFor[type.classNode],
           setters: setters);
       inherited = _getUnshadowedInheritedMembers(declared, inherited);
       allInheritedMembers = _merge(allInheritedMembers, inherited);
     }
     inheritFrom(classNode.supertype);
     inheritFrom(classNode.mixedInType);
     classNode.implementedTypes.forEach(inheritFrom);
@@ skipping 115 matching lines @@
     while (i < first.length) {
       result[storeIndex++] = first[i++];
     }
     while (j < second.length) {
       result[storeIndex++] = second[j++];
     }
     result.length = storeIndex;
     return result;
   }
 
-  void _recordSuperTypes(_ClassInfo subInfo, InterfaceType supertype) {
+  void _recordSuperTypes(_ClassInfo subInfo, Supertype supertype) {
     _ClassInfo superInfo = _infoFor[supertype.classNode];
     if (supertype.typeArguments.isEmpty) {
       if (superInfo.genericSuperTypes == null) return;
       // Since the immediate super type is not generic, all entries in its
       // super type map are also valid entries for this class.
       if (subInfo.genericSuperTypes == null &&
           superInfo.ownsGenericSuperTypeMap) {
         // Instead of copying the map, take ownership of the map object.
         // This may result in more entries being added to the map later. Those
         // are not valid for the super type, but it works out because all
         // lookups in the map are guarded by a subtype check, so the super type
         // will not be bothered by the extra entries.
         subInfo.genericSuperTypes = superInfo.genericSuperTypes;
         superInfo.ownsGenericSuperTypeMap = false;
       } else {
         // Copy over the super type entries.
-        subInfo.genericSuperTypes ??= <Class, InterfaceType>{};
+        subInfo.genericSuperTypes ??= <Class, Supertype>{};
         subInfo.genericSuperTypes.addAll(superInfo.genericSuperTypes);
       }
     } else {
       // Copy over all transitive generic super types, and substitute the
       // free variables with those provided in [supertype].
       Class superclass = supertype.classNode;
-      var substitution = new Map<TypeParameter, DartType>.fromIterables(
+      var substitution = Substitution.fromPairs(
           superclass.typeParameters, supertype.typeArguments);
-      subInfo.genericSuperTypes ??= <Class, InterfaceType>{};
-      superInfo.genericSuperTypes?.forEach((Class key, InterfaceType type) {
-        subInfo.genericSuperTypes[key] = substitute(type, substitution);
+      subInfo.genericSuperTypes ??= <Class, Supertype>{};
+      superInfo.genericSuperTypes?.forEach((Class key, Supertype type) {
+        subInfo.genericSuperTypes[key] = substitution.substituteSupertype(type);
       });
       subInfo.genericSuperTypes[superclass] = supertype;
     }
   }
 
   /// Downwards traversal of the class hierarchy that orders classes so local
   /// hierarchies have contiguous indices.
   int _topDownSortIndex = 0;
   void _topDownSortVisit(_ClassInfo info) {
     if (info.topDownIndex != -1) return;
@@ skipping 280 matching lines @@
   /// For example:
   ///
   ///     class Q<T>
   ///     class A<T>
   ///
   ///     class B extends A<String>
   ///     class C extends B implements Q<int>
   ///
   /// In this case, a single map object `{A: A<String>, Q: Q<int>}` may be
   /// shared by the classes `B` and `C`.
-  Map<Class, InterfaceType> genericSuperTypes;
+  Map<Class, Supertype> genericSuperTypes;
 
   /// If true, this is the current "owner" of [genericSuperTypes], meaning
   /// we may add additional entries to the map or transfer ownership to another
   /// class.
   bool ownsGenericSuperTypeMap = true;
 
   /// Instance fields, getters, methods, and operators declared in this class
   /// or its mixed-in class, sorted according to [_compareMembers].
   List<Member> declaredGettersAndCalls;
 
   /// Non-final instance fields and setters declared in this class or its
   /// mixed-in class, sorted according to [_compareMembers].
   List<Member> declaredSetters;
 
   /// Instance fields, getters, methods, and operators implemented by this class
   /// (declared or inherited).
   List<Member> implementedGettersAndCalls;
 
   /// Non-final instance fields and setters implemented by this class
   /// (declared or inherited).
   List<Member> implementedSetters;
 
   List<Member> interfaceGettersAndCalls;
   List<Member> interfaceSetters;
 
   _ClassInfo(this.classNode);
 }