Add DartType.treatAsRaw to treat List<dynamic> as List in the backend.

sdk/lib/_internal/compiler/implementation/js_backend/backend.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.
 
 part of js_backend;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked;
 
   JavaScriptItemCompilationContext()
@@ skipping 972 matching lines @@
           enqueue(world, helper.getElement(compiler), elements);
         }
         // We also need the native variant of the check (for DOM types).
         helper = getNativeCheckedModeHelper(type, typeCast: false);
         if (helper != null) {
           enqueue(world, helper.getElement(compiler), elements);
         }
       }
     }
     bool isTypeVariable = type.kind == TypeKind.TYPE_VARIABLE;
-    if (!type.isRaw || type.containsTypeVariables) {
+    if (!type.treatAsRaw || type.containsTypeVariables) {
       enqueueInResolution(getSetRuntimeTypeInfo(), elements);
       enqueueInResolution(getGetRuntimeTypeInfo(), elements);
       enqueueInResolution(getGetRuntimeTypeArgument(), elements);
       if (inCheckedMode) {
         enqueueInResolution(getAssertSubtype(), elements);
       }
       enqueueInResolution(getCheckSubtype(), elements);
       if (isTypeVariable) {
         enqueueInResolution(getCheckSubtypeOfRuntimeType(), elements);
         if (inCheckedMode) {
@@ skipping 361 matching lines @@
       if (nativeCheck) {
         return typeCast
             ? 'stringSuperNativeTypeCast'
             : 'stringSuperNativeTypeCheck';
       } else {
         return typeCast
             ? 'stringSuperTypeCast'
             : 'stringSuperTypeCheck';
       }
     } else if ((element == compiler.listClass || element == jsArrayClass) &&
-               type.isRaw) {
+               type.treatAsRaw) {
       if (nativeCheckOnly) return null;
       return typeCast
           ? 'listTypeCast'
           : 'listTypeCheck';
     } else {
       if (Elements.isListSupertype(element, compiler)) {
         if (nativeCheck) {
           return typeCast
               ? 'listSuperNativeTypeCast'
               : 'listSuperNativeTypeCheck';
         } else {
           return typeCast
               ? 'listSuperTypeCast'
               : 'listSuperTypeCheck';
         }
       } else {
         if (nativeCheck) {
           // TODO(karlklose): can we get rid of this branch when we use
           // interceptors?
           return typeCast
               ? 'interceptedTypeCast'
               : 'interceptedTypeCheck';
         } else {
-          if (type.kind == TypeKind.INTERFACE && !type.isRaw) {
+          if (type.kind == TypeKind.INTERFACE && !type.treatAsRaw) {
             return typeCast
                 ? 'subtypeCast'
                 : 'assertSubtype';
           } else if (type.kind == TypeKind.TYPE_VARIABLE) {
             return typeCast
                 ? 'subtypeOfRuntimeTypeCast'
                 : 'assertSubtypeOfRuntimeType';
           } else if (type.kind == TypeKind.FUNCTION) {
             return typeCast
                 ? 'functionSubtypeCast'
@@ skipping 432 matching lines @@
     copy(constant.values);
     copy(constant.protoValue);
     copy(constant);
   }
 
   void visitConstructed(ConstructedConstant constant) {
     copy(constant.fields);
     copy(constant);
   }
 }