Reified metadata in the VM

runtime/vm/parser.h

 // 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.
 
 #ifndef VM_PARSER_H_
 #define VM_PARSER_H_
 
 #include "include/dart_api.h"
 
 #include "lib/invocation_mirror.h"
@@ skipping 123 matching lines @@
   // Parse the top level of a whole script file and register declared classes
   // in the given library.
   static void ParseCompilationUnit(const Library& library,
                                    const Script& script);
 
   // Parse top level of a class and register all functions/fields.
   static void ParseClass(const Class& cls);
 
   static void ParseFunction(ParsedFunction* parsed_function);
 
+  // Parse and evaluate the metadata expressions at token_pos in the
+  // class namespace of class cls (which can be the implicit toplevel
+  // class if the metadata is at the top-level).
+  static RawObject* ParseMetadata(const Class& cls, intptr_t token_pos);
+
   // Format and print a message with source location.
   // A null script means no source and a negative token_pos means no position.
   static void PrintMessage(const Script& script,
                            intptr_t token_pos,
                            const char* message_header,
                            const char* format, ...) PRINTF_ATTRIBUTE(4, 5);
 
   // Build an error object containing a formatted error or warning message.
   // A null script means no source and a negative token_pos means no position.
   static RawError* FormatError(const Script& script,
@@ skipping 100 matching lines @@
   void ConsumeRightAngleBracket();
   void ExpectToken(Token::Kind token_expected);
   void ExpectSemicolon();
   void UnexpectedToken();
   String* ExpectUserDefinedTypeIdentifier(const char* msg);
   String* ExpectIdentifier(const char* msg);
   bool IsLiteral(const char* literal);
 
   void SkipIf(Token::Kind);
   void SkipBlock();
-  void SkipMetadata();
+  intptr_t SkipMetadata();
   void SkipToMatchingParenthesis();
   void SkipTypeArguments();
   void SkipType(bool allow_void);
   void SkipInitializers();
   void SkipExpr();
   void SkipNestedExpr();
   void SkipConditionalExpr();
   void SkipBinaryExpr();
   void SkipUnaryExpr();
   void SkipPostfixExpr();
@@ skipping 43 matching lines @@
   AstNode* RunStaticFieldInitializer(const Field& field);
   RawObject* EvaluateConstConstructorCall(
       const Class& type_class,
       const AbstractTypeArguments& type_arguments,
       const Function& constructor,
       ArgumentListNode* arguments);
   AstNode* FoldConstExpr(intptr_t expr_pos, AstNode* expr);
 
   // Support for parsing of scripts.
   void ParseTopLevel();
-  void ParseClassDeclaration(const GrowableObjectArray& pending_classes);
+  void ParseClassDeclaration(const GrowableObjectArray& pending_classes,
+                             intptr_t metadata_pos);
   void ParseClassDefinition(const Class& cls);
   void ParseMixinTypedef(const GrowableObjectArray& pending_classes);
   void ParseTypedef(const GrowableObjectArray& pending_classes);
-  void ParseTopLevelVariable(TopLevel* top_level);
-  void ParseTopLevelFunction(TopLevel* top_level);
-  void ParseTopLevelAccessor(TopLevel* top_level);
+  void ParseTopLevelVariable(TopLevel* top_level, intptr_t metadata_pos);
+  void ParseTopLevelFunction(TopLevel* top_level, intptr_t metadata_pos);
+  void ParseTopLevelAccessor(TopLevel* top_level, intptr_t metadata_pos);
+  RawArray* EvaluateMetadata();
 
   // Support for parsing libraries.
   RawObject* CallLibraryTagHandler(Dart_LibraryTag tag,
                                    intptr_t token_pos,
                                    const String& url);
   void ParseIdentList(GrowableObjectArray* names);
   void ParseLibraryDefinition();
   void ParseLibraryName();
   void ParseLibraryImportExport();
   void ParseLibraryPart();
   void ParsePartHeader();
   void ParseLibraryNameObsoleteSyntax();
   void ParseLibraryImportObsoleteSyntax();
   void ParseLibraryIncludeObsoleteSyntax();
 
   void ResolveTypeFromClass(const Class& cls,
                             ClassFinalizer::FinalizationKind finalization,
                             AbstractType* type);
   RawAbstractType* ParseType(ClassFinalizer::FinalizationKind finalization);
   void ParseTypeParameters(const Class& cls);
   RawAbstractTypeArguments* ParseTypeArguments(
       Error* malformed_error,
       ClassFinalizer::FinalizationKind finalization);
   void ParseQualIdent(QualIdent* qual_ident);
   void ParseMethodOrConstructor(ClassDesc* members, MemberDesc* method);
   void ParseFieldDefinition(ClassDesc* members, MemberDesc* field);
-  void ParseClassMemberDefinition(ClassDesc* members);
+  void ParseClassMemberDefinition(ClassDesc* members,
+                                  intptr_t metadata_pos);
   void ParseFormalParameter(bool allow_explicit_default_value,
                             ParamList* params);
   void ParseFormalParameters(bool allow_explicit_default_values,
                              ParamList* params);
   void ParseFormalParameterList(bool allow_explicit_default_values,
                                 ParamList* params);
   void CheckConstFieldsInitialized(const Class& cls);
   void AddImplicitConstructor(const Class& cls);
   void CheckConstructors(ClassDesc* members);
   AstNode* ParseExternalInitializedField(const Field& field);
@@ skipping 143 matching lines @@
   AstNode* ParsePrimary();
   AstNode* ParseStringLiteral();
   String* ParseImportStringLiteral();
   AstNode* ParseCompoundLiteral();
   AstNode* ParseListLiteral(intptr_t type_pos,
                             bool is_const,
                             const AbstractTypeArguments& type_arguments);
   AstNode* ParseMapLiteral(intptr_t type_pos,
                            bool is_const,
                            const AbstractTypeArguments& type_arguments);
-  AstNode* ParseNewOperator();
+  AstNode* ParseNewOperator(Token::Kind op_kind);
   AstNode* ParseArgumentDefinitionTest();
 
   // An implicit argument, if non-null, is prepended to the returned list.
   ArgumentListNode* ParseActualParameters(ArgumentListNode* implicit_arguments,
                                           bool require_const);
   AstNode* ParseStaticCall(const Class& cls,
                            const String& method_name,
                            intptr_t ident_pos);
   AstNode* ParseInstanceCall(AstNode* receiver, const String& method_name);
   AstNode* ParseClosureCall(AstNode* closure);
@@ skipping 138 matching lines @@
   // code at all points in the try block where an exit from the block is
   // done using 'return', 'break' or 'continue' statements.
   TryBlocks* try_blocks_list_;
 
   DISALLOW_COPY_AND_ASSIGN(Parser);
 };
 
 }  // namespace dart
 
 #endif  // VM_PARSER_H_