Clean up code generation of guards.

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 2243 matching lines @@
   }
 
   void checkExtendableArray(HInstruction input) {
     beginExpression(JSPrecedence.PREFIX_PRECEDENCE);
     buffer.add('!!');
     use(input, JSPrecedence.MEMBER_PRECEDENCE);
     buffer.add('.fixed\$length');
     endExpression(JSPrecedence.PREFIX_PRECEDENCE);
   }
 
+  void checkFixedArray(HInstruction input) {
+    beginExpression(JSPrecedence.PREFIX_PRECEDENCE);
+    use(input, JSPrecedence.MEMBER_PRECEDENCE);
+    buffer.add('.fixed\$length');
+    endExpression(JSPrecedence.PREFIX_PRECEDENCE);
+  }
+
   void checkNull(HInstruction input) {
     beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
     use(input, JSPrecedence.EQUALITY_PRECEDENCE);
     buffer.add(" === (void 0)");
     endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
   }
 
   void checkFunction(HInstruction input, Element element) {
     beginExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
     beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
     buffer.add('typeof ');
     use(input, JSPrecedence.PREFIX_PRECEDENCE);
     buffer.add(" === 'function'");
     endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
     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) {
+  void checkType(HInstruction input, Element element, [bool negative = false]) {
     world.registerIsCheck(element);
     bool requiresNativeIsCheck =
         backend.emitter.nativeEmitter.requiresNativeIsCheck(element);
-    if (!requiresNativeIsCheck) buffer.add('!!');
+    if (!requiresNativeIsCheck) {
+      if (negative) {
+        buffer.add('!');
+      } else {
+        buffer.add('!!');
+      }
+    } else if (negative) {
+      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) {
     // Make sure List and String don't share supertypes, otherwise we
     // would need to check for List too.
     assert(element !== compiler.listClass
@@ skipping 204 matching lines @@
       buffer.add(', 0');
     }
     buffer.add(')');
   }
 
   void visitTypeGuard(HTypeGuard node) {
     addIndentation();
     HInstruction input = node.guarded;
     Element indexingBehavior = compiler.jsIndexingBehaviorInterface;
     if (node.isInteger()) {
+      // if (input is !int) bailout
       buffer.add('if (');
       checkInt(input, '!==');
       buffer.add(') ');
       bailout(node, 'Not an integer');
     } else if (node.isNumber()) {
+      // if (input is !num) bailout
       buffer.add('if (');
       checkNum(input, '!==');
       buffer.add(') ');
       bailout(node, 'Not a number');
     } else if (node.isBoolean()) {
+      // if (input is !bool) bailout
       buffer.add('if (');
       checkBool(input, '!==');
       buffer.add(') ');
       bailout(node, 'Not a boolean');
     } else if (node.isString()) {
+      // if (input is !string) bailout
       buffer.add('if (');
       checkString(input, '!==');
       buffer.add(') ');
       bailout(node, 'Not a string');
     } else if (node.isExtendableArray()) {
+      // if (input is !Object || input is !Array || input.isFixed) bailout
       buffer.add('if (');
       checkObject(input, '!==');
       buffer.add('||');
       checkArray(input, '!==');
       buffer.add('||');
-      checkExtendableArray(input);
+      checkFixedArray(input);
       buffer.add(') ');
       bailout(node, 'Not an extendable array');
     } else if (node.isMutableArray()) {
+      // if (input is !Object
+      //     || ((input is !Array || input.isImmutable)
+      //         && input is !JsIndexingBehavior)) bailout
       buffer.add('if (');
       checkObject(input, '!==');
-      buffer.add(' || ');
+      buffer.add(' || ((');
       checkArray(input, '!==');
       buffer.add(' || ');
       checkImmutableArray(input);
-      buffer.add(' || !');
-      checkType(input, indexingBehavior);
-      buffer.add(') ');
+      buffer.add(') && ');
+      checkType(input, indexingBehavior, negative: true);
+      buffer.add(')) ');
       bailout(node, 'Not a mutable array');
     } else if (node.isReadableArray()) {
+      // if (input is !Object
+      //     || (input is !Array && input is !JsIndexingBehavior)) bailout
       buffer.add('if (');
       checkObject(input, '!==');
-      buffer.add(' || ');
+      buffer.add(' || (');
       checkArray(input, '!==');
-      buffer.add(' || !');
-      checkType(input, indexingBehavior);
-      buffer.add(') ');
+      buffer.add(' && ');
+      checkType(input, indexingBehavior, negative: true);
+      buffer.add(')) ');
       bailout(node, 'Not an array');
     } else if (node.isIndexablePrimitive()) {
+      // if (input is !String
+      //     && (input is !Object
+      //         || (input is !Array && input is !JsIndexingBehavior))) bailout
       buffer.add('if (');
       checkString(input, '!==');
       buffer.add(' && (');
       checkObject(input, '!==');
-      buffer.add(' || ');
+      buffer.add(' || (');
       checkArray(input, '!==');
-      buffer.add(' || !');
-      checkType(input, indexingBehavior);
-      buffer.add(')) ');
+      buffer.add(' && ');
+      checkType(input, indexingBehavior, negative: true);
+      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();
     HLoopInformation info = block.loopInformation;
@@ skipping 239 matching lines @@
       startBailoutSwitch();
     }
   }
 
   void endLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
     if (labeledBlockInfo.body.start.hasGuards()) {
       endBailoutSwitch();
     }
   }
 }