Reified metadata in the VM

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 "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
@@ skipping 493 matching lines @@
   }
   void Clear() {
     has_abstract = false;
     has_external = false;
     has_final = false;
     has_const = false;
     has_static = false;
     has_var = false;
     has_factory = false;
     has_operator = false;
+    metadata_pos = -1;
     operator_token = Token::kILLEGAL;
     type = NULL;
     name_pos = 0;
     name = NULL;
     redirect_name = NULL;
     constructor_name = NULL;
     params.Clear();
     kind = RawFunction::kRegularFunction;
   }
   bool IsConstructor() const {
@@ skipping 12 matching lines @@
     return kind == RawFunction::kSetterFunction;
   }
   bool has_abstract;
   bool has_external;
   bool has_final;
   bool has_const;
   bool has_static;
   bool has_var;
   bool has_factory;
   bool has_operator;
+  intptr_t metadata_pos;
   Token::Kind operator_token;
   const AbstractType* type;
   intptr_t name_pos;
   String* name;
   // For constructors: NULL or name of redirected to constructor.
   String* redirect_name;
   // For constructors: NULL for unnamed constructor,
   // identifier after classname for named constructors.
   String* constructor_name;
   ParamList params;
@@ skipping 84 matching lines @@
 
   void AddField(const Field& field) {
     ASSERT(!FieldExists(String::Handle(field.name())));
     fields_.Add(field);
   }
 
   const GrowableObjectArray& fields() const {
     return fields_;
   }
 
-  RawClass* clazz() const {
-    return clazz_.raw();
+  const Class& clazz() const {
+    return clazz_;
   }
 
   const String& class_name() const {
     return class_name_;
   }
 
   bool has_constructor() const {
     Function& func = Function::Handle();
     for (int i = 0; i < functions_.Length(); i++) {
       func ^= functions_.At(i);
@@ skipping 172 matching lines @@
         ((instantiator != NULL) && instantiator->is_captured())) {
       parsed_function->set_instantiator(
           new LoadLocalNode(node_sequence->token_pos(), instantiator));
     }
   }
 
   parsed_function->set_default_parameter_values(default_parameter_values);
 }
 
 
+RawObject* Parser::ParseMetadata(const Class& cls, intptr_t token_pos) {
+  Isolate* isolate = Isolate::Current();
+  StackZone zone(isolate);
+  LongJump* base = isolate->long_jump_base();
+  LongJump jump;
+  isolate->set_long_jump_base(&jump);
+  if (setjmp(*jump.Set()) == 0) {
+    const Script& script = Script::Handle(cls.script());
+    const Library& lib = Library::Handle(cls.library());
+    Parser parser(script, lib, token_pos);
+    parser.set_current_class(cls);
+    return parser.EvaluateMetadata();
+  } else {
+    Error& error = Error::Handle();
+    error = isolate->object_store()->sticky_error();
+    isolate->object_store()->clear_sticky_error();
+    isolate->set_long_jump_base(base);
+    return error.raw();
+  }
+  UNREACHABLE();
+  return Object::null();
+}
+
+
+RawArray* Parser::EvaluateMetadata() {
+  if (CurrentToken() != Token::kAT) {
+    ErrorMsg("Metadata character '@' expected");
+  }
+  GrowableObjectArray& meta_values =
+      GrowableObjectArray::Handle(GrowableObjectArray::New());
+  while (CurrentToken() == Token::kAT) {
+    ConsumeToken();
+    intptr_t expr_pos = TokenPos();
+    if (!IsIdentifier()) {
+      ExpectIdentifier("identifier expected");
+    }
+    AstNode* expr = NULL;
+    if ((LookaheadToken(1) == Token::kLPAREN) ||
+        ((LookaheadToken(1) == Token::kPERIOD) &&
+            (LookaheadToken(3) == Token::kLPAREN)) ||
+        ((LookaheadToken(1) == Token::kPERIOD) &&
+            (LookaheadToken(3) == Token::kPERIOD) &&
+            (LookaheadToken(5) == Token::kLPAREN))) {
+      expr = ParseNewOperator(Token::kCONST);
+    } else {
+      expr = ParsePrimary();
+    }
+    if (expr->EvalConstExpr() == NULL) {
+      ErrorMsg(expr_pos, "expression must be a compile-time constant");
+    }
+    const Instance& val = EvaluateConstExpr(expr);
+    meta_values.Add(val);
+  }
+  return Array::MakeArray(meta_values);
+}
+
+
 // TODO(regis): Since a const variable is implicitly final,
 // rename ParseStaticConstGetter to ParseStaticFinalGetter and
 // rename kConstImplicitGetter to kImplicitFinalGetter.
 SequenceNode* Parser::ParseStaticConstGetter(const Function& func) {
   TRACE_PARSER("ParseStaticConstGetter");
   ParamList params;
   ASSERT(func.num_fixed_parameters() == 0);  // static.
   ASSERT(!func.HasOptionalParameters());
   ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
 
@@ skipping 1963 matching lines @@
       Function::New(*method->name,
                     function_kind,
                     method->has_static,
                     method->has_const,
                     method->has_abstract,
                     method->has_external,
                     current_class(),
                     method_pos));
   func.set_result_type(*method->type);
   func.set_end_token_pos(method_end_pos);
+  if (method->metadata_pos > 0) {
+    library_.AddFunctionMetadata(func, method->metadata_pos);
+  }
 
   // If this method is a redirecting factory, set the redirection information.
   if (!redirection_type.IsNull()) {
     ASSERT(func.IsFactory());
     func.SetRedirectionType(redirection_type);
     if (!redirection_identifier.IsNull()) {
       func.SetRedirectionIdentifier(redirection_identifier);
     }
   }
 
@@ skipping 67 matching lines @@
     // Create the field object.
     class_field = Field::New(*field->name,
                              field->has_static,
                              field->has_final,
                              field->has_const,
                              current_class(),
                              field->name_pos);
     class_field.set_type(*field->type);
     class_field.set_has_initializer(has_initializer);
     members->AddField(class_field);
+    if (field->metadata_pos >= 0) {
+      library_.AddFieldMetadata(class_field, field->metadata_pos);
+    }
 
     // For static const fields, set value to "uninitialized" and
     // create a kConstImplicitGetter getter method.
     if (field->has_static && has_initializer) {
       class_field.set_value(init_value);
       if (!has_simple_literal) {
         String& getter_name = String::Handle(Field::GetterSymbol(*field->name));
         getter = Function::New(getter_name,
                                RawFunction::kConstImplicitGetter,
                                field->has_static,
@@ skipping 70 matching lines @@
       member.params.has_optional_positional_parameters ||
       member.params.has_optional_named_parameters ||
       (member.params.num_fixed_parameters != expected_num_parameters)) {
     // Subtract receiver when reporting number of expected arguments.
     ErrorMsg(member.name_pos, "operator %s expects %"Pd" argument(s)",
         member.name->ToCString(), (expected_num_parameters - 1));
   }
 }
 
 
-void Parser::ParseClassMemberDefinition(ClassDesc* members) {
+void Parser::ParseClassMemberDefinition(ClassDesc* members,
+                                        intptr_t metadata_pos) {
   TRACE_PARSER("ParseClassMemberDefinition");
   MemberDesc member;
   current_member_ = &member;
+  member.metadata_pos = metadata_pos;
   if ((CurrentToken() == Token::kEXTERNAL) &&
       (LookaheadToken(1) != Token::kLPAREN)) {
     ConsumeToken();
     member.has_external = true;
   }
   if ((CurrentToken() == Token::kSTATIC) &&
       (LookaheadToken(1) != Token::kLPAREN)) {
     ConsumeToken();
     member.has_static = true;
   }
@@ skipping 192 matching lines @@
     }
     ParseFieldDefinition(members, &member);
   } else {
     UnexpectedToken();
   }
   current_member_ = NULL;
   members->AddMember(member);
 }
 
 
-void Parser::ParseClassDeclaration(const GrowableObjectArray& pending_classes) {
+void Parser::ParseClassDeclaration(const GrowableObjectArray& pending_classes,
+                                   intptr_t metadata_pos) {
   TRACE_PARSER("ParseClassDeclaration");
   bool is_patch = false;
   bool is_abstract = false;
   if (is_patch_source() &&
       (CurrentToken() == Token::kIDENT) &&
       CurrentLiteral()->Equals("patch")) {
     ConsumeToken();
     is_patch = true;
   } else if (CurrentToken() == Token::kABSTRACT) {
     is_abstract = true;
@@ skipping 121 matching lines @@
   if (is_patch) {
     // Apply the changes to the patched class looked up above.
     ASSERT(obj.raw() == library_.LookupLocalObject(class_name));
     // The patched class must not be finalized yet.
     const Class& orig_class = Class::Cast(obj);
     ASSERT(!orig_class.is_finalized());
     orig_class.set_patch_class(cls);
     cls.set_is_patch();
   }
   pending_classes.Add(cls, Heap::kOld);
+  if (metadata_pos >= 0) {
+    library_.AddClassMetadata(cls, metadata_pos);
+  }
 
   if (CurrentToken() != Token::kLBRACE) {
     ErrorMsg("{ expected");
   }
   SkipBlock();
 }
 
 
 void Parser::ParseClassDefinition(const Class& cls) {
   TRACE_PARSER("ParseClassDefinition");
   set_current_class(cls);
   is_top_level_ = true;
   String& class_name = String::Handle(cls.Name());
   const intptr_t class_pos = TokenPos();
   ClassDesc members(cls, class_name, false, class_pos);
   while (CurrentToken() != Token::kLBRACE) {
     ConsumeToken();
   }
   ExpectToken(Token::kLBRACE);
   while (CurrentToken() != Token::kRBRACE) {
-    SkipMetadata();
-    ParseClassMemberDefinition(&members);
+    intptr_t metadata_pos = SkipMetadata();
+    ParseClassMemberDefinition(&members, metadata_pos);
   }
   ExpectToken(Token::kRBRACE);
 
   CheckConstructors(&members);
 
   // Need to compute this here since MakeArray() will clear the
   // functions array in members.
   const bool need_implicit_constructor =
       !members.has_constructor() && !cls.is_patch();
 
@@ skipping 318 matching lines @@
   if (token_kind_ == Token::kGT) {
     ConsumeToken();
   } else if (token_kind_ == Token::kSHR) {
     token_kind_ = Token::kGT;
   } else {
     UNREACHABLE();
   }
 }
 
 
-void Parser::SkipMetadata() {
+intptr_t Parser::SkipMetadata() {
+  if (CurrentToken() != Token::kAT) {
+    return -1;
+  }
+  intptr_t metadata_pos = TokenPos();
   while (CurrentToken() == Token::kAT) {
     ConsumeToken();
     ExpectIdentifier("identifier expected");
     if (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       ExpectIdentifier("identifier expected");
       if (CurrentToken() == Token::kPERIOD) {
         ConsumeToken();
         ExpectIdentifier("identifier expected");
       }
     }
     if (CurrentToken() == Token::kLPAREN) {
       SkipToMatchingParenthesis();
     }
   }
+  return metadata_pos;
 }
 
 
 void Parser::SkipTypeArguments() {
   if (CurrentToken() == Token::kLT) {
     do {
       ConsumeToken();
       SkipType(false);
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
@@ skipping 218 matching lines @@
                                        mixin_type_arguments,
                                        mixin_pos);
     mixin_super_type = mixin_application_type.raw();
     mixin_apps.Add(mixin_application_type);
   } while (CurrentToken() == Token::kCOMMA);
   return MixinAppType::New(super_type,
                            Array::Handle(Array::MakeArray(mixin_apps)));
 }
 
 
-void Parser::ParseTopLevelVariable(TopLevel* top_level) {
+void Parser::ParseTopLevelVariable(TopLevel* top_level,
+                                   intptr_t metadata_pos) {
   TRACE_PARSER("ParseTopLevelVariable");
   const bool is_const = (CurrentToken() == Token::kCONST);
   // Const fields are implicitly final.
   const bool is_final = is_const || (CurrentToken() == Token::kFINAL);
   const bool is_static = true;
   const AbstractType& type =
       AbstractType::ZoneHandle(ParseConstFinalVarOrType(
           FLAG_enable_type_checks ? ClassFinalizer::kTryResolve :
                                     ClassFinalizer::kIgnore));
   Field& field = Field::Handle();
@@ skipping 19 matching lines @@
                  var_name.ToCString());
       }
     }
 
     field = Field::New(var_name, is_static, is_final, is_const,
                        current_class(), name_pos);
     field.set_type(type);
     field.set_value(Instance::Handle(Instance::null()));
     top_level->fields.Add(field);
     library_.AddObject(field, var_name);
+    if (metadata_pos >= 0) {
+      library_.AddFieldMetadata(field, metadata_pos);
+    }
     if (CurrentToken() == Token::kASSIGN) {
       ConsumeToken();
       Instance& field_value = Instance::Handle(Object::sentinel().raw());
       bool has_simple_literal = false;
       if (is_final && (LookaheadToken(1) == Token::kSEMICOLON)) {
         has_simple_literal = IsSimpleLiteral(type, &field_value);
       }
       SkipExpr();
       field.set_value(field_value);
       if (!has_simple_literal) {
@@ skipping 19 matching lines @@
     } else if (CurrentToken() == Token::kSEMICOLON) {
       ConsumeToken();
       break;
     } else {
       ExpectSemicolon();  // Reports error.
     }
   }
 }
 
 
-void Parser::ParseTopLevelFunction(TopLevel* top_level) {
+void Parser::ParseTopLevelFunction(TopLevel* top_level,
+                                   intptr_t metadata_pos) {
   TRACE_PARSER("ParseTopLevelFunction");
   AbstractType& result_type = Type::Handle(Type::DynamicType());
   const bool is_static = true;
   bool is_external = false;
   bool is_patch = false;
   if (is_patch_source() &&
       (CurrentToken() == Token::kIDENT) &&
       CurrentLiteral()->Equals("patch") &&
       (LookaheadToken(1) != Token::kLPAREN)) {
     ConsumeToken();
@@ skipping 64 matching lines @@
                     function_pos));
   func.set_result_type(result_type);
   func.set_end_token_pos(function_end_pos);
   AddFormalParamsToFunction(&params, func);
   top_level->functions.Add(func);
   if (!is_patch) {
     library_.AddObject(func, func_name);
   } else {
     library_.ReplaceObject(func, func_name);
   }
+  if (metadata_pos >= 0) {
+    library_.AddFunctionMetadata(func, metadata_pos);
+  }
 }
 
 
-void Parser::ParseTopLevelAccessor(TopLevel* top_level) {
+void Parser::ParseTopLevelAccessor(TopLevel* top_level,
+                                   intptr_t metadata_pos) {
   TRACE_PARSER("ParseTopLevelAccessor");
   const bool is_static = true;
   bool is_external = false;
   bool is_patch = false;
   AbstractType& result_type = AbstractType::Handle();
   if (is_patch_source() &&
       (CurrentToken() == Token::kIDENT) &&
       CurrentLiteral()->Equals("patch")) {
     ConsumeToken();
     is_patch = true;
@@ skipping 97 matching lines @@
                     accessor_pos));
   func.set_result_type(result_type);
   func.set_end_token_pos(accessor_end_pos);
   AddFormalParamsToFunction(&params, func);
   top_level->functions.Add(func);
   if (!is_patch) {
     library_.AddObject(func, accessor_name);
   } else {
     library_.ReplaceObject(func, accessor_name);
   }
+  if (metadata_pos >= 0) {
+    library_.AddFunctionMetadata(func, metadata_pos);
+  }
 }
 
 
 
 RawObject* Parser::CallLibraryTagHandler(Dart_LibraryTag tag,
                                           intptr_t token_pos,
                                           const String& url) {
   Dart_LibraryTagHandler handler = isolate()->library_tag_handler();
   if (handler == NULL) {
     if (url.StartsWith(Symbols::DartScheme())) {
@@ skipping 250 matching lines @@
 
   if (is_library_source() || is_patch_source()) {
     ParseLibraryDefinition();
   } else if (is_part_source()) {
     ParsePartHeader();
   }
 
   const Class& cls = Class::Handle(isolate());
   while (true) {
     set_current_class(cls);  // No current class.
-    SkipMetadata();
+    intptr_t metadata_pos = SkipMetadata();
     if (CurrentToken() == Token::kCLASS) {
-      ParseClassDeclaration(pending_classes);
+      ParseClassDeclaration(pending_classes, metadata_pos);
     } else if ((CurrentToken() == Token::kTYPEDEF) &&
                (LookaheadToken(1) != Token::kLPAREN)) {
       set_current_class(toplevel_class);
       ParseTypedef(pending_classes);
     } else if ((CurrentToken() == Token::kABSTRACT) &&
         (LookaheadToken(1) == Token::kCLASS)) {
-      ParseClassDeclaration(pending_classes);
+      ParseClassDeclaration(pending_classes, metadata_pos);
     } else if (is_patch_source() && IsLiteral("patch") &&
                (LookaheadToken(1) == Token::kCLASS)) {
-      ParseClassDeclaration(pending_classes);
+      ParseClassDeclaration(pending_classes, metadata_pos);
     } else {
       set_current_class(toplevel_class);
       if (IsVariableDeclaration()) {
-        ParseTopLevelVariable(&top_level);
+        ParseTopLevelVariable(&top_level, metadata_pos);
       } else if (IsFunctionDeclaration()) {
-        ParseTopLevelFunction(&top_level);
+        ParseTopLevelFunction(&top_level, metadata_pos);
       } else if (IsTopLevelAccessor()) {
-        ParseTopLevelAccessor(&top_level);
+        ParseTopLevelAccessor(&top_level, metadata_pos);
       } else if (CurrentToken() == Token::kEOS) {
         break;
       } else {
         UnexpectedToken();
       }
     }
   }
   if ((top_level.fields.Length() > 0) || (top_level.functions.Length() > 0)) {
     Array& array = Array::Handle();
 
@@ skipping 4577 matching lines @@
   // This convention prevents users from explicitly calling constructors.
   String& constructor_name =
       String::Handle(String::Concat(type_class_name, Symbols::Dot()));
   if (named_constructor != NULL) {
     constructor_name = String::Concat(constructor_name, *named_constructor);
   }
   return constructor_name;
 }
 
 
-AstNode* Parser::ParseNewOperator() {
+AstNode* Parser::ParseNewOperator(Token::Kind op_kind) {
   TRACE_PARSER("ParseNewOperator");
   const intptr_t new_pos = TokenPos();
-  ASSERT((CurrentToken() == Token::kNEW) || (CurrentToken() == Token::kCONST));
-  bool is_const = (CurrentToken() == Token::kCONST);
-  ConsumeToken();
+  ASSERT((op_kind == Token::kNEW) || (op_kind == Token::kCONST));
+  bool is_const = (op_kind == Token::kCONST);
   if (!IsIdentifier()) {
     ErrorMsg("type name expected");
   }
   intptr_t type_pos = TokenPos();
   AbstractType& type = AbstractType::Handle(
       ParseType(ClassFinalizer::kCanonicalizeExpression));
   // In case the type is malformed, throw a dynamic type error after finishing
   // parsing the instance creation expression.
   if (!type.IsMalformed() && (type.IsTypeParameter() || type.IsDynamicType())) {
     // Replace the type with a malformed type.
@@ skipping 447 matching lines @@
   } else if (CurrentToken() == Token::kDOUBLE) {
     Double& double_value = Double::ZoneHandle(CurrentDoubleLiteral());
     if (double_value.IsNull()) {
       ErrorMsg("invalid double literal");
     }
     primary = new LiteralNode(TokenPos(), double_value);
     ConsumeToken();
   } else if (CurrentToken() == Token::kSTRING) {
     primary = ParseStringLiteral();
   } else if (CurrentToken() == Token::kNEW) {
-    primary = ParseNewOperator();
+    ConsumeToken();
+    primary = ParseNewOperator(Token::kNEW);
   } else if (CurrentToken() == Token::kCONST) {
     if ((LookaheadToken(1) == Token::kLT) ||
         (LookaheadToken(1) == Token::kLBRACK) ||
         (LookaheadToken(1) == Token::kINDEX) ||
         (LookaheadToken(1) == Token::kLBRACE)) {
       primary = ParseCompoundLiteral();
     } else {
-      primary = ParseNewOperator();
+      ConsumeToken();
+      primary = ParseNewOperator(Token::kCONST);
     }
   } else if (CurrentToken() == Token::kLT ||
              CurrentToken() == Token::kLBRACK ||
              CurrentToken() == Token::kINDEX ||
              CurrentToken() == Token::kLBRACE) {
     primary = ParseCompoundLiteral();
   } else if (CurrentToken() == Token::kSUPER) {
     if (current_function().is_static()) {
       ErrorMsg("cannot access superclass from static method");
     }
@@ skipping 349 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart