Fix several little buglets with stepping

tests/standalone/debugger/debug_lib.dart

 // Copyright (c) 2013, 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.
 
 // Library used by debugger wire protocol tests (standalone VM debugging).
 
 library DartDebugger;
 
 import "dart:async";
 import "dart:convert";
@@ skipping 162 matching lines @@
   void matchResponse(Debugger debugger) {
     Map response = debugger.currentMessage;
     var id = template["id"];
     assert(id != null && id >= 0);
     if (response["id"] != id) {
       debugger.error("Error: expected messaged id $id but got ${response["id"]}.");
     }
   }
 }
 
+class GetLineTableCmd extends Command {
+  GetLineTableCmd() {
+    template = {"id": 0,
+                "command": "getLineNumberTable",
+                "params": {"isolateId": 0, "libraryId": 0, "url": ""}};
+  }
+
+  void send(Debugger debugger) {
+    assert(debugger.scriptUrl != null);
+    template["params"]["url"] = debugger.scriptUrl;
+    template["params"]["libraryId"] = debugger.libraryId;
+    debugger.sendMessage(template);
+  }
+
+  void matchResponse(Debugger debugger) {
+    super.matchResponse(debugger);
+    List<List<int>> table = getJsonValue(debugger.currentMessage, "result:lines");
+    debugger.tokenToLine = {};
+    for (var line in table) {
+      // Each entry begins with a line number...
+      var lineNumber = line[0];
+      for (var pos = 1; pos < line.length; pos += 2) {
+        // ...and is followed by (token offset, col number) pairs.
+        var tokenOffset = line[pos];
+        debugger.tokenToLine[tokenOffset] = lineNumber;
+      }
+    }
+  }
+}
+
+
+class LineMatcher extends Command {
+  int expectedLineNumber;
+
+  LineMatcher(this.expectedLineNumber) {
+    template = {"id": 0, "command": "getStackTrace", "params": {"isolateId": 0}};
+  }
+
+  void matchResponse(Debugger debugger) {
+    assert(debugger.tokenToLine != null);
+    super.matchResponse(debugger);
+    var msg = debugger.currentMessage;
+    List frames = getJsonValue(msg, "result:callFrames");
+    assert(frames != null);
+    var tokenOffset = frames[0]["location"]["tokenOffset"];
+    assert(tokenOffset != null);
+    var lineNumber = debugger.tokenToLine[tokenOffset];
+    assert(lineNumber != null);
+    if (expectedLineNumber != lineNumber) {
+      debugger.error("Error: expected pause at line $expectedLineNumber "
+                     "but reported line is $lineNumber.");
+      return;
+    }
+    print("Matched line number $lineNumber");
+  }
+}
+
+MatchLine(lineNumber) {
+  return new LineMatcher(lineNumber);
+}
+
 
 class FrameMatcher extends Command {
   int frameIndex;
   List<String> functionNames;
   bool exactMatch;
 
   FrameMatcher(this.frameIndex, this.functionNames, this.exactMatch) {
     template = {"id": 0, "command": "getStackTrace", "params": {"isolateId": 0}};
   }
 
   void matchResponse(Debugger debugger) {
     super.matchResponse(debugger);
     var msg = debugger.currentMessage;
     List frames = getJsonValue(msg, "result:callFrames");
     assert(frames != null);
     if (debugger.scriptUrl == null) {
       var name = frames[0]["functionName"];
       if (name == "main") {
         // Extract script url of debugged script.
         debugger.scriptUrl = frames[0]["location"]["url"];
         assert(debugger.scriptUrl != null);
+        debugger.libraryId = frames[0]["location"]["libraryId"];
+        assert(debugger.libraryId != null);
       }
     }
     if (frames.length < functionNames.length) {
       debugger.error("Error: stack trace not long enough "
                      "to match ${functionNames.length} frames");
       return;
     }
     for (int i = 0; i < functionNames.length; i++) {
       var idx = i + frameIndex;
       var name = frames[idx]["functionName"];
       assert(name != null);
       bool isMatch = exactMatch ? name == functionNames[i]
                                 : name.contains(functionNames[i]);
       if (!isMatch) {
         debugger.error("Error: call frame $idx: "
           "expected function name '${functionNames[i]}' but found '$name'");
         return;
       }
     }
+    print("Matched frames: $functionNames");
   }
 }
 
 
 MatchFrame(int frameIndex, String functionName, {exactMatch: false}) {
   return new FrameMatcher(frameIndex, [functionName], exactMatch);
 }
 
 MatchFrames(List<String> functionNames, {exactMatch: false}) {
   return new FrameMatcher(0, functionNames, exactMatch);
@@ skipping 24 matching lines @@
         return;
       }
       String expected = locals[key];
       String actual = reportedLocals[key]['text'];
       if (expected != actual) {
         debugger.error("Error in $functionName(): got '$actual' for local "
             "variable $key, but expected '$expected'");
         return;
       }
     }
+    print("Matched locals ${locals.keys}");
   }
 }
 
 
 MatchLocals(Map localValues) {
   return new LocalsMatcher(localValues);
 }
 
 
 class EventMatcher {
@@ skipping 34 matching lines @@
   RunCommand.stepInto() {
     template = {"id": 0, "command": "stepInto", "params": {"isolateId": 0}};
   }
   RunCommand.stepOut() {
     template = {"id": 0, "command": "stepOut", "params": {"isolateId": 0}};
   }
   void send(Debugger debugger) {
     debugger.sendMessage(template);
     debugger.isPaused = false;
   }
+  void matchResponse(Debugger debugger) {
+    super.matchResponse(debugger);
+    print("Command: ${template['command']}");
+  }
 }
 
 
 Resume() => new RunCommand.resume();
 Step() => new RunCommand.step();
 StepInto() => new RunCommand.stepInto();
 StepOut() => new RunCommand.stepOut();
 
 class SetBreakpointCommand extends Command {
   int line;
   SetBreakpointCommand(int this.line) {
     template = {"id": 0,
                 "command": "setBreakpoint",
                 "params": { "isolateId": 0,
                             "url": null,
                             "line": null }};
   }
 
   void send(Debugger debugger) {
     assert(debugger.scriptUrl != null);
     template["params"]["url"] = debugger.scriptUrl;
     template["params"]["line"] = line;
     debugger.sendMessage(template);
   }
+
+  void matchResponse(Debugger debugger) {
+    super.matchResponse(debugger);
+    print("Set breakpoint at line $line");
+  }
 }
 
 SetBreakpoint(int line) => new SetBreakpointCommand(line);
 
 class Event {
   String name;
   Map params;
 
   Event(Map json) {
     name = json['event'];
     params = json['params'];
   }
 }
 
 
 // A debug script is a list of Command objects.
 class DebugScript {
   List entries;
   DebugScript(List scriptEntries) {
     entries = new List.from(scriptEntries.reversed);
+    entries.add(new GetLineTableCmd());
     entries.add(MatchFrame(0, "main"));
   }
   bool get isEmpty => entries.isEmpty;
   bool get isNextEventMatcher => !isEmpty && currentEntry is EventMatcher;
   get currentEntry => entries.last;
   advance() => entries.removeLast();
   add(entry) => entries.add(entry);
 }
 
 
 class Debugger {
   // Debug target process properties.
   Process targetProcess;
   Socket socket;
   JsonBuffer responses = new JsonBuffer();
 
   DebugScript script;
   int seqNr = 0;  // Sequence number of next debugger command message.
   Command lastCommand = null;  // Most recent command sent to target.
   List<String> errors = new List();
   List<Event> events = new List();
   bool cleanupDone = false;
 
   // Data collected from debug target.
   Map currentMessage = null;  // Currently handled message sent by target.
   String scriptUrl = null;
+  int libraryId = null;
+  Map<int,int> tokenToLine = null;
   bool shutdownEventSeen = false;
   int isolateId = 0;
   bool isPaused = false;
 
   Debugger(this.targetProcess, this.script) {
     var stdoutStringStream = targetProcess.stdout
         .transform(UTF8.decoder)
         .transform(new LineSplitter());
     stdoutStringStream.listen((line) {
       print("TARG: $line");
@@ skipping 216 matching lines @@
   targetOpts.add("--debuggee");
   print('args: ${targetOpts.join(" ")}');
 
   Process.start(Platform.executable, targetOpts).then((Process process) {
     print("Debug target process started, pid ${process.pid}.");
     process.stdin.close();
     var debugger = new Debugger(process, new DebugScript(script));
   });
   return true;
 }