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 417 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.
+ * 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()) {

[Kevin Millikin (Google), 2017/01/24 13:44:13]

Since you've possibly got empty lists for yield positions:

if ((index < list->length()) && (list->At(index)->length() > 0))

[jensj, 2017/01/25 12:52:22]

Done.
Though it shouldn't really change anything (though, sure, it should be faster).

+    MallocGrowableArray<intptr_t>* source = list->At(index);
+    Array& array_object = Array::Handle();
+    source->Sort(LowestFirst);
+
+    intptr_t different_values = 0;
+    intptr_t last_seen = 0;
+    intptr_t size = source->length();
+    for (intptr_t i = 0; i < size; ++i) {

[Kevin Millikin (Google), 2017/01/24 13:44:13]

It seems simpler to me to remove the duplicates from the sorted list and then
copy everything instead of detecting the distinct elements to count them and
then repeating that to copy them.  Something like:

intptr_t last = 0;
for (intptr_t current = 1; current < size; ++current) {
  if ((*list)[last] != (*list)[current]) {
    (*list)[++last] = (*list)[current];
  }
}
list->TruncateTo(last + 1);

[jensj, 2017/01/25 12:52:22]

Semi-done.

+      intptr_t value = source->At(i);
+      if (different_values == 0 || last_seen != value) {
+        last_seen = value;
+        ++different_values;
+      }
+    }
+
+    array_object ^= Array::New(different_values, Heap::kOld);
+    Smi& smi_value = Smi::Handle();
+    different_values = 0;
+    last_seen = 0;
+    for (intptr_t i = 0; i < size; ++i) {
+      intptr_t value = source->At(i);
+      if (different_values == 0 || last_seen != value) {
+        smi_value = Smi::New(value);
+        array_object.SetAt(different_values, smi_value);
+        last_seen = value;
+        ++different_values;
+      }
+    }
+    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_tokens_seen(array_object);
+
+    // Create yields_seen array for the script.
+    array_object ^= AsSortedDuplicateFreeArray(
+        source_uri_index, &program_->yield_token_positions);
+    script.set_yields_seen(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)