Add strong mode type checking pass.

lib/type_environment.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.type_environment;
 
 import 'ast.dart';
 import 'class_hierarchy.dart';
 import 'core_types.dart';
 import 'type_algebra.dart';
 
 typedef void ErrorHandler(TreeNode node, String message);
 
 class TypeEnvironment extends SubtypeTester {
   final CoreTypes coreTypes;
   final ClassHierarchy hierarchy;
-  DartType thisType;
+  InterfaceType thisType;
+
+  DartType returnType;
+  DartType yieldType;
 
   /// An error handler for use in debugging, or `null` if type errors should not
   /// be tolerated.  See [typeError].
   ErrorHandler errorHandler;
 
   TypeEnvironment(this.coreTypes, this.hierarchy);
 
   InterfaceType get objectType => coreTypes.objectClass.rawType;
   InterfaceType get nullType => coreTypes.nullClass.rawType;
   InterfaceType get boolType => coreTypes.boolClass.rawType;
   InterfaceType get intType => coreTypes.intClass.rawType;
   InterfaceType get numType => coreTypes.numClass.rawType;
   InterfaceType get doubleType => coreTypes.doubleClass.rawType;
   InterfaceType get stringType => coreTypes.stringClass.rawType;
   InterfaceType get symbolType => coreTypes.symbolClass.rawType;
   InterfaceType get typeType => coreTypes.typeClass.rawType;
   InterfaceType get rawFunctionType => coreTypes.functionClass.rawType;
 
   Class get intClass => coreTypes.intClass;
   Class get numClass => coreTypes.numClass;
 
-  InterfaceType listType(DartType elementType) {
+  InterfaceType literalListType(DartType elementType) {
     return new InterfaceType(coreTypes.listClass, <DartType>[elementType]);
   }
 
-  InterfaceType mapType(DartType key, DartType value) {
+  InterfaceType literalMapType(DartType key, DartType value) {
     return new InterfaceType(coreTypes.mapClass, <DartType>[key, value]);
   }
 
   InterfaceType iterableType(DartType type) {
     return new InterfaceType(coreTypes.iterableClass, <DartType>[type]);
   }
 
   InterfaceType streamType(DartType type) {
     return new InterfaceType(coreTypes.streamClass, <DartType>[type]);
   }
@@ skipping 68 matching lines @@
   ClassHierarchy get hierarchy;
 
   /// Returns true if [subtype] is a subtype of [supertype].
   bool isSubtypeOf(DartType subtype, DartType supertype) {
     if (identical(subtype, supertype)) return true;
     if (subtype is BottomType) return true;
     if (supertype is DynamicType || supertype == objectType) {
       return true;
     }
     if (subtype is InterfaceType && supertype is InterfaceType) {
-      InterfaceType upcastType =
+      var upcastType =
           hierarchy.getTypeAsInstanceOf(subtype, supertype.classNode);
       if (upcastType == null) return false;
       for (int i = 0; i < upcastType.typeArguments.length; ++i) {
         // Termination: the 'supertype' parameter decreases in size.
         if (!isSubtypeOf(
             upcastType.typeArguments[i], supertype.typeArguments[i])) {
           return false;
         }
       }
       return true;
@@ skipping 65 matching lines @@
       var subtypeParameter = subtype.namedParameters[name];
       if (subtypeParameter == null) return false;
       // Termination: Both types shrink in size.
       if (!isSubtypeOf(supertypeParameter, subtypeParameter)) {
         return false;
       }
     }
     return true;
   }
 }