Introduce Substitution class and Supertype class.

lib/ast.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.
 
 /// -----------------------------------------------------------------------
 ///                           ERROR HANDLING
 /// -----------------------------------------------------------------------
 ///
 /// As a rule of thumb, errors that can be detected statically are handled by
 /// the frontend, typically by translating the erroneous code into a 'throw' or
@@ skipping 275 matching lines @@
   /// applications.
   String name;
   bool isAbstract;
 
   /// The uri of the source file this class was loaded from.
   String fileUri;
 
   final List<TypeParameter> typeParameters;
 
   /// The immediate super type, or `null` if this is the root class.
-  InterfaceType supertype;
+  Supertype supertype;
 
   /// The mixed-in type if this is a mixin application, otherwise `null`.
-  InterfaceType mixedInType;
+  Supertype mixedInType;
 
   /// The types from the `implements` clause.
-  final List<InterfaceType> implementedTypes;
+  final List<Supertype> implementedTypes;
 
   /// Fields declared in the class.
   ///
   /// For mixin applications this should be empty.
   final List<Field> fields;
 
   /// Constructors declared in the class.
   final List<Constructor> constructors;
 
   /// Procedures declared in the class.
   ///
   /// For mixin applications this should be empty.
   final List<Procedure> procedures;
 
   Class(
       {this.name,
       this.isAbstract: false,
       this.supertype,
       this.mixedInType,
       List<TypeParameter> typeParameters,
       List<InterfaceType> implementedTypes,
       List<Constructor> constructors,
       List<Procedure> procedures,
       List<Field> fields,
       this.fileUri})
       : this.typeParameters = typeParameters ?? <TypeParameter>[],
-        this.implementedTypes = implementedTypes ?? <InterfaceType>[],
+        this.implementedTypes = implementedTypes ?? <Supertype>[],
         this.fields = fields ?? <Field>[],
         this.constructors = constructors ?? <Constructor>[],
         this.procedures = procedures ?? <Procedure>[] {
     setParents(this.typeParameters, this);
     setParents(this.constructors, this);
     setParents(this.procedures, this);
     setParents(this.fields, this);
   }
 
   /// The immediate super class, or `null` if this is the root class.
@@ skipping 14 matching lines @@
   ///
   /// This getter is for convenience, not efficiency.  Consider manually
   /// iterating the members to speed up code in production.
   Iterable<Member> get members =>
       <Iterable<Member>>[fields, constructors, procedures].expand((x) => x);
 
   /// The immediately extended, mixed-in, and implemented types.
   ///
   /// This getter is for convenience, not efficiency.  Consider manually
   /// iterating the super types to speed up code in production.
-  Iterable<InterfaceType> get supers => <Iterable<InterfaceType>>[
+  Iterable<Supertype> get supers => <Iterable<Supertype>>[
         supertype == null ? const [] : [supertype],
         mixedInType == null ? const [] : [mixedInType],
         implementedTypes
       ].expand((x) => x);
 
   /// The library containing this class.
   Library get enclosingLibrary => parent;
 
   /// Adds a member to this class.
   ///
@@ skipping 23 matching lines @@
   accept(TreeVisitor v) => v.visitClass(this);
   acceptReference(Visitor v) => v.visitClassReference(this);
 
   /// If true, the class is part of an external library, that is, it is defined
   /// in another build unit.  Only a subset of its members are present.
   ///
   /// These classes should be loaded at either [ClassLevel.Type] or
   /// [ClassLevel.Hierarchy] level.
   bool get isInExternalLibrary => enclosingLibrary.isExternal;
 
+  Supertype get asRawSupertype {
+    return new Supertype(this,
+        new List<DartType>.filled(typeParameters.length, const DynamicType()));
+  }
+
+  Supertype get asThisSupertype {
+    return new Supertype(this, _getAsTypeArguments(typeParameters));
+  }
+
   InterfaceType _rawType;
   InterfaceType get rawType => _rawType ??= new InterfaceType(this);
 
   InterfaceType _thisType;
   InterfaceType get thisType {
     return _thisType ??=
         new InterfaceType(this, _getAsTypeArguments(typeParameters));
   }
 
   InterfaceType _bottomType;
@@ skipping 14 matching lines @@
     visitList(implementedTypes, v);
     visitList(constructors, v);
     visitList(procedures, v);
     visitList(fields, v);
   }
 
   transformChildren(Transformer v) {
     transformList(annotations, v, this);
     transformList(typeParameters, v, this);
     if (supertype != null) {
-      supertype = v.visitDartType(supertype);
+      supertype = v.visitSupertype(supertype);
     }
     if (mixedInType != null) {
-      mixedInType = v.visitDartType(mixedInType);
+      mixedInType = v.visitSupertype(mixedInType);
     }
-    transformTypeList(implementedTypes, v);
+    transformSupertypeList(implementedTypes, v);
     transformList(constructors, v, this);
     transformList(procedures, v, this);
     transformList(fields, v, this);
   }
 }
 
 // ------------------------------------------------------------------------
 //                            MEMBERS
 // ------------------------------------------------------------------------
 
@@ skipping 846 matching lines @@
 
   void set interfaceTarget(Member newTarget) {
     _interfaceTargetReference = newTarget?._getterInterface;
   }
 
   DartType getStaticType(TypeEnvironment types) {
     var interfaceTarget = this.interfaceTarget;
     if (interfaceTarget != null) {
       Class superclass = interfaceTarget.enclosingClass;
       var receiverType = receiver.getStaticTypeAsInstanceOf(superclass, types);
-      return substituteThisType(interfaceTarget.getterType, receiverType);
+      return Substitution
+          .fromInterfaceType(receiverType)
+          .substituteType(interfaceTarget.getterType);
     }
     // Treat the properties of Object specially.
     String nameString = name.name;
     if (nameString == 'hashCode') {
       return types.intType;
     } else if (nameString == 'runtimeType') {
       return types.typeType;
     }
     return const DynamicType();
   }
@@ skipping 76 matching lines @@
       receiver = receiver.accept(v);
       receiver?.parent = this;
     }
   }
 
   accept(ExpressionVisitor v) => v.visitDirectPropertyGet(this);
 
   DartType getStaticType(TypeEnvironment types) {
     Class superclass = target.enclosingClass;
     var receiverType = receiver.getStaticTypeAsInstanceOf(superclass, types);
-    return substituteThisType(target.getterType, receiverType);
+    return Substitution
+        .fromInterfaceType(receiverType)
+        .substituteType(target.getterType);
   }
 }
 
 /// Directly assign a field, or call a setter.
 class DirectPropertySet extends Expression {
   Expression receiver;
   Member target;
   Expression value;
 
   DirectPropertySet(this.receiver, this.target, this.value) {
@@ skipping 53 matching lines @@
 
   accept(ExpressionVisitor v) => v.visitDirectMethodInvocation(this);
 
   DartType getStaticType(TypeEnvironment types) {
     if (types.isOverloadedArithmeticOperator(target)) {
       return types.getTypeOfOverloadedArithmetic(receiver.getStaticType(types),
           arguments.positional[0].getStaticType(types));
     }
     Class superclass = target.enclosingClass;
     var receiverType = receiver.getStaticTypeAsInstanceOf(superclass, types);
-    var returnType =
-        substituteThisType(target.function.returnType, receiverType);
-    return substitutePairwise(
-        returnType, target.function.typeParameters, arguments.types);
+    var returnType = Substitution
+        .fromInterfaceType(receiverType)
+        .substituteType(target.function.returnType);
+    return Substitution
+        .fromPairs(target.function.typeParameters, arguments.types)
+        .substituteType(returnType);
   }
 }
 
 /// Expression of form `super.field`.
 ///
 /// This may invoke a getter, read a field, or tear off a method.
 class SuperPropertyGet extends Expression {
   Name name;
   _MemberAccessor _interfaceTargetReference;
 
   SuperPropertyGet(this.name, [Member interfaceTarget]) {
     _interfaceTargetReference = interfaceTarget?._getterInterface;
   }
 
   Member get interfaceTarget => _interfaceTargetReference?.target;
 
   void set interfaceTarget(Member newTarget) {
     _interfaceTargetReference = newTarget?._getterInterface;
   }
 
   DartType getStaticType(TypeEnvironment types) {
     Class declaringClass = interfaceTarget.enclosingClass;
     if (declaringClass.typeParameters.isEmpty) {
       return interfaceTarget.getterType;
     }
     var receiver =
         types.hierarchy.getTypeAsInstanceOf(types.thisType, declaringClass);
-    return substituteThisType(interfaceTarget.getterType, receiver);
+    return Substitution
+        .fromInterfaceType(receiver)
+        .substituteType(interfaceTarget.getterType);
   }
 
   accept(ExpressionVisitor v) => v.visitSuperPropertyGet(this);
 
   visitChildren(Visitor v) {
     name?.accept(v);
   }
 
   transformChildren(Transformer v) {}
 }
@@ skipping 165 matching lines @@
 
   DartType getStaticType(TypeEnvironment types) {
     if (interfaceTarget != null) {
       if (types.isOverloadedArithmeticOperator(interfaceTarget)) {
         return types.getTypeOfOverloadedArithmetic(
             receiver.getStaticType(types),
             arguments.positional[0].getStaticType(types));
       }
       Class superclass = interfaceTarget.enclosingClass;
       var receiverType = receiver.getStaticTypeAsInstanceOf(superclass, types);
-      var returnType =
-          substituteThisType(interfaceTarget.function.returnType, receiverType);
-      return substitutePairwise(
-          returnType, interfaceTarget.function.typeParameters, arguments.types);
+      var returnType = Substitution
+          .fromInterfaceType(receiverType)
+          .substituteType(interfaceTarget.function.returnType);
+      return Substitution
+          .fromPairs(interfaceTarget.function.typeParameters, arguments.types)
+          .substituteType(returnType);
     }
     if (name.name == 'call') {
       var receiverType = receiver.getStaticType(types);
       if (receiverType is FunctionType) {
         if (receiverType.typeParameters.length != arguments.types.length) {
           return const BottomType();
         }
-        return substitutePairwise(receiverType.returnType,
-            receiverType.typeParameters, arguments.types);
+        return Substitution
+            .fromPairs(receiverType.typeParameters, arguments.types)
+            .substituteType(receiverType.returnType);
       }
     }
     if (name.name == '==') {
       // We use this special case to simplify generation of '==' checks.
       return types.boolType;
     }
     return const DynamicType();
   }
 
   accept(ExpressionVisitor v) => v.visitMethodInvocation(this);
@@ skipping 27 matching lines @@
 
   SuperMethodInvocation(this.name, this.arguments, this.interfaceTarget) {
     arguments?.parent = this;
   }
 
   DartType getStaticType(TypeEnvironment types) {
     if (interfaceTarget == null) return const DynamicType();
     Class superclass = interfaceTarget.enclosingClass;
     var receiverType =
         types.hierarchy.getTypeAsInstanceOf(types.thisType, superclass);
-    var returnType =
-        substituteThisType(interfaceTarget.function.returnType, receiverType);
-    return substitutePairwise(
-        returnType, interfaceTarget.function.typeParameters, arguments.types);
+    var returnType = Substitution
+        .fromInterfaceType(receiverType)
+        .substituteType(interfaceTarget.function.returnType);
+    return Substitution
+        .fromPairs(interfaceTarget.function.typeParameters, arguments.types)
+        .substituteType(returnType);
   }
 
   accept(ExpressionVisitor v) => v.visitSuperMethodInvocation(this);
 
   visitChildren(Visitor v) {
     name?.accept(v);
     arguments?.accept(v);
   }
 
   transformChildren(Transformer v) {
@@ skipping 15 matching lines @@
   /// True if this is a constant call to an external constant factory.
   bool isConst;
 
   Name get name => target?.name;
 
   StaticInvocation(this.target, this.arguments, {this.isConst: false}) {
     arguments?.parent = this;
   }
 
   DartType getStaticType(TypeEnvironment types) {
-    return substitutePairwise(target.function.returnType,
-        target.function.typeParameters, arguments.types);
+    return Substitution
+        .fromPairs(target.function.typeParameters, arguments.types)
+        .substituteType(target.function.returnType);
   }
 
   accept(ExpressionVisitor v) => v.visitStaticInvocation(this);
 
   visitChildren(Visitor v) {
     target?.acceptReference(v);
     arguments?.accept(v);
   }
 
   transformChildren(Transformer v) {
@@ skipping 1583 matching lines @@
 
   transformChildren(Transformer v) {
     bound = v.visitDartType(bound);
   }
 
   /// Returns a possibly synthesized name for this type parameter, consistent
   /// with the names used across all [toString] calls.
   String toString() => debugQualifiedTypeParameterName(this);
 }
 
+class Supertype extends Node {
+  final Class classNode;
+  final List<DartType> typeArguments;
+
+  Supertype(this.classNode, this.typeArguments);
+
+  accept(Visitor v) => v.visitSupertype(this);
+
+  visitChildren(Visitor v) {
+    classNode.acceptReference(v);
+    visitList(typeArguments, v);
+  }
+
+  InterfaceType get asInterfaceType {
+    return new InterfaceType(classNode, typeArguments);
+  }
+
+  bool operator ==(Object other) {
+    if (identical(this, other)) return true;
+    if (other is Supertype) {
+      if (classNode != other.classNode) return false;
+      if (typeArguments.length != other.typeArguments.length) return false;
+      for (int i = 0; i < typeArguments.length; ++i) {
+        if (typeArguments[i] != other.typeArguments[i]) return false;
+      }
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  int get hashCode {
+    int hash = 0x3fffffff & classNode.hashCode;
+    for (int i = 0; i < typeArguments.length; ++i) {
+      hash = 0x3fffffff & (hash * 31 + (hash ^ typeArguments[i].hashCode));
+    }
+    return hash;
+  }
+}
+
 // ------------------------------------------------------------------------
 //                                PROGRAM
 // ------------------------------------------------------------------------
 
 /// A way to bundle up all the libraries in a program.
 class Program extends TreeNode {
   final List<Library> libraries;
 
   /// Map from a source file uri to a line-starts table.
   /// Given a source file uri and a offset in that file one can translate
@@ skipping 50 matching lines @@
     if (result != null) {
       nodes[storeIndex] = result;
       ++storeIndex;
     }
   }
   if (storeIndex < nodes.length) {
     nodes.length = storeIndex;
   }
 }
 
+void transformSupertypeList(List<Supertype> nodes, Transformer visitor) {
+  int storeIndex = 0;
+  for (int i = 0; i < nodes.length; ++i) {
+    var result = visitor.visitSupertype(nodes[i]);
+    if (result != null) {
+      nodes[storeIndex] = result;
+      ++storeIndex;
+    }
+  }
+  if (storeIndex < nodes.length) {
+    nodes.length = storeIndex;
+  }
+}
+
 void transformList(List<TreeNode> nodes, Transformer visitor, TreeNode parent) {
   int storeIndex = 0;
   for (int i = 0; i < nodes.length; ++i) {
     var result = nodes[i].accept(visitor);
     if (result != null) {
       nodes[storeIndex] = result;
       result.parent = parent;
       ++storeIndex;
     }
   }
@@ skipping 17 matching lines @@
 
   @override
   defaultTreeNode(TreeNode node) {
     if (node == child) {
       return replacement;
     } else {
       return node;
     }
   }
 }