Merge of source position information from kernel-sdk.

runtime/vm/kernel_to_il.cc

 // Copyright (c) 2016, 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 <map>
 #include <set>
 #include <string>
 
 #include "vm/kernel_to_il.h"
 
@@ skipping 2269 matching lines @@
   return Fragment(new (Z) GotoInstr(destination)).closed();
 }
 
 
 Fragment FlowGraphBuilder::IntConstant(int64_t value) {
   return Fragment(
       Constant(Integer::ZoneHandle(Z, Integer::New(value, Heap::kOld))));
 }
 
 
-Fragment FlowGraphBuilder::InstanceCall(const dart::String& name,
+Fragment FlowGraphBuilder::InstanceCall(TokenPosition position,
+                                        const dart::String& name,
                                         Token::Kind kind,
                                         intptr_t argument_count,
                                         intptr_t num_args_checked) {
-  return InstanceCall(name, kind, argument_count, Array::null_array(),
+  return InstanceCall(position, name, kind, argument_count, Array::null_array(),
                       num_args_checked);
 }
 
 
-Fragment FlowGraphBuilder::InstanceCall(const dart::String& name,
+Fragment FlowGraphBuilder::InstanceCall(TokenPosition position,
+                                        const dart::String& name,
                                         Token::Kind kind,
                                         intptr_t argument_count,
                                         const Array& argument_names,
                                         intptr_t num_args_checked) {
   ArgumentArray arguments = GetArguments(argument_count);
-  InstanceCallInstr* call = new (Z)
-      InstanceCallInstr(TokenPosition::kNoSource, name, kind, arguments,
-                        argument_names, num_args_checked, ic_data_array_);
+  InstanceCallInstr* call =
+      new (Z) InstanceCallInstr(position, name, kind, arguments, argument_names,
+                                num_args_checked, ic_data_array_);
   Push(call);
   return Fragment(call);
 }
 
 
 Fragment FlowGraphBuilder::ClosureCall(int argument_count,
                                        const Array& argument_names) {
   Value* function = Pop();
   ArgumentArray arguments = GetArguments(argument_count);
   ClosureCallInstr* call = new (Z) ClosureCallInstr(
       function, arguments, argument_names, TokenPosition::kNoSource);
   Push(call);
   return Fragment(call);
 }
 
 
-Fragment FlowGraphBuilder::ThrowException() {
+Fragment FlowGraphBuilder::ThrowException(TokenPosition position) {
   Fragment instructions;
   instructions += Drop();
-  instructions +=
-      Fragment(new (Z) ThrowInstr(TokenPosition::kNoSource)).closed();
+  instructions += Fragment(new (Z) ThrowInstr(position)).closed();
   // Use it's side effect of leaving a constant on the stack (does not change
   // the graph).
   NullConstant();
 
   pending_argument_count_ -= 1;
 
   return instructions;
 }
 
 
@@ skipping 125 matching lines @@
 Fragment FlowGraphBuilder::Return() {
   Value* value = Pop();
   ASSERT(stack_ == NULL);
   ReturnInstr* return_instr =
       new (Z) ReturnInstr(TokenPosition::kNoSource, value);
   if (exit_collector_ != NULL) exit_collector_->AddExit(return_instr);
   return Fragment(return_instr).closed();
 }
 
 
-Fragment FlowGraphBuilder::StaticCall(const Function& target,
+Fragment FlowGraphBuilder::StaticCall(TokenPosition position,
+                                      const Function& target,
                                       intptr_t argument_count) {
-  return StaticCall(target, argument_count, Array::null_array());
+  return StaticCall(position, target, argument_count, Array::null_array());
 }
 
 
 static intptr_t GetResultCidOfListFactory(Zone* zone,
                                           const Function& function,
                                           intptr_t argument_count) {
   if (!function.IsFactory()) {
     return kDynamicCid;
   }
 
   const dart::Class& owner = dart::Class::Handle(zone, function.Owner());
   if ((owner.library() != dart::Library::CoreLibrary()) &&
       (owner.library() != dart::Library::TypedDataLibrary())) {
     return kDynamicCid;
   }
 
   if ((owner.Name() == Symbols::List().raw()) &&
       (function.name() == Symbols::ListFactory().raw())) {
     ASSERT(argument_count == 1 || argument_count == 2);
     return (argument_count == 1) ? kGrowableObjectArrayCid : kArrayCid;
   }
   return FactoryRecognizer::ResultCid(function);
 }
 
 
-Fragment FlowGraphBuilder::StaticCall(const Function& target,
+Fragment FlowGraphBuilder::StaticCall(TokenPosition position,
+                                      const Function& target,
                                       intptr_t argument_count,
                                       const Array& argument_names) {
   ArgumentArray arguments = GetArguments(argument_count);
-  StaticCallInstr* call =
-      new (Z) StaticCallInstr(TokenPosition::kNoSource, target, argument_names,
-                              arguments, ic_data_array_);
+  StaticCallInstr* call = new (Z) StaticCallInstr(
+      position, target, argument_names, arguments, ic_data_array_);
   const intptr_t list_cid =
       GetResultCidOfListFactory(Z, target, argument_count);
   if (list_cid != kDynamicCid) {
     call->set_result_cid(list_cid);
     call->set_is_known_list_constructor(true);
   } else if (target.recognized_kind() != MethodRecognizer::kUnknown) {
     call->set_result_cid(MethodRecognizer::ResultCid(target));
   }
   Push(call);
   return Fragment(call);
@@ skipping 119 matching lines @@
 
   instructions += NullConstant();
   instructions += PushArgument();  // line
 
   instructions += IntConstant(0);
   instructions += PushArgument();  // column
 
   instructions += Constant(H.DartSymbol("Malformed type."));
   instructions += PushArgument();  // message
 
-  instructions += StaticCall(constructor, 5);
+  instructions += StaticCall(TokenPosition::kNoSource, constructor, 5);
   instructions += Drop();
 
   // Throw the exception
   instructions += PushArgument();
-  instructions += ThrowException();
+  instructions += ThrowException(TokenPosition::kNoSource);
 
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::ThrowNoSuchMethodError() {
   const dart::Class& klass = dart::Class::ZoneHandle(
       Z, dart::Library::LookupCoreClass(Symbols::NoSuchMethodError()));
   ASSERT(!klass.IsNull());
   const dart::Function& throw_function = dart::Function::ZoneHandle(
@@ skipping 14 matching lines @@
 
   instructions += NullConstant();
   instructions += PushArgument();  // arguments
 
   instructions += NullConstant();
   instructions += PushArgument();  // argumentNames
 
   instructions += NullConstant();
   instructions += PushArgument();  // existingArgumentNames
 
-  instructions += StaticCall(throw_function, 6);
+  instructions += StaticCall(TokenPosition::kNoSource, throw_function, 6);
   // Leave "result" on the stack since callers expect it to be there (even
   // though the function will result in an exception).
 
   return instructions;
 }
 
 
 dart::RawFunction* FlowGraphBuilder::LookupMethodByMember(
     Member* target,
     const dart::String& method_name) {
@@ skipping 741 matching lines @@
     for (intptr_t i = 0; i < named_argument_count; i++) {
       VariableDeclaration* variable = kernel_function->named_parameters()[i];
       body += LoadLocal(LookupVariable(variable));
       body += PushArgument();
       argument_names.SetAt(i, H.DartSymbol(variable->name()));
     }
   }
   // Forward them to the target.
   intptr_t argument_count = positional_argument_count + named_argument_count;
   if (!target.is_static()) ++argument_count;
-  body += StaticCall(target, argument_count, argument_names);
+  body += StaticCall(TokenPosition::kNoSource, target, argument_count,
+                     argument_names);
 
   // Return the result.
   body += Return();
 
   return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
 }
 
 
 FlowGraph* FlowGraphBuilder::BuildGraphOfNoSuchMethodDispatcher(
     const Function& function) {
@@ skipping 66 matching lines @@
   body += Constant(Bool::False());
   body += PushArgument();
 
   const dart::Class& mirror_class = dart::Class::Handle(
       Z, dart::Library::LookupCoreClass(Symbols::InvocationMirror()));
   ASSERT(!mirror_class.IsNull());
   const Function& allocation_function = Function::ZoneHandle(
       Z, mirror_class.LookupStaticFunction(dart::Library::PrivateCoreLibName(
              Symbols::AllocateInvocationMirror())));
   ASSERT(!allocation_function.IsNull());
-  body += StaticCall(allocation_function, 4);
+  body += StaticCall(TokenPosition::kMinSource, allocation_function, 4);
   body += PushArgument();  // For the call to noSuchMethod.
 
   ArgumentsDescriptor two_arguments(
       Array::Handle(Z, ArgumentsDescriptor::New(2)));
   Function& no_such_method =
       Function::ZoneHandle(Z, Resolver::ResolveDynamicForReceiverClass(
                                   dart::Class::Handle(Z, function.Owner()),
                                   Symbols::NoSuchMethod(), two_arguments));
   if (no_such_method.IsNull()) {
     // If noSuchMethod is not found on the receiver class, call
     // Object.noSuchMethod.
     no_such_method = Resolver::ResolveDynamicForReceiverClass(
         dart::Class::Handle(Z, I->object_store()->object_class()),
         Symbols::NoSuchMethod(), two_arguments);
   }
-  body += StaticCall(no_such_method, 2);
+  body += StaticCall(TokenPosition::kMinSource, no_such_method, 2);
   body += Return();
 
   return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
 }
 
 
 FlowGraph* FlowGraphBuilder::BuildGraphOfInvokeFieldDispatcher(
     const Function& function) {
   // Find the name of the field we should dispatch to.
   const dart::Class& owner = dart::Class::Handle(Z, function.Owner());
@@ skipping 43 matching lines @@
   LocalVariable* closure = NULL;
   if (is_closure_call) {
     closure = scope->VariableAt(0);
 
     // The closure itself is the first argument.
     body += LoadLocal(closure);
   } else {
     // Invoke the getter to get the field value.
     body += LoadLocal(scope->VariableAt(0));
     body += PushArgument();
-    body += InstanceCall(getter_name, Token::kGET, 1);
+    body +=
+        InstanceCall(TokenPosition::kMinSource, getter_name, Token::kGET, 1);
   }
 
   body += PushArgument();
 
   // Push all arguments onto the stack.
   intptr_t pos = 1;
   for (; pos < descriptor.Count(); pos++) {
     body += LoadLocal(scope->VariableAt(pos));
     body += PushArgument();
   }
 
   if (is_closure_call) {
     // Lookup the function in the closure.
     body += LoadLocal(closure);
     body += LoadField(Closure::function_offset());
 
     body += ClosureCall(descriptor.Count(), argument_names);
   } else {
-    body += InstanceCall(Symbols::Call(), Token::kILLEGAL, descriptor.Count(),
-                         argument_names);
+    body += InstanceCall(TokenPosition::kMinSource, Symbols::Call(),
+                         Token::kILLEGAL, descriptor.Count(), argument_names);
   }
 
   body += Return();
 
   return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
 }
 
 
 void FlowGraphBuilder::SetupDefaultParameterValues(FunctionNode* function) {
   intptr_t num_optional_parameters =
@@ skipping 92 matching lines @@
       instructions += LoadLocal(scopes_->this_variable);
       instructions += PushArgument();
 
       ASSERT(init->arguments()->types().length() == 0);
       Array& argument_names = Array::ZoneHandle(Z);
       instructions += TranslateArguments(init->arguments(), &argument_names);
 
       const Function& target = Function::ZoneHandle(
           Z, H.LookupConstructorByKernelConstructor(init->target()));
       intptr_t argument_count = init->arguments()->count() + 1;
-      instructions += StaticCall(target, argument_count, argument_names);
+      instructions += StaticCall(TokenPosition::kNoSource, target,
+                                 argument_count, argument_names);
       instructions += Drop();
     } else if (initializer->IsRedirectingInitializer()) {
       RedirectingInitializer* init = RedirectingInitializer::Cast(initializer);
 
       instructions += LoadLocal(scopes_->this_variable);
       instructions += PushArgument();
 
       ASSERT(init->arguments()->types().length() == 0);
       Array& argument_names = Array::ZoneHandle(Z);
       instructions += TranslateArguments(init->arguments(), &argument_names);
 
       const Function& target = Function::ZoneHandle(
           Z, H.LookupConstructorByKernelConstructor(init->target()));
       intptr_t argument_count = init->arguments()->count() + 1;
-      instructions += StaticCall(target, argument_count, argument_names);
+      instructions += StaticCall(TokenPosition::kNoSource, target,
+                                 argument_count, argument_names);
       instructions += Drop();
     } else if (initializer->IsLocalInitializer()) {
       // The other initializers following this one might read the variable. This
       // is used e.g. for evaluating the arguments to a super call first, run
       // normal field initializers next and then make the actual super call:
       //
       //   The frontend converts
       //
       //      class A {
       //        var x;
@@ skipping 406 matching lines @@
       fragment_ = Constant(constant_evaluator_.EvaluateExpression(node));
     } else {
       const dart::Class& owner = dart::Class::Handle(Z, field.Owner());
       const dart::String& getter_name = H.DartGetterName(kernel_field->name());
       const Function& getter =
           Function::ZoneHandle(Z, owner.LookupStaticFunction(getter_name));
       if (getter.IsNull() || !field.has_initializer()) {
         Fragment instructions = Constant(field);
         fragment_ = instructions + LoadStaticField();
       } else {
-        fragment_ = StaticCall(getter, 0);
+        fragment_ = StaticCall(node->position(), getter, 0);
       }
     }
   } else {
     Procedure* procedure = Procedure::Cast(target);
     const Function& target = Function::ZoneHandle(
         Z, H.LookupStaticMethodByKernelProcedure(procedure));
 
     if (procedure->kind() == Procedure::kGetter) {
-      fragment_ = StaticCall(target, 0);
+      fragment_ = StaticCall(node->position(), target, 0);
     } else if (procedure->kind() == Procedure::kMethod) {
       ASSERT(procedure->IsStatic());
       Function& closure_function =
           Function::ZoneHandle(Z, target.ImplicitClosureFunction());
       closure_function.set_kernel_function(target.kernel_function());
       const Instance& closure =
           Instance::ZoneHandle(Z, closure_function.ImplicitStaticClosure());
       fragment_ = Constant(closure);
     } else {
       UNIMPLEMENTED();
@@ skipping 20 matching lines @@
     LocalVariable* variable = MakeTemporary();
 
     // Prepare argument.
     instructions += LoadLocal(variable);
     instructions += PushArgument();
 
     // Invoke the setter function.
     Procedure* procedure = Procedure::Cast(target);
     const Function& target = Function::ZoneHandle(
         Z, H.LookupStaticMethodByKernelProcedure(procedure));
-    instructions += StaticCall(target, 1);
+    instructions += StaticCall(node->position(), target, 1);
 
     // Drop the unused result & leave the stored value on the stack.
     fragment_ = instructions + Drop();
   }
 }
 
 
 void FlowGraphBuilder::VisitPropertyGet(PropertyGet* node) {
   Fragment instructions = TranslateExpression(node->receiver());
   instructions += PushArgument();
   const dart::String& getter_name = H.DartGetterName(node->name());
-  fragment_ = instructions + InstanceCall(getter_name, Token::kGET, 1);
+  fragment_ = instructions +
+              InstanceCall(node->position(), getter_name, Token::kGET, 1);
 }
 
 
 void FlowGraphBuilder::VisitPropertySet(PropertySet* node) {
   Fragment instructions(NullConstant());
   LocalVariable* variable = MakeTemporary();
   instructions += TranslateExpression(node->receiver());
   instructions += PushArgument();
   instructions += TranslateExpression(node->value());
   instructions += StoreLocal(variable);
   instructions += PushArgument();
 
   const dart::String& setter_name = H.DartSetterName(node->name());
-  instructions += InstanceCall(setter_name, Token::kSET, 2);
+  instructions += InstanceCall(node->position(), setter_name, Token::kSET, 2);
   fragment_ = instructions + Drop();
 }
 
 
 void FlowGraphBuilder::VisitDirectPropertyGet(DirectPropertyGet* node) {
   Function& target = Function::ZoneHandle(Z);
   if (node->target()->IsProcedure()) {
     Procedure* kernel_procedure = Procedure::Cast(node->target());
     Name* kernel_name = kernel_procedure->name();
     if (kernel_procedure->kind() == Procedure::kGetter) {
       target =
           LookupMethodByMember(kernel_procedure, H.DartGetterName(kernel_name));
     } else {
       target =
           LookupMethodByMember(kernel_procedure, H.DartMethodName(kernel_name));
       target = target.ImplicitClosureFunction();
       ASSERT(!target.IsNull());
       fragment_ = BuildImplicitClosureCreation(target);
       return;
     }
   } else {
     ASSERT(node->target()->IsField());
     const dart::String& getter_name = H.DartGetterName(node->target()->name());
     target = LookupMethodByMember(node->target(), getter_name);
     ASSERT(target.IsGetterFunction() || target.IsImplicitGetterFunction());
   }
 
   Fragment instructions = TranslateExpression(node->receiver());
   instructions += PushArgument();
-  fragment_ = instructions + StaticCall(target, 1);
+  fragment_ = instructions + StaticCall(node->position(), target, 1);
 }
 
 
 void FlowGraphBuilder::VisitDirectPropertySet(DirectPropertySet* node) {
   const dart::String& method_name = H.DartSetterName(node->target()->name());
   const Function& target = Function::ZoneHandle(
       Z, LookupMethodByMember(node->target(), method_name));
   ASSERT(target.IsSetterFunction() || target.IsImplicitSetterFunction());
 
   Fragment instructions(NullConstant());
   LocalVariable* value = MakeTemporary();
   instructions += TranslateExpression(node->receiver());
   instructions += PushArgument();
   instructions += TranslateExpression(node->value());
   instructions += StoreLocal(value);
   instructions += PushArgument();
-  instructions += StaticCall(target, 2);
+  instructions += StaticCall(node->position(), target, 2);
 
   fragment_ = instructions + Drop();
 }
 
 
 void FlowGraphBuilder::VisitStaticInvocation(StaticInvocation* node) {
   const Function& target = Function::ZoneHandle(
       Z, H.LookupStaticMethodByKernelProcedure(node->procedure()));
   const dart::Class& klass = dart::Class::ZoneHandle(Z, target.Owner());
   intptr_t argument_count = node->arguments()->count();
@@ skipping 64 matching lines @@
       (target.name() == Symbols::Identical().raw())) {
     ASSERT(argument_count == 2);
 
     List<Expression>& positional = node->arguments()->positional();
     for (intptr_t i = 0; i < positional.length(); ++i) {
       instructions += TranslateExpression(positional[i]);
     }
     instructions += StrictCompare(Token::kEQ_STRICT, /*number_check=*/true);
   } else {
     instructions += TranslateArguments(node->arguments(), NULL);
-    instructions += StaticCall(target, argument_count, argument_names);
+    instructions +=
+        StaticCall(node->position(), target, argument_count, argument_names);
 
     if (target.IsGenerativeConstructor()) {
       // Drop the result of the constructor call and leave [instance_variable]
       // on top-of-stack.
       instructions += Drop();
     }
   }
 
   fragment_ = instructions;
 }
@@ skipping 36 matching lines @@
   instructions += TranslateArguments(node->arguments(), &argument_names);
 
   intptr_t num_args_checked = 1;
   // If we have a special operation (e.g. +/-/==) we mark both arguments as
   // to be checked.
   if (token_kind != Token::kILLEGAL) {
     ASSERT(argument_count <= 2);
     num_args_checked = argument_count;
   }
 
-  fragment_ = instructions + InstanceCall(name, token_kind, argument_count,
-                                          argument_names, num_args_checked);
+  fragment_ = instructions + InstanceCall(node->position(), name, token_kind,
+                                          argument_count, argument_names,
+                                          num_args_checked);
 }
 
 
 void FlowGraphBuilder::VisitDirectMethodInvocation(
     DirectMethodInvocation* node) {
   const dart::String& method_name = H.DartMethodName(node->target()->name());
   const Function& target = Function::ZoneHandle(
       Z, LookupMethodByMember(node->target(), method_name));
 
   intptr_t argument_count = node->arguments()->count() + 1;
   Array& argument_names = Array::ZoneHandle(Z);
 
   ASSERT(node->arguments()->types().length() == 0);
   Fragment instructions = TranslateExpression(node->receiver());
   instructions += PushArgument();
   instructions += TranslateArguments(node->arguments(), &argument_names);
-  fragment_ = instructions + StaticCall(target, argument_count, argument_names);
+  fragment_ = instructions + StaticCall(node->position(), target,
+                                        argument_count, argument_names);
 }
 
 
 void FlowGraphBuilder::VisitConstructorInvocation(ConstructorInvocation* node) {
   if (node->is_const()) {
     fragment_ =
         Constant(constant_evaluator_.EvaluateConstructorInvocation(node));
     return;
   }
 
@@ skipping 39 matching lines @@
 
   instructions += LoadLocal(variable);
   instructions += PushArgument();
 
   Array& argument_names = Array::ZoneHandle(Z);
   instructions += TranslateArguments(node->arguments(), &argument_names);
 
   const Function& target = Function::ZoneHandle(
       Z, H.LookupConstructorByKernelConstructor(klass, node->target()));
   intptr_t argument_count = node->arguments()->count() + 1;
-  instructions += StaticCall(target, argument_count, argument_names);
+  instructions +=
+      StaticCall(node->position(), target, argument_count, argument_names);
   fragment_ = instructions + Drop();
 }
 
 
 void FlowGraphBuilder::VisitIsExpression(IsExpression* node) {
   Fragment instructions = TranslateExpression(node->operand());
 
   // The VM does not like an instanceOf call with a dynamic type. We need to
   // special case this situation.
   const Type& object_type = Type::Handle(Z, Type::ObjectType());
@@ skipping 22 matching lines @@
     }
     instructions += PushArgument();  // Type arguments.
 
     instructions += Constant(type);
     instructions += PushArgument();  // Type.
 
     instructions += Constant(Bool::False());
     instructions += PushArgument();  // Negate?.
 
     instructions +=
-        InstanceCall(dart::Library::PrivateCoreLibName(Symbols::_instanceOf()),
+        InstanceCall(TokenPosition::kNoSource,
+                     dart::Library::PrivateCoreLibName(Symbols::_instanceOf()),
                      Token::kIS, 4);
   }
 
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitAsExpression(AsExpression* node) {
   Fragment instructions = TranslateExpression(node->operand());
 
@@ skipping 19 matching lines @@
       instructions += LoadInstantiatorTypeArguments();
     } else {
       instructions += NullConstant();
     }
     instructions += PushArgument();  // Type arguments.
 
     instructions += Constant(type);
     instructions += PushArgument();  // Type.
 
     instructions += InstanceCall(
+        TokenPosition::kNoSource,
         dart::Library::PrivateCoreLibName(Symbols::_as()), Token::kAS, 3);
   }
 
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitConditionalExpression(ConditionalExpression* node) {
   bool negate;
   Fragment instructions = TranslateCondition(node->condition(), &negate);
@@ skipping 126 matching lines @@
       instructions += Drop();
     }
   }
   instructions += PushArgument();  // The array.
 
   const dart::Class& factory_class =
       dart::Class::Handle(Z, dart::Library::LookupCoreClass(Symbols::List()));
   const Function& factory_method = Function::ZoneHandle(
       Z, factory_class.LookupFactory(
              dart::Library::PrivateCoreLibName(Symbols::ListLiteralFactory())));
-  fragment_ = instructions + StaticCall(factory_method, 2);
+  fragment_ = instructions + StaticCall(node->position(), factory_method, 2);
 }
 
 
 void FlowGraphBuilder::VisitMapLiteral(MapLiteral* node) {
   if (node->is_const()) {
     fragment_ = Constant(constant_evaluator_.EvaluateMapLiteral(node));
     return;
   }
 
   const dart::Class& map_class =
@@ skipping 30 matching lines @@
 
       instructions += LoadLocal(array);
       instructions += IntConstant(2 * i + 1);
       instructions += TranslateExpression(entries[i]->value());
       instructions += StoreIndexed(kArrayCid);
       instructions += Drop();
     }
   }
   instructions += PushArgument();  // The array.
 
-  fragment_ = instructions + StaticCall(factory_method, 2);
+  fragment_ = instructions + StaticCall(node->position(), factory_method, 2);
 }
 
 
 void FlowGraphBuilder::VisitFunctionExpression(FunctionExpression* node) {
   fragment_ = TranslateFunctionNode(node->function(), node);
 }
 
 
 void FlowGraphBuilder::VisitLet(Let* node) {
   Fragment instructions = TranslateStatement(node->variable());
   instructions += TranslateExpression(node->body());
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitThrow(Throw* node) {
   Fragment instructions;
 
   instructions += TranslateExpression(node->expression());
   instructions += PushArgument();
-  instructions += ThrowException();
+  instructions += ThrowException(node->position());
   ASSERT(instructions.is_closed());
 
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitRethrow(Rethrow* node) {
   Fragment instructions;
 
   instructions += LoadLocal(catch_block_->exception_var());
@@ skipping 263 matching lines @@
   fragment_ = loop;
 }
 
 
 void FlowGraphBuilder::VisitForInStatement(ForInStatement* node) {
   Fragment instructions = TranslateExpression(node->iterable());
   instructions += PushArgument();
 
   const dart::String& iterator_getter = dart::String::ZoneHandle(
       Z, dart::Field::GetterSymbol(Symbols::Iterator()));
-  instructions += InstanceCall(iterator_getter, Token::kGET, 1);
+  instructions +=
+      InstanceCall(TokenPosition::kNoSource, iterator_getter, Token::kGET, 1);
   LocalVariable* iterator = scopes_->iterator_variables[for_in_depth_];
   instructions += StoreLocal(iterator);
   instructions += Drop();
 
   ++for_in_depth_;
   ++loop_depth_;
   Fragment condition = LoadLocal(iterator);
   condition += PushArgument();
-  condition += InstanceCall(Symbols::MoveNext(), Token::kILLEGAL, 1);
+  condition += InstanceCall(TokenPosition::kNoSource, Symbols::MoveNext(),
+                            Token::kILLEGAL, 1);
   TargetEntryInstr* body_entry;
   TargetEntryInstr* loop_exit;
   condition += BranchIfTrue(&body_entry, &loop_exit);
 
   Fragment body(body_entry);
   body += EnterScope(node);
   body += LoadLocal(iterator);
   body += PushArgument();
   const dart::String& current_getter = dart::String::ZoneHandle(
       Z, dart::Field::GetterSymbol(Symbols::Current()));
-  body += InstanceCall(current_getter, Token::kGET, 1);
+  body +=
+      InstanceCall(TokenPosition::kNoSource, current_getter, Token::kGET, 1);
   body += StoreLocal(LookupVariable(node->variable()));
   body += Drop();
   body += TranslateStatement(node->body());
   body += ExitScope(node);
 
   if (body.is_open()) {
     JoinEntryInstr* join = BuildJoinEntry();
     instructions += Goto(join);
     body += Goto(join);
 
@@ skipping 100 matching lines @@
       // Call _AssertionError._create constructor.
       body_fragment += LoadLocal(instance);
       body_fragment += PushArgument();  // this
 
       body_fragment += Constant(url);
       body_fragment += PushArgument();  // url
 
       body_fragment += NullConstant();
       body_fragment += PushArgument();  // line
 
-      body_fragment += StaticCall(constructor, 3);
+      body_fragment += StaticCall(TokenPosition::kNoSource, constructor, 3);
       body_fragment += Drop();
 
       // Throw the exception
       body_fragment += PushArgument();
-      body_fragment += ThrowException();
+      body_fragment += ThrowException(TokenPosition::kNoSource);
       body_fragment += Drop();
     }
 
     // If there is an implicit fall-through we have one [SwitchCase] and
     // multiple expressions, e.g.
     //
     //    switch(expr) {
     //      case a:
     //      case b:
     //        <stmt-body>
@@ skipping 43 matching lines @@
 
       for (intptr_t j = 0; j < switch_case->expressions().length(); j++) {
         TargetEntryInstr* then;
         TargetEntryInstr* otherwise;
 
         current_instructions += Constant(constant_evaluator_.EvaluateExpression(
             switch_case->expressions()[j]));
         current_instructions += PushArgument();
         current_instructions += LoadLocal(scopes_->switch_variable);
         current_instructions += PushArgument();
-        current_instructions +=
-            InstanceCall(Symbols::EqualOperator(), Token::kEQ,
-                         /*argument_count=*/2,
-                         /*num_args_checked=*/2);
+        current_instructions += InstanceCall(
+            TokenPosition::kNoSource, Symbols::EqualOperator(), Token::kEQ,
+            /*argument_count=*/2,
+            /*num_args_checked=*/2);
         current_instructions += BranchIfTrue(&then, &otherwise);
 
         Fragment then_fragment(then);
 
         if (body_join != NULL) {
           // There are several branches to the body, so we will make a goto to
           // the join block (the real body has already been prepended with a
           // join instruction).
           then_fragment += Goto(body_join);
         } else {
@@ skipping 99 matching lines @@
 
   otherwise_fragment += Constant(url);
   otherwise_fragment += PushArgument();  // url
 
   otherwise_fragment += IntConstant(0);
   otherwise_fragment += PushArgument();  // line
 
   otherwise_fragment += IntConstant(0);
   otherwise_fragment += PushArgument();  // column
 
-  otherwise_fragment += StaticCall(constructor, 5);
+  otherwise_fragment += StaticCall(TokenPosition::kNoSource, constructor, 5);
   otherwise_fragment += Drop();
 
   // Throw _AssertionError exception.
   otherwise_fragment += PushArgument();
-  otherwise_fragment += ThrowException();
+  otherwise_fragment += ThrowException(TokenPosition::kNoSource);
   otherwise_fragment += Drop();
 
   fragment_ = Fragment(instructions.entry, then);
 }
 
 
 void FlowGraphBuilder::VisitTryFinally(TryFinally* node) {
   InlineBailout("kernel::FlowgraphBuilder::VisitTryFinally");
 
   // There are 5 different cases where we need to execute the finally block:
@@ skipping 134 matching lines @@
       } else {
         catch_body += LoadLocal(CurrentException());
         catch_body += PushArgument();  // exception
         catch_body += NullConstant();
         catch_body += PushArgument();  // type arguments
         catch_body += Constant(*type_guard);
         catch_body += PushArgument();  // guard type
         catch_body += Constant(Object::bool_false());
         catch_body += PushArgument();  // negate
         catch_body += InstanceCall(
+            TokenPosition::kNoSource,
             dart::Library::PrivateCoreLibName(Symbols::_instanceOf()),
             Token::kIS, 4);
 
         TargetEntryInstr* catch_entry;
         TargetEntryInstr* next_catch_entry;
         catch_body += BranchIfTrue(&catch_entry, &next_catch_entry);
 
         Fragment(catch_entry) + catch_handler_body;
         catch_body = Fragment(next_catch_entry);
       }
@@ skipping 97 matching lines @@
 Fragment FlowGraphBuilder::TranslateFunctionNode(FunctionNode* node,
                                                  TreeNode* parent) {
   // The VM has a per-isolate table of functions indexed by the enclosing
   // function and token position.  We don't have token positions, so we've
   // simply numbered the immediately-nested functions with respect to the
   // parent.
   Function& function = Function::ZoneHandle(Z);
   for (intptr_t i = 0; i < scopes_->function_scopes.length(); ++i) {
     if (scopes_->function_scopes[i].function != node) continue;
 
+    // NOTE: This is not TokenPosition in the general sense!
     function = I->LookupClosureFunction(parsed_function_->function(),
                                         TokenPosition(i));
     if (function.IsNull()) {
       const dart::String* name;
       if (parent->IsFunctionExpression()) {
         name = &Symbols::AnonymousClosure();
       } else {
         ASSERT(parent->IsFunctionDeclaration());
         name = &H.DartSymbol(
             FunctionDeclaration::Cast(parent)->variable()->name());
       }
+      // NOTE: This is not TokenPosition in the general sense!
       function = Function::NewClosureFunction(
           *name, parsed_function_->function(), TokenPosition(i));
       function.set_is_debuggable(false);
       LocalScope* scope = scopes_->function_scopes[i].scope;
       const ContextScope& context_scope =
           ContextScope::Handle(Z, scope->PreserveOuterScope(context_depth_));
       function.set_context_scope(context_scope);
       function.set_kernel_function(node);
       KernelReader::SetupFunctionParameters(H, T, dart::Class::Handle(Z),
                                             function, node,
@@ skipping 27 matching lines @@
   instructions += LoadLocal(parsed_function_->current_context_var());
   instructions += StoreInstanceField(Closure::context_offset());
 
   return instructions;
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)