Implement ParameterMirror.metadata.

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/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 414 matching lines @@
   String* ident;
 };
 
 
 struct ParamDesc {
   ParamDesc()
       : type(NULL),
         name_pos(0),
         name(NULL),
         default_value(NULL),
+        metadata(NULL),
         is_final(false),
         is_field_initializer(false) { }
   const AbstractType* type;
   intptr_t name_pos;
   const String* name;
   const Object* default_value;  // NULL if not an optional parameter.
+  const Object* metadata;  // NULL if no metadata or metadata not evaluated.
   bool is_final;
   bool is_field_initializer;
 };
 
 
 struct ParamList {
   ParamList() {
     Clear();
   }
 
@@ skipping 333 matching lines @@
   isolate->set_long_jump_base(&jump);
   if (setjmp(*jump.Set()) == 0) {
     const Script& script = Script::Handle(isolate, func.script());
     const Class& owner = Class::Handle(isolate, func.Owner());
     ASSERT(!owner.IsNull());
     const Library& lib = Library::Handle(isolate, owner.library());
     Parser parser(script, lib, func.token_pos());
     parser.set_current_class(owner);
     parser.SkipFunctionPreamble();
     ParamList params;
-    parser.ParseFormalParameterList(true, &params);
+    parser.ParseFormalParameterList(true, true, &params);
     ParamDesc* param = params.parameters->data();
     const int param_cnt = params.num_fixed_parameters +
                           params.num_optional_parameters;
-    Array& param_descriptor = Array::Handle(isolate, Array::New(param_cnt * 2));
-    for (int i = 0, j = 0; i < param_cnt; i++, j += 2) {
+    Array& param_descriptor = Array::Handle(Array::New(param_cnt * 3));
+    for (int i = 0, j = 0; i < param_cnt; i++, j += 3) {
       param_descriptor.SetAt(j, param[i].is_final ? Bool::True() :

[siva, 2013/08/28 23:26:48]

Ditto comment about '3' here.

                                                     Bool::False());
       param_descriptor.SetAt(j + 1,
           (param[i].default_value == NULL) ? Object::null_instance() :
                                              *(param[i].default_value));
+      const Object* metadata = param[i].metadata;
+      if ((metadata != NULL) && (*metadata).IsError()) {
+        return (*metadata).raw();  // Error evaluating the metadata.
+      }
+      param_descriptor.SetAt(j + 2,
+          (param[i].metadata == NULL) ? Object::null_instance() :
+                                        *(param[i].metadata));
     }
     isolate->set_long_jump_base(base);
     return param_descriptor.raw();
   } 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();
   }
@@ skipping 559 matching lines @@
   } while (!token_stack.is_empty() && is_match && !unexpected_token_found);
   if (!is_match) {
     ErrorMsg(token_pos, "unbalanced '%s'", Token::Str(token));
   } else if (unexpected_token_found) {
     ErrorMsg(block_start_pos, "unterminated block");
   }
 }
 
 
 void Parser::ParseFormalParameter(bool allow_explicit_default_value,
+                                  bool evaluate_metadata,
                                   ParamList* params) {
   TRACE_PARSER("ParseFormalParameter");
   ParamDesc parameter;
   bool var_seen = false;
   bool this_seen = false;
 
-  SkipMetadata();
+  if (evaluate_metadata && (CurrentToken() == Token::kAT)) {
+    parameter.metadata = &Array::ZoneHandle(EvaluateMetadata());
+  } else {
+    SkipMetadata();
+  }
+
   if (CurrentToken() == Token::kFINAL) {
     ConsumeToken();
     parameter.is_final = true;
   } else if (CurrentToken() == Token::kVAR) {
     ConsumeToken();
     var_seen = true;
     // The parameter type is the 'dynamic' type.
     parameter.type = &Type::ZoneHandle(Type::DynamicType());
   }
   if (CurrentToken() == Token::kTHIS) {
@@ skipping 79 matching lines @@
       // Finish parsing the function type parameter.
       ParamList func_params;
 
       // Add implicit closure object parameter.
       func_params.AddFinalParameter(
           TokenPos(),
           &Symbols::ClosureParameter(),
           &Type::ZoneHandle(Type::DynamicType()));
 
       const bool no_explicit_default_values = false;
-      ParseFormalParameterList(no_explicit_default_values, &func_params);
+      ParseFormalParameterList(no_explicit_default_values, false, &func_params);
 
       // The field 'is_static' has no meaning for signature functions.
       const Function& signature_function = Function::Handle(
           Function::New(*parameter.name,
                         RawFunction::kSignatureFunction,
                         /* is_static = */ false,
                         /* is_const = */ false,
                         /* is_abstract = */ false,
                         /* is_external = */ false,
                         current_class(),
@@ skipping 63 matching lines @@
   }
   if (parameter.type->IsVoidType()) {
     ErrorMsg("parameter '%s' may not be 'void'", parameter.name->ToCString());
   }
   params->parameters->Add(parameter);
 }
 
 
 // Parses a sequence of normal or optional formal parameters.
 void Parser::ParseFormalParameters(bool allow_explicit_default_values,
+                                   bool evaluate_metadata,
                                    ParamList* params) {
   TRACE_PARSER("ParseFormalParameters");
   do {
     ConsumeToken();
     if (!params->has_optional_positional_parameters &&
         !params->has_optional_named_parameters &&
         (CurrentToken() == Token::kLBRACK)) {
       // End of normal parameters, start of optional positional parameters.
       params->has_optional_positional_parameters = true;
       return;
     }
     if (!params->has_optional_positional_parameters &&
         !params->has_optional_named_parameters &&
         (CurrentToken() == Token::kLBRACE)) {
       // End of normal parameters, start of optional named parameters.
       params->has_optional_named_parameters = true;
       return;
     }
-    ParseFormalParameter(allow_explicit_default_values, params);
+    ParseFormalParameter(allow_explicit_default_values,
+                         evaluate_metadata,
+                         params);
   } while (CurrentToken() == Token::kCOMMA);
 }
 
 
 void Parser::ParseFormalParameterList(bool allow_explicit_default_values,
+                                      bool evaluate_metadata,
                                       ParamList* params) {
   TRACE_PARSER("ParseFormalParameterList");
   ASSERT(CurrentToken() == Token::kLPAREN);
 
   if (LookaheadToken(1) != Token::kRPAREN) {
     // Parse fixed parameters.
-    ParseFormalParameters(allow_explicit_default_values, params);
+    ParseFormalParameters(allow_explicit_default_values,
+                          evaluate_metadata,
+                          params);
     if (params->has_optional_positional_parameters ||
         params->has_optional_named_parameters) {
       // Parse optional parameters.
-      ParseFormalParameters(allow_explicit_default_values, params);
+      ParseFormalParameters(allow_explicit_default_values,
+                            evaluate_metadata,
+                            params);
       if (params->has_optional_positional_parameters) {
         if (CurrentToken() != Token::kRBRACK) {
           ErrorMsg("',' or ']' expected");
         }
       } else {
         if (CurrentToken() != Token::kRBRACE) {
           ErrorMsg("',' or '}' expected");
         }
       }
       ConsumeToken();  // ']' or '}'.
@@ skipping 870 matching lines @@
 
   // Add implicit parameter for construction phase.
   params.AddFinalParameter(
       TokenPos(),
       &Symbols::PhaseParameter(),
       &Type::ZoneHandle(Type::SmiType()));
 
   if (func.is_const()) {
     params.SetImplicitlyFinal();
   }
-  ParseFormalParameterList(allow_explicit_default_values, &params);
+  ParseFormalParameterList(allow_explicit_default_values, false, &params);
 
   SetupDefaultsForOptionalParams(&params, default_parameter_values);
   ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
   ASSERT(func.NumParameters() == params.parameters->length());
 
   // Now populate function scope with the formal parameters.
   AddFormalParamsToScope(&params, current_block_->scope);
 
   // Initialize instance fields that have an explicit initializer expression.
   // The formal parameter names must not be visible to the instance
@@ skipping 231 matching lines @@
     // The first parameter of a factory is the AbstractTypeArguments vector of
     // the type of the instance to be allocated.
     params.AddFinalParameter(
         TokenPos(),
         &Symbols::TypeArgumentsParameter(),
         &Type::ZoneHandle(Type::DynamicType()));
   }
   ASSERT((CurrentToken() == Token::kLPAREN) || func.IsGetterFunction());
   const bool allow_explicit_default_values = true;
   if (!func.IsGetterFunction()) {
-    ParseFormalParameterList(allow_explicit_default_values, &params);
+    ParseFormalParameterList(allow_explicit_default_values, false, &params);
   } else {
     // TODO(hausner): Remove this once we no longer support the old
     // getter syntax with explicit empty parameter list.
     if (CurrentToken() == Token::kLPAREN) {
       ConsumeToken();
       ExpectToken(Token::kRPAREN);
     }
   }
 
   // The number of parameters and their type are not yet set in local functions,
@@ skipping 216 matching lines @@
   if (method->IsConstructor()) {
     method->params.AddFinalParameter(
         TokenPos(),
         &Symbols::PhaseParameter(),
         &Type::ZoneHandle(Type::SmiType()));
   }
   if (are_implicitly_final) {
     method->params.SetImplicitlyFinal();
   }
   if (!method->IsGetter()) {
-    ParseFormalParameterList(allow_explicit_default_values, &method->params);
+    ParseFormalParameterList(allow_explicit_default_values,
+                             false,
+                             &method->params);
   }
 
   // Now that we know the parameter list, we can distinguish between the
   // unary and binary operator -.
   if (method->has_operator) {
     if ((method->operator_token == Token::kSUB) &&
        (method->params.num_fixed_parameters == 1)) {
       // Patch up name for unary operator - so it does not clash with the
       // name for binary operator -.
       method->operator_token = Token::kNEGATE;
@@ skipping 1031 matching lines @@
   }
   ParamList func_params;
 
   // Add implicit closure object parameter.
   func_params.AddFinalParameter(
       TokenPos(),
       &Symbols::ClosureParameter(),
       &Type::ZoneHandle(Type::DynamicType()));
 
   const bool no_explicit_default_values = false;
-  ParseFormalParameterList(no_explicit_default_values, &func_params);
+  ParseFormalParameterList(no_explicit_default_values, false, &func_params);
   ExpectSemicolon();
   // The field 'is_static' has no meaning for signature functions.
   Function& signature_function = Function::Handle(
       Function::New(*alias_name,
                     RawFunction::kSignatureFunction,
                     /* is_static = */ false,
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     /* is_external = */ false,
                     function_type_alias,
@@ skipping 428 matching lines @@
   }
   // A setter named x= may co-exist with a function named x, thus we do
   // not need to check setters.
 
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("'(' expected");
   }
   const intptr_t function_pos = TokenPos();
   ParamList params;
   const bool allow_explicit_default_values = true;
-  ParseFormalParameterList(allow_explicit_default_values, &params);
+  ParseFormalParameterList(allow_explicit_default_values, false, &params);
 
   intptr_t function_end_pos = function_pos;
   if (is_external) {
     function_end_pos = TokenPos();
     ExpectSemicolon();
   } else if (CurrentToken() == Token::kLBRACE) {
     SkipBlock();
     function_end_pos = TokenPos() - 1;
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
@@ skipping 68 matching lines @@
     }
   }
   const intptr_t name_pos = TokenPos();
   const String* field_name = ExpectIdentifier("accessor name expected");
 
   const intptr_t accessor_pos = TokenPos();
   ParamList params;
 
   if (!is_getter) {
     const bool allow_explicit_default_values = true;
-    ParseFormalParameterList(allow_explicit_default_values, &params);
+    ParseFormalParameterList(allow_explicit_default_values, false, &params);
   }
   String& accessor_name = String::ZoneHandle();
   int expected_num_parameters = -1;
   if (is_getter) {
     expected_num_parameters = 0;
     accessor_name = Field::GetterSymbol(*field_name);
   } else {
     expected_num_parameters = 1;
     accessor_name = Field::SetterSymbol(*field_name);
   }
@@ skipping 5587 matching lines @@
   if (IsIdentifier()) {
     if (LookaheadToken(1) != Token::kLPAREN) {
       SkipType(true);
     }
     ExpectIdentifier("function name expected");
   }
   if (CurrentToken() == Token::kLPAREN) {
     const bool allow_explicit_default_values = true;
     ParamList params;
     params.skipped = true;
-    ParseFormalParameterList(allow_explicit_default_values, &params);
+    ParseFormalParameterList(allow_explicit_default_values, false, &params);
   }
   if (CurrentToken() == Token::kLBRACE) {
     SkipBlock();
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
     SkipExpr();
   }
 }
 
 
@@ skipping 278 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart