Introduce an equality compare node. Equality will need to be handled specially soon (not just an in…

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 "vm/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
@@ skipping 489 matching lines @@
       type_arguments,
       node->right()->AsTypeNode()->type(),
       (node->kind() == Token::kISNOT));
   ReturnComputation(instance_of);
 }
 
 
 // <Expression> :: Comparison { kind:  Token::Kind
 //                              left:  <Expression>
 //                              right: <Expression> }
+// TODO(srdjan): Implement new equality.
 void EffectGraphVisitor::VisitComparisonNode(ComparisonNode* node) {
   if (Token::IsInstanceofOperator(node->kind())) {
     BuildInstanceOf(node);
     return;
   }
   if ((node->kind() == Token::kEQ_STRICT) ||
       (node->kind() == Token::kNE_STRICT)) {
     ValueGraphVisitor for_left_value(owner(), temp_index());
     node->left()->Visit(&for_left_value);
     Append(for_left_value);
     ValueGraphVisitor for_right_value(owner(), for_left_value.temp_index());
     node->right()->Visit(&for_right_value);
     Append(for_right_value);
     StrictCompareComp* comp = new StrictCompareComp(
         node->kind(), for_left_value.value(), for_right_value.value());
     ReturnComputation(comp);
     return;
   }
 
+  if ((node->kind() == Token::kEQ) || (node->kind() == Token::kNE)) {
+    ValueGraphVisitor for_left_value(owner(), temp_index());
+    node->left()->Visit(&for_left_value);
+    Append(for_left_value);
+    ValueGraphVisitor for_right_value(owner(), for_left_value.temp_index());
+    node->right()->Visit(&for_right_value);
+    Append(for_right_value);
+    EqualityCompareComp* comp = new EqualityCompareComp(
+        node->id(), node->token_index(), owner()->try_index(),
+        for_left_value.value(), for_right_value.value());
+    if (node->kind() == Token::kEQ) {
+      ReturnComputation(comp);
+    } else {
+      AddInstruction(new BindInstr(temp_index(), comp));
+      Value* eq_result = new TempVal(temp_index());
+      BooleanNegateComp* negate = new BooleanNegateComp(eq_result);
+      ReturnComputation(negate);
+    }
+    return;
+  }
+
   ArgumentGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   ArgumentGraphVisitor for_right_value(owner(), for_left_value.temp_index());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(for_left_value.value());
   arguments->Add(for_right_value.value());
-  // 'kNE' is not overloadable, must implement as kEQ and negation.
-  // Boolean negation '!' cannot be overloaded neither.
-  if (node->kind() == Token::kNE) {
-    const String& name = String::ZoneHandle(String::NewSymbol("=="));
-    InstanceCallComp* call_equal = new InstanceCallComp(
-        node->id(), node->token_index(), owner()->try_index(), name,
-        arguments, Array::ZoneHandle(), 2);
-    AddInstruction(new BindInstr(temp_index(), call_equal));
-    Value* eq_result = new TempVal(temp_index());
-    if (FLAG_enable_type_checks) {
-      Bailout("GenerateConditionTypeCheck in kNE");
-    }
-    BooleanNegateComp* negate = new BooleanNegateComp(eq_result);
-    ReturnComputation(negate);
-  } else {
-    const String& name = String::ZoneHandle(String::NewSymbol(node->Name()));
-    InstanceCallComp* call = new InstanceCallComp(
-        node->id(), node->token_index(), owner()->try_index(), name,
-        arguments, Array::ZoneHandle(), 2);
-    ReturnComputation(call);
-  }
+  const String& name = String::ZoneHandle(String::NewSymbol(node->Name()));
+  InstanceCallComp* call = new InstanceCallComp(
+      node->id(), node->token_index(), owner()->try_index(), name,
+      arguments, Array::ZoneHandle(), 2);
+  ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
   // "!" cannot be overloaded, therefore do not call operator.
   if (node->kind() == Token::kNOT) {
     ValueGraphVisitor for_value(owner(), temp_index());
     node->operand()->Visit(&for_value);
     Append(for_value);
     if (FLAG_enable_type_checks) {
@@ skipping 1619 matching lines @@
 
 void FlowGraphPrinter::VisitStrictCompare(StrictCompareComp* comp) {
   OS::Print("StrictCompare(%s, ", Token::Str(comp->kind()));
   comp->left()->Accept(this);
   OS::Print(", ");
   comp->right()->Accept(this);
   OS::Print(")");
 }
 
 
+void FlowGraphPrinter::VisitEqualityCompare(EqualityCompareComp* comp) {
+  comp->left()->Accept(this);
+  OS::Print(" == ");
+  comp->right()->Accept(this);
+}
+
+
 
 void FlowGraphPrinter::VisitStaticCall(StaticCallComp* comp) {
   OS::Print("StaticCall(%s",
             String::Handle(comp->function().name()).ToCString());
   for (intptr_t i = 0; i < comp->ArgumentCount(); ++i) {
     OS::Print(", ");
     comp->ArgumentAt(i)->Accept(this);
   }
   OS::Print(")");
 }
@@ skipping 394 matching lines @@
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart