Strip meta-data when VM runs with --enable-mirrors=false

runtime/vm/parser.cc

 // Copyright (c) 2012, 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/parser.h"
 #include "vm/flags.h"
 
 #ifndef DART_PRECOMPILED
 
 #include "lib/invocation_mirror.h"
@@ skipping 3949 matching lines @@
                     method->has_native,
                     current_class(),
                     method->decl_begin_pos));
   func.set_result_type(*method->type);
   func.set_end_token_pos(method_end_pos);
   func.set_is_redirecting(is_redirecting);
   func.set_modifier(async_modifier);
   if (library_.is_dart_scheme() && library_.IsPrivate(*method->name)) {
     func.set_is_reflectable(false);
   }
-  if (method->metadata_pos > 0) {
+  if (FLAG_enable_mirrors && (method->metadata_pos > 0)) {
     library_.AddFunctionMetadata(func, method->metadata_pos);
   }
   if (method->has_native) {
     func.set_native_name(*native_name);
   }
 
   // If this method is a redirecting factory, set the redirection information.
   if (!redirection_type.IsNull()) {
     ASSERT(func.IsFactory());
     func.SetRedirectionType(redirection_type);
@@ skipping 79 matching lines @@
                              field->has_static,
                              field->has_final,
                              field->has_const,
                              is_reflectable,
                              current_class(),
                              *field->type,
                              field->name_pos);
     class_field.set_has_initializer(has_initializer);
     members->AddField(class_field);
     field->field_ = &class_field;
-    if (field->metadata_pos >= 0) {
+    if (FLAG_enable_mirrors && (field->metadata_pos >= 0)) {
       library_.AddFieldMetadata(class_field, field->metadata_pos);
     }
 
     // Start tracking types for fields with simple initializers in their
     // definition. This avoids some of the overhead to track this at runtime
     // and rules out many fields from being unnecessary unboxing candidates.
     if (!field->has_static && has_initializer && has_simple_literal) {
       class_field.RecordStore(init_value);
       if (!init_value.IsNull() && init_value.IsDouble()) {
         class_field.set_is_double_initialized(true);
@@ skipping 376 matching lines @@
   Object& obj = Object::Handle(Z, library_.LookupLocalObject(*enum_name));
   if (!obj.IsNull()) {
     ReportError(name_pos, "'%s' is already defined", enum_name->ToCString());
   }
   Class& cls = Class::Handle(Z);
   cls = Class::New(*enum_name, script_, declaration_pos);
   cls.set_library(library_);
   library_.AddClass(cls);
   cls.set_is_synthesized_class();
   cls.set_is_enum_class();
-  if (metadata_pos >= 0) {
+  if (FLAG_enable_mirrors && (metadata_pos >= 0)) {
     library_.AddClassMetadata(cls, tl_owner, metadata_pos);
   }
   cls.set_super_type(Type::Handle(Z, Type::ObjectType()));
   pending_classes.Add(cls, Heap::kOld);
 }
 
 
 void Parser::ParseClassDeclaration(const GrowableObjectArray& pending_classes,
                                    const Object& tl_owner,
                                    intptr_t metadata_pos) {
@@ skipping 102 matching lines @@
                     class_name.ToCString(),
                     String::Handle(orig_bound.UserVisibleName()).ToCString());
       }
     }
     cls.set_type_parameters(orig_type_parameters);
   }
 
   if (is_abstract) {
     cls.set_is_abstract();
   }
-  if (metadata_pos >= 0) {
+  if (FLAG_enable_mirrors && (metadata_pos >= 0)) {
     library_.AddClassMetadata(cls, tl_owner, metadata_pos);
   }
 
   const bool is_mixin_declaration = (CurrentToken() == Token::kASSIGN);
   if (is_mixin_declaration && is_patch) {
     ReportError(classname_pos,
                 "mixin application '%s' may not be a patch class",
                 class_name.ToCString());
   }
 
@@ skipping 412 matching lines @@
   mixin_application.set_is_synthesized_class();
 
   // This mixin application alias needs an implicit constructor, but it is
   // too early to call 'AddImplicitConstructor(mixin_application)' here,
   // because this class should be lazily compiled.
   if (CurrentToken() == Token::kIMPLEMENTS) {
     ParseInterfaceList(mixin_application);
   }
   ExpectSemicolon();
   pending_classes.Add(mixin_application, Heap::kOld);
-  if (metadata_pos >= 0) {
+  if (FLAG_enable_mirrors && (metadata_pos >= 0)) {
     library_.AddClassMetadata(mixin_application, tl_owner, metadata_pos);
   }
 }
 
 
 // Look ahead to detect if we are seeing ident [ TypeParameters ] "(".
 // We need this lookahead to distinguish between the optional return type
 // and the alias name of a function type alias.
 // Token position remains unchanged.
 bool Parser::IsFunctionTypeAliasName() {
@@ skipping 145 matching lines @@
     signature_function = signature_class.signature_function();
     function_type_alias.PatchSignatureFunction(signature_function);
   }
   ASSERT(signature_function.signature_class() == signature_class.raw());
 
   // The alias should not be marked as finalized yet, since it needs to be
   // checked in the class finalizer for illegal self references.
   ASSERT(!function_type_alias.IsCanonicalSignatureClass());
   ASSERT(!function_type_alias.is_finalized());
   pending_classes.Add(function_type_alias, Heap::kOld);
-  if (metadata_pos >= 0) {
+  if (FLAG_enable_mirrors && (metadata_pos >= 0)) {
     library_.AddClassMetadata(function_type_alias,
                               tl_owner,
                               metadata_pos);
   }
 }
 
 
 // Consumes exactly one right angle bracket. If the current token is a single
 // bracket token, it is consumed normally. However, if it is a double or triple
 // bracket, it is replaced by a single or double bracket token without
@@ skipping 102 matching lines @@
       } else {
         type_parameter_bound = I->object_store()->object_type();
       }
       type_parameter = TypeParameter::New(cls,
                                           index,
                                           type_parameter_name,
                                           type_parameter_bound,
                                           declaration_pos);
       type_parameters_array.Add(
           &AbstractType::ZoneHandle(Z, type_parameter.raw()));
-      if (metadata_pos >= 0) {
+      if (FLAG_enable_mirrors && (metadata_pos >= 0)) {
         library_.AddTypeParameterMetadata(type_parameter, metadata_pos);
       }
       index++;
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) || (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
       ReportError("right angle bracket expected");
     }
@@ skipping 138 matching lines @@
 
     const bool is_reflectable =
         !(library_.is_dart_scheme() && library_.IsPrivate(var_name));
 
     field = Field::NewTopLevel(var_name, is_final, is_const, owner, name_pos);
     field.SetFieldType(type);
     field.set_is_reflectable(is_reflectable);
     field.SetStaticValue(Object::null_instance(), true);
     top_level->AddField(field);
     library_.AddObject(field, var_name);
-    if (metadata_pos >= 0) {
+    if (FLAG_enable_mirrors && (metadata_pos >= 0)) {
       library_.AddFieldMetadata(field, metadata_pos);
     }
     if (CurrentToken() == Token::kASSIGN) {
       ConsumeToken();
       Instance& field_value = Instance::Handle(Z, Object::sentinel().raw());
       bool has_simple_literal = false;
       if (LookaheadToken(1) == Token::kSEMICOLON) {
         has_simple_literal = IsSimpleLiteral(type, &field_value);
       }
       SkipExpr();
@@ skipping 170 matching lines @@
     library_.AddObject(func, func_name);
   } else {
     // Need to remove the previously added function that is being patched.
     const Class& toplevel_cls = Class::Handle(Z, library_.toplevel_class());
     const Function& replaced_func =
         Function::Handle(Z, toplevel_cls.LookupStaticFunction(func_name));
     ASSERT(!replaced_func.IsNull());
     toplevel_cls.RemoveFunction(replaced_func);
     library_.ReplaceObject(func, func_name);
   }
-  if (metadata_pos >= 0) {
+  if (FLAG_enable_mirrors && (metadata_pos >= 0)) {
     library_.AddFunctionMetadata(func, metadata_pos);
   }
 }
 
 
 void Parser::ParseTopLevelAccessor(TopLevel* top_level,
                                    const Object& owner,
                                    intptr_t metadata_pos) {
   TRACE_PARSER("ParseTopLevelAccessor");
   const intptr_t decl_begin_pos = TokenPos();
@@ skipping 144 matching lines @@
     // Need to remove the previously added accessor that is being patched.
     const Class& toplevel_cls = Class::Handle(Z,
         owner.IsClass() ? Class::Cast(owner).raw()
                         : PatchClass::Cast(owner).patched_class());
     const Function& replaced_func =
         Function::Handle(Z, toplevel_cls.LookupFunction(accessor_name));
     ASSERT(!replaced_func.IsNull());
     toplevel_cls.RemoveFunction(replaced_func);
     library_.ReplaceObject(func, accessor_name);
   }
-  if (metadata_pos >= 0) {
+  if (FLAG_enable_mirrors && (metadata_pos >= 0)) {
     library_.AddFunctionMetadata(func, metadata_pos);
   }
 }
 
 
 RawObject* Parser::CallLibraryTagHandler(Dart_LibraryTag tag,
                                          intptr_t token_pos,
                                          const String& url) {
   Dart_LibraryTagHandler handler = I->library_tag_handler();
   if (handler == NULL) {
@@ skipping 141 matching lines @@
   // library import, call the library tag handler to request loading
   // the library.
   if (library.LoadNotStarted() &&
       (!is_deferred_import || FLAG_load_deferred_eagerly)) {
     library.SetLoadRequested();
     CallLibraryTagHandler(Dart_kImportTag, import_pos, canon_url);
   }
 
   Namespace& ns = Namespace::Handle(Z,
       Namespace::New(library, show_names, hide_names));
-  if (metadata_pos >= 0) {
+  if (FLAG_enable_mirrors && (metadata_pos >= 0)) {
     ns.AddMetadata(tl_owner, metadata_pos);
   }
 
   // Ensure that private dart:_ libraries are only imported into dart:
   // libraries, including indirectly through exports.
   const String& lib_url = String::Handle(Z, library_.url());
   if (canon_url.StartsWith(Symbols::DartSchemePrivate()) &&
       !lib_url.StartsWith(Symbols::DartScheme())) {
     ReportError(import_pos, "private library is not accessible");
   }
@@ skipping 65 matching lines @@
   // declaration that follows the library definitions. Therefore, we
   // need to remember the position of the last token that was
   // successfully consumed.
   intptr_t rewind_pos = TokenPos();
   intptr_t metadata_pos = SkipMetadata();
   if (CurrentToken() == Token::kLIBRARY) {
     if (is_patch_source()) {
       ReportError("patch cannot override library name");
     }
     ParseLibraryName();
-    if (metadata_pos >= 0) {
+    if (FLAG_enable_mirrors && (metadata_pos >= 0)) {
       library_.AddLibraryMetadata(tl_owner, metadata_pos);
     }
     rewind_pos = TokenPos();
     metadata_pos = SkipMetadata();
   }
   while ((CurrentToken() == Token::kIMPORT) ||
       (CurrentToken() == Token::kEXPORT)) {
     ParseLibraryImportExport(tl_owner, metadata_pos);
     rewind_pos = TokenPos();
     metadata_pos = SkipMetadata();
@@ skipping 1568 matching lines @@
   function = I->LookupClosureFunction(innermost_function(), function_pos);
   if (function.IsNull()) {
     // The function will be registered in the lookup table by the
     // EffectGraphVisitor::VisitClosureNode when the newly allocated closure
     // function has been properly setup.
     is_new_closure = true;
     function = Function::NewClosureFunction(*function_name,
                                             innermost_function(),
                                             function_pos);
     function.set_result_type(result_type);
-    if (metadata_pos >= 0) {
+    if (FLAG_enable_mirrors && (metadata_pos >= 0)) {
       library_.AddFunctionMetadata(function, metadata_pos);
     }
   }
 
   // The function type needs to be finalized at compile time, since the closure
   // may be type checked at run time when assigned to a function variable,
   // passed as a function argument, or returned as a function result.
 
   LocalVariable* function_variable = NULL;
   Type& function_type = Type::ZoneHandle(Z);
@@ skipping 6775 matching lines @@
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED