Introduce Substitution class and Supertype class.

test/type_subtype_test.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.
 
 import 'package:test/test.dart';
 import 'package:kernel/ast.dart';
 import 'package:kernel/class_hierarchy.dart';
 import 'package:kernel/type_environment.dart';
 import 'type_parser.dart';
 
@@ skipping 103 matching lines @@
   LazyTypeEnvironment environment;
 
   MockSubtypeTester(
       this.hierarchy, this.objectType, this.rawFunctionType, this.environment);
 }
 
 MockSubtypeTester makeSubtypeTester(Map<String, List<String>> testcase) {
   LazyTypeEnvironment environment = new LazyTypeEnvironment();
   Class objectClass = environment.lookup('Object');
   Class functionClass = environment.lookup('Function');
-  functionClass.supertype = objectClass.rawType;
+  functionClass.supertype = objectClass.asRawSupertype;
   for (var typeString in testcase.keys) {
     InterfaceType type = environment.parseFresh(typeString);
     Class class_ = type.classNode;
     for (TypeParameterType typeArg in type.typeArguments) {
       class_.typeParameters.add(typeArg.parameter);
     }
     for (var supertypeString in testcase[typeString]) {
       if (class_.supertype == null) {
-        class_.supertype = environment.parse(supertypeString);
+        class_.supertype = environment.parseSuper(supertypeString);
       } else {
-        class_.implementedTypes.add(environment.parse(supertypeString));
+        class_.implementedTypes.add(environment.parseSuper(supertypeString));
       }
     }
   }
   var program = new Program([environment.dummyLibrary]);
   var hierarchy = new ClassHierarchy(program);
   return new MockSubtypeTester(
       hierarchy, objectClass.rawType, functionClass.rawType, environment);
 }
 
 main() {
   var tester = makeSubtypeTester(classEnvironment);
   var environment = tester.environment;
   for (var testCase in testCases) {
     test('$testCase', () {
       var subtype = environment.parseFresh(testCase.subtype);
       var supertype = environment.parseFresh(testCase.supertype);
       if (tester.isSubtypeOf(subtype, supertype) != testCase.isSubtype) {
         fail('isSubtypeOf(${testCase.subtype}, ${testCase.supertype}) returned '
             '${!testCase.isSubtype} but should return ${testCase.isSubtype}');
       }
       if (subtype != supertype && tester.isSubtypeOf(supertype, subtype)) {
         fail('isSubtypeOf(${testCase.supertype}, ${testCase.subtype}) returned '
             'true but should return false');
       }
     });
   }
 }