Revert "Debugging in kernel shaping up."

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 348 matching lines @@
             Symbols::TypeArgumentsParameter(), AbstractType::dynamic_type());
         scope_->InsertParameterAt(pos++, variable);
         result_->type_arguments_variable = variable;
       }
       AddParameters(node, pos);
 
       // We generate a syntethic body for implicit closure functions - which
       // will forward the call to the real function.
       //     -> see BuildGraphOfImplicitClosureFunction
       if (!function.IsImplicitClosureFunction()) {
-        // TODO(jensj): HACK: Push the begin token to after any parameters to
-        // avoid crash when breaking on definition line of async method in
-        // debugger. It seems that another scope needs to be added
-        // in which captures are made, but I can't make that work.
-        // This 'solution' doesn't crash, but I cannot see the parameters at
-        // that particular breakpoint either.
-        // Also push the end token to after the "}" to avoid crashing on
-        // stepping past the last line (to the "}" character).
-        if (node->body() != NULL && node->body()->position().IsReal()) {
-          scope_->set_begin_token_pos(node->body()->position());
-        }
-        if (scope_->end_token_pos().IsReal()) {
-          scope_->set_end_token_pos(scope_->end_token_pos().Next());
-        }
         node_->AcceptVisitor(this);
       }
       break;
     }
     case RawFunction::kImplicitGetter:
     case RawFunction::kImplicitStaticFinalGetter:
     case RawFunction::kImplicitSetter: {
       ASSERT(node_->IsField());
       if (IsStaticInitializer(function, Z)) {
         node_->AcceptVisitor(this);
@@ skipping 2149 matching lines @@
   argument->set_temp_index(argument->temp_index() - 1);
   ++pending_argument_count_;
 
   return Fragment(argument);
 }
 
 
 Fragment FlowGraphBuilder::Return(TokenPosition position) {
   Value* value = Pop();
   ASSERT(stack_ == NULL);
-
-  Fragment fragment;
-
-  const Function& function = parsed_function_->function();
-  if (FLAG_support_debugger && position.IsDebugPause() &&
-      !function.is_native()) {
-    fragment <<=
-        new (Z) DebugStepCheckInstr(position, RawPcDescriptors::kRuntimeCall);
-  }
-
-  ReturnInstr* return_instr = new (Z) ReturnInstr(position, value);
+  ReturnInstr* return_instr =
+      new (Z) ReturnInstr(TokenPosition::kNoSource, value);
   if (exit_collector_ != NULL) exit_collector_->AddExit(return_instr);
-  fragment <<= return_instr;
-  return fragment.closed();
+  return Fragment(return_instr).closed();
 }
 
 
 Fragment FlowGraphBuilder::StaticCall(TokenPosition position,
                                       const Function& target,
                                       intptr_t argument_count) {
   return StaticCall(position, target, argument_count, Array::null_array());
 }
 
 
@@ skipping 103 matching lines @@
                                       LocalVariable* variable) {
   Fragment instructions;
   if (variable->is_captured()) {
     LocalVariable* value = MakeTemporary();
     instructions += LoadContextAt(variable->owner()->context_level());
     instructions += LoadLocal(value);
     instructions +=
         StoreInstanceField(Context::variable_offset(variable->index()));
   } else {
     Value* value = Pop();
-    if (FLAG_support_debugger && position.IsDebugPause() &&
-        !variable->IsInternal()) {
-      if (value->definition()->IsConstant() ||
-          value->definition()->IsAllocateObject() ||
-          (value->definition()->IsLoadLocal() &&
-           !value->definition()->AsLoadLocal()->local().IsInternal())) {
-        instructions <<= new (Z)
-            DebugStepCheckInstr(position, RawPcDescriptors::kRuntimeCall);
-      }
-    }
-
     StoreLocalInstr* store =
         new (Z) StoreLocalInstr(*variable, value, position);
     instructions <<= store;
     Push(store);
   }
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::StoreStaticField(const dart::Field& field) {
@@ skipping 493 matching lines @@
 
       // False branch will contain the next comparison.
       dispatch = Fragment(dispatch.entry, otherwise);
       block = otherwise;
     }
     body = dispatch;
 
     context_depth_ = current_context_depth;
   }
 
-  if (FLAG_support_debugger && function->position().IsDebugPause() &&
-      !dart_function.is_native() && dart_function.is_debuggable()) {
-    // If a switch was added above: Start the switch by injecting a debugable
-    // safepoint so stepping over an await works.
-    // If not, still start the body with a debugable safepoint to ensure
-    // breaking on a method always happens, even if there are no
-    // assignments/calls/runtimecalls in the first basic block.
-    // Place this check at the last parameter to ensure parameters
-    // are in scope in the debugger at method entry.
-    const int num_params = dart_function.NumParameters();
-    TokenPosition check_pos = TokenPosition::kNoSource;
-    if (num_params > 0) {
-      LocalScope* scope = parsed_function_->node_sequence()->scope();
-      const LocalVariable& parameter = *scope->VariableAt(num_params - 1);
-      check_pos = parameter.token_pos();
-    }
-    if (!check_pos.IsDebugPause()) {
-      // No parameters or synthetic parameters.
-      check_pos = function->position();
-      ASSERT(check_pos.IsDebugPause());
-    }
-    Fragment check(
-        new (Z) DebugStepCheckInstr(check_pos, RawPcDescriptors::kRuntimeCall));
-    body = check + body;
-  }
-
   normal_entry->LinkTo(body.entry);
 
   // When compiling for OSR, use a depth first search to prune instructions
   // unreachable from the OSR entry. Catch entries are always considered
   // reachable, even if they become unreachable after OSR.
   if (osr_id_ != Compiler::kNoOSRDeoptId) {
     BitVector* block_marks = new (Z) BitVector(Z, next_block_id_);
     bool found = graph_entry_->PruneUnreachable(graph_entry_, NULL, osr_id_,
                                                 block_marks);
     ASSERT(found);
@@ skipping 2857 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)