Fix issue 979: operator arity must be verified.

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/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 338 matching lines @@
   MemberDesc() {
     Clear();
   }
   void Clear() {
     has_abstract = false;
     has_final = false;
     has_const = false;
     has_static = false;
     has_var = false;
     has_factory = false;
+    is_operator = false;
     type = NULL;
     name_pos = 0;
     name = NULL;
     redirect_name = NULL;
     params.Clear();
     kind = RawFunction::kFunction;
   }
   bool IsConstructor() const {
     return (kind == RawFunction::kConstructor) && !has_static;
   }
   bool IsFactory() const {
     return (kind == RawFunction::kConstructor) && has_static;
   }
   bool IsFactoryOrConstructor() const {
     return (kind == RawFunction::kConstructor);
   }
   bool IsGetter() const {
     return kind == RawFunction::kGetterFunction;
   }
   bool IsSetter() const {
     return kind == RawFunction::kSetterFunction;
   }
   bool has_abstract;
   bool has_final;
   bool has_const;
   bool has_static;
   bool has_var;
   bool has_factory;
+  bool is_operator;
   const AbstractType* type;
   intptr_t name_pos;
   String* name;
   String* redirect_name;  // For constructors: NULL or redirected constructor.
   ParamList params;
   RawFunction::Kind kind;
 };
 
 
 class ClassDesc : public ValueObject {
@@ skipping 211 matching lines @@
           new LoadLocalNode(node_sequence->token_index(), *receiver));
     }
   }
 
   parsed_function->set_default_parameter_values(default_parameter_values);
   isolate->set_ast_node_id(prev_ast_node_id);
 }
 
 
 SequenceNode* Parser::ParseStaticConstGetter(const Function& func) {
+  TRACE_PARSER("ParseStaticConstGetter");
   ParamList params;
   ASSERT(func.num_fixed_parameters() == 0);  // static.
   ASSERT(func.num_optional_parameters() == 0);
   ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   // Static const fields must have an initializer.
@@ skipping 511 matching lines @@
       if (signature_class.NumTypeParameters() > 0) {
         CaptureReceiver();
       }
     }
   }
   return new ClosureNode(token_pos, implicit_closure_function, receiver, NULL);
 }
 
 
 AstNode* Parser::ParseSuperFieldAccess(const String& field_name) {
+  TRACE_PARSER("ParseSuperFieldAccess");
   const intptr_t field_pos = token_index_;
   const Class& super_class = Class::Handle(current_class().SuperClass());
   if (super_class.IsNull()) {
     ErrorMsg("class '%s' does not have a superclass",
              String::Handle(current_class().Name()).ToCString());
   }
   AstNode* implicit_argument = LoadReceiver(field_pos);
 
   const String& getter_name =
       String::ZoneHandle(Field::GetterName(field_name));
@@ skipping 193 matching lines @@
 
 
 struct FieldInitExpression {
   Field* inst_field;
   AstNode* expr;
 };
 
 
 void Parser::ParseInitializedInstanceFields(const Class& cls,
                  GrowableArray<FieldInitExpression>* initializers) {
+  TRACE_PARSER("ParseInitializedInstanceFields");
   const Array& fields = Array::Handle(cls.fields());
   Field& f = Field::Handle();
   const intptr_t saved_pos = token_index_;
   for (int i = 0; i < fields.Length(); i++) {
     f ^= fields.At(i);
     if (!f.is_static() && f.has_initializer()) {
       Field& field = Field::ZoneHandle();
       field ^= fields.At(i);
       intptr_t field_pos = field.token_index();
       SetPosition(field_pos);
@@ skipping 47 matching lines @@
     // Generate implicit super() if we haven't seen an explicit super call
     // or constructor redirection.
     GenerateSuperConstructorCall(cls, receiver);
   }
   CheckConstFieldsInitialized(cls);
 }
 
 
 void Parser::ParseConstructorRedirection(const Class& cls,
                                          LocalVariable* receiver) {
+  TRACE_PARSER("ParseConstructorRedirection");
   ASSERT(CurrentToken() == Token::kTHIS);
   const intptr_t call_pos = token_index_;
   ConsumeToken();
   String& ctor_name = String::Handle(cls.Name());
   String& ctor_suffix = String::Handle(String::NewSymbol("."));
 
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     ctor_suffix = String::Concat(
         ctor_suffix, *ExpectIdentifier("constructor name expected"));
@@ skipping 73 matching lines @@
   // Empty constructor body.
   SequenceNode* statements = CloseBlock();
   return statements;
 }
 
 
 // Parser is at the opening parenthesis of the formal parameter declaration
 // of function. Parse the formal parameters, initializers and code.
 SequenceNode* Parser::ParseConstructor(const Function& func,
                                        Array& default_parameter_values) {
+  TRACE_PARSER("ParseConstructor");
   ASSERT(func.IsConstructor());
   ASSERT(!func.IsFactory());
   ASSERT(!func.is_static());
   ASSERT(!func.IsLocalFunction());
   const Class& cls = Class::Handle(func.owner());
   ASSERT(!cls.IsNull());
 
   if (CurrentToken() == Token::kCLASS) {
     // Special case: implicit constructor.
     // The parser adds an implicit default constructor when a class
@@ skipping 231 matching lines @@
   SequenceNode* statements = CloseBlock();
   return statements;
 }
 
 
 // Parser is at the opening parenthesis of the formal parameter
 // declaration of the function or constructor.
 // Parse the formal parameters and code.
 SequenceNode* Parser::ParseFunc(const Function& func,
                                 Array& default_parameter_values) {
+  TRACE_PARSER("ParseFunc");
   if (func.IsConstructor()) {
     return ParseConstructor(func, default_parameter_values);
   }
 
   ASSERT(!func.IsConstructor());
   OpenFunctionBlock(func);  // Build local scope for function.
 
   ParamList params;
   // Static functions do not have a receiver.
   // An instance closure may capture and access the receiver, but via the
@@ skipping 110 matching lines @@
       ExpectToken(Token::kASSIGN);
       SetAllowFunctionLiterals(false);
       SkipExpr();
       SetAllowFunctionLiterals(true);
     }
   } while (CurrentToken() == Token::kCOMMA);
 }
 
 
 void Parser::ParseQualIdent(QualIdent* qual_ident) {
+  TRACE_PARSER("ParseQualIdent");
   ASSERT(IsIdentifier());
   ASSERT(!current_class().IsNull());
   qual_ident->ident_pos = token_index_;
   qual_ident->ident = CurrentLiteral();
   qual_ident->lib_prefix = NULL;
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     // An identifier cannot be resolved in a local scope when top level parsing.
     if (is_top_level_ ||
         !ResolveIdentInLocalScope(qual_ident->ident_pos,
@@ skipping 15 matching lines @@
           qual_ident->ident =
               ExpectIdentifier("identifier expected after '.'");
         }
       }
     }
   }
 }
 
 
 void Parser::ParseMethodOrConstructor(ClassDesc* members, MemberDesc* method) {
+  TRACE_PARSER("ParseMethodOrConstructor");
   ASSERT(CurrentToken() == Token::kLPAREN);
   intptr_t method_pos = this->token_index_;
   ASSERT(method->type != NULL);
   ASSERT(method->name_pos > 0);
   ASSERT(current_member_ == method);
 
   if (method->has_var) {
     ErrorMsg(method->name_pos, "keyword var not allowed for methods");
   }
   if (method->has_final) {
@@ skipping 190 matching lines @@
   func.set_end_token_index(method_end_pos);
 
   // No need to resolve parameter types yet, or add parameters to local scope.
   ASSERT(is_top_level_);
   AddFormalParamsToFunction(&method->params, func);
   members->AddFunction(&func);
 }
 
 
 void Parser::ParseFieldDefinition(ClassDesc* members, MemberDesc* field) {
+  TRACE_PARSER("ParseFieldDefinition");
   // The parser has read the first field name and is now at the token
   // after the field name.
   ASSERT(CurrentToken() == Token::kSEMICOLON ||
          CurrentToken() == Token::kCOMMA ||
          CurrentToken() == Token::kASSIGN);
   ASSERT(field->type != NULL);
   ASSERT(field->name_pos > 0);
   ASSERT(current_member_ == field);
 
   if (field->has_const) {
@@ skipping 85 matching lines @@
       break;
     }
     ConsumeToken();
     field->name_pos = this->token_index_;
     field->name = ExpectIdentifier("field name expected");
   }
   ExpectSemicolon();
 }
 
 
+void Parser::CheckOperatorArity(const MemberDesc& member) {
+  const String& assign_index_name =
+      String::Handle(String::NewSymbol(Token::Str(Token::kASSIGN_INDEX)));
+  const String& negate_name =
+      String::Handle(String::NewSymbol(Token::Str(Token::kNEGATE)));
+  const String& bit_not_name =
+      String::Handle(String::NewSymbol(Token::Str(Token::kBIT_NOT)));
+  intptr_t expected_num_parameters;  // Includes receiver.
+  if (member.name->Equals(assign_index_name)) {
+    expected_num_parameters = 3;
+  } else if (member.name->Equals(negate_name) ||
+      member.name->Equals(bit_not_name)) {
+    expected_num_parameters = 1;
+  } else {
+    expected_num_parameters = 2;
+  }
+  if ((member.params.num_optional_parameters > 0) ||
+      (member.params.has_named_optional_parameters) ||
+      (member.params.num_fixed_parameters != expected_num_parameters)) {
+    // Subtract receiver when reporting number of expected arguments.
+    ErrorMsg(member.name_pos, "operator %s expects %d argument(s)",
+        member.name->ToCString(), (expected_num_parameters - 1));
+  }
+}
+
+
 void Parser::ParseClassMemberDefinition(ClassDesc* members) {
+  TRACE_PARSER("ParseClassMemberDefinition");
   MemberDesc member;
   current_member_ = &member;
   if ((CurrentToken() == Token::kABSTRACT) &&
       (LookaheadToken(1) != Token::kLPAREN)) {
     ConsumeToken();
     member.has_abstract = true;
   }
   if ((CurrentToken() == Token::kSTATIC) &&
       (LookaheadToken(1) != Token::kLPAREN)) {
     ConsumeToken();
@@ skipping 138 matching lines @@
              (LookaheadToken(1) != Token::kCOMMA)  &&
              (LookaheadToken(1) != Token::kSEMICOLON)) {
     ConsumeToken();
     if (!Token::CanBeOverloaded(CurrentToken())) {
       ErrorMsg("invalid operator overloading");
     }
     if (member.has_static) {
       ErrorMsg("operator overloading functions cannot be static");
     }
     member.kind = RawFunction::kFunction;
+    member.is_operator = true;
     member.name_pos = this->token_index_;
     member.name =
         &String::ZoneHandle(String::NewSymbol(Token::Str(CurrentToken())));
     ConsumeToken();
   } else if (IsIdentifier()) {
     member.name = CurrentLiteral();
     member.name_pos = token_index_;
     ConsumeToken();
   } else {
     ErrorMsg("identifier expected");
   }
 
   ASSERT(member.name != NULL);
   if (CurrentToken() == Token::kLPAREN) {
     if (members->is_interface() && member.has_static) {
       if (member.has_factory) {
         ErrorMsg("factory constructors are not allowed in interfaces");
       } else {
         ErrorMsg("static methods are not allowed in interfaces");
       }
     }
     // Constructor or method.
     if (member.type == NULL) {
       member.type = &Type::ZoneHandle(Type::DynamicType());
     }
     ParseMethodOrConstructor(members, &member);
+    if (member.is_operator) {
+      CheckOperatorArity(member);

[hausner, 2012/02/16 17:39:36]

Suggestion. I think this is unnecessarily complicated. In CheckOperatorArity you
have to create several handles and do string compares to figure out which
operator we're dealing with and what the expected arity is.

Instead, you could remember the operator token a few lines above and pass it to
CheckOperatorArity(). You also don't need the is_operator field in MemberDesc. A
local boolean variable here would be enough to remember that you need to call
CheckOperatorArity.
  

+    }
   } else if (CurrentToken() ==  Token::kSEMICOLON ||
              CurrentToken() == Token::kCOMMA ||
              CurrentToken() == Token::kASSIGN) {
     // Field definition.
     if (member.type == NULL) {
       if (member.has_final) {
         member.type = &Type::ZoneHandle(Type::DynamicType());
       } else {
         ErrorMsg("missing 'var', 'final' or type in field declaration");
       }
@@ skipping 411 matching lines @@
     if (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       ExpectIdentifier("name expected");
     }
     SkipTypeArguments();
   }
 }
 
 
 void Parser::ParseTypeParameters(const Class& cls) {
+  TRACE_PARSER("ParseTypeParameters");
   if (CurrentToken() == Token::kLT) {
     GrowableArray<AbstractType*> type_parameters_array;
     GrowableArray<AbstractType*> bounds_array;
     intptr_t index = 0;
     do {
       ConsumeToken();
       if (CurrentToken() != Token::kIDENT) {
         ErrorMsg("type parameter name expected");
       }
       String& type_parameter_name = *CurrentLiteral();
@@ skipping 29 matching lines @@
       bound = bounds.TypeAt(i);
       ResolveTypeFromClass(cls, kCanResolve, &bound);
       bounds.SetTypeAt(i, bound);
     }
   }
 }
 
 
 RawAbstractTypeArguments* Parser::ParseTypeArguments(
     TypeResolution type_resolution) {
+  TRACE_PARSER("ParseTypeArguments");
   if (CurrentToken() == Token::kLT) {
     GrowableArray<AbstractType*> types;
     do {
       ConsumeToken();
       AbstractType& type = AbstractType::ZoneHandle(ParseType(type_resolution));
       types.Add(&type);
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) || (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
       ErrorMsg("right angle bracket expected");
     }
     if (type_resolution != kIgnore) {
       return NewTypeArguments(types);
     }
   }
   return TypeArguments::null();
 }
 
 
 // Parse and return an array of interface types.
 RawArray* Parser::ParseInterfaceList() {
+  TRACE_PARSER("ParseInterfaceList");
   ASSERT((CurrentToken() == Token::kIMPLEMENTS) ||
          (CurrentToken() == Token::kEXTENDS));
   GrowableArray<AbstractType*> interfaces;
   String& interface_name = String::Handle();
   do {
     ConsumeToken();
     intptr_t supertype_pos = token_index_;
     AbstractType& interface = AbstractType::ZoneHandle(ParseType(kCanResolve));
     interface_name = interface.Name();
     for (int i = 0; i < interfaces.length(); i++) {
@@ skipping 47 matching lines @@
                String::Handle(interface.Name()).ToCString(),
                String::Handle(conflicting.Name()).ToCString());
     }
   }
   cls_interfaces = NewArray<AbstractType>(all_interfaces);
   cls.set_interfaces(cls_interfaces);
 }
 
 
 void Parser::ParseTopLevelVariable(TopLevel* top_level) {
+  TRACE_PARSER("ParseTopLevelVariable");
   const bool is_final = (CurrentToken() == Token::kFINAL);
   const bool is_static = true;
   const AbstractType& type = AbstractType::ZoneHandle(ParseFinalVarOrType(
       FLAG_enable_type_checks ? kCanResolve : kIgnore));
 
   while (true) {
     const intptr_t name_pos = token_index_;
     String& var_name = *ExpectIdentifier("variable name expected");
 
     if (library_.LookupObject(var_name) != Object::null()) {
@@ skipping 37 matching lines @@
       ConsumeToken();
       break;
     } else {
       ExpectSemicolon();  // Reports error.
     }
   }
 }
 
 
 void Parser::ParseTopLevelFunction(TopLevel* top_level) {
+  TRACE_PARSER("ParseTopLevelFunction");
   AbstractType& result_type = Type::Handle(Type::DynamicType());
   const bool is_static = true;
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
   } else {
     // Parse optional type.
     if ((CurrentToken() == Token::kIDENT) &&
         (LookaheadToken(1) != Token::kLPAREN)) {
       result_type = ParseType(kCanResolve);
@@ skipping 43 matching lines @@
                     is_static, false, function_pos));
   func.set_result_type(result_type);
   func.set_end_token_index(function_end_pos);
   AddFormalParamsToFunction(&params, func);
   top_level->functions.Add(&func);
   library_.AddObject(func, func_name);
 }
 
 
 void Parser::ParseTopLevelAccessor(TopLevel* top_level) {
+  TRACE_PARSER("ParseTopLevelAccessor");
   const bool is_static = true;
   AbstractType& result_type = AbstractType::Handle();
   bool is_getter = (CurrentToken() == Token::kGET);
   if (CurrentToken() == Token::kGET ||
       CurrentToken() == Token::kSET) {
     ConsumeToken();
     result_type = Type::DynamicType();
   } else {
     if (CurrentToken() == Token::kVOID) {
       ConsumeToken();
@@ skipping 60 matching lines @@
                                RawFunction::kSetterFunction,
                     is_static, false, accessor_pos));
   func.set_result_type(result_type);
   AddFormalParamsToFunction(&params, func);
   top_level->functions.Add(&func);
   library_.AddObject(func, accessor_name);
 }
 
 
 void Parser::ParseLibraryName() {
+  TRACE_PARSER("ParseLibraryName");
   if ((script_.kind() == RawScript::kLibrary) &&
       (CurrentToken() != Token::kLIBRARY)) {
     // Handle error case early to get consistent error message.
     ExpectToken(Token::kLIBRARY);
   }
   if (CurrentToken() == Token::kLIBRARY) {
     ConsumeToken();
     ExpectToken(Token::kLPAREN);
     if (CurrentToken() != Token::kSTRING) {
       ErrorMsg("library name expected");
@@ skipping 20 matching lines @@
                                Api::NewLocalHandle(url),
                                Api::NewLocalHandle(import_map));
   if (Dart_IsError(result)) {
     ErrorMsg(token_pos, "library handler failed: %s", Dart_GetError(result));
   }
   return result;
 }
 
 
 void Parser::ParseLibraryImport() {
+  TRACE_PARSER("ParseLibraryImport");
   while (CurrentToken() == Token::kIMPORT) {
     const intptr_t import_pos = token_index_;
     ConsumeToken();
     ExpectToken(Token::kLPAREN);
     if (CurrentToken() != Token::kSTRING) {
       ErrorMsg("library url expected");
     }
     const String& url = *ParseImportStringLiteral();
     String& prefix = String::Handle();
     if (CurrentToken() == Token::kCOMMA) {
@@ skipping 45 matching lines @@
       } else {
         library_prefix = LibraryPrefix::New(prefix, library);
         library_.AddObject(library_prefix, prefix);
       }
     }
   }
 }
 
 
 void Parser::ParseLibraryInclude() {
+  TRACE_PARSER("ParseLibraryInclude");
   const Array& import_map = Array::Handle(library_.import_map());
   while (CurrentToken() == Token::kSOURCE) {
     const intptr_t source_pos = token_index_;
     ConsumeToken();
     ExpectToken(Token::kLPAREN);
     if (CurrentToken() != Token::kSTRING) {
       ErrorMsg("source url expected");
     }
     const String& url = *ParseImportStringLiteral();
     ExpectToken(Token::kRPAREN);
     ExpectToken(Token::kSEMICOLON);
     Dart_Handle handle = CallLibraryTagHandler(kCanonicalizeUrl,
                                                source_pos,
                                                url,
                                                import_map);
     const String& canon_url = String::CheckedHandle(Api::UnwrapHandle(handle));
     CallLibraryTagHandler(kSourceTag, source_pos, canon_url, import_map);
   }
 }
 
 
 void Parser::ParseLibraryDefinition() {
+  TRACE_PARSER("ParseLibraryDefinition");
   // Handle the script tag.
   if (CurrentToken() == Token::kSCRIPTTAG) {
     // Nothing to do for script tags except to skip them.
     ConsumeToken();
   }
 
   ParseLibraryName();
   ParseLibraryImport();
   ParseLibraryInclude();
 }
 
 
 void Parser::ParseTopLevel() {
+  TRACE_PARSER("ParseTopLevel");
   // Collect the classes found at the top level in this growable array.
   // They need to be registered with class finalization after parsing
   // has been completed.
   GrowableArray<const Class*> classes;
   SetPosition(0);
   is_top_level_ = true;
   TopLevel top_level;
   Class& toplevel_class = Class::ZoneHandle(
       Class::New(String::ZoneHandle(String::NewSymbol("::")),
                  script_,
@@ skipping 161 matching lines @@
     if (param_desc.is_final) {
       parameter->set_is_final();
     }
   }
 }
 
 
 // Builds ReturnNode/NativeBodyNode for a native function.
 void Parser::ParseNativeFunctionBlock(const ParamList* params,
                                       const Function& func) {
+  TRACE_PARSER("ParseNativeFunctionBlock");
   const Class& cls = Class::Handle(func.owner());
   const int num_parameters = params->parameters->length();
 
   // Parse the function name out.
   const intptr_t native_pos = token_index_;
   const String& native_name = ParseNativeDeclaration();
 
   // Now resolve the native function to the corresponding native entrypoint.
   NativeFunction native_function = NativeEntry::ResolveNative(cls,
                                                               native_name,
@@ skipping 96 matching lines @@
     variable->set_is_final();
   }
   return initialization;
 }
 
 
 // Parses ('var' | 'final' [type] | type).
 // The presence of 'final' must be detected and remembered before the call.
 // If a type is parsed, it is resolved (or not) according to type_resolution.
 RawAbstractType* Parser::ParseFinalVarOrType(TypeResolution type_resolution) {
+  TRACE_PARSER("ParseFinalVarOrType");
   if (CurrentToken() == Token::kVAR) {
     ConsumeToken();
     return Type::DynamicType();
   }
   bool type_is_optional = false;
   if (CurrentToken() == Token::kFINAL) {
     ConsumeToken();
     type_is_optional = true;
   }
   if (CurrentToken() != Token::kIDENT) {
@@ skipping 690 matching lines @@
   ExpectToken(Token::kLPAREN);
   AstNode* cond_expr = ParseExpr(kAllowConst);
   ExpectToken(Token::kRPAREN);
   ExpectSemicolon();
   return new DoWhileNode(do_pos, label, cond_expr, dowhile_body);
 }
 
 
 AstNode* Parser::ParseForInStatement(intptr_t forin_pos,
                                      SourceLabel* label) {
+  TRACE_PARSER("ParseForInStatement");
   bool is_final = (CurrentToken() == Token::kFINAL);
   const String* loop_var_name = NULL;
   LocalVariable* loop_var = NULL;
   intptr_t loop_var_pos = 0;
   if (LookaheadToken(1) == Token::kIN) {
     loop_var_pos = token_index_;
     loop_var_name = ExpectIdentifier("variable name expected");
   } else {
     // The case without a type is handled above, so require a type here.
     const AbstractType& type = AbstractType::ZoneHandle(ParseFinalVarOrType(
@@ skipping 203 matching lines @@
   ArgumentListNode* arguments = new ArgumentListNode(begin);
   arguments->Add(new LiteralNode(begin,
       Integer::ZoneHandle(Integer::New(begin))));
   arguments->Add(new LiteralNode(end,
       Integer::ZoneHandle(Integer::New(end))));
   return MakeStaticCall(kAssertionErrorName, kThrowNewName, arguments);
 }
 
 
 AstNode* Parser::ParseAssertStatement() {
+  TRACE_PARSER("ParseAssertStatement");
   ConsumeToken();  // Consume assert keyword.
   ExpectToken(Token::kLPAREN);
   const intptr_t condition_pos = token_index_;
   if (!FLAG_enable_asserts && !FLAG_enable_type_checks) {
     SkipExpr();
     ExpectToken(Token::kRPAREN);
     return NULL;
   }
   AstNode* condition = ParseExpr(kAllowConst);
   const intptr_t condition_end = token_index_;
@@ skipping 62 matching lines @@
     if (!added_to_scope) {
       ErrorMsg(stack_trace_param.token_index,
                "name '%s' already exists in scope",
                stack_trace_param.var->ToCString());
     }
   }
 }
 
 
 SequenceNode* Parser::ParseFinallyBlock() {
+  TRACE_PARSER("ParseFinallyBlock");
   OpenBlock();
   ExpectToken(Token::kLBRACE);
   ParseStatementSequence();
   ExpectToken(Token::kRBRACE);
   SequenceNode* finally_block = CloseBlock();
   return finally_block;
 }
 
 
 void Parser::PushTryBlock(Block* try_block) {
@@ skipping 275 matching lines @@
     current_block_->statements->Add(try_catch_node);
     SequenceNode* sequence = CloseBlock();
     sequence->set_label(try_label);
     try_catch_node = sequence;
   }
   return try_catch_node;
 }
 
 
 AstNode* Parser::ParseJump(String* label_name) {
+  TRACE_PARSER("ParseJump");
   ASSERT(CurrentToken() == Token::kBREAK || CurrentToken() == Token::kCONTINUE);
   Token::Kind jump_kind = CurrentToken();
   const intptr_t jump_pos = token_index_;
   SourceLabel* target = NULL;
   ConsumeToken();
   if (IsIdentifier()) {
     // Explicit label after break/continue.
     const String& target_name = *CurrentLiteral();
     ConsumeToken();
     // Handle pathological cases first.
@@ skipping 837 matching lines @@
                             kThrowNewName,
                             arguments);
     }
   }
   CheckFunctionIsCallable(call_pos, func);
   return new StaticCallNode(call_pos, func, arguments);
 }
 
 
 AstNode* Parser::ParseInstanceCall(AstNode* receiver, const String& func_name) {
+  TRACE_PARSER("ParseInstanceCall");
   const intptr_t call_pos = token_index_;
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg(call_pos, "left parenthesis expected");
   }
   ArgumentListNode* arguments = ParseActualParameters(NULL, kAllowConst);
   return new InstanceCallNode(call_pos, receiver, func_name, arguments);
 }
 
 
 AstNode* Parser::ParseClosureCall(AstNode* closure) {
+  TRACE_PARSER("ParseClosureCall");
   const intptr_t call_pos = token_index_;
   ASSERT(CurrentToken() == Token::kLPAREN);
   ArgumentListNode* arguments = ParseActualParameters(NULL, kAllowConst);
   return new ClosureCallNode(call_pos, closure, arguments);
 }
 
 
 AstNode* Parser::ParseInstanceFieldAccess(AstNode* receiver,
                                           const String& field_name) {
   TRACE_PARSER("ParseInstanceFieldAccess");
@@ skipping 815 matching lines @@
   }
   ErrorMsg(ident_pos, "import variable '%s' has not been defined",
            ident.ToCString());
   return String::null();
 }
 
 
 // Parses type = [ident "."] ident ["<" type { "," type } ">"] and resolve it
 // according to the given type_resolution.
 RawAbstractType* Parser::ParseType(TypeResolution type_resolution) {
+  TRACE_PARSER("ParseType");
   if (CurrentToken() != Token::kIDENT) {
     ErrorMsg("type name expected");
   }
   QualIdent type_name;
   if (type_resolution == kIgnore) {
     SkipQualIdent();
   } else {
     ParseQualIdent(&type_name);
     // An identifier cannot be resolved in a local scope when top level parsing.
     if (!is_top_level_ &&
@@ skipping 372 matching lines @@
     factory_param->Add(kv_pairs);
     return new ConstructorCallNode(literal_pos,
                                    map_type_arguments,
                                    map_literal_factory,
                                    factory_param);
   }
 }
 
 
 AstNode* Parser::ParseCompoundLiteral() {
+  TRACE_PARSER("ParseCompoundLiteral");
   bool is_const = false;
   if (CurrentToken() == Token::kCONST) {
     is_const = true;
     ConsumeToken();
   }
   const intptr_t type_pos = token_index_;
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::ZoneHandle(ParseTypeArguments(kMustResolve));
   AstNode* primary = NULL;
   if ((CurrentToken() == Token::kLBRACK) ||
@@ skipping 221 matching lines @@
 
 
 // A string literal consists of the concatenation of the next n tokens
 // that satisfy the EBNF grammar:
 // literal = kSTRING {{ interpol }+ kSTRING }
 // interpol = kINTERPOL_VAR | (kINTERPOL_START expression kINTERPOL_END)
 // In other words, the scanner breaks down interpolated strings so that
 // a string literal always begins and ends with a kSTRING token, and
 // there are never two kSTRING tokens next to each other.
 AstNode* Parser::ParseStringLiteral() {
+  TRACE_PARSER("ParseStringLiteral");
   AstNode* primary = NULL;
   const intptr_t literal_start = token_index_;
   if ((CurrentToken() == Token::kSTRING) &&
       (LookaheadToken(1) != Token::kINTERPOL_VAR) &&
       (LookaheadToken(1) != Token::kINTERPOL_START)) {
     // Common case: no interpolation.
     primary = new LiteralNode(literal_start, *CurrentLiteral());
     ConsumeToken();
     return primary;
   }
@@ skipping 35 matching lines @@
 
 
 // An import string literal consists of the concatenation of the next n tokens
 // that satisfy the EBNF grammar:
 // literal = kSTRING {{ interpol }+ kSTRING }
 // interpol = kINTERPOL_VAR
 // In other words, the scanner breaks down interpolated strings so that
 // a string literal always begins and ends with a kSTRING token, and
 // there are never two kSTRING tokens next to each other.
 String* Parser::ParseImportStringLiteral() {
+  TRACE_PARSER("ParseImportStringLiteral");
   if ((CurrentToken() == Token::kSTRING) &&
       (LookaheadToken(1) != Token::kINTERPOL_VAR) &&
       (LookaheadToken(1) != Token::kINTERPOL_START)) {
     // Common case: no interpolation.
     String* result = CurrentLiteral();
     ConsumeToken();
     return result;
   }
   // String interpolation needed.
   String& result = String::ZoneHandle(String::New(""));
@@ skipping 433 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart