Include source in kernel.

runtime/vm/kernel_binary.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.
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 #include <map>
 #include <vector>
 
 #include "platform/globals.h"
 #include "vm/flags.h"
@@ skipping 810 matching lines @@
   strings_.WriteToStatic<StringImpl>(writer);
 
   // Build up the "String* -> index" table.
   WriterHelper* helper = writer->helper();
   for (int i = 0; i < strings_.length(); i++) {
     helper->strings().Push(strings_[i]);
   }
 }
 
 
-void LineStartingTable::ReadFrom(Reader* reader) {
+void LineStartingTableAndSource::ReadFrom(Reader* reader) {
   size_ = reader->helper()->program()->source_uri_table().strings().length();
-  values_ = new intptr_t*[size_];
+  source_code_ = new String*[size_];
+  line_starts_ = new intptr_t*[size_];
   for (intptr_t i = 0; i < size_; ++i) {
+    source_code_[i] = StringImpl::ReadFrom(reader);
     intptr_t line_count = reader->ReadUInt();
     intptr_t* line_starts = new intptr_t[line_count + 1];

[Kevin Millikin (Google), 2016/12/20 12:03:33]

I think we should define a simple class that contains just the (pointer to the)
array of ints, but has (only) public member functions for getting the size and
zero-based get/set indexing into the payload --- it's just a representation
decision to put the size as the first element of the array and not something the
client wants to worry about.

That could be a separate change.

[jensj, 2016/12/20 13:30:23]

I've done another change instead. Hopefully that'll do too.

     line_starts[0] = line_count;
     intptr_t previous_line_start = 0;
     for (intptr_t j = 0; j < line_count; ++j) {
       intptr_t line_start = reader->ReadUInt() + previous_line_start;
       line_starts[j + 1] = line_start;
       previous_line_start = line_start;
     }
-    values_[i] = line_starts;
+    line_starts_[i] = line_starts;
   }
 }
 
 
-void LineStartingTable::WriteTo(Writer* writer) {
+void LineStartingTableAndSource::WriteTo(Writer* writer) {
   for (intptr_t i = 0; i < size_; ++i) {
-    intptr_t* line_starts = values_[i];
+    StringImpl::WriteTo(writer, source_code_[i]);
+    intptr_t* line_starts = line_starts_[i];
     intptr_t line_count = line_starts[0];
     writer->WriteUInt(line_count);
 
     intptr_t previous_line_start = 0;
     for (intptr_t j = 0; j < line_count; ++j) {
       intptr_t line_start = line_starts[j + 1];
       writer->WriteUInt(line_start - previous_line_start);
       previous_line_start = line_start;
     }
   }
@@ skipping 1959 matching lines @@
 Program* Program::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   uint32_t magic = reader->ReadUInt32();
   if (magic != kMagicProgramFile) FATAL("Invalid magic identifier");
 
   Program* program = new Program();
   reader->helper()->set_program(program);
 
   program->string_table_.ReadFrom(reader);
   program->source_uri_table_.ReadFrom(reader);
-  program->line_starting_table_.ReadFrom(reader);
+  program->line_starting_table_and_source_.ReadFrom(reader);
 
   int libraries = reader->ReadUInt();
   program->libraries().EnsureInitialized(libraries);
   for (int i = 0; i < libraries; i++) {
     program->libraries().GetOrCreate<Library>(i)->ReadFrom(reader);
   }
 
   program->main_method_ = Procedure::Cast(Reference::ReadMemberFrom(reader));
 
   return program;
 }
 
 
 void Program::WriteTo(Writer* writer) {
   TRACE_WRITE_OFFSET();
 
   writer->helper()->SetProgram(this);
 
   writer->WriteUInt32(kMagicProgramFile);
 
   // NOTE: Currently we don't GC strings and we require that all referenced
   // strings in nodes are present in [string_table_].
   string_table_.WriteTo(writer);
   source_uri_table_.WriteTo(writer);
-  line_starting_table_.WriteTo(writer);
+  line_starting_table_and_source_.WriteTo(writer);
 
   libraries_.WriteTo(writer);
   Reference::WriteMemberTo(writer, main_method_);
 }
 
 
 FunctionNode* FunctionNode::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   TypeParameterScope<ReaderHelper> scope(reader->helper());
 
@@ skipping 63 matching lines @@
 void WritePrecompiledKernel(ByteWriter* byte_writer, kernel::Program* program) {
   ASSERT(byte_writer != NULL);
 
   kernel::Writer writer(byte_writer);
   program->WriteTo(&writer);
 }
 
 
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)