Revert "[kernel] Stream everything. Replace .kernel_function with .kernel_offset"

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/kernel_binary.h"
@@ skipping 184 matching lines @@
         return dart::Library::Handle(Z);
       }
 
       NameIndex main_library = H.EnclosingName(main);
       dart::Library& library = LookupLibrary(main_library);
       // Sanity check that we can find the main entrypoint.
       Object& main_obj = Object::Handle(
           Z, library.LookupObjectAllowPrivate(H.DartSymbol("main")));
       ASSERT(!main_obj.IsNull());
 
+      Function& to_patch = Function::Handle(
+          Z, builtin_library.LookupFunctionAllowPrivate(
+                 dart::String::Handle(dart::String::New("_getMainClosure"))));
+
+      Procedure* procedure =
+          reinterpret_cast<Procedure*>(to_patch.kernel_function());
+      // If dart:_builtin was not compiled from Kernel at all it does not need
+      // to be patched.
+      if (procedure != NULL) {
+        // We will handle the StaticGet specially and will not use the name.
+        // Note that we pass "true" in cannot_stream to avoid trying to stream
+        // a non-existing part of the binary.
+        //
+        // TODO(kmillikin): we are leaking the new function body.  Find a way to
+        // deallocate it.
+        procedure->function()->ReplaceBody(
+            new ReturnStatement(new StaticGet(NameIndex(), false), false));
+      }
       return library;
     }
   }
 
   // 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;
@@ skipping 31 matching lines @@
     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(), script_class,
                                     kernel_field->position()));
-    field.set_kernel_offset(kernel_field->kernel_offset());
+    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);
     fields_.Add(&field);
     library.AddObject(field, name);
   }
   toplevel_class.AddFields(fields_);
 
   // Load toplevel procedures.
@@ skipping 131 matching lines @@
       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
                            script_class, type, kernel_field->position()));
-      field.set_kernel_offset(kernel_field->kernel_offset());
+      field.set_kernel_field(kernel_field);
       field.set_has_initializer(kernel_field->initializer() != NULL);
       GenerateFieldAccessors(klass, field, kernel_field);
       fields_.Add(&field);
     }
     klass.AddFields(fields_);
   }
 
   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);
 
     const dart::String& name =
         H.DartConstructorName(kernel_constructor->canonical_name());
     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, kernel_constructor->position()));
     function.set_end_token_pos(kernel_constructor->end_position());
     functions_.Add(&function);
-    function.set_kernel_offset(kernel_constructor->kernel_offset());
+    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
 
     if (FLAG_enable_mirrors) {
       library.AddFunctionMetadata(function, TokenPosition::kNoSource,
-                                  kernel_constructor->kernel_offset());
+                                  kernel_constructor);
     }
   }
 
   for (intptr_t i = 0; i < kernel_klass->procedures().length(); i++) {
     Procedure* kernel_procedure = kernel_klass->procedures()[i];
     ActiveMemberScope active_member_scope(&active_class_, kernel_procedure);
     ReadProcedure(library, klass, kernel_procedure, kernel_klass);
   }
 
   klass.SetFunctions(Array::Handle(MakeFunctionsArray()));
 
   if (!klass.is_marked_for_parsing()) {
     klass.set_is_marked_for_parsing();
   }
 
   if (FLAG_enable_mirrors) {
     library.AddClassMetadata(klass, toplevel_class, TokenPosition::kNoSource,
-                             kernel_klass->kernel_offset());
+                             kernel_klass);
   }
 
   return klass;
 }
 
 
 void KernelReader::ReadProcedure(const dart::Library& library,
                                  const dart::Class& owner,
                                  Procedure* kernel_procedure,
                                  Class* kernel_klass) {
@@ skipping 38 matching lines @@
       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, kernel_procedure->position()));
   function.set_end_token_pos(kernel_procedure->end_position());
   functions_.Add(&function);
-  function.set_kernel_offset(kernel_procedure->kernel_offset());
+  function.set_kernel_function(kernel_procedure);
 
   function.set_is_debuggable(
       kernel_procedure->function()->dart_async_marker() == FunctionNode::kSync);
   switch (kernel_procedure->function()->dart_async_marker()) {
     case FunctionNode::kSyncStar:
       function.set_modifier(RawFunction::kSyncGen);
       break;
     case FunctionNode::kAsync:
       function.set_modifier(RawFunction::kAsync);
       function.set_is_inlinable(!FLAG_causal_async_stacks);
@@ skipping 18 matching lines @@
 
   if (kernel_klass == NULL) {
     library.AddObject(function, name);
     ASSERT(!Object::Handle(
                 Z, library.LookupObjectAllowPrivate(
                        H.DartProcedureName(kernel_procedure->canonical_name())))
                 .IsNull());
   }
   if (FLAG_enable_mirrors) {
     library.AddFunctionMetadata(function, TokenPosition::kNoSource,
-                                kernel_procedure->kernel_offset());
+                                kernel_procedure);
   }
 }
 
 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));
@@ skipping 49 matching lines @@
     intptr_t uri_size = program_->source_table().UriSizeFor(index);
     dart::String& uri_string = H.DartString(uri_buffer, uri_size, Heap::kOld);
     dart::String& import_uri_string =
         import_uri == -1 ? uri_string : H.DartString(import_uri, Heap::kOld);
     uint8_t* source_buffer = program_->source_table().SourceCodeFor(index);
     intptr_t source_size = program_->source_table().SourceCodeSizeFor(index);
     dart::String& source_code =
         H.DartString(source_buffer, source_size, Heap::kOld);
     script = Script::New(import_uri_string, uri_string, source_code,
                          RawScript::kKernelTag);
-    script.set_kernel_data(program_->libraries()[0]->kernel_data());
-    script.set_kernel_data_size(program_->libraries()[0]->kernel_data_size());
     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);
 
     // Create line_starts array for the script.
     intptr_t* line_starts = program_->source_table().LineStartsFor(index);
     intptr_t line_count = program_->source_table().LineCountFor(index);
     Array& array_object = Array::Handle(Z, Array::New(line_count, Heap::kOld));
     Smi& value = Smi::Handle(Z);
@@ skipping 67 matching lines @@
           // non-static
           // fields that are final.
           kernel_field->IsStatic() ? kernel_field->IsConst()
                                    : kernel_field->IsFinal(),
           false,  // is_abstract
           false,  // is_external
           false,  // is_native
           script_class, kernel_field->position()));
   functions_.Add(&getter);
   getter.set_end_token_pos(kernel_field->end_position());
-  getter.set_kernel_offset(kernel_field->kernel_offset());
+  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->canonical_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
                          script_class, kernel_field->position()));
     functions_.Add(&setter);
     setter.set_end_token_pos(kernel_field->end_position());
-    setter.set_kernel_offset(kernel_field->kernel_offset());
+    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,
                                            DartTypeTranslator type_translator,
                                            const dart::Class& klass,
@@ skipping 146 matching lines @@
   } else {
     ASSERT(0 <= kind && kind <= Procedure::kFactory);
     return static_cast<RawFunction::Kind>(lookuptable[kind]);
   }
 }
 
 
 ParsedFunction* ParseStaticFieldInitializer(Zone* zone,
                                             const dart::Field& field) {
   Thread* thread = Thread::Current();
+  kernel::Field* kernel_field = kernel::Field::Cast(
+      reinterpret_cast<kernel::Node*>(field.kernel_field()));
 
   dart::String& init_name = dart::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,
       dart::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_offset(field.kernel_offset());
+  initializer_fun.set_kernel_function(kernel_field);
   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)