Allow breakpoints on strict equal

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/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 1379 matching lines @@
 
 
 void FlowGraphOptimizer::InlineStringIsEmptyGetter(InstanceCallInstr* call) {
   AddReceiverCheck(call);
 
   LoadFieldInstr* load = BuildLoadStringLength(call->ArgumentAt(0));
   InsertBefore(call, load, NULL, Definition::kValue);
 
   ConstantInstr* zero = flow_graph()->GetConstant(Smi::Handle(Smi::New(0)));
   StrictCompareInstr* compare =
-      new StrictCompareInstr(Token::kEQ_STRICT,
+      new StrictCompareInstr(call->token_pos(),
+                             Token::kEQ_STRICT,
                              new Value(load),
                              new Value(zero));
   ReplaceCall(call, compare);
 }
 
 
 void FlowGraphOptimizer::InlineObjectCid(InstanceCallInstr* call) {
   LoadClassIdInstr* load = new LoadClassIdInstr(new Value(call->ArgumentAt(0)));
   ReplaceCall(call, load);
 }
@@ skipping 1189 matching lines @@
 
 
 template <typename T>
 bool FlowGraphOptimizer::StrictifyEqualityCompare(
     EqualityCompareInstr* compare,
     T current_instruction) const {
   if (CanStrictifyEqualityCompare(compare)) {
     Token::Kind strict_kind = (compare->kind() == Token::kEQ) ?
         Token::kEQ_STRICT : Token::kNE_STRICT;
     StrictCompareInstr* strict_comp =
-        new StrictCompareInstr(strict_kind,
+        new StrictCompareInstr(compare->token_pos(),
+                               strict_kind,
                                compare->left()->CopyWithType(),
                                compare->right()->CopyWithType());
     current_instruction->ReplaceWith(strict_comp, current_iterator());
     return true;
   }
   return false;
 }
 
 
 template <typename T>
@@ skipping 3383 matching lines @@
   return join;
 }
 
 
 BranchInstr* BranchSimplifier::CloneBranch(BranchInstr* branch,
                                            Value* left,
                                            Value* right) {
   ComparisonInstr* comparison = branch->comparison();
   ComparisonInstr* new_comparison = NULL;
   if (comparison->IsStrictCompare()) {
-    new_comparison = new StrictCompareInstr(comparison->kind(), left, right);
+    new_comparison = new StrictCompareInstr(comparison->token_pos(),
+                                            comparison->kind(),
+                                            left,
+                                            right);
   } else if (comparison->IsEqualityCompare()) {
     EqualityCompareInstr* equality_compare = comparison->AsEqualityCompare();
     EqualityCompareInstr* new_equality_compare =
         new EqualityCompareInstr(equality_compare->token_pos(),
                                  comparison->kind(),
                                  left,
                                  right,
                                  Array::Handle());
     new_equality_compare->set_ic_data(equality_compare->ic_data());
     new_comparison = new_equality_compare;
@@ skipping 505 matching lines @@
 
   // Insert materializations at environment uses.
   const Class& cls = Class::Handle(alloc->constructor().Owner());
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, cls, *fields);
   }
 }
 
 
 }  // namespace dart