Rename the class "KernelReader" to "KernelLoader".

runtime/vm/kernel_loader.h

 // 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.
 
-#ifndef RUNTIME_VM_KERNEL_READER_H_
-#define RUNTIME_VM_KERNEL_READER_H_
+#ifndef RUNTIME_VM_KERNEL_LOADER_H_
+#define RUNTIME_VM_KERNEL_LOADER_H_
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 #include <map>
 
 #include "vm/kernel.h"
 #include "vm/kernel_binary_flowgraph.h"
 #include "vm/kernel_to_il.h"
 #include "vm/object.h"
 
 namespace dart {
 namespace kernel {
 
-class KernelReader;
+class KernelLoader;
 
 class BuildingTranslationHelper : public TranslationHelper {
  public:
-  BuildingTranslationHelper(KernelReader* reader, Thread* thread)
-      : TranslationHelper(thread), reader_(reader) {}
+  BuildingTranslationHelper(KernelLoader* loader, Thread* thread)
+      : TranslationHelper(thread), loader_(loader) {}
   virtual ~BuildingTranslationHelper() {}
 
   virtual RawLibrary* LookupLibraryByKernelLibrary(NameIndex library);
   virtual RawClass* LookupClassByKernelClass(NameIndex klass);
 
  private:
-  KernelReader* reader_;
+  KernelLoader* loader_;
 };
 
 template <typename VmType>
 class Mapping {
  public:
   bool Lookup(intptr_t canonical_name, VmType** handle) {
     typename MapType::Pair* pair = map_.LookupPair(canonical_name);
     if (pair != NULL) {
       *handle = pair->value;
       return true;
     }
     return false;
   }
 
   void Insert(intptr_t canonical_name, VmType* object) {
     map_.Insert(canonical_name, object);
   }
 
  private:
   typedef IntMap<VmType*> MapType;
   MapType map_;
 };
 
-class KernelReader {
+class KernelLoader {
  public:
-  explicit KernelReader(Program* program);
+  explicit KernelLoader(Program* program);
 
   // Returns the library containing the main procedure, null if there
   // was no main procedure, or a failure object if there was an error.
-  Object& ReadProgram();
+  Object& LoadProgram();
 
   // Finds all libraries that have been modified in this incremental
   // version of the kernel program file.
   void FindModifiedLibraries(Isolate* isolate,
                              BitVector* modified_libs,
                              bool force_reload);
 
-  void ReadLibrary(intptr_t kernel_offset);
+  void LoadLibrary(intptr_t kernel_offset);
 
   const String& DartSymbol(StringIndex index) {
     return translation_helper_.DartSymbol(index);
   }
 
   const String& LibraryUri(intptr_t library_index) {
     return translation_helper_.DartSymbol(
         translation_helper_.CanonicalNameString(
             library_canonical_name(library_index)));
   }
@@ skipping 13 matching lines @@
                       (program_->library_count() - index) * 4);
     reader.set_offset(reader.ReadUInt32());
 
     // Start reading library.
     reader.ReadFlags();
     return reader.ReadCanonicalNameReference();
   }
 
   uint8_t CharacterAt(StringIndex string_index, intptr_t index);
 
-  static bool FieldHasFunctionLiteralInitializer(const Field& field,
-                                                 TokenPosition* start,
-                                                 TokenPosition* end);
-
  private:
   friend class BuildingTranslationHelper;
 
-  void ReadPreliminaryClass(Class* klass,
+  void LoadPreliminaryClass(Class* klass,
                             ClassHelper* class_helper,
                             intptr_t type_parameter_count);
-  Class& ReadClass(const Library& library, const Class& toplevel_class);
-  void ReadProcedure(const Library& library, const Class& owner, bool in_class);
+  Class& LoadClass(const Library& library, const Class& toplevel_class);
+  void LoadProcedure(const Library& library, const Class& owner, bool in_class);
 
-  void ReadAndSetupTypeParameters(const Object& set_on,
+  void LoadAndSetupTypeParameters(const Object& set_on,
                                   intptr_t type_parameter_count,
                                   const Class& parameterized_class,
                                   const Function& parameterized_function);
 
   RawArray* MakeFunctionsArray();
 
   // If klass's script is not the script at the uri index, return a PatchClass
   // for klass whose script corresponds to the uri index.
   // Otherwise return klass.
   const Object& ClassForScriptAt(const Class& klass, intptr_t source_uri_index);
@@ skipping 27 matching lines @@
   Mapping<Class> classes_;
 
   GrowableArray<const Function*> functions_;
   GrowableArray<const Field*> fields_;
 };
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
-#endif  // RUNTIME_VM_KERNEL_READER_H_
+#endif  // RUNTIME_VM_KERNEL_LOADER_H_