Support column-based breakpoints in the VM and Observatory.

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 "vm/code_generator.h"
 #include "vm/code_patcher.h"
@@ skipping 47 matching lines @@
  private:
   GrowableObjectArray* objs_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoteObjectCache);
 };
 
 
 // Create an unresolved breakpoint in given token range and script.
 BreakpointLocation::BreakpointLocation(const Script& script,
                                        intptr_t token_pos,
-                                       intptr_t end_token_pos)
+                                       intptr_t end_token_pos,
+                                       intptr_t requested_column_number)
     : script_(script.raw()),
       url_(script.url()),
       token_pos_(token_pos),
       end_token_pos_(end_token_pos),
       is_resolved_(false),
       next_(NULL),
       conditions_(NULL),
+      requested_line_number_(-1),
+      requested_column_number_(requested_column_number),
       function_(Function::null()),
-      line_number_(-1) {
+      line_number_(-1),
+      column_number_(-1) {
   ASSERT(!script.IsNull());
   ASSERT(token_pos_ >= 0);
 }
 
 // Create a latent breakpoint at given url and line number.
 BreakpointLocation::BreakpointLocation(const String& url,
-                                       intptr_t line_number)
+                                       intptr_t requested_line_number,
+                                       intptr_t requested_column_number)
     : script_(Script::null()),
       url_(url.raw()),
       token_pos_(-1),
       end_token_pos_(-1),
       is_resolved_(false),
       next_(NULL),
       conditions_(NULL),
+      requested_line_number_(requested_line_number),
+      requested_column_number_(requested_column_number),
       function_(Function::null()),
-      line_number_(line_number) {
+      line_number_(-1),
+      column_number_(-1) {
   ASSERT(line_number_ >= 0);

[hausner, 2015/09/03 00:37:50]

This assert would fire right away, since the field is initialized to -1. 

It looks like this constructor is not executed in our tests.

[turnidge, 2015/09/04 18:05:29]

Thanks.  I have added a set of tests for latent breakpoint to my CLs.

 }
 
 
 BreakpointLocation::~BreakpointLocation() {
   Breakpoint* bpt = breakpoints();
   while (bpt != NULL) {
     Breakpoint* temp = bpt;
     bpt = bpt->next();
     delete temp;
   }
 }
 
 
 bool BreakpointLocation::AnyEnabled() const {
   return breakpoints() != NULL;
 }
 
 
 void BreakpointLocation::SetResolved(const Function& func, intptr_t token_pos) {
   ASSERT(!IsLatent());
   ASSERT(func.script() == script_);
   ASSERT((func.token_pos() <= token_pos) &&
          (token_pos <= func.end_token_pos()));
   ASSERT(func.is_debuggable());
   function_ = func.raw();
   token_pos_ = token_pos;
   end_token_pos_ = token_pos;
-  line_number_ = -1;  // Recalculate lazily.

[hausner, 2015/09/03 00:37:50]

Why is it not necessary to recalculate the line number once we know the
definitive location of the breakpoint?

[turnidge, 2015/09/04 18:05:29]

After my change, the line number before resolution is stored in
requested_line_number_ and the line number after resolution is stored in
line_number_.  Because the field isn't being used for both things, the field is
still -1 from the constructor call.

   is_resolved_ = true;
 }
 
 
 // TODO(hausner): Get rid of library parameter. A source breakpoint location
 // does not imply a library, since the same source code can be included
 // in more than one library, e.g. the text location of mixin functions.
 void BreakpointLocation::GetCodeLocation(Library* lib,
                                          Script* script,
                                          intptr_t* pos) {
@@ skipping 10 matching lines @@
       const Class& cls = Class::Handle(func.origin());
       *lib = cls.library();
     } else {
       *lib = Library::null();
     }
   }
 }
 
 
 intptr_t BreakpointLocation::LineNumber() {
-  // Latent breakpoints must have a requested line number >= 0.
-  ASSERT(!IsLatent() || line_number_ >= 0);
+  ASSERT(IsResolved());
   // Compute line number lazily since it causes scanning of the script.
   if (line_number_ < 0) {
     const Script& script = Script::Handle(this->script());
     script.GetTokenLocation(token_pos_, &line_number_, NULL);
   }
   return line_number_;
 }
 
 
+intptr_t BreakpointLocation::ColumnNumber() {
+  ASSERT(IsResolved());
+  // Compute column number lazily since it causes scanning of the script.
+  if (column_number_ < 0) {
+    const Script& script = Script::Handle(this->script());
+    script.GetTokenLocation(token_pos_, &line_number_, &column_number_);
+  }
+  return column_number_;
+}
+
+
 void Breakpoint::set_bpt_location(BreakpointLocation* new_bpt_location) {
   ASSERT(bpt_location_->IsLatent());  // Only reason to move.
   bpt_location_ = new_bpt_location;
 }
 
 
 void Breakpoint::VisitObjectPointers(ObjectPointerVisitor* visitor) {
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&closure_));
 }
 
@@ skipping 1424 matching lines @@
     last_pos = iter.CurrentPosition();
     iter.Advance();
   }
   return last_pos;
 }
 
 
 // Given a function and a token range, return the best fit
 // token position to set a breakpoint. The best fit is the safe point
 // in the line closest to the beginning of the token range, and within
 // that line, the safe point with the lowest compiled code address.

[hausner, 2015/09/03 00:37:50]

Update the comment to describe how the requested column is taken into account?

[turnidge, 2015/09/04 18:05:29]

I updated this comment.  It turns out that, given the two-pass nature of the
algorithm, my attempts at a short explanation were lossy, so I put in a pretty
large comment.

 intptr_t Debugger::ResolveBreakpointPos(const Function& func,
                                         intptr_t requested_token_pos,
-                                        intptr_t last_token_pos) {
+                                        intptr_t last_token_pos,
+                                        intptr_t requested_column) {
   ASSERT(func.HasCode());
   ASSERT(!func.HasOptimizedCode());
 
   if (requested_token_pos < func.token_pos()) {
     requested_token_pos = func.token_pos();
   }
   if (last_token_pos > func.end_token_pos()) {
     last_token_pos = func.end_token_pos();
   }
 
+  Script& script = Script::Handle(func.script());
   Code& code = Code::Handle(func.unoptimized_code());
   ASSERT(!code.IsNull());
   PcDescriptors& desc = PcDescriptors::Handle(code.pc_descriptors());
 
   // First pass: find the safe point which is closest to the beginning
   // of the given token range.
   intptr_t best_fit_pos = INT_MAX;
+  intptr_t best_column = INT_MAX;
   PcDescriptors::Iterator iter(desc, kSafepointKind);
   while (iter.MoveNext()) {
-    const intptr_t desc_token_pos = iter.TokenPos();
-    if ((desc_token_pos != Scanner::kNoSourcePos) &&
-        (desc_token_pos < best_fit_pos) &&
-        (desc_token_pos >= requested_token_pos) &&
-        (desc_token_pos <= last_token_pos)) {
-       best_fit_pos = desc_token_pos;
+    const intptr_t pos = iter.TokenPos();
+    if ((pos == Scanner::kNoSourcePos) ||
+        (pos < requested_token_pos) ||
+        (pos > last_token_pos)) {
+      // Token is not in the target range.
+      continue;
+    }
+
+    intptr_t token_start_column = -1;
+    if (requested_column >= 0) {

[hausner, 2015/09/03 00:37:50]

Do I understand this code right:

If the caller requests a column that is past the last safe point in the line,
then you will look for the first token in the next line.

Shouldn't the breakpoint then resolve to the closest column *before* the
requested one (if one exists)?

[turnidge, 2015/09/04 18:05:29]

There is a kind of logic to the current implementation -- if you ask for a
breakpoint after the last safepoint token, you are asking for a breakpoint past
the current line.

For this line:

  var x = function(y);  // long coment here

If they specify a breakpoint in the comment, then they are stopping after the
code has executed, not before.  If they specify a breakpoint at column 1000000,
they are stopping after the code has executed.

This is also kind of consistent with the current behavior of when there is no
safepoint on the current line -- when we can't satisfy the constraints, search
forward.

I can see that this might confuse people down the path, but my preference is to
keep it as-is and change it if they complain.  Is that ok?

+      intptr_t ignored = -1;
+      intptr_t token_len = -1;
+      script.GetTokenLocation(pos, &ignored, &token_start_column, &token_len);

[hausner, 2015/09/03 00:37:50]

GetTokenLocation is a really expensive operation, especially when the column
position is requested. The source text has to be rescanned. And if we don't have
the source, it will be reconstructed from the token stream.

That said, I don't know how to avoid this other than caching token info details
for a function once a breakpoint is requested.

[turnidge, 2015/09/04 18:05:29]

I agree.  I have added a TODO/comment about this.  Perhaps I should implement a
caching approach in a follow-up CL?

+      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 over the
+        // requested column.
+        continue;
+      }
+    }
+
+    // Prefer the lowest (first) token pos.
+    if (pos < best_fit_pos) {
+      best_fit_pos = pos;
+      best_column = token_start_column;
     }
   }
+
   // Second pass (if we found a safe point in the first pass):
   // For all token positions on the same line, select the one
   // with the lowest compiled code address. E.g., in a line with
   // the nested function calls f(g(x)), the call g() will have a lower
   // compiled code address but is not the lowest token position in the

[hausner, 2015/09/03 00:37:50]

Could you please update the comment to include the column number explanation?

[turnidge, 2015/09/04 18:05:29]

Done.

   // line.
   if (best_fit_pos != INT_MAX) {
     const Script& script = Script::Handle(func.script());
     const TokenStream& tokens = TokenStream::Handle(script.tokens());
     const intptr_t begin_pos = best_fit_pos;
     const intptr_t end_of_line_pos = LastTokenOnLine(tokens, begin_pos);
     uword lowest_pc_offset = kUwordMax;
     PcDescriptors::Iterator iter(desc, kSafepointKind);
     while (iter.MoveNext()) {
       const intptr_t pos = iter.TokenPos();
-      if ((pos != Scanner::kNoSourcePos) &&
-          (begin_pos <= pos) && (pos <= end_of_line_pos) &&
-          (iter.PcOffset() < lowest_pc_offset)) {
+      if ((pos == Scanner::kNoSourcePos) ||
+          (pos < begin_pos) ||
+          (pos > end_of_line_pos)) {
+        // Token is not on same line as best fit.
+        continue;
+      }
+
+      if (requested_column >= 0) {
+        intptr_t ignored = -1;
+        intptr_t token_start_column = -1;
+        script.GetTokenLocation(pos, &ignored, &token_start_column);
+        if (token_start_column != best_column) {

[hausner, 2015/09/03 00:37:50]

Maybe comment that there may be more than one token PC descriptor at the same
token position (e.g. for implicitly generated code).

[turnidge, 2015/09/04 18:05:29]

Done.

+          continue;
+        }
+      }
+
+      // Prefer the lowest pc offset.
+      if (iter.PcOffset() < lowest_pc_offset) {
         lowest_pc_offset = iter.PcOffset();
         best_fit_pos = pos;
       }
     }
     return best_fit_pos;
   }
 
-  // We didn't find a safe point in the given token range. Try and find
-  // a safe point in the remaining source code of the function.
+  // We didn't find a safe point in the given token range. Try and
+  // find a safe point in the remaining source code of the function.
+  // Since we have moved to the next line of the function, we no
+  // longer are requesting a specific column number.
   if (last_token_pos < func.end_token_pos()) {
-    return ResolveBreakpointPos(func, last_token_pos, func.end_token_pos());
+    return ResolveBreakpointPos(func, last_token_pos, func.end_token_pos(),
+                                -1 /* no column */);
   }
   return -1;
 }
 
 
 void Debugger::MakeCodeBreakpointAt(const Function& func,
                                     BreakpointLocation* loc) {
   ASSERT(loc->token_pos_ != Scanner::kNoSourcePos);
   ASSERT((loc != NULL) && loc->IsResolved());
   ASSERT(!func.HasOptimizedCode());
@@ skipping 172 matching lines @@
         }
       }
     }
   }
   return best_fit.raw();
 }
 
 
 BreakpointLocation* Debugger::SetBreakpoint(const Script& script,
                                             intptr_t token_pos,
-                                            intptr_t last_token_pos) {
+                                            intptr_t last_token_pos,
+                                            intptr_t requested_column) {
   Function& func = Function::Handle(isolate_);
   func = FindBestFit(script, token_pos);
   if (func.IsNull()) {
     return NULL;
   }
   // There may be more than one function object for a given function
   // in source code. There may be implicit closure functions, and
   // there may be copies of mixin functions. Collect all compiled
   // functions whose source code range matches exactly the best fit
   // function we found.
   GrowableObjectArray& functions =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
   FindCompiledFunctions(script,
                         func.token_pos(),
                         func.end_token_pos(),
                         &functions);
 
   if (functions.Length() > 0) {
     // One or more function object containing this breakpoint location
     // have already been compiled. We can resolve the breakpoint now.
     DeoptimizeWorld();
     func ^= functions.At(0);
     intptr_t breakpoint_pos =
-        ResolveBreakpointPos(func, token_pos, last_token_pos);
+        ResolveBreakpointPos(func, token_pos, last_token_pos, requested_column);
     if (breakpoint_pos >= 0) {
-      BreakpointLocation* bpt = GetBreakpointLocation(script, breakpoint_pos);
+      BreakpointLocation* bpt =
+          GetBreakpointLocation(script, breakpoint_pos, requested_column);
       if (bpt != NULL) {
         // A source breakpoint for this location already exists.
         return bpt;
       }
-      bpt = new BreakpointLocation(script, token_pos, last_token_pos);
+      bpt = new BreakpointLocation(script, token_pos, last_token_pos,
+                                   requested_column);
       bpt->SetResolved(func, breakpoint_pos);
       RegisterBreakpointLocation(bpt);
 
       // Create code breakpoints for all compiled functions we found.
       const intptr_t num_functions = functions.Length();
       for (intptr_t i = 0; i < num_functions; i++) {
         func ^= functions.At(i);
         ASSERT(func.HasCode());
         MakeCodeBreakpointAt(func, bpt);
       }
       if (FLAG_verbose_debug) {
         intptr_t line_number;
-        script.GetTokenLocation(breakpoint_pos, &line_number, NULL);
+        intptr_t column_number;
+        script.GetTokenLocation(breakpoint_pos, &line_number, &column_number);
         OS::Print("Resolved BP for "
-                  "function '%s' at line %" Pd "\n",
+                  "function '%s' at line %" Pd " col %" Pd "\n",
                   func.ToFullyQualifiedCString(),
-                  line_number);
+                  line_number, column_number);
       }
       return bpt;
     }
   }
   // There is no compiled function at this token position.
   // Register an unresolved breakpoint.
   if (FLAG_verbose_debug && !func.IsNull()) {
     intptr_t line_number;
-    script.GetTokenLocation(token_pos, &line_number, NULL);
+    intptr_t column_number;
+    script.GetTokenLocation(token_pos, &line_number, &column_number);
     OS::Print("Registering pending breakpoint for "
-              "uncompiled function '%s' at line %" Pd "\n",
+              "uncompiled function '%s' at line %" Pd " col %" Pd "\n",
               func.ToFullyQualifiedCString(),
-              line_number);
+              line_number, column_number);
   }
-  BreakpointLocation* bpt = GetBreakpointLocation(script, token_pos);
+  BreakpointLocation* bpt =
+      GetBreakpointLocation(script, token_pos, requested_column);
   if (bpt == NULL) {
-    bpt = new BreakpointLocation(script, token_pos, last_token_pos);
+    bpt = new BreakpointLocation(script, token_pos, last_token_pos,
+                                 requested_column);
     RegisterBreakpointLocation(bpt);
   }
   return bpt;
 }
 
 
 // Synchronize the enabled/disabled state of all code breakpoints
 // associated with the breakpoint location loc.
 void Debugger::SyncBreakpointLocation(BreakpointLocation* loc) {
   bool any_enabled = loc->AnyEnabled();
@@ skipping 26 matching lines @@
 Breakpoint* Debugger::SetBreakpointAtEntry(const Function& target_function,
                                            bool single_shot) {
   ASSERT(!target_function.IsNull());
   if (!target_function.is_debuggable()) {
     return NULL;
   }
   const Script& script = Script::Handle(target_function.script());
   BreakpointLocation* bpt_location =
       SetBreakpoint(script,
                     target_function.token_pos(),
-                    target_function.end_token_pos());
+                    target_function.end_token_pos(),
+                    -1 /* no column */);
   if (single_shot) {
     return bpt_location->AddSingleShot(this);
   } else {
     return bpt_location->AddRepeated(this);
   }
 }
 
 
 Breakpoint* Debugger::SetBreakpointAtActivation(const Instance& closure) {
   if (!closure.IsClosure()) {
     return NULL;
   }
   const Function& func = Function::Handle(Closure::function(closure));
   const Script& script = Script::Handle(func.script());
   BreakpointLocation* bpt_location = SetBreakpoint(script,
                                                    func.token_pos(),
-                                                   func.end_token_pos());
+                                                   func.end_token_pos(),
+                                                   -1 /* no column */);
   return bpt_location->AddPerClosure(this, closure);
 }
 
 
 Breakpoint* Debugger::BreakpointAtActivation(const Instance& closure) {
   if (!closure.IsClosure()) {
     return NULL;
   }
 
   BreakpointLocation* loc = breakpoint_locations_;
   while (loc != NULL) {
     Breakpoint* bpt = loc->breakpoints();
     while (bpt != NULL) {
       if (bpt->IsPerClosure()) {
         if (closure.raw() == bpt->closure()) {
           return bpt;
         }
       }
       bpt = bpt->next();
     }
     loc = loc->next();
   }
 
   return NULL;
 }
 
 
 Breakpoint* Debugger::SetBreakpointAtLine(const String& script_url,
                                           intptr_t line_number) {
-  BreakpointLocation* loc = BreakpointLocationAtLine(script_url, line_number);
+  BreakpointLocation* loc =
+      BreakpointLocationAtLineCol(script_url, line_number, -1 /* no column */);
   if (loc != NULL) {
     return loc->AddRepeated(this);
   }
+  return NULL;
+}
+
+
+Breakpoint* Debugger::SetBreakpointAtLineCol(const String& script_url,
+                                             intptr_t line_number,
+                                             intptr_t column_number) {
+  BreakpointLocation* loc = BreakpointLocationAtLineCol(script_url,
+                                                        line_number,
+                                                        column_number);
+  if (loc != NULL) {
+    return loc->AddRepeated(this);
+  }
   return NULL;
 }
 
 
-BreakpointLocation* Debugger::BreakpointLocationAtLine(const String& script_url,
-                                                       intptr_t line_number) {
+BreakpointLocation* Debugger::BreakpointLocationAtLineCol(
+    const String& script_url,
+    intptr_t line_number,
+    intptr_t column_number) {
   Library& lib = Library::Handle(isolate_);
   Script& script = Script::Handle(isolate_);
   const GrowableObjectArray& libs =
       GrowableObjectArray::Handle(isolate_->object_store()->libraries());
   const GrowableObjectArray& scripts =
     GrowableObjectArray::Handle(isolate_, GrowableObjectArray::New());
   for (intptr_t i = 0; i < libs.Length(); i++) {
     lib ^= libs.At(i);
     script = lib.LookupScript(script_url);
     if (!script.IsNull()) {
       scripts.Add(script);
     }
   }
   if (scripts.Length() == 0) {
     // No script found with given url. Create a latent breakpoint which
     // will be set if the url is loaded later.
     BreakpointLocation* latent_bpt = GetLatentBreakpoint(script_url,
-                                                         line_number);
+                                                         line_number,
+                                                         column_number);
     if (FLAG_verbose_debug) {
-      OS::Print("Set latent breakpoint in url '%s' at line %" Pd "\n",
+      OS::Print("Set latent breakpoint in url '%s' at "
+                "line %" Pd " col %" Pd "\n",
                 script_url.ToCString(),
-                line_number);
+                line_number, column_number);
     }
     return latent_bpt;
   }
   if (scripts.Length() > 1) {
     if (FLAG_verbose_debug) {
       OS::Print("Multiple scripts match url '%s'\n", script_url.ToCString());
     }
     return NULL;
   }
   script ^= scripts.At(0);
@@ skipping 11 matching lines @@
     if (FLAG_verbose_debug) {
       OS::Print("No executable code at line %" Pd " in '%s'\n",
                 line_number, script_url.ToCString());
     }
     return NULL;
   }
 
   BreakpointLocation* bpt = NULL;
   ASSERT(first_token_idx <= last_token_idx);
   while ((bpt == NULL) && (first_token_idx <= last_token_idx)) {
-    bpt = SetBreakpoint(script, first_token_idx, last_token_idx);
+    bpt = SetBreakpoint(script, first_token_idx, last_token_idx, column_number);
     first_token_idx++;
   }
   if ((bpt == NULL) && FLAG_verbose_debug) {
     OS::Print("No executable code at line %" Pd " in '%s'\n",
                 line_number, script_url.ToCString());
   }
   return bpt;
 }
 
 
@@ skipping 580 matching lines @@
       // TODO(hausner): What should we do if function is optimized?
       // Can we deoptimize the function?
       ASSERT(!func.HasOptimizedCode());
 
       // There is no local function within func that contains the
       // breakpoint token position. Resolve the breakpoint if necessary
       // and set the code breakpoints.
       if (!loc->IsResolved()) {
         // Resolve source breakpoint in the newly compiled function.
         intptr_t bp_pos =
-            ResolveBreakpointPos(func, loc->token_pos(), loc->end_token_pos());
+            ResolveBreakpointPos(func, loc->token_pos(), loc->end_token_pos(),
+                                 loc->requested_column_number());
         if (bp_pos < 0) {
           if (FLAG_verbose_debug) {
             OS::Print("Failed resolving breakpoint for function '%s'\n",
                       String::Handle(func.name()).ToCString());
           }
           continue;
         }
         intptr_t requested_pos = loc->token_pos();
         intptr_t requested_end_pos = loc->end_token_pos();
         loc->SetResolved(func, bp_pos);
         Breakpoint* bpt = loc->breakpoints();
         while (bpt != NULL) {
           if (FLAG_verbose_debug) {
-            OS::Print("Resolved BP %" Pd " to pos %" Pd ", line %" Pd ", "
-                      "function '%s' (requested range %" Pd "-%" Pd ")\n",
+            OS::Print("Resolved BP %" Pd " to pos %" Pd ", "
+                      "line %" Pd " col %" Pd ", "
+                      "function '%s' (requested range %" Pd "-%" Pd ", "
+                      "requested col %" Pd ")\n",
                       bpt->id(),
                       loc->token_pos(),
                       loc->LineNumber(),
+                      loc->ColumnNumber(),
                       func.ToFullyQualifiedCString(),
                       requested_pos,
-                      requested_end_pos);
+                      requested_end_pos,
+                      loc->requested_column_number());
           }
           SignalBpResolved(bpt);
           SendServiceBreakpointEvent(ServiceEvent::kBreakpointResolved, bpt);
           bpt = bpt->next();
         }
       }
       ASSERT(loc->IsResolved());
       if (FLAG_verbose_debug) {
         Breakpoint* bpt = loc->breakpoints();
         while (bpt != NULL) {
-          OS::Print("Setting breakpoint %" Pd " at line %" Pd " for %s '%s'\n",
+          OS::Print("Setting breakpoint %" Pd " at line %" Pd " col %" Pd ""
+                    " for %s '%s'\n",
                     bpt->id(),
                     loc->LineNumber(),
+                    loc->ColumnNumber(),
                     func.IsClosureFunction() ? "closure" : "function",
                     String::Handle(func.name()).ToCString());
           bpt = bpt->next();
         }
       }
       MakeCodeBreakpointAt(func, loc);
     }
   }
 }
 
@@ skipping 22 matching lines @@
         found_match = true;
         BreakpointLocation* matched_loc = loc;
         loc = loc->next();
         if (prev_loc == NULL) {
           latent_locations_ = loc;
         } else {
           prev_loc->set_next(loc);
         }
         // Now find the token range at the requested line and make a
         // new unresolved source breakpoint.
-        intptr_t line_number = matched_loc->LineNumber();
+        intptr_t line_number = matched_loc->requested_line_number();
+        intptr_t column_number = matched_loc->requested_column_number();
         ASSERT(line_number >= 0);
         intptr_t first_token_pos, last_token_pos;
         script.TokenRangeAtLine(line_number, &first_token_pos, &last_token_pos);
         if ((first_token_pos < 0) ||
             (last_token_pos < 0)) {
           // Script does not contain the given line number or there are no
           // tokens on the line. Drop the breakpoint silently.
           Breakpoint* bpt = matched_loc->breakpoints();
           while (bpt != NULL) {
             if (FLAG_verbose_debug) {
               OS::Print("No code found at line %" Pd ": "
                         "dropping latent breakpoint %" Pd " in '%s'\n",
                         line_number,
                         bpt->id(),
                         url.ToCString());
             }
             Breakpoint* prev = bpt;
             bpt = bpt->next();
             delete prev;
           }
           delete matched_loc;
         } else {
           // We don't expect to already have a breakpoint for this location.
           // If there is one, assert in debug build but silently drop
           // the latent breakpoint in release build.
           BreakpointLocation* existing_loc =
-              GetBreakpointLocation(script, first_token_pos);
+              GetBreakpointLocation(script, first_token_pos, column_number);
           ASSERT(existing_loc == NULL);
           if (existing_loc == NULL) {
             // Create and register a new source breakpoint for the
             // latent breakpoint.
             BreakpointLocation* unresolved_loc =
                 new BreakpointLocation(script,
                                        first_token_pos,
-                                       last_token_pos);
+                                       last_token_pos,
+                                       column_number);
             RegisterBreakpointLocation(unresolved_loc);
 
             // Move breakpoints over.
             Breakpoint* bpt = matched_loc->breakpoints();
             unresolved_loc->set_breakpoints(bpt);
             matched_loc->set_breakpoints(NULL);
             while (bpt != NULL) {
               bpt->set_bpt_location(unresolved_loc);
               if (FLAG_verbose_debug) {
                 OS::Print("Converted latent breakpoint "
-                          "%" Pd " in '%s' at line %" Pd "\n",
+                          "%" Pd " in '%s' at line %" Pd " col %" Pd "\n",
                           bpt->id(),
                           url.ToCString(),
-                          line_number);
+                          line_number, column_number);
               }
               bpt = bpt->next();
             }
             SyncBreakpointLocation(unresolved_loc);
           }
           delete matched_loc;
           // Break out of the iteration over loaded libraries. If the
           // same url has been loaded into more than one library, we
           // only set a breakpoint in the first one.
           // TODO(hausner): There is one possible pitfall here.
@@ skipping 143 matching lines @@
       delete temp_bpt;
     } else {
       prev_bpt = curr_bpt;
       curr_bpt = curr_bpt->next();
     }
   }
 }
 
 
 BreakpointLocation* Debugger::GetBreakpointLocation(const Script& script,
-                                                    intptr_t token_pos) {
+                                                    intptr_t token_pos,
+                                                    intptr_t requested_column) {
   BreakpointLocation* bpt = breakpoint_locations_;
   while (bpt != NULL) {
-    if ((bpt->script_ == script.raw()) && (bpt->token_pos_ == token_pos)) {
+    if ((bpt->script_ == script.raw()) &&
+        (bpt->token_pos_ == token_pos) &&
+        (bpt->requested_column_number_ == requested_column)) {
       return bpt;
     }
     bpt = bpt->next();
   }
   return NULL;
 }
 
 
 Breakpoint* Debugger::GetBreakpointById(intptr_t id) {
   BreakpointLocation* loc = breakpoint_locations_;
   while (loc != NULL) {
     Breakpoint* bpt = loc->breakpoints();
     while (bpt != NULL) {
       if (bpt->id() == id) {
         return bpt;
       }
       bpt = bpt->next();
     }
     loc = loc->next();
   }
   return NULL;
 }
 
 
 BreakpointLocation* Debugger::GetLatentBreakpoint(const String& url,
-                                                  intptr_t line) {
+                                                  intptr_t line,
+                                                  intptr_t column) {
   BreakpointLocation* bpt = latent_locations_;
   String& bpt_url = String::Handle(isolate_);
   while (bpt != NULL) {
     bpt_url = bpt->url();
-    if (bpt_url.Equals(url) && (bpt->LineNumber() == line)) {
+    if (bpt_url.Equals(url) &&
+        (bpt->requested_line_number() == line) &&
+        (bpt->requested_column_number() == column)) {
       return bpt;
     }
     bpt = bpt->next();
   }
-  // No breakpint for this url and line requested. Allocate new one.
-  bpt = new BreakpointLocation(url, line);
+  // No breakpoint for this location requested. Allocate new one.
+  bpt = new BreakpointLocation(url, line, column);
   bpt->set_next(latent_locations_);
   latent_locations_ = bpt;
   return bpt;
 }
 
 
 void Debugger::RegisterBreakpointLocation(BreakpointLocation* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(breakpoint_locations_);
   breakpoint_locations_ = bpt;
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart