Introduce Substitution class and Supertype class.

lib/analyzer/loader.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.analyzer.loader;
 
 import 'dart:async';
 import 'dart:io' as io;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/file_system/file_system.dart';
@@ skipping 256 matching lines @@
     for (int i = 0; i < classNode.typeParameters.length; ++i) {
       var parameter = element.typeParameters[i];
       var parameterNode = classNode.typeParameters[i];
       parameterNode.bound = parameter.bound == null
           ? scope.defaultTypeParameterBound
           : scope.buildType(parameter.bound);
     }
     // Initialize supertypes.
     Iterable<InterfaceType> mixins = element.mixins;
     if (element.isMixinApplication && mixins.isNotEmpty) {
-      var last = scope.buildType(mixins.last);
-      if (last is ast.InterfaceType) {
-        classNode.mixedInType = last;
-      }
+      classNode.mixedInType = scope.buildSupertype(mixins.last);
       mixins = mixins.take(mixins.length - 1);
     }
     if (element.supertype != null) {
-      ast.InterfaceType supertype = scope.buildType(element.supertype);
+      ast.Supertype supertype = scope.buildSupertype(element.supertype);
       bool useSharedMixin = true;
       for (var mixin in mixins) {
-        var mixinType = scope.buildType(mixin);
-        if (mixinType is ast.InterfaceType) {
-          if (useSharedMixin &&
-              areDistinctUnboundTypeVariables(supertype, mixinType)) {
-            // Use a shared mixin application class for this library.
-            var mixinClass = getSharedMixinApplicationClass(
-                scope.currentLibrary, supertype.classNode, mixinType.classNode);
-            supertype = new ast.InterfaceType(
-                mixinClass,
-                supertype.typeArguments.length > mixinType.typeArguments.length
-                    ? supertype.typeArguments
-                    : mixinType.typeArguments);
-          } else {
-            // Generate a new class specific for this mixin application.
-            var freshParameters =
-                getFreshTypeParameters(classNode.typeParameters);
-            var mixinClass = new ast.Class(
-                name: '${classNode.name}^${mixinType.classNode.name}',
-                isAbstract: true,
-                typeParameters: freshParameters.freshTypeParameters,
-                supertype: freshParameters.substitute(supertype),
-                mixedInType: freshParameters.substitute(mixinType));
-            mixinClass.level = ast.ClassLevel.Type;
-            supertype = new ast.InterfaceType(mixinClass,
-                classNode.typeParameters.map(makeTypeParameterType).toList());
-            addMixinClassToLibrary(mixinClass, classNode.enclosingLibrary);
-            // This class cannot be used from anywhere else, so don't try to
-            // generate shared mixin applications using it.
-            useSharedMixin = false;
-          }
+        var mixinType = scope.buildSupertype(mixin);
+        if (useSharedMixin &&
+            areDistinctUnboundTypeVariables(supertype, mixinType)) {
+          // Use a shared mixin application class for this library.
+          var mixinClass = getSharedMixinApplicationClass(
+              scope.currentLibrary, supertype.classNode, mixinType.classNode);
+          supertype = new ast.Supertype(
+              mixinClass,
+              supertype.typeArguments.length > mixinType.typeArguments.length
+                  ? supertype.typeArguments
+                  : mixinType.typeArguments);
+        } else {
+          // Generate a new class specific for this mixin application.
+          var freshParameters =
+              getFreshTypeParameters(classNode.typeParameters);
+          var mixinClass = new ast.Class(
+              name: '${classNode.name}^${mixinType.classNode.name}',
+              isAbstract: true,
+              typeParameters: freshParameters.freshTypeParameters,
+              supertype: freshParameters.substituteSuper(supertype),
+              mixedInType: freshParameters.substituteSuper(mixinType));
+          mixinClass.level = ast.ClassLevel.Type;
+          supertype = new ast.Supertype(mixinClass,
+              classNode.typeParameters.map(makeTypeParameterType).toList());
+          addMixinClassToLibrary(mixinClass, classNode.enclosingLibrary);
+          // This class cannot be used from anywhere else, so don't try to
+          // generate shared mixin applications using it.
+          useSharedMixin = false;
         }
       }
       classNode.supertype = supertype;
       for (var implementedType in element.interfaces) {
-        classNode.implementedTypes.add(scope.buildType(implementedType));
+        classNode.implementedTypes.add(scope.buildSupertype(implementedType));
       }
     }
   }
 
   void promoteToHierarchyLevel(ast.Class classNode) {
     if (classNode.level.index >= ast.ClassLevel.Hierarchy.index) return;
     promoteToTypeLevel(classNode);
     classNode.level = ast.ClassLevel.Hierarchy;
     var element = getClassElement(classNode);
     if (element != null) {
@@ skipping 156 matching lines @@
     // ensure unary minus is called 'unary-'.
     String name =
         element is PropertyAccessorElement ? element.displayName : element.name;
     return new ast.Name(name, getLibraryReference(element.library));
   }
 
   /// True if the two types have form `C<T1 ... Tm>` and `D<T1 ... Tn>`, and
   /// `T1 ... TN` are distinct type variables with no upper bound, where
   /// `N = max(m,n)`.
   bool areDistinctUnboundTypeVariables(
-      ast.InterfaceType first, ast.InterfaceType second) {
+      ast.Supertype first, ast.Supertype second) {
     var seen = new Set<ast.TypeParameter>();
     if (first.typeArguments.length < second.typeArguments.length) {
       var tmp = first;
       first = second;
       second = tmp;
     }
     for (int i = 0; i < first.typeArguments.length; ++i) {
       var firstArg = first.typeArguments[i];
       if (!(firstArg is ast.TypeParameterType &&
           seen.add(firstArg.parameter) &&
@@ skipping 44 matching lines @@
       var superArgs = typeArguments.length != superclass.typeParameters.length
           ? typeArguments.sublist(0, superclass.typeParameters.length)
           : typeArguments;
       var mixinArgs = typeArguments.length != mixedInClass.typeParameters.length
           ? typeArguments.sublist(0, mixedInClass.typeParameters.length)
           : typeArguments;
       var result = new ast.Class(
           name: name,
           isAbstract: true,
           typeParameters: fresh.freshTypeParameters,
-          supertype: new ast.InterfaceType(superclass, superArgs),
-          mixedInType: new ast.InterfaceType(mixedInClass, mixinArgs),
+          supertype: new ast.Supertype(superclass, superArgs),
+          mixedInType: new ast.Supertype(mixedInClass, mixinArgs),
           fileUri: mixedInClass.fileUri);
       result.level = ast.ClassLevel.Type;
       library.addClass(result);
       return result;
     });
   }
 
   String formatErrorMessage(
       AnalysisError error, String filename, LineInfo lines) {
     var location = lines.getLocation(error.offset);
@@ skipping 236 matching lines @@
   AnalysisContext context = AnalysisEngine.instance.createAnalysisContext()
     ..sourceFactory = new SourceFactory(resolvers)
     ..analysisOptions = createAnalysisOptions(options.strongMode);
 
   options.declaredVariables.forEach((String name, String value) {
     context.declaredVariables.define(name, value);
   });
 
   return context;
 }