Fix inlining annotations for AOT.

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_RUNTIME
 
 #include "lib/invocation_mirror.h"
@@ skipping 4220 matching lines @@
   func.set_modifier(async_modifier);
   if (library_.is_dart_scheme() && library_.IsPrivate(*method->name)) {
     func.set_is_reflectable(false);
   }
   if (is_patch_source() && IsPatchAnnotation(method->metadata_pos)) {
     // Currently, we just ignore the patch annotation. If the function
     // name already exists in the patched class, this function will replace
     // the one in the patched class.
     method->metadata_pos = TokenPosition::kNoSource;
   }
-  if (FLAG_enable_mirrors && (method->metadata_pos.IsReal())) {
+  if (method->metadata_pos.IsReal()) {
     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 86 matching lines @@
                              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 (is_patch_source() && IsPatchAnnotation(field->metadata_pos)) {
       // Currently, we just ignore the patch annotation on fields.
       // All fields in the patch class are added to the patched class.
       field->metadata_pos = TokenPosition::kNoSource;
     }
-    if (FLAG_enable_mirrors && (field->metadata_pos.IsReal())) {
+    if ((field->metadata_pos.IsReal())) {
       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 364 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(library_, *enum_name, script_, declaration_pos);
   library_.AddClass(cls);
   cls.set_is_synthesized_class();
   cls.set_is_enum_class();
-  if (FLAG_enable_mirrors && (metadata_pos.IsReal())) {
+  if (metadata_pos.IsReal()) {
     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,
                                    TokenPosition metadata_pos) {
   TRACE_PARSER("ParseClassDeclaration");
@@ skipping 96 matching lines @@
                       String::Handle(orig_bound.UserVisibleName()).ToCString());
         }
       }
     }
     cls.set_type_parameters(orig_type_parameters);
   }
 
   if (is_abstract) {
     cls.set_is_abstract();
   }
-  if (FLAG_enable_mirrors && metadata_pos.IsReal()) {
+  if (metadata_pos.IsReal()) {
     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 467 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 (FLAG_enable_mirrors && metadata_pos.IsReal()) {
+  if (metadata_pos.IsReal()) {
     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(bool* use_function_type_syntax) {
   if (IsIdentifier()) {
@@ skipping 127 matching lines @@
          Type::Cast(function_type).signature());
 
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing function type alias '%s'\n",
               String::Handle(Z, signature_function.Signature()).ToCString());
   }
   // 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.is_finalized());
   pending_classes.Add(function_type_alias, Heap::kOld);
-  if (FLAG_enable_mirrors && metadata_pos.IsReal()) {
+  if (metadata_pos.IsReal()) {
     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 bracket, it is replaced by a single bracket token without
 // incrementing the token index.
 void Parser::ConsumeRightAngleBracket() {
   if (token_kind_ == Token::kGT) {
@@ skipping 148 matching lines @@
         type_parameter_bound = I->object_store()->object_type();
       }
       // Note that we cannot yet calculate the final index of a function type
       // parameter, because we may not have parsed the parent function yet.
       type_parameter = TypeParameter::New(
           parameterizing_class ? current_class() : Class::Handle(Z),
           parameterizing_class ? Function::Handle(Z) : innermost_function(),
           index, type_parameter_name, type_parameter_bound, declaration_pos);
       type_parameters_array.Add(
           &AbstractType::ZoneHandle(Z, type_parameter.raw()));
-      if (FLAG_enable_mirrors && metadata_pos.IsReal()) {
+      if (metadata_pos.IsReal()) {
         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 141 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 (FLAG_enable_mirrors && metadata_pos.IsReal()) {
+    if (metadata_pos.IsReal()) {
       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 177 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 (FLAG_enable_mirrors && metadata_pos.IsReal()) {
+  if (metadata_pos.IsReal()) {
     library_.AddFunctionMetadata(func, metadata_pos);
   }
 }
 
 void Parser::ParseTopLevelAccessor(TopLevel* top_level,
                                    const Object& owner,
                                    TokenPosition metadata_pos) {
   TRACE_PARSER("ParseTopLevelAccessor");
   const TokenPosition decl_begin_pos = TokenPos();
   const bool is_static = true;
@@ skipping 139 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 (FLAG_enable_mirrors && metadata_pos.IsReal()) {
+  if (metadata_pos.IsReal()) {
     library_.AddFunctionMetadata(func, metadata_pos);
   }
 }
 
 RawObject* Parser::CallLibraryTagHandler(Dart_LibraryTag tag,
                                          TokenPosition token_pos,
                                          const String& url) {
   Dart_LibraryTagHandler handler = I->library_tag_handler();
   if (handler == NULL) {
     if (url.StartsWith(Symbols::DartScheme())) {
@@ skipping 188 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 (FLAG_enable_mirrors && metadata_pos.IsReal()) {
+  if (metadata_pos.IsReal()) {
     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 66 matching lines @@
   // declaration that follows the library definitions. Therefore, we
   // need to remember the position of the last token that was
   // successfully consumed.
   TokenPosition rewind_pos = TokenPos();
   TokenPosition metadata_pos = SkipMetadata();
   if (CurrentToken() == Token::kLIBRARY) {
     if (is_patch_source()) {
       ReportError("patch cannot override library name");
     }
     ParseLibraryName();
-    if (FLAG_enable_mirrors && metadata_pos.IsReal()) {
+    if (metadata_pos.IsReal()) {
       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 1561 matching lines @@
     // The function will be registered in the lookup table by the
     // EffectGraphVisitor::VisitClosureNode when the newly allocated closure
     // function has been properly setup.
     found_func = false;
     function = Function::NewClosureFunction(*function_name,
                                             innermost_function(), function_pos);
     function.set_result_type(result_type);
     // The result type may refer to the function's type parameters,
     // but was not parsed in the scope of the function. Adjust.
     result_type.SetScopeFunction(function);
-    if (FLAG_enable_mirrors && metadata_pos.IsReal()) {
+    if (metadata_pos.IsReal()) {
       library_.AddFunctionMetadata(function, metadata_pos);
     }
   }
 
   ASSERT(function.parent_function() == innermost_function_.raw());
   innermost_function_ = function.raw();
 
   if (CurrentToken() == Token::kLT) {
     if (!FLAG_generic_method_syntax) {
       ReportError("generic functions not supported");
@@ skipping 7038 matching lines @@
 bool Parser::FieldHasFunctionLiteralInitializer(const Field& field,
                                                 TokenPosition* start,
                                                 TokenPosition* end) {
   UNREACHABLE();
   return false;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME