VM: [Kernel] Partial support for metadata annotations

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 182 matching lines @@
     Procedure* kernel_procedure = kernel_library->procedures()[i];
     ReadProcedure(library, toplevel_class, kernel_procedure);
   }
 
   const GrowableObjectArray& classes =
       GrowableObjectArray::Handle(I->object_store()->pending_classes());
 
   // Load all classes.
   for (intptr_t i = 0; i < kernel_library->classes().length(); i++) {
     Class* kernel_klass = kernel_library->classes()[i];
-    classes.Add(ReadClass(library, kernel_klass), Heap::kOld);
+    classes.Add(ReadClass(library, toplevel_class, kernel_klass), Heap::kOld);
   }
 
   classes.Add(toplevel_class, Heap::kOld);
 }
 
 
 void KernelReader::ReadPreliminaryClass(dart::Class* klass,
                                         Class* kernel_klass) {
   ASSERT(kernel_klass->IsNormalClass());
   NormalClass* kernel_normal_class = NormalClass::Cast(kernel_klass);
@@ skipping 60 matching lines @@
         T.TranslateTypeWithoutFinalization(kernel_interface_type);
     if (type.IsMalformed()) H.ReportError("Malformed interface type.");
     interfaces.SetAt(i, type);
   }
   klass->set_interfaces(interfaces);
   if (kernel_klass->is_abstract()) klass->set_is_abstract();
 }
 
 
 dart::Class& KernelReader::ReadClass(const dart::Library& library,
+                                     const dart::Class& toplevel_class,
                                      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);
 
   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);
 
@@ skipping 33 matching lines @@
                                false,  // is_native
                                klass, kernel_constructor->position()));
     function.set_end_token_pos(kernel_constructor->end_position());
     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
+
+    if (FLAG_enable_mirrors) {
+      library.AddFunctionMetadata(function, TokenPosition::kNoSource,
+                                  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);
   }
 
   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);
+  }
+
   return klass;
 }
 
 
 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);
@@ skipping 56 matching lines @@
   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());
   }
+  if (FLAG_enable_mirrors) {
+    library.AddFunctionMetadata(function, TokenPosition::kNoSource,
+                                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 290 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)