Source positions for constructors and lots of async machinery

runtime/vm/regexp_assembler_ir.cc

 // Copyright (c) 2014, 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/regexp_assembler_ir.h"
 
 #include "vm/bit_vector.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 18 matching lines @@
         String::Handle(String::New(__FUNCTION__)), Heap::kOld))))));
 
 #define PRINT(arg) if (FLAG_trace_irregexp) { Print(arg); }
 
 namespace dart {
 
 DEFINE_FLAG(bool, trace_irregexp, false, "Trace irregexps");
 
 
 static const intptr_t kInvalidTryIndex = CatchClauseNode::kInvalidTryIndex;
-static const intptr_t kNoSourcePos = Scanner::kNoSourcePos;
+static const intptr_t kNoSourcePos = Token::kNoSourcePos;
 static const intptr_t kMinStackSize = 512;
 
 
 void PrintUtf16(uint16_t c) {
   const char* format = (0x20 <= c && c <= 0x7F) ?
         "%c" : (c <= 0xff) ? "\\x%02x" : "\\u%04x";
   OS::Print(format, c);
 }
 
 
@@ skipping 531 matching lines @@
                              desc.name,
                              desc.token_kind,
                              arguments,
                              Object::null_array(),
                              desc.checked_argument_count,
                              ic_data_array_);
 }
 
 
 LoadLocalInstr* IRRegExpMacroAssembler::LoadLocal(LocalVariable* local) const {
-  return new(Z) LoadLocalInstr(*local);
+  return new(Z) LoadLocalInstr(*local, kNoSourcePos);
 }
 
 
 void IRRegExpMacroAssembler::StoreLocal(LocalVariable* local,
                                         Value* value) {
-  Do(new(Z) StoreLocalInstr(*local, value));
+  Do(new(Z) StoreLocalInstr(*local, value, kNoSourcePos));
 }
 
 
 void IRRegExpMacroAssembler::set_current_instruction(Instruction* instruction) {
   current_instruction_ = instruction;
 }
 
 
 Value* IRRegExpMacroAssembler::Bind(Definition* definition) {
   AppendInstruction(definition);
   definition->set_temp_index(temp_id_.Alloc());
 
   return new(Z) Value(definition);
 }
 
 
 void IRRegExpMacroAssembler::Do(Definition* definition) {
   AppendInstruction(definition);
 }
 
 
 Value* IRRegExpMacroAssembler::BindLoadLocal(const LocalVariable& local) {
   if (local.IsConst()) {
     return Bind(new(Z) ConstantInstr(*local.ConstValue()));
   }
   ASSERT(!local.is_captured());
-  return Bind(new(Z) LoadLocalInstr(local));
+  return Bind(new(Z) LoadLocalInstr(local, kNoSourcePos));
 }
 
 
 // In some cases, the V8 irregexp engine generates unreachable code by emitting
 // a jmp not followed by a bind. We cannot do the same, since it is impossible
 // to append to a block following a jmp. In such cases, assume that we are doing
 // the correct thing, but output a warning when tracing.
 #define HANDLE_DEAD_CODE_EMISSION() \
   if (current_instruction_ == NULL) { \
     if (FLAG_trace_irregexp) { \
@@ skipping 1282 matching lines @@
   }
 
   // Here pattern_val might be untagged so this must not trigger a GC.
   Value* index_val = BindLoadLocal(*index);
 
   return Bind(new(Z) LoadCodeUnitsInstr(
       pattern_val,
       index_val,
       characters,
       specialization_cid_,
-      Scanner::kNoSourcePos));
+      kNoSourcePos));
 }
 
 
 #undef __
 
 }  // namespace dart