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 597 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, Token::Kind operator_token) {
+  intptr_t expected_num_parameters;  // Includes receiver.
+  if (operator_token == Token::kASSIGN_INDEX) {
+    expected_num_parameters = 3;
+  } else if ((operator_token == Token::kNEGATE) ||
+      (operator_token == Token::kBIT_NOT)) {
+    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 47 matching lines @@
           ((follower == Token::kPERIOD) &&    // Qualified class name of type,
            (LookaheadToken(3) != Token::kLPAREN))) {  // but not a named constr.
         ASSERT(is_top_level_);
         // The declared type of fields is never ignored, even in unchecked mode,
         // because getters and setters could be closurized at some time (not
         // supported yet).
         member.type = &AbstractType::ZoneHandle(ParseType(kCanResolve));
       }
     }
   }
+  Token::Kind operator_token = Token::kILLEGAL;
   // Optionally parse a (possibly named) constructor name or factory.
   if (IsIdentifier() &&
       (CurrentLiteral()->Equals(members->class_name()) || member.has_factory)) {
     if (member.has_factory) {
       // The factory name may be qualified.
       QualIdent factory_name;
       ParseQualIdent(&factory_name);
       member.name_pos = factory_name.ident_pos;
       member.name = factory_name.ident;  // Unqualified identifier.
       // The class of the factory result type is specified by the factory name.
@@ skipping 70 matching lines @@
              (LookaheadToken(1) != Token::kASSIGN) &&
              (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");
     }
+    operator_token = CurrentToken();
     member.kind = RawFunction::kFunction;
     member.name_pos = this->token_index_;
     member.name =
-        &String::ZoneHandle(String::NewSymbol(Token::Str(CurrentToken())));
+        &String::ZoneHandle(String::NewSymbol(Token::Str(operator_token)));
     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 (operator_token != Token::kILLEGAL) {
+      CheckOperatorArity(member, operator_token);
+    }
   } 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