Add a new magic element type for annotating types that have Javascript array behavior.

lib/compiler/implementation/ssa/codegen.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.
 
 class SsaCodeGeneratorTask extends CompilerTask {
   final JavaScriptBackend backend;
   SsaCodeGeneratorTask(JavaScriptBackend backend)
       : this.backend = backend,
         super(backend.compiler);
   String get name() => 'SSA code generator';
@@ skipping 2046 matching lines @@
     buffer.add(" || ");
     beginExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
     checkObject(input, '===');
     buffer.add(" && ");
     checkType(input, element);
     endExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
     endExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
   }
 
   void checkType(HInstruction input, Element element) {
+    world.registerIsCheck(element);
     bool requiresNativeIsCheck =
         backend.emitter.nativeEmitter.requiresNativeIsCheck(element);
     if (!requiresNativeIsCheck) buffer.add('!!');
     use(input, JSPrecedence.MEMBER_PRECEDENCE);
     buffer.add('.');
     buffer.add(compiler.namer.operatorIs(element));
     if (requiresNativeIsCheck) buffer.add('()');
   }
 
   void handleStringSupertypeCheck(HInstruction input, Element element) {
@@ skipping 30 matching lines @@
   }
 
   void visitIs(HIs node) {
     Type type = node.typeExpression;
     Element element = type.element;
     if (element.kind === ElementKind.TYPE_VARIABLE) {
       compiler.unimplemented("visitIs for type variables", instruction: node);
     } else if (element.kind === ElementKind.TYPEDEF) {
       compiler.unimplemented("visitIs for typedefs", instruction: node);
     }
-    world.registerIsCheck(type.element);
     LibraryElement coreLibrary = compiler.coreLibrary;
     ClassElement objectClass = compiler.objectClass;
     HInstruction input = node.expression;
 
     if (node.nullOk) {
       beginExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
       checkNull(input);
       buffer.add(' || ');
     }
     if (element === objectClass || element === compiler.dynamicClass) {
@@ skipping 145 matching lines @@
     } else {
       assert(guard.guarded is HParameterValue);
       buffer.add(' 0');
     }
     buffer.add(')');
   }
 
   void visitTypeGuard(HTypeGuard node) {
     addIndentation();
     HInstruction input = node.guarded;
+    Element indexingBehavior = compiler.javaScriptIndexingBehaviorInterface;
     if (node.isInteger()) {
       buffer.add('if (');
       checkInt(input, '!==');
       buffer.add(') ');
       bailout(node, 'Not an integer');
     } else if (node.isNumber()) {
       buffer.add('if (');
       checkNum(input, '!==');
       buffer.add(') ');
       bailout(node, 'Not a number');
@@ skipping 12 matching lines @@
       checkObject(input, '!==');
       buffer.add('||');
       checkArray(input, '!==');
       buffer.add('||');
       checkExtendableArray(input);
       buffer.add(') ');
       bailout(node, 'Not an extendable array');
     } else if (node.isMutableArray()) {
       buffer.add('if (');
       checkObject(input, '!==');
-      buffer.add('||');
+      buffer.add(' || ');
       checkArray(input, '!==');
-      buffer.add('||');
+      buffer.add(' || ');
       checkImmutableArray(input);
+      buffer.add(' || !');
+      checkType(input, indexingBehavior);
       buffer.add(') ');
       bailout(node, 'Not a mutable array');
     } else if (node.isReadableArray()) {
       buffer.add('if (');
       checkObject(input, '!==');
-      buffer.add('||');
+      buffer.add(' || ');
       checkArray(input, '!==');
+      buffer.add(' || !');
+      checkType(input, indexingBehavior);
       buffer.add(') ');
       bailout(node, 'Not an array');
     } else if (node.isIndexablePrimitive()) {
       buffer.add('if (');
       checkString(input, '!==');
       buffer.add(' && (');
       checkObject(input, '!==');
-      buffer.add('||');
+      buffer.add(' || ');
       checkArray(input, '!==');
+      buffer.add(' || !');
+      checkType(input, indexingBehavior);
       buffer.add(')) ');
       bailout(node, 'Not a string or array');
     } else {
       compiler.internalError('Unexpected type guard', instruction: input);
     }
     buffer.add(';\n');
   }
 
   void beginLoop(HBasicBlock block) {
     addIndentation();
@@ skipping 287 matching lines @@
       startBailoutSwitch();
     }
   }
 
   void endLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
     if (labeledBlockInfo.body.start.hasGuards()) {
       endBailoutSwitch();
     }
   }
 }