coverage: Improve generation, see below.

runtime/vm/coverage.cc

 // 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.
 
 #include "vm/coverage.h"
 
 #include "include/dart_api.h"
 
 #include "vm/compiler.h"
 #include "vm/isolate.h"
@@ skipping 39 matching lines @@
     // then just skip this method.
     // TODO(iposva): Maybe we should skip synthesized methods in general too.
     if (function.is_abstract() || function.IsRedirectingFactory()) {
       return;
     }
     if (function.IsNonImplicitClosureFunction() &&
         (function.context_scope() == ContextScope::null())) {
       // TODO(iposva): This can arise if we attempt to compile an inner function
       // before we have compiled its enclosing function or if the enclosing
       // function failed to compile.
-      OS::Print("### Coverage skipped compiling: %s\n", function.ToCString());
       return;
     }
     const Error& err = Error::Handle(
         isolate, Compiler::CompileFunction(isolate, function));
     if (!err.IsNull()) {
-      OS::Print("### Coverage failed compiling:\n%s\n", err.ToErrorCString());
       return;
     }
   }
   ASSERT(function.HasCode());
 
   // Print the hit counts for all IC datas.
   ZoneGrowableArray<const ICData*>* ic_data_array =
       new(isolate) ZoneGrowableArray<const ICData*>();
   function.RestoreICDataMap(ic_data_array);
   const Code& code = Code::Handle(function.unoptimized_code());
   const PcDescriptors& descriptors = PcDescriptors::Handle(
       code.pc_descriptors());
 
+  const intptr_t begin_pos = function.token_pos();
+  const intptr_t end_pos = function.end_token_pos();
+  intptr_t last_line = -1;
+  intptr_t last_count = 0;
   for (int j = 0; j < descriptors.Length(); j++) {
     HANDLESCOPE(isolate);
     PcDescriptors::Kind kind = descriptors.DescriptorKind(j);
     // Only IC based calls have counting.
     if ((kind == PcDescriptors::kIcCall) ||
         (kind == PcDescriptors::kUnoptStaticCall)) {
       intptr_t deopt_id = descriptors.DeoptId(j);
       const ICData* ic_data= (*ic_data_array)[deopt_id];
       if (!ic_data->IsNull()) {
         intptr_t token_pos = descriptors.TokenPos(j);
+        // Filter out descriptors that do not map to tokens in the source code.
+        if (token_pos < begin_pos ||
+            token_pos > end_pos) {
+          continue;
+        }
         intptr_t line = pos_to_line[token_pos];
 #if defined(DEBUG)
         const Script& script = Script::Handle(function.script());
         intptr_t test_line = -1;
         script.GetTokenLocation(token_pos, &test_line, NULL);
         ASSERT(test_line == line);
 #endif
-        hits_arr.AddValue(line);
-        hits_arr.AddValue(ic_data->AggregateCount());
+        // Merge hit data where possible.
+        if (last_line == line) {
+          last_count += ic_data->AggregateCount();
+        } else {
+          if (last_line != -1) {
+            hits_arr.AddValue(last_line);
+            hits_arr.AddValue(last_count);
+          }
+          last_count = ic_data->AggregateCount();
+          last_line = line;
+        }
       }
     }
   }
+  // Write last hit value if needed.
+  if (last_line != -1) {
+    hits_arr.AddValue(last_line);
+    hits_arr.AddValue(last_count);
+  }
 }
 
 
 void CodeCoverage::PrintClass(const Class& cls, const JSONArray& jsarr) {
   Isolate* isolate = Isolate::Current();
+  if (cls.EnsureIsFinalized(isolate) != Error::null()) {
+    // Only classes that have been finalized do have a meaningful list of
+    // functions.
+    return;
+  }
   Array& functions = Array::Handle(cls.functions());
   ASSERT(!functions.IsNull());
   Function& function = Function::Handle();
   Script& script = Script::Handle();
   String& saved_url = String::Handle();
   String& url = String::Handle();
   GrowableArray<intptr_t> pos_to_line;
   int i = 0;
   while (i < functions.Length()) {
     HANDLESCOPE(isolate);
@@ skipping 101 matching lines @@
   JSONObject coverage(stream);
   coverage.AddProperty("type", "CodeCoverage");
   coverage.AddProperty("id", "coverage");
   {
     JSONArray jsarr(&coverage, "coverage");
     for (int i = 0; i < libs.Length(); i++) {
       lib ^= libs.At(i);
       ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
       while (it.HasNext()) {
         cls = it.GetNextClass();
-        if (cls.EnsureIsFinalized(isolate) == Error::null()) {
-          // Only classes that have been finalized do have a meaningful list of
-          // functions.
-          PrintClass(cls, jsarr);
-        }
+        PrintClass(cls, jsarr);
       }
     }
   }
 }
 
 
 }  // namespace dart