Implement '==', '!=' and instanceof (without code generation).

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/flags.h"
 #include "vm/intermediate_language.h"
 #include "vm/longjump.h"
@@ skipping 232 matching lines @@
 void EffectGraphVisitor::VisitStringConcatNode(StringConcatNode* node) {
   Bailout("EffectGraphVisitor::VisitStringConcatNode");
 }
 
 
 // <Expression> :: Comparison { kind:  Token::Kind
 //                              left:  <Expression>
 //                              right: <Expression> }
 void EffectGraphVisitor::VisitComparisonNode(ComparisonNode* node) {
   if (Token::IsInstanceofOperator(node->kind())) {
-    Bailout("instanceof not yet implemented");
-  } else if ((node->kind() == Token::kEQ) || (node->kind() == Token::kNE)) {
-    Bailout("'==' or '!=' comparison not yet implemented");
+    ArgumentGraphVisitor for_left_value(owner(), temp_index());
+    node->left()->Visit(&for_left_value);
+    Append(for_left_value);
+    InstanceOfComp* instance_of = new InstanceOfComp(
+        node->id(),
+        node->token_index(),
+        for_left_value.value(),
+        node->right()->AsTypeNode()->type(),
+        (node->kind() == Token::kISNOT));
+    ReturnComputation(instance_of);
+    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;
   }
 
   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());
-  const String& name = String::ZoneHandle(String::NewSymbol(node->Name()));
-  InstanceCallComp* call =
-      new InstanceCallComp(node->id(), node->token_index(), name,
-                           arguments, Array::ZoneHandle(), 2);
-  ReturnComputation(call);
+  // '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(), 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(), 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) {
-    Bailout("EffectGraphVisitor::VisitUnaryOpNode NOT");
+    ValueGraphVisitor for_value(owner(), temp_index());
+    node->operand()->Visit(&for_value);
+    Append(for_value);
+    if (FLAG_enable_type_checks) {
+      Bailout("GenerateConditionTypeCheck in kNOT");
+    }
+    BooleanNegateComp* negate = new BooleanNegateComp(for_value.value());
+    ReturnComputation(negate);
+    return;
   }
   ArgumentGraphVisitor for_value(owner(), temp_index());
   node->operand()->Visit(&for_value);
   Append(for_value);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(1);
   arguments->Add(for_value.value());
   const String& name =
       String::ZoneHandle(String::NewSymbol((node->kind() == Token::kSUB)
                                                ? Token::Str(Token::kNEGATE)
                                                : node->Name()));
@@ skipping 629 matching lines @@
 
 void FlowGraphPrinter::VisitInstanceSetter(InstanceSetterComp* comp) {
   OS::Print("InstanceSetter(");
   comp->receiver()->Accept(this);
   OS::Print(", ");
   comp->value()->Accept(this);
   OS::Print(")");
 }
 
 
+void FlowGraphPrinter::VisitBooleanNegate(BooleanNegateComp* comp) {
+  OS::Print("! ");
+  comp->value()->Accept(this);
+}
+
+
+void FlowGraphPrinter::VisitInstanceOf(InstanceOfComp* comp) {
+  comp->value()->Accept(this);
+  OS::Print(" %s %s",
+      comp->negate_result() ? "ISNOT" : "IS",
+      String::Handle(comp->type().Name()).ToCString());
+}
+
 void FlowGraphPrinter::VisitJoinEntry(JoinEntryInstr* instr) {
   OS::Print("%2d: [join]", instr->block_number());
 }
 
 
 void FlowGraphPrinter::VisitTargetEntry(TargetEntryInstr* instr) {
   OS::Print("%2d: [target]", instr->block_number());
 }
 
 
@@ skipping 66 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