Handle list and map literals

pkg/compiler/lib/src/ssa/builder.dart

 // Copyright (c) 2012, 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 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 3547 matching lines @@
   /// returns [:true:] if an error can be statically determined.
   bool checkTypeVariableBounds(
       ast.NewExpression node, ResolutionInterfaceType type) {
     if (!options.enableTypeAssertions) return false;
 
     Map<ResolutionDartType, Set<ResolutionDartType>> seenChecksMap =
         new Map<ResolutionDartType, Set<ResolutionDartType>>();
     bool definitelyFails = false;
 
     void addTypeVariableBoundCheck(
-        GenericType instance,
+        ResolutionInterfaceType instance,
         ResolutionDartType typeArgument,
         ResolutionTypeVariableType typeVariable,
         ResolutionDartType bound) {
       if (definitelyFails) return;
 
       int subtypeRelation = types.computeSubtypeRelation(typeArgument, bound);
-      if (subtypeRelation == Types.IS_SUBTYPE) return;
+      if (subtypeRelation == DartTypes.IS_SUBTYPE) return;
 
       String message = "Can't create an instance of malbounded type '$type': "
           "'${typeArgument}' is not a subtype of bound '${bound}' for "
           "type variable '${typeVariable}' of type "
           "${type == instance
               ? "'${type.element.thisType}'"
               : "'${instance.element.thisType}' on the supertype "
                 "'${instance}' of '${type}'"
             }.";
-      if (subtypeRelation == Types.NOT_SUBTYPE) {
+      if (subtypeRelation == DartTypes.NOT_SUBTYPE) {
         generateTypeError(node, message);
         definitelyFails = true;
         return;
-      } else if (subtypeRelation == Types.MAYBE_SUBTYPE) {
+      } else if (subtypeRelation == DartTypes.MAYBE_SUBTYPE) {
         Set<ResolutionDartType> seenChecks = seenChecksMap.putIfAbsent(
             typeArgument, () => new Set<ResolutionDartType>());
         if (!seenChecks.contains(bound)) {
           seenChecks.add(bound);
           assertIsSubtype(node, typeArgument, bound, message);
         }
       }
     }
 
     types.checkTypeVariableBounds(type, addTypeVariableBoundCheck);
     if (definitelyFails) {
       return true;
     }
     for (ResolutionInterfaceType supertype in type.element.allSupertypes) {
-      ResolutionDartType instance = type.asInstanceOf(supertype.element);
+      ResolutionInterfaceType instance = type.asInstanceOf(supertype.element);
       types.checkTypeVariableBounds(instance, addTypeVariableBoundCheck);
       if (definitelyFails) {
         return true;
       }
     }
     return false;
   }
 
   visitStaticSend(ast.Send node) {
     internalError(node, "Unexpected visitStaticSend");
@@ skipping 3197 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }