Make undefined and null equivalent.

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 224 matching lines @@
       buffer.add('(');
     }
   }
 
   void endExpression(int precedence) {
     if (precedence < expectedPrecedence) {
       buffer.add(')');
     }
   }
 
+  void withPrecedence(int precedence, void action()) {
+    int oldPrecedence = expectedPrecedence;
+    beginExpression(precedence);
+    expectedPrecedence = precedence;
+    action();
+    expectedPrecedence = oldPrecedence;
+    endExpression(precedence);
+  }
+
   void preGenerateMethod(HGraph graph) {
     new SsaInstructionMerger(generateAtUseSite).visitGraph(graph);
     new SsaConditionMerger(generateAtUseSite,
                            controlFlowOperators).visitGraph(graph);
     SsaLiveIntervalBuilder intervalBuilder =
         new SsaLiveIntervalBuilder(compiler);
     intervalBuilder.visitGraph(graph);
     SsaVariableAllocator allocator = new SsaVariableAllocator(
         compiler,
         intervalBuilder.liveInstructions,
@@ skipping 907 matching lines @@
       this.expectedPrecedence = JSPrecedence.SHIFT_PRECEDENCE;
       visitInvokeUnary(node, op);
       buffer.add(' >>> 0');
       this.expectedPrecedence = oldPrecedence;
       endExpression(unsignedShiftPrecedences.precedence);
     } else {
       visitInvokeUnary(node, op);
     }
   }
 
+  void emitIdentityComparison(HInstruction left, HInstruction right) {
+    HType leftType = left.propagatedType;
+    HType rightType = right.propagatedType;
+    if (leftType.canBeNull() && rightType.canBeNull()) {
+      if (left.isConstantNull() || right.isConstantNull() ||
+          (leftType.isPrimitive() && leftType == rightType)) {
+        beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+        use(left, JSPrecedence.EQUALITY_PRECEDENCE);
+        buffer.add(' == ');
+        use(right, JSPrecedence.RELATIONAL_PRECEDENCE);
+        endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+      } else {
+        assert(NullConstant.JsNull == 'null');
+        withPrecedence(JSPrecedence.CONDITIONAL_PRECEDENCE, () {
+          beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+          use(left, JSPrecedence.EQUALITY_PRECEDENCE);
+          buffer.add(' == null');
+          endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+          buffer.add(' ? ');
+          this.expectedPrecedence = JSPrecedence.ASSIGNMENT_PRECEDENCE;
+          withPrecedence(JSPrecedence.LOGICAL_AND_PRECEDENCE, () {
+            beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+            use(right, JSPrecedence.EQUALITY_PRECEDENCE);
+            buffer.add(' == null');
+            endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+            buffer.add(" : ");
+            beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+            use(left, JSPrecedence.EQUALITY_PRECEDENCE);
+            buffer.add(' === ');
+            use(right, JSPrecedence.EQUALITY_PRECEDENCE);
+            endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+          });
+        });
+      }
+    } else {
+      beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+      use(left, JSPrecedence.EQUALITY_PRECEDENCE);
+      buffer.add(' === ');
+      use(right, JSPrecedence.RELATIONAL_PRECEDENCE);
+      endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+    }
+  }
+
   visitEquals(HEquals node) {
     if (node.builtin) {
-      beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
-      use(node.left, JSPrecedence.EQUALITY_PRECEDENCE);
-      buffer.add(' === ');
-      use(node.right, JSPrecedence.RELATIONAL_PRECEDENCE);
-      endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+      emitIdentityComparison(node.left, node.right);
     } else if (node.element === equalsNullElement ||
                node.element === boolifiedEqualsNullElement) {
       beginExpression(JSPrecedence.CALL_PRECEDENCE);
       use(node.target, JSPrecedence.CALL_PRECEDENCE);
       buffer.add('(');
       use(node.left, JSPrecedence.ASSIGNMENT_PRECEDENCE);
       buffer.add(')');
       endExpression(JSPrecedence.CALL_PRECEDENCE);
     } else {
       visitInvokeStatic(node);
     }
   }
 
+  visitIdentity(HIdentity node) {
+    assert(node.builtin);
+    emitIdentityComparison(node.left, node.right);
+  }
+
   visitAdd(HAdd node)               => visitInvokeBinary(node, '+');
   visitDivide(HDivide node)         => visitInvokeBinary(node, '/');
   visitMultiply(HMultiply node)     => visitInvokeBinary(node, '*');
   visitSubtract(HSubtract node)     => visitInvokeBinary(node, '-');
   // Truncating divide does not have a JS equivalent.
   visitTruncatingDivide(HTruncatingDivide node) => visitInvokeStatic(node);
   // Modulo cannot be mapped to the native operator (different semantics).
   visitModulo(HModulo node)                     => visitInvokeStatic(node);
 
   visitBitAnd(HBitAnd node)         => visitBitInvokeBinary(node, '&');
   visitBitNot(HBitNot node)         => visitBitInvokeUnary(node, '~');
   visitBitOr(HBitOr node)           => visitBitInvokeBinary(node, '|');
   visitBitXor(HBitXor node)         => visitBitInvokeBinary(node, '^');
   visitShiftRight(HShiftRight node) => visitBitInvokeBinary(node, '>>');
   visitShiftLeft(HShiftLeft node)   => visitBitInvokeBinary(node, '<<');
 
   visitNegate(HNegate node)         => visitInvokeUnary(node, '-');
 
-  visitIdentity(HIdentity node)         => visitInvokeBinary(node, '===');
   visitLess(HLess node)                 => visitInvokeBinary(node, '<');
   visitLessEqual(HLessEqual node)       => visitInvokeBinary(node, '<=');
   visitGreater(HGreater node)           => visitInvokeBinary(node, '>');
   visitGreaterEqual(HGreaterEqual node) => visitInvokeBinary(node, '>=');
 
   visitBoolify(HBoolify node) {
     beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
     assert(node.inputs.length == 1);
     use(node.inputs[0], JSPrecedence.EQUALITY_PRECEDENCE);
     buffer.add(' === true');
@@ skipping 539 matching lines @@
     beginExpression(JSPrecedence.EXPRESSION_PRECEDENCE);
     buffer.add(parts[0]);
     for (int i = 0; i < inputs.length; i++) {
       use(inputs[i], JSPrecedence.EXPRESSION_PRECEDENCE);
       buffer.add(parts[i + 1]);
     }
     endExpression(JSPrecedence.EXPRESSION_PRECEDENCE);
   }
 
   visitForeignNew(HForeignNew node) {
-    var i = 0;
+    int j = 0;
     node.element.forEachInstanceField(
       includeBackendMembers: true,
       includeSuperMembers: true,
       f: (ClassElement enclosingClass, Element member) {
         world.registerFieldInitializer(member.name,
                                        enclosingClass.computeType(compiler),
-                                       node.inputs[i].isInteger());
+                                       node.inputs[j].isInteger());
 
-        i++;
+        j++;
       });
     String jsClassReference = compiler.namer.isolateAccess(node.element);
     beginExpression(JSPrecedence.MEMBER_PRECEDENCE);
     buffer.add('new $jsClassReference(');
     // We can't use 'visitArguments', since our arguments start at input[0].
     List<HInstruction> inputs = node.inputs;
     for (int i = 0; i < inputs.length; i++) {
       if (i != 0) buffer.add(', ');
       use(inputs[i], JSPrecedence.ASSIGNMENT_PRECEDENCE);
     }
@@ skipping 428 matching lines @@
 
   void checkBool(HInstruction input, String cmp) {
     beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
     buffer.add('typeof ');
     use(input, JSPrecedence.PREFIX_PRECEDENCE);
     buffer.add(" $cmp 'boolean'");
     endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
   }
 
   void checkObject(HInstruction input, String cmp) {
-    beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
-    buffer.add('typeof ');
-    use(input, JSPrecedence.PREFIX_PRECEDENCE);
-    buffer.add(" $cmp 'object'");
-    endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+    assert(NullConstant.JsNull == 'null');
+    if (cmp == "===") {
+      withPrecedence(JSPrecedence.LOGICAL_AND_PRECEDENCE, () {
+        beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+        buffer.add('typeof ');
+        use(input, JSPrecedence.PREFIX_PRECEDENCE);
+        buffer.add(" === 'object'");
+        endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+        buffer.add(" && ");
+        beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+        use(input, JSPrecedence.PREFIX_PRECEDENCE);
+        buffer.add(" !== null");
+        endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+      });
+    } else {
+      assert(cmp == "!==");
+      withPrecedence(JSPrecedence.LOGICAL_OR_PRECEDENCE, () {
+        beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+        buffer.add('typeof ');
+        use(input, JSPrecedence.PREFIX_PRECEDENCE);
+        buffer.add(" !== 'object'");
+        endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+        buffer.add(" || ");
+        beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+        use(input, JSPrecedence.PREFIX_PRECEDENCE);
+        buffer.add(" === null");
+        endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
+      });
+    }
   }
 
   void checkArray(HInstruction input, String cmp) {
     beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
     use(input, JSPrecedence.MEMBER_PRECEDENCE);
     buffer.add('.constructor $cmp Array');
     endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
   }
 
   void checkImmutableArray(HInstruction input) {
@@ skipping 15 matching lines @@
   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)");
+    buffer.add(" == null");
     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);
+    withPrecedence(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);
+    });
   }
 
   void checkType(HInstruction input, Element element, [bool negative = false]) {
     world.registerIsCheck(element);
     bool requiresNativeIsCheck =
         backend.emitter.nativeEmitter.requiresNativeIsCheck(element);
     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
            && !Elements.isListSupertype(element, compiler));
-    beginExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
-    checkString(input, '===');
-    buffer.add(' || ');
-    beginExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
-    checkObject(input, '===');
-    buffer.add(' && ');
-    checkType(input, element);
-    endExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
-    endExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
+    withPrecedence(JSPrecedence.LOGICAL_OR_PRECEDENCE, () {
+      checkString(input, '===');
+      buffer.add(' || ');
+      withPrecedence(JSPrecedence.LOGICAL_AND_PRECEDENCE, () {
+        checkObject(input, '===');
+        buffer.add(' && ');
+        checkType(input, element);
+      });
+    });
   }
 
   void handleListOrSupertypeCheck(HInstruction input, Element element) {
     // Make sure List and String don't share supertypes, otherwise we
     // would need to check for String too.
     assert(element !== compiler.stringClass
            && !Elements.isStringSupertype(element, compiler));
     beginExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
     checkObject(input, '===');
     buffer.add(' && (');
@@ skipping 11 matching lines @@
     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);
     }
     LibraryElement coreLibrary = compiler.coreLibrary;
     ClassElement objectClass = compiler.objectClass;
     HInstruction input = node.expression;
 
+    int oldPrecedence;
     if (node.nullOk) {
+      oldPrecedence = expectedPrecedence;
       beginExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
+      expectedPrecedence = JSPrecedence.LOGICAL_OR_PRECEDENCE;
       checkNull(input);
       buffer.add(' || ');
     }
     if (element === objectClass || element === compiler.dynamicClass) {
       // The constant folder also does this optimization, but we make
       // it safe by assuming it may have not run.
       buffer.add('true');
     } else if (element == compiler.stringClass) {
       checkString(input, '===');
     } else if (element == compiler.doubleClass) {
@@ skipping 33 matching lines @@
       checkObject(node.typeInfoCall, '===');
       cls.typeParameters.forEach((name, _) {
         buffer.add(' && ');
         beginExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
         use(node.typeInfoCall, JSPrecedence.EQUALITY_PRECEDENCE);
         buffer.add(".${name.slowToString()} === '${arguments.head}'");
         endExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
       });
     }
     if (node.nullOk) {
+      expectedPrecedence = oldPrecedence;
       endExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
     }
   }
 
   void visitTypeConversion(HTypeConversion node) {
     if (node.isChecked()) {
       Element element = node.type.computeType(compiler).element;
       world.registerIsCheck(element);
       SourceString helper;
       String additionalArgument;
@@ skipping 500 matching lines @@
       startBailoutSwitch();
     }
   }
 
   void endLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
     if (labeledBlockInfo.body.start.hasGuards()) {
       endBailoutSwitch();
     }
   }
 }