Include source in kernel.

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 85 matching lines @@
 KernelReader::KernelReader(Program* program)
     : program_(program),
       thread_(dart::Thread::Current()),
       zone_(thread_->zone()),
       isolate_(thread_->isolate()),
       scripts_(Array::ZoneHandle(zone_)),
       translation_helper_(this, thread_, zone_, isolate_),
       type_translator_(&translation_helper_,
                        &active_class_,
                        /*finalize=*/false) {
-  intptr_t source_file_count = program_->line_starting_table().size();
+  intptr_t source_file_count = program_->source_table().size();
   scripts_ = Array::New(source_file_count, Heap::kOld);
 }
 
 Object& KernelReader::ReadProgram() {
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     Procedure* main = program_->main_method();
     Library* kernel_main_library = Library::Cast(main->parent());
 
     intptr_t length = program_->libraries().length();
@@ skipping 34 matching lines @@
   // The bootstrapper will take care of creating the native wrapper classes, but
   // we will add the synthetic constructors to them here.
   if (library.name() ==
       Symbols::Symbol(Symbols::kDartNativeWrappersLibNameId).raw()) {
     ASSERT(library.LoadInProgress());
   } else {
     library.SetLoadInProgress();
   }
   // Setup toplevel class (which contains library fields/procedures).
 
-  Script& script = ScriptAt(kernel_library->source_uri_index());
+  Script& script = ScriptAt(kernel_library->source_uri_index(),
+                            kernel_library->import_uri());
   dart::Class& toplevel_class = dart::Class::Handle(
       Z, dart::Class::New(library, Symbols::TopLevel(), script,
                           TokenPosition::kNoSource));
   toplevel_class.set_is_cycle_free();
   library.set_toplevel_class(toplevel_class);
 
   ActiveClassScope active_class_scope(&active_class_, NULL, &toplevel_class);
   // Load toplevel fields.
   for (intptr_t i = 0; i < kernel_library->fields().length(); i++) {
     Field* kernel_field = kernel_library->fields()[i];
@@ skipping 145 matching lines @@
                                               kernel_constructor->function());
 
     const dart::String& name = H.DartConstructorName(kernel_constructor);
     Function& function = dart::Function::ZoneHandle(
         Z, dart::Function::New(name, RawFunction::kConstructor,
                                false,  // is_static
                                kernel_constructor->IsConst(),
                                false,  // is_abstract
                                kernel_constructor->IsExternal(),
                                false,  // is_native
-                               klass, TokenPosition::kNoSource));
+                               klass, TokenPosition::kMinSource));
+    function.set_end_token_pos(TokenPosition::kMinSource);
     klass.AddFunction(function);
     function.set_kernel_function(kernel_constructor);
     function.set_result_type(T.ReceiverType(klass));
     SetupFunctionParameters(H, T, klass, function,
                             kernel_constructor->function(),
                             true,    // is_method
                             false);  // is_closure
   }
 
   for (intptr_t i = 0; i < kernel_klass->procedures().length(); i++) {
@@ skipping 56 matching lines @@
     }
   }
   const Object& script_class =
       ClassForScriptAt(owner, kernel_procedure->source_uri_index());
   dart::Function& function = dart::Function::ZoneHandle(
       Z, Function::New(name, GetFunctionType(kernel_procedure),
                        !is_method,  // is_static
                        false,       // is_const
                        is_abstract, is_external,
                        native_name != NULL,  // is_native
-                       script_class, TokenPosition::kNoSource));
+                       script_class, TokenPosition::kMinSource));
+  function.set_end_token_pos(TokenPosition::kMinSource);
   owner.AddFunction(function);
   function.set_kernel_function(kernel_procedure);
   function.set_is_debuggable(false);
   if (native_name != NULL) {
     function.set_native_name(*native_name);
   }
 
   SetupFunctionParameters(H, T, owner, function, kernel_procedure->function(),
                           is_method,
                           false);  // is_closure
@@ skipping 10 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;
 }
 
-Script& KernelReader::ScriptAt(intptr_t source_uri_index) {
+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];
-    script = Script::New(H.DartString(uri, Heap::kOld),
-                         dart::String::ZoneHandle(Z), RawScript::kKernelTag);
+    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_->line_starting_table().valuesFor(source_uri_index);
-    intptr_t line_count = line_starts[0];
+        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 + 1]);
+      value = Smi::New(line_starts[i]);
       array_object.SetAt(i, value);
     }
     script.set_line_starts(array_object);
   }
   return script;
 }
 
 void KernelReader::GenerateFieldAccessors(const dart::Class& klass,
                                           const dart::Field& field,
                                           Field* kernel_field) {
@@ 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)