Source position tests for switch and try catch finally

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 "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/compiler.h"
@@ skipping 836 matching lines @@
 
 
 Definition* EffectGraphVisitor::BuildStoreLocal(const LocalVariable& local,
                                                 Value* value,
                                                 intptr_t token_pos) {
   if (local.is_captured()) {
     LocalVariable* tmp_var = EnterTempLocalScope(value);
     intptr_t delta =
         owner()->context_level() - local.owner()->context_level();
     ASSERT(delta >= 0);
-    Value* context = Bind(BuildCurrentContext());
+    Value* context = Bind(BuildCurrentContext(token_pos));
     while (delta-- > 0) {
       context = Bind(new(Z) LoadFieldInstr(
           context, Context::parent_offset(), Type::ZoneHandle(Z, Type::null()),
           token_pos));
     }
     Value* tmp_val = Bind(new(Z) LoadLocalInstr(*tmp_var));
     StoreInstanceFieldInstr* store =
         new(Z) StoreInstanceFieldInstr(Context::variable_offset(local.index()),
                                        context,
                                        tmp_val,
                                        kEmitStoreBarrier,
                                        token_pos);
     Do(store);
     return ExitTempLocalScope(tmp_var);
   } else {
     return new(Z) StoreLocalInstr(local, value, token_pos);
   }
 }
 
 
 Definition* EffectGraphVisitor::BuildLoadLocal(const LocalVariable& local,
                                                intptr_t token_pos) {
   if (local.IsConst()) {
     return new(Z) ConstantInstr(*local.ConstValue(), token_pos);
   } else if (local.is_captured()) {
     intptr_t delta =
         owner()->context_level() - local.owner()->context_level();
     ASSERT(delta >= 0);
-    Value* context = Bind(BuildCurrentContext());
+    Value* context = Bind(BuildCurrentContext(token_pos));
     while (delta-- > 0) {
       context = Bind(new(Z) LoadFieldInstr(
           context, Context::parent_offset(), Type::ZoneHandle(Z, Type::null()),
           token_pos));
     }
     return new(Z) LoadFieldInstr(context,
                                  Context::variable_offset(local.index()),
                                  local.type(),
                                  token_pos);
   } else {
     return new(Z) LoadLocalInstr(local, token_pos);
   }
 }
 
 
 // Stores current context into the 'variable'
-void EffectGraphVisitor::BuildSaveContext(const LocalVariable& variable) {
-  Value* context = Bind(BuildCurrentContext());
-  Do(BuildStoreLocal(variable, context));
+void EffectGraphVisitor::BuildSaveContext(
+    const LocalVariable& variable,
+    intptr_t token_pos) {
+  Value* context = Bind(BuildCurrentContext(token_pos));
+  Do(BuildStoreLocal(variable, context, token_pos));
 }
 
 
 // Loads context saved in 'context_variable' into the current context.
-void EffectGraphVisitor::BuildRestoreContext(const LocalVariable& variable) {
-  Value* load_saved_context = Bind(BuildLoadLocal(variable));
-  Do(BuildStoreContext(load_saved_context));
+void EffectGraphVisitor::BuildRestoreContext(
+    const LocalVariable& variable,
+    intptr_t token_pos) {
+  Value* load_saved_context = Bind(BuildLoadLocal(variable, token_pos));
+  Do(BuildStoreContext(load_saved_context, token_pos));
 }
 
 
-Definition* EffectGraphVisitor::BuildStoreContext(Value* value) {
+Definition* EffectGraphVisitor::BuildStoreContext(
+    Value* value, intptr_t token_pos) {
   return new(Z) StoreLocalInstr(
-      *owner()->parsed_function().current_context_var(), value);
+      *owner()->parsed_function().current_context_var(), value, token_pos);
 }
 
 
-Definition* EffectGraphVisitor::BuildCurrentContext() {
+Definition* EffectGraphVisitor::BuildCurrentContext(intptr_t token_pos) {
   return new(Z) LoadLocalInstr(
-      *owner()->parsed_function().current_context_var());
+      *owner()->parsed_function().current_context_var(),
+      token_pos);
 }
 
 
 void TestGraphVisitor::ConnectBranchesTo(
     const GrowableArray<TargetEntryInstr**>& branches,
     JoinEntryInstr* join) const {
   ASSERT(!branches.is_empty());
   for (intptr_t i = 0; i < branches.length(); i++) {
     TargetEntryInstr* target =
         new(Z) TargetEntryInstr(owner()->AllocateBlockId(),
@@ skipping 184 matching lines @@
       (node->token_pos() >= 0) && !function.is_native()) {
     AddInstruction(new(Z) DebugStepCheckInstr(node->token_pos(),
                                               RawPcDescriptors::kRuntimeCall));
   }
 
   NestedContextAdjustment context_adjustment(owner(), owner()->context_level());
 
   if (node->inlined_finally_list_length() > 0) {
     LocalVariable* temp = owner()->parsed_function().finally_return_temp_var();
     ASSERT(temp != NULL);
-    Do(BuildStoreLocal(*temp, return_value));
+    Do(BuildStoreLocal(*temp, return_value, node->token_pos()));
     for (intptr_t i = 0; i < node->inlined_finally_list_length(); i++) {
       InlineBailout("EffectGraphVisitor::VisitReturnNode (exception)");
       EffectGraphVisitor for_effect(owner());
       node->InlinedFinallyNodeAt(i)->Visit(&for_effect);
       Append(for_effect);
       if (!is_open()) {
         return;
       }
     }
-    return_value = Bind(BuildLoadLocal(*temp));
+    return_value = Bind(BuildLoadLocal(*temp, node->token_pos()));
   }
 
   if (Isolate::Current()->flags().type_checks()) {
     const bool is_implicit_dynamic_getter =
         (!function.is_static() &&
         ((function.kind() == RawFunction::kImplicitGetter) ||
          (function.kind() == RawFunction::kImplicitStaticFinalGetter)));
     // Implicit getters do not need a type check at return, unless they compute
     // the initial value of a static field.
     // The body of a constructor cannot modify the type of the
@@ skipping 21 matching lines @@
   if (function.IsAsyncClosure() &&
       (node->return_type() == ReturnNode::kRegular)) {
     // Temporary store the computed return value.
     Do(BuildStoreExprTemp(return_value));
 
     LocalVariable* rcv_var =
         node->scope()->LookupVariable(Symbols::AsyncCompleter(), false);
     ASSERT(rcv_var != NULL && rcv_var->is_captured());
     ZoneGrowableArray<PushArgumentInstr*>* arguments =
         new(Z) ZoneGrowableArray<PushArgumentInstr*>(2);
-    Value* rcv_value = Bind(BuildLoadLocal(*rcv_var));
+    Value* rcv_value = Bind(BuildLoadLocal(*rcv_var, node->token_pos()));
     arguments->Add(PushArgument(rcv_value));
     Value* returned_value = Bind(BuildLoadExprTemp());
     arguments->Add(PushArgument(returned_value));
     InstanceCallInstr* call = new(Z) InstanceCallInstr(
-        Scanner::kNoSourcePos,
+        node->token_pos(),
         Symbols::CompleterComplete(),
         Token::kILLEGAL,
         arguments,
         Object::null_array(),
         1,
         owner()->ic_data_array());
     Do(call);
 
     // Rebind the return value for the actual return call to be null.
     return_value = BuildNullValue();
@@ skipping 1081 matching lines @@
   const intptr_t jump_count = owner()->next_await_counter();
   ASSERT(jump_count >= 0);
   // Sanity check that we always add a JoinEntryInstr before adding a new
   // state.
   ASSERT(jump_count == owner()->await_joins()->length());
   // Store the counter in :await_jump_var.
   Value* jump_val = Bind(new(Z) ConstantInstr(
       Smi::ZoneHandle(Z, Smi::New(jump_count))));
   Do(BuildStoreLocal(*jump_var, jump_val));
   // Save the current context for resuming.
-  BuildSaveContext(*ctx_var);
+  BuildSaveContext(*ctx_var, node->token_pos());
 }
 
 
 intptr_t EffectGraphVisitor::GetCurrentTempLocalIndex() const {
   return kFirstLocalSlotFromFp
       - owner()->num_stack_locals()
       - owner()->num_copied_params()
       - owner()->args_pushed()
       - owner()->temp_count() + 1;
 }
@@ skipping 255 matching lines @@
         context_tmp_val = Bind(new(Z) LoadLocalInstr(*context_tmp_var));
         Do(new(Z) StoreInstanceFieldInstr(Closure::context_offset(),
                                           closure_tmp_val,
                                           context_tmp_val,
                                           kEmitStoreBarrier,
                                           node->token_pos()));
         Do(ExitTempLocalScope(context_tmp_var));
       }
     } else {
       // Store current context in closure.
-      closure_tmp_val = Bind(new(Z) LoadLocalInstr(*closure_tmp_var));
-      Value* context = Bind(BuildCurrentContext());
+      closure_tmp_val = Bind(
+          new(Z) LoadLocalInstr(*closure_tmp_var, node->token_pos()));
+      Value* context = Bind(BuildCurrentContext(node->token_pos()));
       Do(new(Z) StoreInstanceFieldInstr(Closure::context_offset(),
                                         closure_tmp_val,
                                         context,
                                         kEmitStoreBarrier,
                                         node->token_pos()));
     }
     ReturnDefinition(ExitTempLocalScope(closure_tmp_var));
   }
 }
 
@@ skipping 187 matching lines @@
 }
 
 
 void EffectGraphVisitor::VisitInitStaticFieldNode(InitStaticFieldNode* node) {
   Value* field = Bind(new(Z) ConstantInstr(node->field()));
   AddInstruction(new(Z) InitStaticFieldInstr(field, node->field()));
 }
 
 
 void EffectGraphVisitor::VisitCloneContextNode(CloneContextNode* node) {
-  Value* context = Bind(BuildCurrentContext());
+  Value* context = Bind(BuildCurrentContext(node->token_pos()));
   Value* clone = Bind(new(Z) CloneContextInstr(node->token_pos(), context));
-  Do(BuildStoreContext(clone));
+  Do(BuildStoreContext(clone, node->token_pos()));
 }
 
 
 Value* EffectGraphVisitor::BuildObjectAllocation(ConstructorCallNode* node) {
   const Class& cls = Class::ZoneHandle(Z, node->constructor().Owner());
   const bool cls_is_parameterized = cls.NumTypeArguments() > 0;
 
   ZoneGrowableArray<PushArgumentInstr*>* allocate_arguments =
       new(Z) ZoneGrowableArray<PushArgumentInstr*>(
           cls_is_parameterized ? 1 : 0);
@@ skipping 1143 matching lines @@
 
 
 bool EffectGraphVisitor::HasContextScope() const {
   const ContextScope& context_scope = ContextScope::Handle(
       owner()->function().context_scope());
   return !context_scope.IsNull() && (context_scope.num_variables() > 0);
 }
 
 
 void EffectGraphVisitor::UnchainContexts(intptr_t n) {
+  // TODO(johnmccutchan): Pass this in.
+  const intptr_t token_pos = ClassifyingTokenPositions::kContext;
   if (n > 0) {
-    Value* context = Bind(BuildCurrentContext());
+    Value* context = Bind(BuildCurrentContext(token_pos));
     while (n-- > 0) {
       context = Bind(
           new(Z) LoadFieldInstr(context,
                                 Context::parent_offset(),
                                 // Not an instance, no type.
                                 Type::ZoneHandle(Z, Type::null()),
-                                Scanner::kNoSourcePos));
+                                token_pos));
     }
-    Do(BuildStoreContext(context));
+    Do(BuildStoreContext(context, token_pos));
   }
 }
 
 
 void EffectGraphVisitor::AdjustContextLevel(LocalScope* target_scope) {
   ASSERT(target_scope != NULL);
   intptr_t target_context_level = 0;
   if (target_scope->num_context_variables() > 0) {
     // The scope of the target label allocates a context, therefore its outer
     // scope is at a lower context level.
@@ skipping 37 matching lines @@
     // Allocate and chain a new context (Except don't chain when at the function
     // entry if the function does not capture any variables from outer scopes).
     Value* allocated_context =
         Bind(new(Z) AllocateContextInstr(node->token_pos(),
                                          num_context_variables));
     { LocalVariable* tmp_var = EnterTempLocalScope(allocated_context);
       if (!is_top_level_sequence || HasContextScope()) {
         ASSERT(is_top_level_sequence ||
                (nested_block.ContextLevel() ==
                 nested_block.outer()->ContextLevel() + 1));
-        Value* tmp_val = Bind(new(Z) LoadLocalInstr(*tmp_var));
-        Value* parent_context = Bind(BuildCurrentContext());
+        Value* tmp_val = Bind(
+            new(Z) LoadLocalInstr(*tmp_var, node->token_pos()));
+        Value* parent_context = Bind(BuildCurrentContext(node->token_pos()));
         Do(new(Z) StoreInstanceFieldInstr(Context::parent_offset(),
                                           tmp_val,
                                           parent_context,
                                           kEmitStoreBarrier,
-                                          Scanner::kNoSourcePos));
+                                          node->token_pos()));
       }
-      Do(BuildStoreContext(Bind(ExitTempLocalScope(tmp_var))));
+      Do(BuildStoreContext(
+          Bind(ExitTempLocalScope(tmp_var)),
+          node->token_pos()));
     }
 
     // If this node_sequence is the body of the function being compiled, copy
     // the captured parameters from the frame into the context.
     if (is_top_level_sequence) {
       ASSERT(scope->context_level() == 1);
       const int num_params = function.NumParameters();
       int param_frame_index = (num_params == function.num_fixed_parameters()) ?
           (kParamEndSlotFromFp + num_params) : kFirstLocalSlotFromFp;
       for (int pos = 0; pos < num_params; param_frame_index--, pos++) {
@@ skipping 161 matching lines @@
       EffectGraphVisitor for_true(owner());
       EffectGraphVisitor for_false(owner());
 
       // Build async jump or sync yield jump.
       ASSERT(function.IsAsyncClosure() ||
              function.IsAsyncGenClosure() ||
              function.IsSyncGenClosure());
 
       // Restore the saved continuation context, i.e. the context that was
       // saved into :await_ctx_var before the closure suspended.
-      for_true.BuildRestoreContext(*old_context);
+      for_true.BuildRestoreContext(*old_context, Scanner::kNoSourcePos);
 
       // Goto saved join.
       for_true.Goto((*owner()->await_joins())[i]);
 
       Join(for_test, for_true, for_false);
       if (i == 0) {
         // Manually link up the preamble start.
         preamble_start->previous()->set_next(for_test.entry());
         for_test.entry()->set_previous(preamble_start->previous());
       }
@@ skipping 21 matching lines @@
   if (nested_block.break_target() != NULL) {
     if (is_open()) Goto(nested_block.break_target());
     exit_ = nested_block.break_target();
   }
 }
 
 
 void EffectGraphVisitor::VisitCatchClauseNode(CatchClauseNode* node) {
   InlineBailout("EffectGraphVisitor::VisitCatchClauseNode (exception)");
   // Restores current context from local variable ':saved_try_context_var'.
-  BuildRestoreContext(node->context_var());
+  BuildRestoreContext(node->context_var(), node->token_pos());
 
   EffectGraphVisitor for_catch(owner());
   node->VisitChildren(&for_catch);
   Append(for_catch);
 }
 
 
 void EffectGraphVisitor::VisitTryCatchNode(TryCatchNode* node) {
   InlineBailout("EffectGraphVisitor::VisitTryCatchNode (exception)");
   const intptr_t original_handler_index = owner()->try_index();
   const intptr_t try_handler_index = node->try_index();
   ASSERT(try_handler_index != original_handler_index);
   owner()->set_try_index(try_handler_index);
 
   // Preserve current context into local variable ':saved_try_context_var'.
-  BuildSaveContext(node->context_var());
+  BuildSaveContext(node->context_var(), node->token_pos());
 
   EffectGraphVisitor for_try(owner());
   node->try_block()->Visit(&for_try);
 
   if (for_try.is_open()) {
     JoinEntryInstr* after_try =
         new(Z) JoinEntryInstr(owner()->AllocateBlockId(),
                               original_handler_index);
     for_try.Goto(after_try);
     for_try.exit_ = after_try;
@@ skipping 50 matching lines @@
     if (is_open()) Goto(join);
     exit_ = join;
   }
 
   if (finally_block != NULL) {
     ASSERT(node->rethrow_clause() != NULL);
     // Create a handler for the code in the catch block, containing the
     // code in the finally block.
     owner()->set_try_index(original_handler_index);
     EffectGraphVisitor for_finally(owner());
-    for_finally.BuildRestoreContext(catch_block->context_var());
+    for_finally.BuildRestoreContext(catch_block->context_var(),
+                                    finally_block->token_pos());
 
     node->rethrow_clause()->Visit(&for_finally);
     if (for_finally.is_open()) {
       // Rethrow the exception.  Manually build the graph for rethrow.
       Value* exception = for_finally.Bind(
           for_finally.BuildLoadLocal(catch_block->rethrow_exception_var()));
       for_finally.PushArgument(exception);
       Value* stacktrace = for_finally.Bind(
           for_finally.BuildLoadLocal(catch_block->rethrow_stacktrace_var()));
       for_finally.PushArgument(stacktrace);
@@ skipping 271 matching lines @@
   Report::MessageF(Report::kBailout,
                    Script::Handle(function.script()),
                    function.token_pos(),
                    "FlowGraphBuilder Bailout: %s %s",
                    String::Handle(function.name()).ToCString(),
                    reason);
   UNREACHABLE();
 }
 
 }  // namespace dart