Rename the class "KernelReader" to "KernelLoader".

runtime/vm/kernel_loader.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 "vm/kernel_loader.h"
 
 #include <string.h>
 
 #include "vm/dart_api_impl.h"
 #include "vm/kernel_binary.h"
-#include "vm/kernel_binary_flowgraph.h"
 #include "vm/kernel_to_il.h"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/symbols.h"
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 namespace dart {
 namespace kernel {
 
@@ skipping 75 matching lines @@
   const Instance& SimpleValue() { return *simple_value_; }
   Zone* zone() const { return zone_; }
 
  private:
   TranslationHelper& translation_helper_;
   Zone* zone_;
   Instance* simple_value_;
   StreamingFlowGraphBuilder* builder_;
 };
 
-RawArray* KernelReader::MakeFunctionsArray() {
+RawArray* KernelLoader::MakeFunctionsArray() {
   const intptr_t len = functions_.length();
   const Array& res = Array::Handle(zone_, Array::New(len, Heap::kOld));
   for (intptr_t i = 0; i < len; i++) {
     res.SetAt(i, *functions_[i]);
   }
   return res.raw();
 }
 
 RawLibrary* BuildingTranslationHelper::LookupLibraryByKernelLibrary(
     NameIndex library) {
-  return reader_->LookupLibrary(library).raw();
+  return loader_->LookupLibrary(library).raw();
 }
 
 RawClass* BuildingTranslationHelper::LookupClassByKernelClass(NameIndex klass) {
-  return reader_->LookupClass(klass).raw();
+  return loader_->LookupClass(klass).raw();
 }
 
-KernelReader::KernelReader(Program* program)
+KernelLoader::KernelLoader(Program* program)
     : program_(program),
       thread_(Thread::Current()),
       zone_(thread_->zone()),
       isolate_(thread_->isolate()),
       scripts_(Array::ZoneHandle(zone_)),
       patch_classes_(Array::ZoneHandle(zone_)),
       translation_helper_(this, thread_),
       builder_(&translation_helper_,
                zone_,
                program_->kernel_data(),
@@ skipping 30 matching lines @@
       Z, TypedData::New(kTypedDataUint32ArrayCid, count, Heap::kOld));
   for (intptr_t i = 0; i < count; ++i) {
     names.SetUint32(i << 2, reader.ReadUInt());
   }
 
   H.SetStringOffsets(offsets);
   H.SetStringData(data);
   H.SetCanonicalNames(names);
 }
 
-Object& KernelReader::ReadProgram() {
+Object& KernelLoader::LoadProgram() {
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     intptr_t length = program_->library_count();
     for (intptr_t i = 0; i < length; i++) {
-      ReadLibrary(library_offset(i));
+      LoadLibrary(library_offset(i));
     }
 
     for (intptr_t i = 0; i < length; i++) {
       Library& library = LookupLibrary(library_canonical_name(i));
       if (!library.Loaded()) library.SetLoaded();
     }
 
     if (ClassFinalizer::ProcessPendingClasses(/*from_kernel=*/true)) {
       // If 'main' is not found return a null library, this is the case
       // when bootstrapping is in progress.
@@ skipping 12 matching lines @@
   }
 
   // Either class finalization failed or we caught a compile error.
   // In both cases sticky error would be set.
   Error& error = Error::Handle(Z);
   error = thread_->sticky_error();
   thread_->clear_sticky_error();
   return error;
 }
 
-void KernelReader::FindModifiedLibraries(Isolate* isolate,
+void KernelLoader::FindModifiedLibraries(Isolate* isolate,
                                          BitVector* modified_libs,
                                          bool force_reload) {
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     if (force_reload) {
       // If a reload is being forced we mark all libraries as having
       // been modified.
       const GrowableObjectArray& libs =
           GrowableObjectArray::Handle(isolate->object_store()->libraries());
       intptr_t num_libs = libs.Length();
@@ skipping 16 matching lines @@
       library_helper.ReadUntilIncluding(LibraryHelper::kCanonicalName);
       dart::Library& lib = LookupLibrary(library_helper.canonical_name_);
       if (!lib.IsNull() && !lib.is_dart_scheme()) {
         // This is a library that already exists so mark it as being modified.
         modified_libs->Add(lib.index());
       }
     }
   }
 }
 
-void KernelReader::ReadLibrary(intptr_t kernel_offset) {
+void KernelLoader::LoadLibrary(intptr_t kernel_offset) {
   builder_.SetOffset(kernel_offset);
   LibraryHelper library_helper(&builder_);
   library_helper.ReadUntilIncluding(LibraryHelper::kCanonicalName);
   Library& library = LookupLibrary(library_helper.canonical_name_);
   // The Kernel library is external implies that it is already loaded.
   ASSERT(!library_helper.IsExternal() || library.Loaded());
   if (library.Loaded()) return;
 
   library_helper.ReadUntilIncluding(LibraryHelper::kName);
   library.SetName(H.DartSymbol(library_helper.name_index_));
@@ skipping 20 matching lines @@
   library.set_toplevel_class(toplevel_class);
 
   const GrowableObjectArray& classes =
       GrowableObjectArray::Handle(Z, I->object_store()->pending_classes());
 
   library_helper.ReadUntilExcluding(LibraryHelper::kClasses);
 
   // Load all classes.
   int class_count = builder_.ReadListLength();  // read list length.
   for (intptr_t i = 0; i < class_count; ++i) {
-    classes.Add(ReadClass(library, toplevel_class), Heap::kOld);
+    classes.Add(LoadClass(library, toplevel_class), Heap::kOld);
   }
 
   fields_.Clear();
   functions_.Clear();
   ActiveClassScope active_class_scope(&active_class_, &toplevel_class);
   // Load toplevel fields.
   intptr_t field_count = builder_.ReadListLength();  // read list length.
   for (intptr_t i = 0; i < field_count; ++i) {
     intptr_t field_offset = builder_.ReaderOffset();
     ActiveMemberScope active_member_scope(&active_class_, NULL);
@@ skipping 31 matching lines @@
                                &kernel_data);
     }
     fields_.Add(&field);
     library.AddObject(field, name);
   }
   toplevel_class.AddFields(fields_);
 
   // Load toplevel procedures.
   intptr_t procedure_count = builder_.ReadListLength();  // read list length.
   for (intptr_t i = 0; i < procedure_count; ++i) {
-    ReadProcedure(library, toplevel_class, false);
+    LoadProcedure(library, toplevel_class, false);
   }
 
   toplevel_class.SetFunctions(Array::Handle(MakeFunctionsArray()));
 
   classes.Add(toplevel_class, Heap::kOld);
 }
 
-void KernelReader::ReadPreliminaryClass(Class* klass,
+void KernelLoader::LoadPreliminaryClass(Class* klass,
                                         ClassHelper* class_helper,
                                         intptr_t type_parameter_count) {
   // Note: This assumes that ClassHelper is exactly at the position where
   // the length of the type parameters have been read, and that the order in
   // the binary is as follows: [...], kTypeParameters, kSuperClass, kMixinType,
   // kImplementedClasses, [...].
 
   // Set type parameters.
-  ReadAndSetupTypeParameters(*klass, type_parameter_count, *klass,
+  LoadAndSetupTypeParameters(*klass, type_parameter_count, *klass,
                              Function::Handle(Z));
 
   // Set super type.  Some classes (e.g., Object) do not have one.
   Tag type_tag = builder_.ReadTag();  // read super class type (part 1).
   if (type_tag == kSomething) {
     AbstractType& super_type =
         T.BuildTypeWithoutFinalization();  // read super class type (part 2).
     if (super_type.IsMalformed()) H.ReportError("Malformed super type");
     klass->set_super_type(super_type);
   }
@@ skipping 10 matching lines @@
         T.BuildTypeWithoutFinalization();  // read ith type.
     if (type.IsMalformed()) H.ReportError("Malformed interface type.");
     interfaces.SetAt(i, type);
   }
   class_helper->SetJustRead(ClassHelper::kImplementedClasses);
   klass->set_interfaces(interfaces);
 
   if (class_helper->is_abstract_) klass->set_is_abstract();
 }
 
-Class& KernelReader::ReadClass(const Library& library,
+Class& KernelLoader::LoadClass(const Library& library,
                                const Class& toplevel_class) {
   ClassHelper class_helper(&builder_);
   intptr_t class_offset = builder_.ReaderOffset();
   class_helper.ReadUntilIncluding(ClassHelper::kCanonicalName);
   Class& klass = LookupClass(class_helper.canonical_name_);
 
   // 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.
   if (klass.script() == Script::null()) {
     class_helper.ReadUntilIncluding(ClassHelper::kSourceUriIndex);
     klass.set_script(ScriptAt(class_helper.source_uri_index_));
   }
   if (klass.token_pos() == TokenPosition::kNoSource) {
     class_helper.ReadUntilIncluding(ClassHelper::kPosition);
     klass.set_token_pos(class_helper.position_);
   }
 
   class_helper.ReadUntilIncluding(ClassHelper::kAnnotations);
   intptr_t class_offset_after_annotations = builder_.ReaderOffset();
   class_helper.ReadUntilExcluding(ClassHelper::kTypeParameters);
   intptr_t type_parameter_counts =
       builder_.ReadListLength();  // read type_parameters list length.
 
   ActiveClassScope active_class_scope(&active_class_, &klass);
   if (!klass.is_cycle_free()) {
-    ReadPreliminaryClass(&klass, &class_helper, type_parameter_counts);
+    LoadPreliminaryClass(&klass, &class_helper, type_parameter_counts);
   } else {
     for (intptr_t i = 0; i < type_parameter_counts; ++i) {
       builder_.SkipStringReference();  // read ith name index.
       builder_.SkipDartType();         // read ith bound.
     }
     class_helper.SetJustRead(ClassHelper::kTypeParameters);
   }
 
   fields_.Clear();
   functions_.Clear();
@@ skipping 96 matching lines @@
     if (FLAG_enable_mirrors && constructor_helper.annotation_count_ > 0) {
       library.AddFunctionMetadata(function, TokenPosition::kNoSource,
                                   constructor_offset, &kernel_data);
     }
   }
   class_helper.SetJustRead(ClassHelper::kConstructors);
 
   class_helper.ReadUntilExcluding(ClassHelper::kProcedures);
   int procedure_count = builder_.ReadListLength();  // read list length.
   for (intptr_t i = 0; i < procedure_count; ++i) {
-    ReadProcedure(library, klass, true);
+    LoadProcedure(library, klass, true);
   }
   class_helper.SetJustRead(ClassHelper::kProcedures);
 
   klass.SetFunctions(Array::Handle(MakeFunctionsArray()));
 
   if (!klass.is_marked_for_parsing()) {
     klass.set_is_marked_for_parsing();
   }
 
   if (FLAG_enable_mirrors && class_helper.annotation_count_ > 0) {
     TypedData& header_data = builder_.reader_->CopyDataToVMHeap(
         Z, class_offset, class_offset_after_annotations);
     library.AddClassMetadata(klass, toplevel_class, TokenPosition::kNoSource,
                              class_offset, &header_data);
   }
 
   class_helper.ReadUntilExcluding(ClassHelper::kEnd);
 
   return klass;
 }
 
-void KernelReader::ReadProcedure(const Library& library,
+void KernelLoader::LoadProcedure(const Library& library,
                                  const Class& owner,
                                  bool in_class) {
   intptr_t procedure_offset = builder_.ReaderOffset();
   ProcedureHelper procedure_helper(&builder_);
 
   procedure_helper.ReadUntilExcluding(ProcedureHelper::kAnnotations);
   const String& name = H.DartProcedureName(procedure_helper.canonical_name_);
   bool is_method = in_class && !procedure_helper.IsStatic();
   bool is_abstract = procedure_helper.IsAbstract();
   bool is_external = procedure_helper.IsExternal();
@@ skipping 99 matching lines @@
 
   if (native_name != NULL) {
     function.set_native_name(*native_name);
   }
 
   function_node_helper.ReadUntilExcluding(FunctionNodeHelper::kTypeParameters);
   if (!function.IsFactory()) {
     // Read type_parameters list length.
     intptr_t type_parameter_count = builder_.ReadListLength();
     // Set type parameters.
-    ReadAndSetupTypeParameters(function, type_parameter_count, Class::Handle(Z),
+    LoadAndSetupTypeParameters(function, type_parameter_count, Class::Handle(Z),
                                function);
     function_node_helper.SetJustRead(FunctionNodeHelper::kTypeParameters);
   }
 
   function_node_helper.ReadUntilExcluding(
       FunctionNodeHelper::kRequiredParameterCount);
   builder_.SetupFunctionParameters(owner, function, is_method,
                                    false,  // is_closure
                                    &function_node_helper);
   function_node_helper.ReadUntilExcluding(FunctionNodeHelper::kEnd);
@@ skipping 11 matching lines @@
   TypedData& kernel_data = builder_.reader_->CopyDataToVMHeap(
       Z, procedure_offset, builder_.ReaderOffset());
   function.set_kernel_data(kernel_data);
 
   if (FLAG_enable_mirrors && annotation_count > 0) {
     library.AddFunctionMetadata(function, TokenPosition::kNoSource,
                                 procedure_offset, &kernel_data);
   }
 }
 
-void KernelReader::ReadAndSetupTypeParameters(
+void KernelLoader::LoadAndSetupTypeParameters(
     const Object& set_on,
     intptr_t type_parameter_count,
     const Class& parameterized_class,
     const Function& parameterized_function) {
   ASSERT(type_parameter_count >= 0);
   if (type_parameter_count == 0) {
     return;
   }
   // First setup the type parameters, so if any of the following code uses it
   // (in a recursive way) we're fine.
@@ skipping 38 matching lines @@
       AbstractType& bound =
           T.BuildTypeWithoutFinalization();  // read ith bound.
       if (bound.IsMalformedOrMalbounded()) {
         bound = I->object_store()->object_type();
       }
       parameter.set_bound(bound);
     }
   }
 }
 
-const Object& KernelReader::ClassForScriptAt(const Class& klass,
+const Object& KernelLoader::ClassForScriptAt(const Class& klass,
                                              intptr_t source_uri_index) {
   Script& correct_script = ScriptAt(source_uri_index);
   if (klass.script() != correct_script.raw()) {
     // Use cache for patch classes. This works best for in-order usages.
     PatchClass& patch_class = PatchClass::ZoneHandle(Z);
     patch_class ^= patch_classes_.At(source_uri_index);
     if (patch_class.IsNull() || patch_class.origin_class() != klass.raw()) {
       patch_class = PatchClass::New(klass, correct_script);
       patch_classes_.SetAt(source_uri_index, patch_class);
     }
     return patch_class;
   }
   return klass;
 }
 
-Script& KernelReader::ScriptAt(intptr_t index, StringIndex import_uri) {
+Script& KernelLoader::ScriptAt(intptr_t index, StringIndex import_uri) {
   Script& script = Script::ZoneHandle(Z);
   script ^= scripts_.At(index);
   if (script.IsNull()) {
     // Create script with correct uri(s).
     String& uri_string = builder_.SourceTableUriFor(index);
     String& import_uri_string =
         import_uri == -1 ? uri_string : H.DartString(import_uri, Heap::kOld);
     script = Script::New(import_uri_string, uri_string,
                          builder_.GetSourceFor(index), RawScript::kKernelTag);
     script.set_kernel_script_index(index);
     script.set_kernel_string_offsets(H.string_offsets());
     script.set_kernel_string_data(H.string_data());
     script.set_kernel_canonical_names(H.canonical_names());
     scripts_.SetAt(index, script);
 
     script.set_line_starts(builder_.GetLineStartsFor(index));
     script.set_debug_positions(Array::Handle(Array::null()));
     script.set_yield_positions(Array::Handle(Array::null()));
   }
   return script;
 }
 
-void KernelReader::GenerateFieldAccessors(const Class& klass,
+void KernelLoader::GenerateFieldAccessors(const Class& klass,
                                           const Field& field,
                                           FieldHelper* field_helper,
                                           intptr_t field_offset) {
   Tag tag = builder_.PeekTag();
   if (field_helper->IsStatic() && tag == kNothing) {
     // Static fields without an initializer are implicitly initialized to null.
     // We do not need a getter.
     field.SetStaticValue(Instance::Handle(Z), true);
     return;
   }
@@ skipping 66 matching lines @@
     functions_.Add(&setter);
     setter.set_kernel_data(TypedData::Handle(Z, field.kernel_data()));
     setter.set_end_token_pos(field_helper->end_position_);
     setter.set_kernel_offset(field_offset);
     setter.set_result_type(Object::void_type());
     setter.set_is_debuggable(false);
     SetupFieldAccessorFunction(klass, setter);
   }
 }
 
-void KernelReader::SetupFieldAccessorFunction(const Class& klass,
+void KernelLoader::SetupFieldAccessorFunction(const Class& klass,
                                               const Function& function) {
   bool is_setter = function.IsImplicitSetterFunction();
   bool is_method = !function.IsStaticFunction();
   intptr_t parameter_count = (is_method ? 1 : 0) + (is_setter ? 1 : 0);
 
   function.SetNumOptionalParameters(0, false);
   function.set_num_fixed_parameters(parameter_count);
   function.set_parameter_types(
       Array::Handle(Z, Array::New(parameter_count, Heap::kOld)));
   function.set_parameter_names(
       Array::Handle(Z, Array::New(parameter_count, Heap::kOld)));
 
   intptr_t pos = 0;
   if (is_method) {
     function.SetParameterTypeAt(pos, T.ReceiverType(klass));
     function.SetParameterNameAt(pos, Symbols::This());
     pos++;
   }
   if (is_setter) {
     function.SetParameterTypeAt(pos, AbstractType::dynamic_type());
     function.SetParameterNameAt(pos, Symbols::Value());
     pos++;
   }
 }
 
-Library& KernelReader::LookupLibrary(NameIndex library) {
+Library& KernelLoader::LookupLibrary(NameIndex library) {
   Library* handle = NULL;
   if (!libraries_.Lookup(library, &handle)) {
     const String& url = H.DartSymbol(H.CanonicalNameString(library));
     handle = &Library::Handle(Z, Library::LookupLibrary(thread_, url));
     if (handle->IsNull()) {
       *handle = Library::New(url);
       handle->Register(thread_);
     }
     ASSERT(!handle->IsNull());
     libraries_.Insert(library, handle);
   }
   return *handle;
 }
 
-Class& KernelReader::LookupClass(NameIndex klass) {
+Class& KernelLoader::LookupClass(NameIndex klass) {
   Class* handle = NULL;
   if (!classes_.Lookup(klass, &handle)) {
     Library& library = LookupLibrary(H.CanonicalNameParent(klass));
     const String& name = H.DartClassName(klass);
     handle = &Class::Handle(Z, library.LookupClass(name));
     if (handle->IsNull()) {
       *handle = Class::New(library, name, Script::Handle(Z),
                            TokenPosition::kNoSource);
       library.AddClass(*handle);
     }
     // 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);
   }
   return *handle;
 }
 
-RawFunction::Kind KernelReader::GetFunctionType(
+RawFunction::Kind KernelLoader::GetFunctionType(
     ProcedureHelper::Kind procedure_kind) {
   intptr_t lookuptable[] = {
       RawFunction::kRegularFunction,  // Procedure::kMethod
       RawFunction::kGetterFunction,   // Procedure::kGetter
       RawFunction::kSetterFunction,   // Procedure::kSetter
       RawFunction::kRegularFunction,  // Procedure::kOperator
       RawFunction::kConstructor,      // Procedure::kFactory
   };
   intptr_t kind = static_cast<int>(procedure_kind);
   ASSERT(0 <= kind && kind <= ProcedureHelper::kFactory);
   return static_cast<RawFunction::Kind>(lookuptable[kind]);
 }
 
-bool KernelReader::FieldHasFunctionLiteralInitializer(const Field& field,
-                                                      TokenPosition* start,
-                                                      TokenPosition* end) {
-  Zone* zone = Thread::Current()->zone();
-  const Script& script = Script::Handle(zone, field.Script());
-
-  TranslationHelper translation_helper(
-      Thread::Current(), script.kernel_string_offsets(),
-      script.kernel_string_data(), script.kernel_canonical_names());
-
-  StreamingFlowGraphBuilder builder(
-      &translation_helper, zone, field.kernel_offset(),
-      TypedData::Handle(zone, field.kernel_data()));
-  kernel::FieldHelper field_helper(&builder);
-  field_helper.ReadUntilExcluding(kernel::FieldHelper::kEnd, true);
-  return field_helper.FieldHasFunctionLiteralInitializer(start, end);
-}
-
 ParsedFunction* ParseStaticFieldInitializer(Zone* zone, const Field& field) {
   Thread* thread = Thread::Current();
 
   String& init_name = String::Handle(zone, field.name());
   init_name = Symbols::FromConcat(thread, Symbols::InitPrefix(), init_name);
 
   // Create a static initializer.
   const Object& owner = Object::Handle(field.RawOwner());
   const Function& initializer_fun = Function::ZoneHandle(
       zone, Function::New(init_name, RawFunction::kImplicitStaticFinalGetter,
                           true,   // is_static
                           false,  // is_const
                           false,  // is_abstract
                           false,  // is_external
                           false,  // is_native
                           owner, TokenPosition::kNoSource));
   initializer_fun.set_kernel_data(TypedData::Handle(zone, field.kernel_data()));
   initializer_fun.set_kernel_offset(field.kernel_offset());
   initializer_fun.set_result_type(AbstractType::Handle(zone, field.type()));
   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)