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

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2013, 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.
 
 #include "vm/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 6289 matching lines @@
   }
 
   if (IsNonConstant(left) || IsNonConstant(right)) {
     // TODO(vegorov): incorporate nullability information into the lattice.
     if ((left.IsNull() && instr->right()->Type()->HasDecidableNullability()) ||
         (right.IsNull() && instr->left()->Type()->HasDecidableNullability())) {
       bool result = left.IsNull() ? instr->right()->Type()->IsNull()
                                   : 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.

 }
 
 
 static bool CompareIntegers(Token::Kind kind,
                             const Integer& left,
                             const Integer& right) {
   const int result = left.CompareWith(right);
   switch (kind) {
     case Token::kEQ: return (result == 0);
     case Token::kNE: return (result != 0);
@@ skipping 1523 matching lines @@
   }
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, alloc->cls(), *fields);
   }
 }
 
 
 }  // namespace dart