Debugging in kernel shaping up.

runtime/vm/kernel_reader.cc

 // Copyright (c) 2016, 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/kernel_reader.h"
 
 #include <string.h>
 
 #include "vm/dart_api_impl.h"
 #include "vm/longjump.h"
@@ skipping 432 matching lines @@
                                              intptr_t source_uri_index) {
   Script& correct_script = ScriptAt(source_uri_index);
   if (klass.script() != correct_script.raw()) {
     // TODO(jensj): We could probably cache this so we don't create
     // new PatchClasses all the time
     return PatchClass::ZoneHandle(Z, PatchClass::New(klass, correct_script));
   }
   return klass;
 }
 
+static int LowestFirst(const intptr_t* a, const intptr_t* b) {
+  return *a - *b;
+}
+
+/**
+ * If index exists as sublist in list, sort the sublist from lowest to highest,
+ * then copy it, as Smis and without duplicates,
+ * to a new Array in Heap::kOld which is returned.
+ * Note that the source list is both sorted and de-duplicated as well, but will
+ * possibly contain duplicate and unsorted data at the end.
+ * Otherwise (when sublist doesn't exist in list) return new empty array.
+ */
+static RawArray* AsSortedDuplicateFreeArray(
+    intptr_t index,
+    MallocGrowableArray<MallocGrowableArray<intptr_t>*>* list) {
+  if ((index < list->length()) && (list->At(index)->length() > 0)) {
+    MallocGrowableArray<intptr_t>* source = list->At(index);
+    source->Sort(LowestFirst);
+
+    intptr_t size = source->length();
+    intptr_t last = 0;
+    for (intptr_t current = 1; current < size; ++current) {
+      if (source->At(last) != source->At(current)) {
+        (*source)[++last] = source->At(current);
+      }
+    }
+    Array& array_object = Array::Handle();
+    array_object ^= Array::New(last + 1, Heap::kOld);
+    Smi& smi_value = Smi::Handle();
+    for (intptr_t i = 0; i <= last; ++i) {
+      smi_value = Smi::New(source->At(i));
+      array_object.SetAt(i, smi_value);
+    }
+    return array_object.raw();
+  } else {
+    return Array::New(0);
+  }
+}
+
 Script& KernelReader::ScriptAt(intptr_t source_uri_index, String* import_uri) {
   Script& script = Script::ZoneHandle(Z);
   script ^= scripts_.At(source_uri_index);
   if (script.IsNull()) {
     // Create script with correct uri(s).
     String* uri = program_->source_uri_table().strings()[source_uri_index];
     dart::String& uri_string = H.DartString(uri, Heap::kOld);
     dart::String& import_uri_string =
         import_uri == NULL ? uri_string : H.DartString(import_uri, Heap::kOld);
     dart::String& source_code = H.DartString(
         program_->source_table().SourceFor(source_uri_index), Heap::kOld);
     script = Script::New(import_uri_string, uri_string, source_code,
                          RawScript::kKernelTag);
     scripts_.SetAt(source_uri_index, script);
 
     // Create line_starts array for the script.
     intptr_t* line_starts =
         program_->source_table().LineStartsFor(source_uri_index);
     intptr_t line_count =
         program_->source_table().LineCountFor(source_uri_index);
     Array& array_object = Array::Handle(Z, Array::New(line_count, Heap::kOld));
     Smi& value = Smi::Handle(Z);
     for (intptr_t i = 0; i < line_count; ++i) {
       value = Smi::New(line_starts[i]);
       array_object.SetAt(i, value);
     }
     script.set_line_starts(array_object);
+
+    // Create tokens_seen array for the script.
+    array_object ^= AsSortedDuplicateFreeArray(
+        source_uri_index, &program_->valid_token_positions);
+    script.set_debug_positions(array_object);
+
+    // Create yield_positions array for the script.
+    array_object ^= AsSortedDuplicateFreeArray(
+        source_uri_index, &program_->yield_token_positions);
+    script.set_yield_positions(array_object);
   }
   return script;
 }
 
 void KernelReader::GenerateFieldAccessors(const dart::Class& klass,
                                           const dart::Field& field,
                                           Field* kernel_field) {
   if (kernel_field->IsStatic() && kernel_field->initializer() != NULL) {
     // Static fields with initializers either have the static value set to the
     // initializer value if it is simple enough or else set to an uninitialized
@@ skipping 250 matching lines @@
   initializer_fun.set_is_debuggable(false);
   initializer_fun.set_is_reflectable(false);
   initializer_fun.set_is_inlinable(false);
   return new (zone) ParsedFunction(thread, initializer_fun);
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)