Enable coverage tool to handle multiple files and libraries

tools/coverage.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.
 
 // This test forks a second vm process that runs a dart script as
 // a debug target, single stepping through the entire program, and
 // recording each breakpoint. At the end, a coverage map of the source
 // is printed.
 //
 // Usage: dart coverage.dart [--wire] [--verbose] target_script.dart
 //
 //   --wire      see json messages sent between the processes.
 //   --verbose   see the stdout and stderr output of the debug
 //               target process.
 
 import "dart:io";
 import "dart:utf";
 import "dart:json" as JSON;
 
 
 // Whether or not to print debug target process on the console.
 var showDebuggeeOutput = false;
 
 // Whether or not to print the debugger wire messages on the console.
 var verboseWire = false;
 
+var debugger = null;
 
 class Program {
   static int numBps = 0;
 
   // Maps source code url to source.
   static var sources = new Map<String, Source>();
 
   // Takes a JSON Debugger response and increments the count for
   // the source position.
-  static void recordBp(Debugger debugger, Map<String,dynamic> msg) {
+  static void recordBp(Map<String,dynamic> msg) {
     // Progress indicator.
     if (++numBps % 1000 == 0) print(numBps);
     var location = msg["params"]["location"];
     if (location == null) return;
     String url = location["url"];
     assert(url != null);
+    int libId = location["libraryId"];
+    assert(libId != null);
     int tokenPos = location["tokenOffset"];;
     Source s = sources[url];
     if (s == null) {
-      debugger.GetLineNumberTable(url);
+      debugger.getLineNumberTable(url, libId);
       s = new Source(url);
       sources[url] = s;
     }
     s.recordBp(tokenPos);
   }
 
   // Prints the annotated source code.
   static void printCoverage() {
     print("Coverage info collected from $numBps breakpoints:");
     for(Source s in sources.values) s.printCoverage();
@@ skipping 82 matching lines @@
 
   void handleResponse(Map response) {
     var url = msg["params"]["url"];
     Source s = Program.sources[url];
     assert(s != null);
     s.SetLineInfo(response["result"]["lines"]);
   }
 }
 
 
+class GetLibrariesCmd {
+  Map msg;
+  GetLibrariesCmd(int isolateId) {
+    msg = { "id": 0,
+            "command":  "getLibraries",
+            "params": { "isolateId" : isolateId } };
+  }
+
+  void handleResponse(Map response) {
+    List libs = response["result"]["libraries"];
+    for (var lib in libs) {
+      String url = lib["url"];
+      int libraryId = lib["id"];
+      bool enable = !url.startsWith("dart:") && !url.startsWith("package:");
+      if (enable) {
+        print("Enable stepping for '$url'");

[srdjan, 2013/07/18 18:51:12]

Is that a debugging print?

[hausner, 2013/07/18 19:00:26]

I thought it might be a helpful indicator on what the coverage tool is doing,
similar to the "isolate xxx created" messages.
 

+        debugger.enableDebugging(libraryId, true);
+      }
+    }
+  }
+}
+
+
+class SetLibraryPropertiesCmd {
+  Map msg;
+  SetLibraryPropertiesCmd(int isolateId, int libraryId, bool enableDebugging) {
+    msg = { "id": 0,
+            "command":  "setLibraryProperties",
+            "params": { "isolateId" : isolateId,
+                        "libraryId": libraryId,
+                        "debuggingEnabled": "$enableDebugging" } };
+  }
+
+  void handleResponse(Map response) {
+    // Nothing to do.
+  }
+}
+
+
 class Debugger {
   // Debug target process properties.
   Process targetProcess;
   Socket socket;
   bool cleanupDone = false;
   JsonBuffer responses = new JsonBuffer();
   List<String> errors = new List();
 
   // Data collected from debug target.
   Map currentMessage = null;  // Currently handled message sent by target.
   var outstandingCommand = null;
-  var queuedCommand = null;
+  var queuedCommands = new List();
   String scriptUrl = null;
   bool shutdownEventSeen = false;
   int isolateId = 0;
   int libraryId = null;
 
   int nextMessageId = 0;
   bool isPaused = false;
   bool pendingAck = false;
 
   Debugger(this.targetProcess) {
@@ skipping 43 matching lines @@
       var location = msg["params"]["location"];
       assert(location != null);
       print("Isolate $isolateId: breakpoint $bpId resolved"
             " at location $location");
       // We may want to maintain a table of breakpoints in the future.
     } else if (msg["event"] == "paused") {
       isPaused = true;
       if (libraryId == null) {
         libraryId = msg["params"]["location"]["libraryId"];
         assert(libraryId != null);
+        // This is the first paused event we got. Get all libraries from
+        // the debugger so we can turn on debugging events for them.
+        getLibraries();
       }
       if (msg["params"]["reason"] == "breakpoint") {
-        Program.recordBp(this, msg);
+        Program.recordBp(msg);
       }
     } else {
       error("Error: unknown debugger event received");
     }
   }
 
   // Handle one JSON message object.
   void handleMessage(Map<String,dynamic> receivedMsg) {
     currentMessage = receivedMsg;
     if (receivedMsg["event"] != null) {
@@ skipping 36 matching lines @@
         return;
       }
       if (shutdownEventSeen) {
         if (outstandingCommand != null) {
           error("Error: outstanding command when shutdown received");
         }
         cleanup();
         return;
       }
       if (isPaused && (outstandingCommand == null)) {
-        var cmd = queuedCommand;
-        queuedCommand = null;
+        var cmd = queuedCommands.length > 0 ? queuedCommands.removeAt(0) : null;
         if (cmd == null) {
           cmd = new StepCmd(isolateId);
           isPaused = false;
         }
         sendMessage(cmd.msg);
         outstandingCommand = cmd;
       }
       msg = responses.getNextMessage();
     }
   }
 
   // Send a debugger command to the target VM.
   void sendMessage(Map<String,dynamic> msg) {
     assert(msg["id"] != null);
     msg["id"] = nextMessageId++;
     String jsonMsg = JSON.stringify(msg);
     if (verboseWire) print("SEND: $jsonMsg");
     socket.write(jsonMsg);
   }
 
-  void GetLineNumberTable(String url) {
-    assert(queuedCommand == null);
-    queuedCommand = new GetLineTableCmd(isolateId, libraryId, url);
+  void getLineNumberTable(String url, int libId) {
+    queuedCommands.add(new GetLineTableCmd(isolateId, libId, url));
+  }
+
+  void getLibraries() {
+    queuedCommands.add(new GetLibrariesCmd(isolateId));
   }
   
+  void enableDebugging(libraryId, enable) {
+    queuedCommands.add(new SetLibraryPropertiesCmd(isolateId, libraryId, enable));
+  }
+
   bool get errorsDetected => errors.length > 0;
 
   // Record error message.
   void error(String s) {
     errors.add(s);
   }
 
   void openConnection(int portNumber) {
     Socket.connect("127.0.0.1", portNumber).then((s) {
       socket = s;
@@ skipping 163 matching lines @@
         verboseWire = true;
         break;
       default:
         targetOpts.add(str);
         break;
     }
   }
 
   Process.start(options.executable, targetOpts).then((Process process) {
     process.stdin.close();
-    var debugger = new Debugger(process);
+    debugger = new Debugger(process);
   });
 }