Merge of source position information from kernel-sdk.

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 75 matching lines @@
 RawLibrary* BuildingTranslationHelper::LookupLibraryByKernelLibrary(
     Library* library) {
   return reader_->LookupLibrary(library).raw();
 }
 
 
 RawClass* BuildingTranslationHelper::LookupClassByKernelClass(Class* klass) {
   return reader_->LookupClass(klass).raw();
 }
 
+Program* KernelReader::ReadPrecompiledProgram() {
+  Program* program = ReadPrecompiledKernelFromBuffer(buffer_, buffer_length_);
+  if (program == NULL) return NULL;
+  intptr_t source_file_count = program->line_starting_table().size();
+  scripts_ = Array::New(source_file_count);
+  program_ = program;
+  return program;
+}
 
 Object& KernelReader::ReadProgram() {
   ASSERT(!bootstrapping_);
-  Program* program = ReadPrecompiledKernelFromBuffer(buffer_, buffer_length_);
+  Program* program = ReadPrecompiledProgram();
   if (program == NULL) {
     const dart::String& error = H.DartString("Failed to read .kernell file");
     return Object::Handle(Z, ApiError::New(error));
   }
 
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     Procedure* main = program->main_method();
     Library* kernel_main_library = Library::Cast(main->parent());
 
@@ skipping 43 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).
 
-  // TODO(27590): Figure out why we need this script stuff here.
-  Script& script = Script::Handle(
-      Z,
-      Script::New(H.DartString(""), H.DartString(""), RawScript::kScriptTag));
-  script.SetLocationOffset(0, 0);
-  script.Tokenize(H.DartString("nop() {}"));
+  Script& script = ScriptAt(kernel_library->source_uri_index());
   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);
   if (bootstrapping_) {
     GrowableObjectArray::Handle(Z, I->object_store()->pending_classes())
         .Add(toplevel_class, Heap::kOld);
   }
 
   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];
 
     ActiveMemberScope active_member_scope(&active_class_, kernel_field);
     const dart::String& name = H.DartFieldName(kernel_field->name());
+    const Object& script_class =
+        ClassForScriptAt(toplevel_class, kernel_field->source_uri_index());
     dart::Field& field = dart::Field::Handle(
         Z, dart::Field::NewTopLevel(name, kernel_field->IsFinal(),
-                                    kernel_field->IsConst(), toplevel_class,
-                                    TokenPosition::kNoSource));
+                                    kernel_field->IsConst(), script_class,
+                                    kernel_field->position()));
     field.set_kernel_field(kernel_field);
     const AbstractType& type = T.TranslateType(kernel_field->type());
     field.SetFieldType(type);
     field.set_has_initializer(kernel_field->initializer() != NULL);
     GenerateFieldAccessors(toplevel_class, field, kernel_field);
     toplevel_class.AddField(field);
     library.AddObject(field, name);
   }
 
   // Load toplevel procedures.
@@ skipping 86 matching lines @@
 }
 
 
 dart::Class& KernelReader::ReadClass(const dart::Library& library,
                                      Class* kernel_klass) {
   // This will trigger a call to [ReadPreliminaryClass] if not already done.
   dart::Class& klass = LookupClass(kernel_klass);
 
   ActiveClassScope active_class_scope(&active_class_, kernel_klass, &klass);
 
-  TokenPosition pos(0);
-
   for (intptr_t i = 0; i < kernel_klass->fields().length(); i++) {
     Field* kernel_field = kernel_klass->fields()[i];
     ActiveMemberScope active_member_scope(&active_class_, kernel_field);
 
     const dart::String& name = H.DartFieldName(kernel_field->name());
     const AbstractType& type =
         T.TranslateTypeWithoutFinalization(kernel_field->type());
     dart::Field& field = dart::Field::Handle(
         Z, dart::Field::New(name, kernel_field->IsStatic(),
                             // In the VM all const fields are implicitly final
                             // whereas in Kernel they are not final because they
                             // are not explicitly declared that way.
                             kernel_field->IsFinal() || kernel_field->IsConst(),
                             kernel_field->IsConst(),
                             false,  // is_reflectable
-                            klass, type, pos));
+                            klass, type, kernel_field->position()));
     field.set_kernel_field(kernel_field);
     field.set_has_initializer(kernel_field->initializer() != NULL);
     GenerateFieldAccessors(klass, field, kernel_field);
     klass.AddField(field);
   }
 
   for (intptr_t i = 0; i < kernel_klass->constructors().length(); i++) {
     Constructor* kernel_constructor = kernel_klass->constructors()[i];
     ActiveMemberScope active_member_scope(&active_class_, kernel_constructor);
     ActiveFunctionScope active_function_scope(&active_class_,
                                               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, pos));
+                               klass, TokenPosition::kNoSource));
     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 15 matching lines @@
 void KernelReader::ReadProcedure(const dart::Library& library,
                                  const dart::Class& owner,
                                  Procedure* kernel_procedure,
                                  Class* kernel_klass) {
   ActiveClassScope active_class_scope(&active_class_, kernel_klass, &owner);
   ActiveMemberScope active_member_scope(&active_class_, kernel_procedure);
   ActiveFunctionScope active_function_scope(&active_class_,
                                             kernel_procedure->function());
 
   const dart::String& name = H.DartProcedureName(kernel_procedure);
-  TokenPosition pos(0);
   bool is_method = kernel_klass != NULL && !kernel_procedure->IsStatic();
   bool is_abstract = kernel_procedure->IsAbstract();
   bool is_external = kernel_procedure->IsExternal();
   dart::String* native_name = NULL;
   if (is_external) {
     // Maybe it has a native implementation, which is not external as far as
     // the VM is concerned because it does have an implementation.  Check for
     // an ExternalName annotation and extract the string from it.
     for (int i = 0; i < kernel_procedure->annotations().length(); ++i) {
       Expression* annotation = kernel_procedure->annotations()[i];
@@ skipping 15 matching lines @@
 
       is_external = false;
       ASSERT(invocation->arguments()->positional().length() == 1 &&
              invocation->arguments()->named().length() == 0);
       StringLiteral* literal =
           StringLiteral::Cast(invocation->arguments()->positional()[0]);
       native_name = &H.DartSymbol(literal->value());
       break;
     }
   }
+  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
-                       owner, pos));
+                       script_class, TokenPosition::kNoSource));
   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
 
   if (kernel_klass == NULL) {
     library.AddObject(function, name);
     ASSERT(!Object::Handle(Z, library.LookupObjectAllowPrivate(
                                   H.DartProcedureName(kernel_procedure)))
                 .IsNull());
   }
 }
 
+const Object& KernelReader::ClassForScriptAt(const dart::Class& klass,
+                                             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& script = Script::ZoneHandle(Z);
+  script ^= scripts_.At(source_uri_index);
+  if (script.IsNull()) {
+    String* uri = program_->source_uri_table().strings()[source_uri_index];
+    script = Script::New(H.DartString(uri), dart::String::ZoneHandle(Z),
+                         RawScript::kKernelTag);
+    scripts_.SetAt(source_uri_index, script);
+    intptr_t* line_starts =
+        program_->line_starting_table().valuesFor(source_uri_index);
+    intptr_t line_count = line_starts[0];
+    Array& array_object = Array::Handle(Z, Array::New(line_count));
+    Smi& value = Smi::Handle(Z);
+    for (intptr_t i = 0; i < line_count; ++i) {
+      value = Smi::New(line_starts[i + 1]);
+      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) {
-  TokenPosition pos(0);
-
   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
     // sentinel.
     SimpleExpressionConverter converter(H.thread(), Z);
     if (converter.IsSimple(kernel_field->initializer())) {
       // We do not need a getter.
       field.SetStaticValue(converter.SimpleValue(), true);
       return;
     }
     // We do need a getter that evaluates the initializer if necessary.
     field.SetStaticValue(Object::sentinel(), true);
   }
 
   const dart::String& getter_name = H.DartGetterName(kernel_field->name());
+  const Object& script_class =
+      ClassForScriptAt(klass, kernel_field->source_uri_index());
   Function& getter = Function::ZoneHandle(
       Z,
       Function::New(
           getter_name,
           kernel_field->IsStatic() ? RawFunction::kImplicitStaticFinalGetter
                                    : RawFunction::kImplicitGetter,
           kernel_field->IsStatic(),
           // The functions created by the parser have is_const for static fields
           // that are const (not just final) and they have is_const for
           // non-static
           // fields that are final.
           kernel_field->IsStatic() ? kernel_field->IsConst()
                                    : kernel_field->IsFinal(),
           false,  // is_abstract
           false,  // is_external
           false,  // is_native
-          klass, pos));
+          script_class, kernel_field->position()));
   klass.AddFunction(getter);
   if (klass.IsTopLevel()) {
     dart::Library& library = dart::Library::Handle(Z, klass.library());
     library.AddObject(getter, getter_name);
   }
   getter.set_kernel_function(kernel_field);
   getter.set_result_type(AbstractType::Handle(Z, field.type()));
   getter.set_is_debuggable(false);
   SetupFieldAccessorFunction(klass, getter);
 
   if (!kernel_field->IsStatic() && !kernel_field->IsFinal()) {
     // Only static fields can be const.
     ASSERT(!kernel_field->IsConst());
     const dart::String& setter_name = H.DartSetterName(kernel_field->name());
     Function& setter = Function::ZoneHandle(
         Z, Function::New(setter_name, RawFunction::kImplicitSetter,
                          false,  // is_static
                          false,  // is_const
                          false,  // is_abstract
                          false,  // is_external
                          false,  // is_native
-                         klass, pos));
+                         script_class, kernel_field->position()));
     klass.AddFunction(setter);
     setter.set_kernel_function(kernel_field);
     setter.set_result_type(Object::void_type());
     setter.set_is_debuggable(false);
     SetupFieldAccessorFunction(klass, setter);
   }
 }
 
 
 void KernelReader::SetupFunctionParameters(TranslationHelper translation_helper,
@@ skipping 112 matching lines @@
 dart::Class& KernelReader::LookupClass(Class* klass) {
   dart::Class* handle = NULL;
   if (!classes_.Lookup(klass, &handle)) {
     dart::Library& library = LookupLibrary(klass->parent());
     const dart::String& name = H.DartClassName(klass);
     handle = &dart::Class::Handle(Z, library.LookupClass(name));
     if (handle->IsNull()) {
       // The class needs to have a script because all the functions in the class
       // will inherit it.  The predicate Function::IsOptimizable uses the
       // absence of a script to detect test functions that should not be
-      // optimized.  Use a dummy script.
-      //
-      // TODO(27590): We shouldn't need a dummy script per class.  At the
-      // least we could have a singleton.  At best, we'd change IsOptimizable to
-      // detect test functions some other way (like simply not setting the
-      // optimizable bit on those functions in the first place).
-      TokenPosition pos(0);
-      Script& script =
-          Script::Handle(Z, Script::New(H.DartString(""), H.DartString(""),
-                                        RawScript::kScriptTag));
-      handle =
-          &dart::Class::Handle(Z, dart::Class::New(library, name, script, pos));
+      // optimized.
+      Script& script = ScriptAt(klass->source_uri_index());
+      handle = &dart::Class::Handle(
+          Z, dart::Class::New(library, name, script, TokenPosition::kNoSource));
       library.AddClass(*handle);
     } else if (handle->script() == Script::null()) {
       // When bootstrapping we can encounter classes that do not yet have a
       // dummy script.
-      TokenPosition pos(0);
-      Script& script =
-          Script::Handle(Z, Script::New(H.DartString(""), H.DartString(""),
-                                        RawScript::kScriptTag));
+      Script& script = ScriptAt(klass->source_uri_index());
       handle->set_script(script);
     }
     // Insert the class in the cache before calling ReadPreliminaryClass so
     // we do not risk allocating the class again by calling LookupClass
     // recursively from ReadPreliminaryClass for the same class.
     classes_.Insert(klass, handle);
     if (!handle->is_type_finalized()) {
       ReadPreliminaryClass(handle, klass);
     }
   }
@@ skipping 15 matching lines @@
   } else {
     ASSERT(0 <= kind && kind <= Procedure::kFactory);
     return static_cast<RawFunction::Kind>(lookuptable[kind]);
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)