iv-phonic 0.0.1 → 0.0.2

data/ext/include/iv/parser.h

@@ -140,15 +140,20 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
 #undef V
   class Target : private Noncopyable<Target>::type {
    public:
-    Target(parser_type * parser, BreakableStatement* target)
+    typedef typename SpaceVector<Factory, Identifier*>::type Identifiers;
+    enum Type {
+      kNamedOnlyStatement = 0,  // (00)2
+      kIterationStatement = 2,  // (10)2
+      kSwitchStatement = 3      // (11)2
+    };
+    Target(parser_type* parser, Type type)
       : parser_(parser),
         prev_(parser->target()),
-        node_(target) {
+        labels_(parser->labels()),
+        node_(NULL),
+        type_(type) {
       parser_->set_target(this);
-      if (parser_->labels()) {
-        target->set_labels(parser_->labels());
-        parser_->set_labels(NULL);
-      }
+      parser_->set_labels(NULL);
     }
     ~Target() {
       parser_->set_target(prev_);
@@ -156,13 +161,36 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
     inline Target* previous() const {
       return prev_;
     }
-    inline BreakableStatement* node() const {
+    inline bool IsAnonymous() const {
+      return type_ & 2;
+    }
+    inline bool IsIteration() const {
+      return type_ == kIterationStatement;
+    }
+    inline bool IsSwitch() const {
+      return type_ == kSwitchStatement;
+    }
+    inline bool IsNamedOnly() const {
+      return !IsAnonymous();
+    }
+    inline BreakableStatement** node() {
+      node_ = new(parser_->factory())BreakableStatement*();
       return node_;
     }
+    inline Identifiers* labels() const {
+      return labels_;
+    }
+    inline void set_node(BreakableStatement* node) {
+      if (node_) {
+        *node_ = node;
+      }
+    }
    private:
     parser_type* parser_;
     Target* prev_;
-    BreakableStatement* node_;
+    Identifiers* labels_;
+    BreakableStatement** node_;
+    int type_;
   };
 
   Parser(BasicSource* source, Factory* space)
@@ -200,7 +228,7 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
 //   | FunctionDeclaration
   bool ParseSourceElements(Token::Type end,
                            FunctionLiteral* function, bool *res) {
-    Statement *stmt;
+    Statement* stmt;
     bool recognize_use_strict_directive = true;
     const StrictSwitcher switcher(this);
     while (token_ != end) {
@@ -369,11 +397,9 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
 //  and this statement is very useful for not breaking FunctionDeclaration.
   Statement* ParseFunctionDeclaration(bool *res) {
     assert(token_ == Token::FUNCTION);
-    Next();
-    IS(Token::IDENTIFIER);
-    FunctionLiteral* expr = ParseFunctionLiteral(
+    FunctionLiteral* const expr = ParseFunctionLiteral(
         FunctionLiteral::DECLARATION,
-        FunctionLiteral::GENERAL, true, CHECK);
+        FunctionLiteral::GENERAL, CHECK);
     // define named function as FunctionDeclaration
     scope_->AddFunctionDeclaration(expr);
     return factory_->NewFunctionStatement(expr);
@@ -388,9 +414,9 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
 //    | StatementList Statement
   Block* ParseBlock(bool *res) {
     assert(token_ == Token::LBRACE);
-    Block *block = factory_->NewBlock();
-    Statement *stmt;
-    Target target(this, block);
+    Block* const block = factory_->NewBlock();
+    Statement* stmt;
+    Target target(this, Target::kNamedOnlyStatement);
 
     Next();
     while (token_ != Token::RBRACE) {
@@ -398,6 +424,7 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
       block->AddStatement(stmt);
     }
     Next();
+    target.set_node(block);
     return block;
   }
 
@@ -406,7 +433,7 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
 //    : CONST VariableDeclarationList ';'
   Statement* ParseVariableStatement(bool *res) {
     assert(token_ == Token::VAR || token_ == Token::CONST);
-    VariableStatement* stmt = factory_->NewVariableStatement(token_);
+    VariableStatement* const stmt = factory_->NewVariableStatement(token_);
     ParseVariableDeclarations(stmt, true, CHECK);
     ExpectSemicolon(CHECK);
     return stmt;
@@ -428,14 +455,14 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
   Statement* ParseVariableDeclarations(VariableStatement* stmt,
                                        bool contains_in,
                                        bool *res) {
-    Identifier *name;
-    Expression *expr;
-    Declaration *decl;
+    Identifier* name;
+    Expression* expr;
+    Declaration* decl;
 
     do {
       Next();
       IS(Token::IDENTIFIER);
-      name = factory_->NewIdentifier(lexer_.Buffer());
+      name = ParseIdentifier(lexer_.Buffer());
       // section 12.2.1
       // within the strict code, Identifier must not be "eval" or "arguments"
       if (strict_) {
@@ -449,7 +476,6 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
           }
         }
       }
-      Next();
 
       if (token_ == Token::ASSIGN) {
         Next();
@@ -480,24 +506,23 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
 //    | IF '(' Expression ')' Statement
   Statement* ParseIfStatement(bool *res) {
     assert(token_ == Token::IF);
-    IfStatement *if_stmt = NULL;
-    Statement* stmt;
+    Statement* else_statement = NULL;
     Next();
 
     EXPECT(Token::LPAREN);
 
-    Expression *expr = ParseExpression(true, CHECK);
+    Expression* const expr = ParseExpression(true, CHECK);
 
     EXPECT(Token::RPAREN);
 
-    stmt = ParseStatement(CHECK);
-    if_stmt = factory_->NewIfStatement(expr, stmt);
+    Statement* const then_statement = ParseStatement(CHECK);
     if (token_ == Token::ELSE) {
       Next();
-      stmt = ParseStatement(CHECK);
-      if_stmt->SetElse(stmt);
+      else_statement = ParseStatement(CHECK);
     }
-    return if_stmt;
+    return factory_->NewIfStatement(expr,
+                                    then_statement,
+                                    else_statement);
   }
 
 //  IterationStatement
@@ -514,23 +539,22 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
   Statement* ParseDoWhileStatement(bool *res) {
     //  DO Statement WHILE '(' Expression ')' ';'
     assert(token_ == Token::DO);
-    DoWhileStatement* dowhile = factory_->NewDoWhileStatement();
-    Target target(this, dowhile);
+    Target target(this, Target::kIterationStatement);
     Next();
 
-    Statement *stmt = ParseStatement(CHECK);
-    dowhile->set_body(stmt);
+    Statement* const stmt = ParseStatement(CHECK);
 
     EXPECT(Token::WHILE);
 
     EXPECT(Token::LPAREN);
 
-    Expression *expr = ParseExpression(true, CHECK);
-    dowhile->set_cond(expr);
+    Expression* const expr = ParseExpression(true, CHECK);
 
     EXPECT(Token::RPAREN);
 
     ExpectSemicolon(CHECK);
+    DoWhileStatement* const dowhile = factory_->NewDoWhileStatement(stmt, expr);
+    target.set_node(dowhile);
     return dowhile;
   }
 
@@ -541,15 +565,15 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
 
     EXPECT(Token::LPAREN);
 
-    Expression *expr = ParseExpression(true, CHECK);
-    WhileStatement* whilestmt = factory_->NewWhileStatement(expr);
-    Target target(this, whilestmt);
+    Expression* const expr = ParseExpression(true, CHECK);
+    Target target(this, Target::kIterationStatement);
 
     EXPECT(Token::RPAREN);
 
-    Statement* stmt = ParseStatement(CHECK);
-    whilestmt->set_body(stmt);
+    Statement* const stmt = ParseStatement(CHECK);
+    WhileStatement* const whilestmt = factory_->NewWhileStatement(stmt, expr);
 
+    target.set_node(whilestmt);
     return whilestmt;
   }
 
@@ -571,7 +595,7 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
 
     if (token_ != Token::SEMICOLON) {
       if (token_ == Token::VAR || token_ == Token::CONST) {
-        VariableStatement *var = factory_->NewVariableStatement(token_);
+        VariableStatement* const var = factory_->NewVariableStatement(token_);
         ParseVariableDeclarations(var, false, CHECK);
         init = var;
         if (token_ == Token::IN) {
@@ -583,17 +607,17 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
             // so check declarations' size is 1.
             RAISE("invalid for-in left-hand-side");
           }
-          Expression *enumerable = ParseExpression(true, CHECK);
+          Expression* const enumerable = ParseExpression(true, CHECK);
           EXPECT(Token::RPAREN);
-          ForInStatement* forstmt =
-              factory_->NewForInStatement(init, enumerable);
-          Target target(this, forstmt);
-          Statement *body = ParseStatement(CHECK);
-          forstmt->set_body(body);
+          Target target(this, Target::kIterationStatement);
+          Statement* const body = ParseStatement(CHECK);
+          ForInStatement* const forstmt =
+              factory_->NewForInStatement(body, init, enumerable);
+          target.set_node(forstmt);
           return forstmt;
         }
       } else {
-        Expression *init_expr = ParseExpression(false, CHECK);
+        Expression* const init_expr = ParseExpression(false, CHECK);
         init = factory_->NewExpressionStatement(init_expr);
         if (token_ == Token::IN) {
           // for in loop
@@ -601,13 +625,13 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
             RAISE("invalid for-in left-hand-side");
           }
           Next();
-          Expression *enumerable = ParseExpression(true, CHECK);
+          Expression* const enumerable = ParseExpression(true, CHECK);
           EXPECT(Token::RPAREN);
-          ForInStatement* forstmt =
-              factory_->NewForInStatement(init, enumerable);
-          Target target(this, forstmt);
-          Statement *body = ParseStatement(CHECK);
-          forstmt->set_body(body);
+          Target target(this, Target::kIterationStatement);
+          Statement* const body = ParseStatement(CHECK);
+          ForInStatement* const forstmt =
+              factory_->NewForInStatement(body, init, enumerable);
+          target.set_node(forstmt);
           return forstmt;
         }
       }
@@ -616,7 +640,7 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
     // ordinary for loop
     EXPECT(Token::SEMICOLON);
 
-    Expression *cond = NULL;
+    Expression* cond = NULL;
     if (token_ == Token::SEMICOLON) {
       // no cond expr
       Next();
@@ -625,7 +649,7 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
       EXPECT(Token::SEMICOLON);
     }
 
-    ExpressionStatement *next = NULL;
+    ExpressionStatement* next = NULL;
     if (token_ == Token::RPAREN) {
       Next();
     } else {
@@ -634,60 +658,47 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
       EXPECT(Token::RPAREN);
     }
 
-    ForStatement *for_stmt = factory_->NewForStatement();
-    Target target(this, for_stmt);
-    Statement *body = ParseStatement(CHECK);
-    for_stmt->set_body(body);
-    if (init) {
-      for_stmt->SetInit(init);
-    }
-    if (cond) {
-      for_stmt->SetCondition(cond);
-    }
-    if (next) {
-      for_stmt->SetNext(next);
-    }
-
-    return for_stmt;
+    Target target(this, Target::kIterationStatement);
+    Statement* const body = ParseStatement(CHECK);
+    ForStatement* const forstmt =
+        factory_->NewForStatement(body, init, cond, next);
+    target.set_node(forstmt);
+    return forstmt;
   }
 
 //  ContinueStatement
 //    : CONTINUE Identifier_opt ';'
   Statement* ParseContinueStatement(bool *res) {
     assert(token_ == Token::CONTINUE);
-    ContinueStatement *continue_stmt = factory_->NewContinueStatement();
+    Identifier* label = NULL;
+    IterationStatement** target;
     Next();
     if (!lexer_.has_line_terminator_before_next() &&
         token_ != Token::SEMICOLON &&
         token_ != Token::RBRACE &&
         token_ != Token::EOS) {
       IS(Token::IDENTIFIER);
-      Identifier* label = factory_->NewIdentifier(lexer_.Buffer());
-      continue_stmt->SetLabel(label);
-      IterationStatement* target = LookupContinuableTarget(label);
-      if (target) {
-        continue_stmt->SetTarget(target);
-      } else {
+      label = ParseIdentifier(lexer_.Buffer());
+      target = LookupContinuableTarget(label);
+      if (!target) {
         RAISE("label not found");
       }
-      Next();
     } else {
-      IterationStatement* target = LookupContinuableTarget();
-      if (target) {
-        continue_stmt->SetTarget(target);
-      } else {
+      target = LookupContinuableTarget();
+      if (!target) {
         RAISE("label not found");
       }
     }
     ExpectSemicolon(CHECK);
-    return continue_stmt;
+    return factory_->NewContinueStatement(label, target);
   }
 
 //  BreakStatement
 //    : BREAK Identifier_opt ';'
   Statement* ParseBreakStatement(bool *res) {
     assert(token_ == Token::BREAK);
-    BreakStatement *break_stmt = factory_->NewBreakStatement();
+    Identifier* label = NULL;
+    BreakableStatement** target = NULL;
     Next();
     if (!lexer_.has_line_terminator_before_next() &&
         token_ != Token::SEMICOLON &&
@@ -695,8 +706,7 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
         token_ != Token::EOS) {
       // label
       IS(Token::IDENTIFIER);
-      Identifier* label = factory_->NewIdentifier(lexer_.Buffer());
-      break_stmt->SetLabel(label);
+      label = ParseIdentifier(lexer_.Buffer());
       if (ContainsLabel(labels_, label)) {
         // example
         //
@@ -708,24 +718,19 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
         // In iv, BreakStatement with label, but without target is
         // interpreted as EmptyStatement
       } else {
-        BreakableStatement* target = LookupBreakableTarget(label);
-        if (target) {
-          break_stmt->SetTarget(target);
-        } else {
+        target = LookupBreakableTarget(label);
+        if (!target) {
           RAISE("label not found");
         }
       }
-      Next();
     } else {
-      BreakableStatement* target = LookupBreakableTarget();
-      if (target) {
-        break_stmt->SetTarget(target);
-      } else {
+      target = LookupBreakableTarget();
+      if (!target) {
         RAISE("label not found");
       }
     }
     ExpectSemicolon(CHECK);
-    return break_stmt;
+    return factory_->NewBreakStatement(label, target);
   }
 
 //  ReturnStatement
@@ -782,7 +787,7 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
 
     Expression *expr = ParseExpression(true, CHECK);
     SwitchStatement *switch_stmt = factory_->NewSwitchStatement(expr);
-    Target target(this, switch_stmt);
+    Target target(this, Target::kSwitchStatement);
 
     EXPECT(Token::RPAREN);
 
@@ -794,6 +799,7 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
     }
     Next();
 
+    target.set_node(switch_stmt);
     return switch_stmt;
   }
 
@@ -808,16 +814,16 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
 //    : DEFAULT ':' StatementList_opt
   CaseClause* ParseCaseClause(bool *res) {
     assert(token_ == Token::CASE || token_ == Token::DEFAULT);
-    CaseClause *clause = factory_->NewCaseClause();
-    Statement *stmt;
+    CaseClause* clause;
+    Statement* stmt;
 
     if (token_ == Token::CASE) {
       Next();
-      Expression *expr = ParseExpression(true, CHECK);
-      clause->SetExpression(expr);
+      Expression* const expr = ParseExpression(true, CHECK);
+      clause = factory_->NewCaseClause(false, expr);
     } else  {
       EXPECT(Token::DEFAULT);
-      clause->SetDefault();
+      clause = factory_->NewCaseClause(true, NULL);
     }
 
     EXPECT(Token::COLON);
@@ -836,13 +842,12 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
 //    : THROW Expression ';'
   Statement* ParseThrowStatement(bool *res) {
     assert(token_ == Token::THROW);
-    Expression *expr;
     Next();
     // Throw requires Expression
     if (lexer_.has_line_terminator_before_next()) {
       RAISE("missing expression between throw and newline");
     }
-    expr = ParseExpression(true, CHECK);
+    Expression* const expr = ParseExpression(true, CHECK);
     ExpectSemicolon(CHECK);
     return factory_->NewThrowStatement(expr);
   }
@@ -859,14 +864,14 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
 //    : FINALLY Block
   Statement* ParseTryStatement(bool *res) {
     assert(token_ == Token::TRY);
-    Identifier *name;
-    Block *block;
+    Identifier* name = NULL;
+    Block* catch_block = NULL;
+    Block* finally_block = NULL;
     bool has_catch_or_finally = false;
 
     Next();
 
-    block = ParseBlock(CHECK);
-    TryStatement *try_stmt = factory_->NewTryStatement(block);
+    Block* const try_block = ParseBlock(CHECK);
 
     if (token_ == Token::CATCH) {
       // Catch
@@ -874,7 +879,7 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
       Next();
       EXPECT(Token::LPAREN);
       IS(Token::IDENTIFIER);
-      name = factory_->NewIdentifier(lexer_.Buffer());
+      name = ParseIdentifier(lexer_.Buffer());
       // section 12.14.1
       // within the strict code, Identifier must not be "eval" or "arguments"
       if (strict_) {
@@ -889,25 +894,23 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
           }
         }
       }
-      Next();
       EXPECT(Token::RPAREN);
-      block = ParseBlock(CHECK);
-      try_stmt->SetCatch(name, block);
+      catch_block = ParseBlock(CHECK);
     }
 
     if (token_ == Token::FINALLY) {
       // Finally
       has_catch_or_finally= true;
       Next();
-      block = ParseBlock(CHECK);
-      try_stmt->SetFinally(block);
+      finally_block = ParseBlock(CHECK);
     }
 
     if (!has_catch_or_finally) {
       RAISE("missing catch or finally after try statement");
     }
 
-    return try_stmt;
+    return factory_->NewTryStatement(try_block,
+                                     name, catch_block, finally_block);
   }
 
 //  DebuggerStatement
@@ -920,7 +923,7 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
   }
 
   Statement* ParseExpressionStatement(bool *res) {
-    Expression* expr = ParseExpression(true, CHECK);
+    Expression* const expr = ParseExpression(true, CHECK);
     ExpectSemicolon(CHECK);
     return factory_->NewExpressionStatement(expr);
   }
@@ -932,7 +935,7 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
 //    : Expression ';'
   Statement* ParseExpressionOrLabelledStatement(bool *res) {
     assert(token_ == Token::IDENTIFIER);
-    Expression* expr = ParseExpression(true, CHECK);
+    Expression* const expr = ParseExpression(true, CHECK);
     if (token_ == Token::COLON &&
         expr->AsIdentifier()) {
       // LabelledStatement
@@ -949,9 +952,9 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
         RAISE("duplicate label");
       }
       labels->push_back(label);
-      LabelScope scope(this, labels, exist_labels);
+      const LabelScope scope(this, labels, exist_labels);
 
-      Statement* stmt = ParseStatement(CHECK);
+      Statement* const stmt = ParseStatement(CHECK);
       return factory_->NewLabelledStatement(expr, stmt);
     }
     ExpectSemicolon(CHECK);
@@ -963,11 +966,10 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
     if (strict_) {
       RAISE("function statement not allowed in strict code");
     }
-    Next();
-    IS(Token::IDENTIFIER);
-    FunctionLiteral* expr = ParseFunctionLiteral(FunctionLiteral::STATEMENT,
-                                                 FunctionLiteral::GENERAL,
-                                                 true, CHECK);
+    FunctionLiteral* const expr = ParseFunctionLiteral(
+        FunctionLiteral::STATEMENT,
+        FunctionLiteral::GENERAL,
+        CHECK);
     // define named function as variable declaration
     scope_->AddUnresolved(expr->name(), false);
     return factory_->NewFunctionStatement(expr);
@@ -977,8 +979,8 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
 //    : AssignmentExpression
 //    | Expression ',' AssignmentExpression
   Expression* ParseExpression(bool contains_in, bool *res) {
-    Expression *right;
-    Expression *result = ParseAssignmentExpression(contains_in, CHECK);
+    Expression* right;
+    Expression* result = ParseAssignmentExpression(contains_in, CHECK);
     while (token_ == Token::COMMA) {
       Next();
       right = ParseAssignmentExpression(contains_in, CHECK);
@@ -991,7 +993,7 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
 //    : ConditionalExpression
 //    | LeftHandSideExpression AssignmentOperator AssignmentExpression
   Expression* ParseAssignmentExpression(bool contains_in, bool *res) {
-    Expression *result = ParseConditionalExpression(contains_in, CHECK);
+    Expression* const result = ParseConditionalExpression(contains_in, CHECK);
     if (!Token::IsAssignOp(token_)) {
       return result;
     }
@@ -1013,7 +1015,7 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
     }
     const Token::Type op = token_;
     Next();
-    Expression *right = ParseAssignmentExpression(contains_in, CHECK);
+    Expression* const right = ParseAssignmentExpression(contains_in, CHECK);
     return factory_->NewAssignment(op, result, right);
   }
 
@@ -1021,14 +1023,13 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
 //    : LogicalOrExpression
 //    | LogicalOrExpression '?' AssignmentExpression ':' AssignmentExpression
   Expression* ParseConditionalExpression(bool contains_in, bool *res) {
-    Expression *result;
-    result = ParseBinaryExpression(contains_in, 9, CHECK);
+    Expression* result = ParseBinaryExpression(contains_in, 9, CHECK);
     if (token_ == Token::CONDITIONAL) {
       Next();
       // see ECMA-262 section 11.12
-      Expression *left = ParseAssignmentExpression(true, CHECK);
+      Expression* const left = ParseAssignmentExpression(true, CHECK);
       EXPECT(Token::COLON);
-      Expression *right = ParseAssignmentExpression(contains_in, CHECK);
+      Expression* const right = ParseAssignmentExpression(contains_in, CHECK);
       result = factory_->NewConditionalExpression(result, left, right);
     }
     return result;
@@ -1369,8 +1370,7 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
 //    | LeftHandSideExpression INCREMENT
 //    | LeftHandSideExpression DECREMENT
   Expression* ParsePostfixExpression(bool *res) {
-    Expression *expr;
-    expr = ParseMemberExpression(true, CHECK);
+    Expression* expr = ParseMemberExpression(true, CHECK);
     if (!lexer_.has_line_terminator_before_next() &&
         (token_ == Token::INC || token_ == Token::DEC)) {
       if (!expr->IsValidLeftHandSide()) {
@@ -1414,9 +1414,8 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
     if (token_ != Token::NEW) {
       if (token_ == Token::FUNCTION) {
         // FunctionExpression
-        Next();
         expr = ParseFunctionLiteral(FunctionLiteral::EXPRESSION,
-                                    FunctionLiteral::GENERAL, true, CHECK);
+                                    FunctionLiteral::GENERAL, CHECK);
       } else {
         expr = ParsePrimaryExpression(CHECK);
       }
@@ -1429,7 +1428,6 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
       }
       expr = con;
     }
-    FunctionCall *funcall;
     while (true) {
       switch (token_) {
         case Token::LBRACK: {
@@ -1443,15 +1441,14 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
         case Token::PERIOD: {
           Next(Lexer::kIgnoreReservedWords);  // IDENTIFIERNAME
           IS(Token::IDENTIFIER);
-          Identifier* ident = factory_->NewIdentifier(lexer_.Buffer());
-          Next();
+          Identifier* const ident = ParseIdentifier(lexer_.Buffer());
           expr = factory_->NewIdentifierAccess(expr, ident);
           break;
         }
 
         case Token::LPAREN:
           if (allow_call) {
-            funcall = factory_->NewFunctionCall(expr);
+            FunctionCall* const funcall = factory_->NewFunctionCall(expr);
             ParseArguments(funcall, CHECK);
             expr = funcall;
           } else {
@@ -1481,7 +1478,7 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
 //    | STRING
 //    | REGEXP
   Expression* ParsePrimaryExpression(bool *res) {
-    Expression *result = NULL;
+    Expression* result = NULL;
     switch (token_) {
       case Token::THIS:
         result = factory_->NewThisLiteral();
@@ -1489,8 +1486,7 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
         break;
 
       case Token::IDENTIFIER:
-        result = factory_->NewIdentifier(lexer_.Buffer());
-        Next();
+        result = ParseIdentifier(lexer_.Buffer());
         break;
 
       case Token::NULL_LITERAL:
@@ -1569,7 +1565,7 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
 //    : AssignmentExpression
 //    | ArgumentList ',' AssignmentExpression
   Call* ParseArguments(Call* func, bool *res) {
-    Expression *expr;
+    Expression* expr;
     Next();
     while (token_ != Token::RPAREN) {
       expr = ParseAssignmentExpression(true, CHECK);
@@ -1614,8 +1610,8 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
 //    : ','
 //    | Elision ','
   Expression* ParseArrayLiteral(bool *res) {
-    ArrayLiteral *array = factory_->NewArrayLiteral();
-    Expression *expr;
+    ArrayLiteral* const array = factory_->NewArrayLiteral();
+    Expression* expr;
     Next();
     while (token_ != Token::RBRACK) {
       if (token_ == Token::COMMA) {
@@ -1660,10 +1656,10 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
 //    : IDENTIFIER
   Expression* ParseObjectLiteral(bool *res) {
     typedef std::tr1::unordered_map<IdentifierKey, int> ObjectMap;
-    ObjectLiteral *object = factory_->NewObjectLiteral();
+    ObjectLiteral* const object = factory_->NewObjectLiteral();
     ObjectMap map;
-    Expression *expr;
-    Identifier *ident;
+    Expression* expr;
+    Identifier* ident;
 
     // IDENTIFIERNAME
     Next(Lexer::kIgnoreReservedWordsAndIdentifyGetterOrSetter);
@@ -1674,9 +1670,8 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
         Next(Lexer::kIgnoreReservedWords);  // IDENTIFIERNAME
         if (token_ == Token::COLON) {
           // property
-          ident = factory_->NewIdentifier(
+          ident = ParseIdentifier(
               is_get ? ParserData::kGet : ParserData::kSet);
-          Next();
           expr = ParseAssignmentExpression(true, CHECK);
           object->AddDataProperty(ident, expr);
           typename ObjectMap::iterator it = map.find(ident);
@@ -1699,17 +1694,16 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
               token_ == Token::STRING ||
               token_ == Token::NUMBER) {
             if (token_ == Token::NUMBER) {
-              ident = factory_->NewIdentifier(lexer_.Buffer8());
+              ident = ParseIdentifier(lexer_.Buffer8());
             } else {
-              ident = factory_->NewIdentifier(lexer_.Buffer());
+              ident = ParseIdentifier(lexer_.Buffer());
             }
-            Next();
             typename ObjectLiteral::PropertyDescriptorType type =
                 (is_get) ? ObjectLiteral::GET : ObjectLiteral::SET;
             expr = ParseFunctionLiteral(
                 FunctionLiteral::EXPRESSION,
                 (is_get) ? FunctionLiteral::GETTER : FunctionLiteral::SETTER,
-                false, CHECK);
+                CHECK);
             object->AddAccessor(type, ident, expr);
             typename ObjectMap::iterator it = map.find(ident);
             if (it == map.end()) {
@@ -1732,8 +1726,7 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
       } else if (token_ == Token::IDENTIFIER ||
                  token_ == Token::STRING ||
                  token_ == Token::NUMBER) {
-        ident = factory_->NewIdentifier(lexer_.Buffer());
-        Next();
+        ident = ParseIdentifier(lexer_.Buffer());
         EXPECT(Token::COLON);
         expr = ParseAssignmentExpression(true, CHECK);
         object->AddDataProperty(ident, expr);
@@ -1768,7 +1761,6 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
   FunctionLiteral* ParseFunctionLiteral(
       typename FunctionLiteral::DeclType decl_type,
       typename FunctionLiteral::ArgType arg_type,
-      bool allow_identifier,
       bool *res) {
     // IDENTIFIER
     // IDENTIFIER_opt
@@ -1783,19 +1775,27 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
       kDetectDuplicateParameter
     } throw_error_if_strict_code = kDetectNone;
 
-    FunctionLiteral *literal = factory_->NewFunctionLiteral(decl_type);
+    FunctionLiteral* const literal = factory_->NewFunctionLiteral(decl_type);
     literal->set_strict(strict_);
-    if (allow_identifier && token_ == Token::IDENTIFIER) {
-      Identifier* const name = factory_->NewIdentifier(lexer_.Buffer());
-      literal->SetName(name);
-      const EvalOrArguments val = IsEvalOrArguments(name);
-      if (val) {
-        throw_error_if_strict_code = (val == kEval) ?
-            kDetectEvalName : kDetectArgumentsName;
-        throw_error_if_strict_code_line = lexer_.line_number();
-      }
+
+    if (arg_type == FunctionLiteral::GENERAL) {
+      assert(token_ == Token::FUNCTION);
       Next();
+      if (token_ == Token::IDENTIFIER) {
+        Identifier* const name = ParseIdentifier(lexer_.Buffer());
+        literal->SetName(name);
+        const EvalOrArguments val = IsEvalOrArguments(name);
+        if (val) {
+          throw_error_if_strict_code = (val == kEval) ?
+              kDetectEvalName : kDetectArgumentsName;
+          throw_error_if_strict_code_line = lexer_.line_number();
+        }
+      } else if (decl_type == FunctionLiteral::DECLARATION ||
+                 decl_type == FunctionLiteral::STATEMENT) {
+        IS(Token::IDENTIFIER);
+      }
     }
+
     const ScopeSwitcher switcher(this, literal->scope());
     literal->set_start_position(lexer_.pos() - 2);
 
@@ -1808,7 +1808,7 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
     } else if (arg_type == FunctionLiteral::SETTER) {
       // if setter, parameter count is 1
       IS(Token::IDENTIFIER);
-      Identifier* const ident = factory_->NewIdentifier(lexer_.Buffer());
+      Identifier* const ident = ParseIdentifier(lexer_.Buffer());
       if (!throw_error_if_strict_code) {
         const EvalOrArguments val = IsEvalOrArguments(ident);
         if (val) {
@@ -1818,12 +1818,11 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
         }
       }
       literal->AddParameter(ident);
-      Next();
       EXPECT(Token::RPAREN);
     } else {
       while (token_ != Token::RPAREN) {
         IS(Token::IDENTIFIER);
-        Identifier* const ident = factory_->NewIdentifier(lexer_.Buffer());
+        Identifier* const ident = ParseIdentifier(lexer_.Buffer());
         if (!throw_error_if_strict_code) {
           const EvalOrArguments val = IsEvalOrArguments(ident);
           if (val) {
@@ -1839,7 +1838,6 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
         }
         literal->AddParameter(ident);
         param_set.insert(ident);
-        Next();
         if (token_ != Token::RPAREN) {
           EXPECT(Token::COMMA);
         }
@@ -1894,11 +1892,18 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
     return literal;
   }
 
+  template<typename Range>
+  Identifier* ParseIdentifier(const Range& range) {
+    Identifier* const ident = factory_->NewIdentifier(range);
+    Next();
+    return ident;
+  }
+
   bool ContainsLabel(const Identifiers* const labels,
                      const Identifier * const label) const {
     assert(label != NULL);
     if (labels) {
-      const SpaceUString& value = label->value();
+      const typename Identifier::value_type& value = label->value();
       for (typename Identifiers::const_iterator it = labels->begin(),
            last = labels->end();
            it != last; ++it) {
@@ -1912,61 +1917,59 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
 
   bool TargetsContainsLabel(const Identifier* const label) const {
     assert(label != NULL);
-    for (Target* target = target_;
+    for (const Target* target = target_;
          target != NULL;
          target = target->previous()) {
-      if (ContainsLabel(target->node()->labels(), label)) {
+      if (ContainsLabel(target->labels(), label)) {
         return true;
       }
     }
     return false;
   }
 
-  BreakableStatement* LookupBreakableTarget(
+  BreakableStatement** LookupBreakableTarget(
       const Identifier* const label) const {
     assert(label != NULL);
-    for (const Target* target = target_;
+    for (Target* target = target_;
          target != NULL;
          target = target->previous()) {
-      if (ContainsLabel(target->node()->labels(), label)) {
+      if (ContainsLabel(target->labels(), label)) {
         return target->node();
       }
     }
     return NULL;
   }
 
-  BreakableStatement* LookupBreakableTarget() const {
-    for (const Target* target = target_;
+  BreakableStatement** LookupBreakableTarget() const {
+    for (Target* target = target_;
          target != NULL;
          target = target->previous()) {
-      if (target->node()->AsAnonymousBreakableStatement()) {
+      if (target->IsAnonymous()) {
         return target->node();
       }
     }
     return NULL;
   }
 
-  IterationStatement* LookupContinuableTarget(
+  IterationStatement** LookupContinuableTarget(
       const Identifier* const label) const {
     assert(label != NULL);
-    for (const Target* target = target_;
+    for (Target* target = target_;
          target != NULL;
          target = target->previous()) {
-      IterationStatement* const iter = target->node()->AsIterationStatement();
-      if (iter && ContainsLabel(iter->labels(), label)) {
-        return iter;
+      if (target->IsIteration() && ContainsLabel(target->labels(), label)) {
+        return reinterpret_cast<IterationStatement**>(target->node());
       }
     }
     return NULL;
   }
 
-  IterationStatement* LookupContinuableTarget() const {
-    for (const Target* target = target_;
+  IterationStatement** LookupContinuableTarget() const {
+    for (Target* target = target_;
          target != NULL;
          target = target->previous()) {
-      IterationStatement* const iter = target->node()->AsIterationStatement();
-      if (iter) {
-        return iter;
+      if (target->IsIteration()) {
+        return reinterpret_cast<IterationStatement**>(target->node());
       }
     }
     return NULL;
@@ -2050,6 +2053,9 @@ class Parser : private Noncopyable<Parser<Factory> >::type {
   inline void set_target(Target* target) {
     target_ = target;
   }
+  inline Factory* factory() const {
+    return factory_;
+  }
   inline Identifiers* labels() const {
     return labels_;
   }