TokenPositions on more nodes when running from Kernel

runtime/vm/debugger.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/debugger.h"
 
 #include "include/dart_api.h"
 
 #include "platform/address_sanitizer.h"
 
@@ skipping 1753 matching lines @@
   Zone* zone = Thread::Current()->zone();
   Script& script = Script::Handle(zone, func.script());
   Code& code = Code::Handle(zone, func.unoptimized_code());
   ASSERT(!code.IsNull());
   PcDescriptors& desc = PcDescriptors::Handle(zone, code.pc_descriptors());
 
   // First pass: find the safe point which is closest to the beginning
   // of the given token range.
   TokenPosition best_fit_pos = TokenPosition::kMaxSource;
   intptr_t best_column = INT_MAX;
+  intptr_t best_line = INT_MAX;
   PcDescriptors::Iterator iter(desc, kSafepointKind);
   while (iter.MoveNext()) {
     const TokenPosition pos = iter.TokenPos();
     if ((!pos.IsReal()) || (pos < requested_token_pos) ||
         (pos > last_token_pos)) {
       // Token is not in the target range.
       continue;
     }
 
     intptr_t token_start_column = -1;
+    intptr_t token_line = -1;
     if (requested_column >= 0) {
-      intptr_t ignored = -1;
       intptr_t token_len = -1;
       // TODO(turnidge): GetTokenLocation is a very expensive
       // operation, and this code will blow up when we are setting
       // column breakpoints on, for example, a large, single-line
       // program.  Consider rewriting this code so that it only scans
       // the program code once and caches the token positions and
       // lengths.
-      script.GetTokenLocation(pos, &ignored, &token_start_column, &token_len);
+      script.GetTokenLocation(pos, &token_line, &token_start_column,
+                              &token_len);
       intptr_t token_end_column = token_start_column + token_len - 1;
       if ((token_end_column < requested_column) ||
           (token_start_column > best_column)) {
         // Prefer the token with the lowest column number compatible
         // with the requested column.
         continue;
       }
     }
 
     // Prefer the lowest (first) token pos.
     if (pos < best_fit_pos) {
       best_fit_pos = pos;
+      best_line = token_line;
       best_column = token_start_column;
     }
   }
 
   // Second pass (if we found a safe point in the first pass).  Find
   // the token on the line which is at the best fit column (if column
   // was specified) and has the lowest code address.
   if (best_fit_pos != TokenPosition::kMaxSource) {
     const Script& script = Script::Handle(zone, func.script());
-    const TokenStream& tokens = TokenStream::Handle(zone, script.tokens());
     const TokenPosition begin_pos = best_fit_pos;
-    const TokenPosition end_of_line_pos =
-        LastTokenOnLine(zone, tokens, begin_pos);
+
+    TokenPosition end_of_line_pos;
+    if (script.kind() == RawScript::kKernelTag) {
+      if (best_line == -1) {
+        script.GetTokenLocation(begin_pos, &best_line, NULL);
+      }
+      ASSERT(best_line > 0);
+      TokenPosition ignored;
+      script.TokenRangeAtLine(best_line, &ignored, &end_of_line_pos);
+      if (end_of_line_pos < begin_pos) {
+        end_of_line_pos = begin_pos;
+      }
+    } else {
+      const TokenStream& tokens = TokenStream::Handle(zone, script.tokens());
+      end_of_line_pos = LastTokenOnLine(zone, tokens, begin_pos);
+    }
+
     uword lowest_pc_offset = kUwordMax;
     PcDescriptors::Iterator iter(desc, kSafepointKind);
     while (iter.MoveNext()) {
       const TokenPosition pos = iter.TokenPos();
       if (!pos.IsReal() || (pos < begin_pos) || (pos > end_of_line_pos)) {
         // Token is not on same line as best fit.
         continue;
       }
 
       if (requested_column >= 0) {
@@ skipping 1075 matching lines @@
 
 
 bool Debugger::IsAtAsyncJump(ActivationFrame* top_frame) {
   Zone* zone = Thread::Current()->zone();
   Object& closure_or_null =
       Object::Handle(zone, top_frame->GetAsyncOperation());
   if (!closure_or_null.IsNull()) {
     ASSERT(closure_or_null.IsInstance());
     ASSERT(Instance::Cast(closure_or_null).IsClosure());
     const Script& script = Script::Handle(zone, top_frame->SourceScript());
+    if (script.kind() == RawScript::kKernelTag) {
+      return false;
+    }
     const TokenStream& tokens = TokenStream::Handle(zone, script.tokens());
     TokenStream::Iterator iter(zone, tokens, top_frame->TokenPos());
     if ((iter.CurrentTokenKind() == Token::kIDENT) &&
         ((iter.CurrentLiteral() == Symbols::Await().raw()) ||
          (iter.CurrentLiteral() == Symbols::YieldKw().raw()))) {
       return true;
     }
   }
   return false;
 }
@@ skipping 655 matching lines @@
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart