[kernel] Only add metadata if there's at least one annotation

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 265 matching lines @@
                                     field_helper.IsConst(), script_class,
                                     field_helper.position_));
     field.set_kernel_offset(field_offset);
     const AbstractType& type = T.BuildType();  // read type.
     field.SetFieldType(type);
     field_helper.SetJustRead(FieldHelper::kType);
     field_helper.ReadUntilExcluding(FieldHelper::kInitializer);
     field.set_has_initializer(builder_.PeekTag() == kSomething);
     GenerateFieldAccessors(toplevel_class, field, &field_helper, field_offset);
     field_helper.ReadUntilExcluding(FieldHelper::kEnd);
-    if (FLAG_enable_mirrors) {
+    if (FLAG_enable_mirrors && field_helper.annotation_count_ > 0) {
       library.AddFieldMetadata(field, TokenPosition::kNoSource, field_offset);
     }
     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) {
@@ skipping 162 matching lines @@
                            // whereas in Kernel they are not final because they
                            // are not explicitly declared that way.
                            field_helper.IsFinal() || field_helper.IsConst(),
                            field_helper.IsConst(), is_reflectable, script_class,
                            type, field_helper.position_));
       field.set_kernel_offset(field_offset);
       field_helper.ReadUntilExcluding(FieldHelper::kInitializer);
       field.set_has_initializer(builder_.PeekTag() == kSomething);
       GenerateFieldAccessors(klass, field, &field_helper, field_offset);
       field_helper.ReadUntilExcluding(FieldHelper::kEnd);
-      if (FLAG_enable_mirrors) {
+      if (FLAG_enable_mirrors && field_helper.annotation_count_ > 0) {
         library.AddFieldMetadata(field, TokenPosition::kNoSource, field_offset);
       }
       fields_.Add(&field);
     }
     klass.AddFields(fields_);
     class_helper.SetJustRead(ClassHelper::kFields);
   }
 
   class_helper.ReadUntilExcluding(ClassHelper::kConstructors);
   int constructor_count = builder_.ReadListLength();  // read list length.
@@ skipping 22 matching lines @@
     function_node_helper.ReadUntilExcluding(
         FunctionNodeHelper::kRequiredParameterCount);
     builder_.SetupFunctionParameters(klass, function,
                                      true,   // is_method
                                      false,  // is_closure
                                      &function_node_helper);
     function_node_helper.ReadUntilExcluding(FunctionNodeHelper::kEnd);
     constructor_helper.SetJustRead(ConstructorHelper::kFunction);
     constructor_helper.ReadUntilExcluding(ConstructorHelper::kEnd);
 
-    if (FLAG_enable_mirrors) {
+    if (FLAG_enable_mirrors && constructor_helper.annotation_count_ > 0) {
       library.AddFunctionMetadata(function, TokenPosition::kNoSource,
                                   constructor_offset);
     }
   }
   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);
   }
   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) {
+  if (FLAG_enable_mirrors && class_helper.annotation_count_ > 0) {
     library.AddClassMetadata(klass, toplevel_class, TokenPosition::kNoSource,
                              class_offset);
   }
 
   class_helper.ReadUntilExcluding(ClassHelper::kEnd);
 
   return klass;
 }
 
 
@@ skipping 15 matching lines @@
                                   is_factory_procedure, member_type_parameters,
                                   member_type_parameters_offset_start);
 
   procedure_helper.ReadUntilExcluding(ProcedureHelper::kAnnotations);
   const dart::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();
   dart::String* native_name = NULL;
+  intptr_t annotation_count;
   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.
-    intptr_t annotation_count = builder_.ReadListLength();  // read list length.
+    annotation_count = builder_.ReadListLength();  // read list length.
     for (int i = 0; i < annotation_count; ++i) {
       if (builder_.PeekTag() != kConstructorInvocation &&
           builder_.PeekTag() != kConstConstructorInvocation) {
         builder_.SkipExpression();
         continue;
       }
       builder_.ReadTag();
       builder_.ReadPosition();
       NameIndex annotation_class = H.EnclosingName(
           builder_.ReadCanonicalNameReference());  // read target reference,
@@ skipping 29 matching lines @@
       ASSERT(list_length == 0);
 
       // Skip remaining annotations
       for (++i; i < annotation_count; ++i) {
         builder_.SkipExpression();  // read ith annotation.
       }
 
       break;
     }
     procedure_helper.SetJustRead(ProcedureHelper::kAnnotations);
+  } else {
+    procedure_helper.ReadUntilIncluding(ProcedureHelper::kAnnotations);
+    annotation_count = procedure_helper.annotation_count_;
   }
   const Object& script_class =
       ClassForScriptAt(owner, procedure_helper.source_uri_index_);
   dart::Function& function = dart::Function::ZoneHandle(
       Z, Function::New(name, GetFunctionType(procedure_helper.kind_),
                        !is_method,  // is_static
                        false,       // is_const
                        is_abstract, is_external,
                        native_name != NULL,  // is_native
                        script_class, procedure_helper.position_));
@@ skipping 38 matching lines @@
   function_node_helper.ReadUntilExcluding(FunctionNodeHelper::kEnd);
   procedure_helper.SetJustRead(ProcedureHelper::kFunction);
 
   if (!in_class) {
     library.AddObject(function, name);
     ASSERT(!Object::Handle(
                 Z, library.LookupObjectAllowPrivate(
                        H.DartProcedureName(procedure_helper.canonical_name_)))
                 .IsNull());
   }
-  if (FLAG_enable_mirrors) {
+  if (FLAG_enable_mirrors && annotation_count > 0) {
     library.AddFunctionMetadata(function, TokenPosition::kNoSource,
                                 procedure_offset);
   }
 
   procedure_helper.ReadUntilExcluding(ProcedureHelper::kEnd);
 }
 
 const Object& KernelReader::ClassForScriptAt(const dart::Class& klass,
                                              intptr_t source_uri_index) {
   Script& correct_script = ScriptAt(source_uri_index);
@@ skipping 224 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)