Hit breakpoints in single line closures.

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 461 matching lines @@
   const String& func_name = String::Handle(func.name());
   Class& func_class = Class::Handle(func.Owner());
   String& class_name = String::Handle(func_class.Name());
 
   return OS::SCreate(Thread::Current()->zone(), "%s%s%s",
                      func_class.IsTopLevel() ? "" : class_name.ToCString(),
                      func_class.IsTopLevel() ? "" : ".", func_name.ToCString());
 }
 
 
-// Returns true if function contains the token position in the given script.
-static bool FunctionContains(const Function& func,
+// Returns true if the function |func| overlaps the token range
+// [|token_pos|, |end_token_pos|] in |script|.
+static bool FunctionOverlaps(const Function& func,
                              const Script& script,
-                             TokenPosition token_pos) {
-  if ((func.token_pos() <= token_pos) && (token_pos <= func.end_token_pos())) {
+                             TokenPosition token_pos,
+                             TokenPosition end_token_pos) {
+  TokenPosition func_start = func.token_pos();
+  if (((func_start <= token_pos) && (token_pos <= func.end_token_pos())) ||
+      ((token_pos <= func_start) && (func_start <= end_token_pos))) {
     // Check script equality second because it allocates
     // handles as a side effect.
     return func.script() == script.raw();
   }
   return false;
 }
 
 
+static bool IsImplicitFunction(const Function& func) {
+  switch (func.kind()) {
+    case RawFunction::kImplicitGetter:
+    case RawFunction::kImplicitSetter:
+    case RawFunction::kImplicitStaticFinalGetter:
+      return true;
+    default:
+      return false;
+  }
+}
+
+
 bool Debugger::HasBreakpoint(const Function& func, Zone* zone) {
   if (!func.HasCode()) {
     // If the function is not compiled yet, just check whether there
     // is a user-defined breakpoint that falls into the token
     // range of the function. This may be a false positive: the breakpoint
     // might be inside a local closure.
     Script& script = Script::Handle(zone);
     BreakpointLocation* sbpt = breakpoint_locations_;
     while (sbpt != NULL) {
       script = sbpt->script();
-      if (FunctionContains(func, script, sbpt->token_pos())) {
+      if (FunctionOverlaps(func, script, sbpt->token_pos(),
+                           sbpt->end_token_pos())) {
         return true;
       }
       sbpt = sbpt->next_;
     }
     return false;
   }
   CodeBreakpoint* cbpt = code_breakpoints_;
   while (cbpt != NULL) {
     if (func.raw() == cbpt->function()) {
       return true;
@@ skipping 2127 matching lines @@
     *best_fit = func->raw();
   } else {
     if ((func->token_pos() > best_fit->token_pos()) &&
         ((func->end_token_pos() <= best_fit->end_token_pos()))) {
       *best_fit = func->raw();
     }
   }
 }
 
 
-static bool IsTokenPosWithinFunction(const Function& func, TokenPosition pos) {
-  return (func.token_pos() <= pos && pos <= func.end_token_pos());
-}
-
-
 // Returns true if a best fit is found. A best fit can either be a function
 // or a field. If it is a function, then the best fit function is returned
 // in |best_fit|. If a best fit is a field, it means that a latent
 // breakpoint can be set in the range |token_pos| to |last_token_pos|.
 bool Debugger::FindBestFit(const Script& script,
                            TokenPosition token_pos,
                            TokenPosition last_token_pos,
                            Function* best_fit) {
   Zone* zone = Thread::Current()->zone();
   Class& cls = Class::Handle(zone);
   const GrowableObjectArray& closures = GrowableObjectArray::Handle(
       zone, isolate_->object_store()->closure_functions());
   Array& functions = Array::Handle(zone);
   Function& function = Function::Handle(zone);
   Array& fields = Array::Handle(zone);
   Field& field = Field::Handle(zone);
   Error& error = Error::Handle(zone);
 
   const intptr_t num_closures = closures.Length();
   for (intptr_t i = 0; i < num_closures; i++) {
     function ^= closures.At(i);
-    if (function.script() != script.raw()) {
-      continue;
-    }
-    if (IsTokenPosWithinFunction(function, token_pos)) {
+    if (FunctionOverlaps(function, script, token_pos, last_token_pos)) {
       // Select the inner most closure.
       SelectBestFit(best_fit, &function);
     }
   }
   if (!best_fit->IsNull()) {
     // The inner most closure found will be the best fit. Going
     // over class functions below will not help in any further
     // narrowing.
     return true;
   }
@@ skipping 16 matching lines @@
       // EnsureIsFinalized only returns an error object if there
       // is no longjump base on the stack.
       continue;
     }
     functions = cls.functions();
     if (!functions.IsNull()) {
       const intptr_t num_functions = functions.Length();
       for (intptr_t pos = 0; pos < num_functions; pos++) {
         function ^= functions.At(pos);
         ASSERT(!function.IsNull());
-        if (IsTokenPosWithinFunction(function, token_pos)) {
+        if (IsImplicitFunction(function)) {

[siva, 2017/05/31 19:20:54]

Should this also include other function types that do not have a source e.g:
kInvokeFieldDispatcher, kNoSuchMethodDispatcher, kMethodExtractor,
kIrregexpFunction

[sivachandra, 2017/05/31 20:16:46]

Likewise, I think there are implicit constructors as well? AFAICT, there is no
kind for an implicit constructor. Do you think we should use a heuristic like
start_token_pos == end_token_pos to determine whether a function is an implicit
function? This will cover the implicit constructors as well.

+          // Implicit functions do not have a user specifiable source
+          // location.
+          continue;
+        }
+        if (FunctionOverlaps(function, script, token_pos, last_token_pos)) {
           // Closures and inner functions within a class method are not
           // present in the functions of a class. Hence, we can return
           // right away as looking through other functions of a class
           // will not narrow down to any inner function/closure.
           *best_fit = function.raw();
           return true;
         }
       }
     }
     // If none of the functions in the class contain token_pos, then we
@@ skipping 1307 matching lines @@
     // we'll resolve the breakpoint when the inner function is compiled.
     return;
   }
   // Iterate over all source breakpoints to check whether breakpoints
   // need to be set in the newly compiled function.
   Zone* zone = Thread::Current()->zone();
   Script& script = Script::Handle(zone);
   for (BreakpointLocation* loc = breakpoint_locations_; loc != NULL;
        loc = loc->next()) {
     script = loc->script();
-    if (FunctionContains(func, script, loc->token_pos())) {
+    if (FunctionOverlaps(func, script, loc->token_pos(),
+                         loc->end_token_pos())) {
       Function& inner_function = Function::Handle(zone);
       inner_function = FindInnermostClosure(func, loc->token_pos());
       if (!inner_function.IsNull()) {
         // The local function of a function we just compiled cannot
         // be compiled already.
         ASSERT(!inner_function.HasCode());
         if (FLAG_verbose_debug) {
           OS::Print("Pending BP remains unresolved in inner function '%s'\n",
                     inner_function.ToFullyQualifiedCString());
         }
@@ skipping 423 matching lines @@
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart