Constant fold strict comparison based on incoming types: different (exact) types means that the res…

runtime/vm/flow_graph_optimizer.cc

Index: runtime/vm/flow_graph_optimizer.cc
===================================================================
--- runtime/vm/flow_graph_optimizer.cc	(revision 29815)
+++ runtime/vm/flow_graph_optimizer.cc	(working copy)
@@ -6307,14 +6307,27 @@
                                   : instr->left()->Type()->IsNull();
       if (instr->kind() == Token::kNE_STRICT) result = !result;
       SetValue(instr, Bool::Get(result));
-    } else {
-      SetValue(instr, non_constant_);
+      return;

[Kevin Millikin (Google), 2013/11/07 11:29:37]

If you want the early return, this should be:

if ((left.IsNull() && instr->right()->Type()->HasDecidableNullability()) ||
    (right.IsNull() && instr->left()->Type()->HasDecidableNullability())) {
  // ...
} else {
  SetValue(instr, non_constant_);
}
return;

     }
-  } else if (IsConstant(left) && IsConstant(right)) {
+  }
+  if (IsConstant(left) && IsConstant(right)) {
     bool result = (left.raw() == right.raw());
     if (instr->kind() == Token::kNE_STRICT) result = !result;
     SetValue(instr, Bool::Get(result));
+    return;
   }
+  const intptr_t left_cid = instr->left()->Type()->ToCid();
+  const intptr_t right_cid = instr->right()->Type()->ToCid();
+  if ((left_cid != kDynamicCid) && (right_cid != kDynamicCid)) {
+    // If exact classes (cids) are known and they differ, the result
+    // of strict compare can be computed.
+    if (left_cid != right_cid) {
+      const bool result = (instr->kind() == Token::kEQ_STRICT) ? false : true;
+      SetValue(instr, Bool::Get(result));
+      return;
+    }
+  }
+  SetValue(instr, non_constant_);

[Kevin Millikin (Google), 2013/11/07 11:29:37]

Abbreviate non-constant by X, constant by C, unknown constant by ?.  We don't
want to transition to non_constant in the cases [C,?], [?,C], and [?,?].

We only want to make this transition if one of them is X (which is why I suggest
catching it above in the case for one input non-constant).  We can remove this
call to SetValue if we have the one above.

An alternative fix is to instead have have here:

if (!IsUnknown(left) && !IsUnknown(right)) {
  SetValue(instr, non_constant_);
}

but I think that's less clear.

 }