Introduce Substitution class and Supertype class.

lib/analyzer/ast_from_analyzer.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.ast_from_analyzer;
 
 import '../ast.dart' as ast;
 import '../frontend/accessors.dart';
 import '../frontend/super_initializers.dart';
 import '../log.dart';
 import '../type_algebra.dart';
@@ skipping 302 matching lines @@
     var typeParameter = getTypeParameterReference(element);
     assert(bound != null);
     typeParameter.bound = bound;
     return typeParameter;
   }
 
   ast.DartType buildType(DartType type) {
     return new TypeAnnotationBuilder(this).buildFromDartType(type);
   }
 
+  ast.Supertype buildSupertype(DartType type) {
+    if (type is InterfaceType) {
+      var classElement = type.element;
+      if (classElement == null) return getRootClassReference().asRawSupertype;
+      var classNode = getClassReference(classElement);
+      if (classNode.typeParameters.isEmpty ||
+          classNode.typeParameters.length != type.typeArguments.length) {
+        return classNode.asRawSupertype;
+      } else {
+        return new ast.Supertype(classNode,
+          type.typeArguments.map(buildType).toList(growable: false));
+      }
+    }
+    return getRootClassReference().asRawSupertype;
+  }
+
   ast.DartType buildTypeAnnotation(AstNode node) {
     return new TypeAnnotationBuilder(this).build(node);
   }
 
   ast.DartType buildOptionalTypeAnnotation(AstNode node) {
     return node == null ? null : new TypeAnnotationBuilder(this).build(node);
   }
 
   ast.DartType getInferredType(Expression node) {
     if (!strongMode) return const ast.DynamicType();
@@ skipping 1934 matching lines @@
       return;
     }
     node.accept(this);
   }
 
   /// Builds an empty class for broken classes that have no AST.
   ///
   /// This should only be used to recover from a compile-time error.
   void buildBrokenClass() {
     currentClass.name = element.name;
-    currentClass.supertype = scope.getRootClassReference().rawType;
+    currentClass.supertype = scope.getRootClassReference().asRawSupertype;
     currentClass.constructors.add(
         new ast.Constructor(new ast.FunctionNode(new ast.InvalidStatement())));
   }
 
   void addAnnotations(List<Annotation> annotations) {
     // Class type parameters are not in scope in the annotation list.
     for (var annotation in annotations) {
       currentClass.addAnnotation(annotationScope.buildAnnotation(annotation));
     }
   }
@@ skipping 468 matching lines @@
   if (element is FieldElement) return element.getter;
   return element;
 }
 
 Element desynthesizeSetter(Element element) {
   if (element == null || !element.isSynthetic) return element;
   if (element is PropertyAccessorElement) return element.variable;
   if (element is FieldElement) return element.setter;
   return element;
 }