Implement correct semantics of Boolean Conversion

runtime/vm/flow_graph_builder.cc

 // 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.
 
 #include "vm/flow_graph_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/class_finalizer.h"
@@ skipping 21 matching lines @@
 namespace dart {
 
 DEFINE_FLAG(bool, eliminate_type_checks, true,
             "Eliminate type checks when allowed by static type analysis.");
 DEFINE_FLAG(bool, print_ast, false, "Print abstract syntax tree.");
 DEFINE_FLAG(bool, print_scopes, false, "Print scopes of local variables.");
 DEFINE_FLAG(bool, trace_type_check_elimination, false,
             "Trace type check elimination at compile time.");
 
 DECLARE_FLAG(bool, enable_type_checks);
+DECLARE_FLAG(bool, enable_asserts);

[srdjan, 2014/12/05 00:49:28]

alphabetically.

[hausner, 2014/12/05 20:36:10]

Done.

 DECLARE_FLAG(int, optimization_counter_threshold);
 DECLARE_FLAG(bool, warn_on_javascript_compatibility);
 
 // Quick access to the locally defined isolate() method.
 #define I (isolate())
 
 // TODO(srdjan): Allow compiler to add constants as they are encountered in
 // the compilation.
 const double kCommonDoubleConstants[] =
     {-1.0, -0.5, -0.1, 0.0, 0.1, 0.5, 1.0, 2.0, 4.0, 5.0,
@@ skipping 825 matching lines @@
   return CreateSuccessorFor(true_successor_addresses_);
 }
 
 
 BlockEntryInstr* TestGraphVisitor::CreateFalseSuccessor() const {
   return CreateSuccessorFor(false_successor_addresses_);
 }
 
 
 void TestGraphVisitor::ReturnValue(Value* value) {
-  if (FLAG_enable_type_checks) {
+  if (FLAG_enable_type_checks || FLAG_enable_asserts) {
     value = Bind(new(I) AssertBooleanInstr(condition_token_pos(), value));
   }
   Value* constant_true = Bind(new(I) ConstantInstr(Bool::True()));
   StrictCompareInstr* comp =
       new(I) StrictCompareInstr(condition_token_pos(),
                                 Token::kEQ_STRICT,
                                 value,
                                 constant_true,
                                 false);  // No number check.
   BranchInstr* branch = new(I) BranchInstr(comp);
@@ skipping 334 matching lines @@
 //                            left:  <Expression>
 //                            right: <Expression> }
 void EffectGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     // See ValueGraphVisitor::VisitBinaryOpNode.
     TestGraphVisitor for_left(owner(), node->left()->token_pos());
     node->left()->Visit(&for_left);
     EffectGraphVisitor empty(owner());
-    if (FLAG_enable_type_checks) {
+    if (FLAG_enable_type_checks || FLAG_enable_asserts) {
       ValueGraphVisitor for_right(owner());
       node->right()->Visit(&for_right);
       Value* right_value = for_right.value();
       for_right.Do(new(I) AssertBooleanInstr(node->right()->token_pos(),
                                              right_value));
       if (node->kind() == Token::kAND) {
         Join(for_left, for_right, empty);
       } else {
         Join(for_left, empty, for_right);
       }
@@ skipping 44 matching lines @@
     // of left is sufficient.
     // AND:  left ? right === true : false;
     // OR:   left ? true : right === true;
 
     TestGraphVisitor for_test(owner(), node->left()->token_pos());
     node->left()->Visit(&for_test);
 
     ValueGraphVisitor for_right(owner());
     node->right()->Visit(&for_right);
     Value* right_value = for_right.value();
-    if (FLAG_enable_type_checks) {
+    if (FLAG_enable_type_checks|| FLAG_enable_asserts) {
       right_value =
           for_right.Bind(new(I) AssertBooleanInstr(node->right()->token_pos(),
                                                    right_value));
     }
     Value* constant_true = for_right.Bind(new(I) ConstantInstr(Bool::True()));
     Value* compare =
         for_right.Bind(new(I) StrictCompareInstr(node->token_pos(),
                                                  Token::kEQ_STRICT,
                                                  right_value,
                                                  constant_true,
@@ skipping 438 matching lines @@
 
     Definition* result = new(I) InstanceCallInstr(
         node->token_pos(),
         Symbols::EqualOperator(),
         Token::kEQ,  // Result is negated later for kNE.
         arguments,
         Object::null_array(),
         2,
         owner()->ic_data_array());
     if (node->kind() == Token::kNE) {
-      if (FLAG_enable_type_checks) {
+      if (FLAG_enable_type_checks || FLAG_enable_asserts) {
         Value* value = Bind(result);
         result = new(I) AssertBooleanInstr(node->token_pos(), value);
       }
       Value* value = Bind(result);
       result = new(I) BooleanNegateInstr(value);
     }
     ReturnDefinition(result);
     return;
   }
 
@@ skipping 25 matching lines @@
 }
 
 
 void EffectGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
   // "!" cannot be overloaded, therefore do not call operator.
   if (node->kind() == Token::kNOT) {
     ValueGraphVisitor for_value(owner());
     node->operand()->Visit(&for_value);
     Append(for_value);
     Value* value = for_value.value();
-    if (FLAG_enable_type_checks) {
+    if (FLAG_enable_type_checks || FLAG_enable_asserts) {
       value =
           Bind(new(I) AssertBooleanInstr(node->operand()->token_pos(), value));
     }
     BooleanNegateInstr* negate = new(I) BooleanNegateInstr(value);
     ReturnDefinition(negate);
     return;
   }
 
   ValueGraphVisitor for_value(owner());
   node->operand()->Visit(&for_value);
@@ skipping 2479 matching lines @@
   Report::MessageF(Report::kBailout,
                    Script::Handle(function.script()),
                    function.token_pos(),
                    "FlowGraphBuilder Bailout: %s %s",
                    String::Handle(function.name()).ToCString(),
                    reason);
   UNREACHABLE();
 }
 
 }  // namespace dart