iv-phonic 0.1.0 → 0.1.1

data/ext/include/iv/parser.h

@@ -218,16 +218,16 @@ class Parser
     int type_;
   };
 
-  class TargetScope : private Noncopyable<Target>::type {
+  class TargetSwitcher : private Noncopyable<TargetSwitcher>::type {
    public:
-    explicit TargetScope(parser_type* parser)
+    explicit TargetSwitcher(parser_type* parser)
       : parser_(parser),
         target_(parser->target()),
         labels_(parser->labels()) {
       parser_->set_target(NULL);
       parser_->set_labels(NULL);
     }
-    ~TargetScope() {
+    ~TargetSwitcher() {
       parser_->set_target(target_);
       parser_->set_labels(labels_);
     }
@@ -237,12 +237,12 @@ class Parser
     Identifiers* labels_;
   };
 
-  Parser(Factory* space, const Source* source)
+  Parser(Factory* factory, const Source* source)
     : lexer_(source),
       error_(),
       strict_(false),
       error_state_(0),
-      factory_(space),
+      factory_(factory),
       scope_(NULL),
       target_(NULL),
       labels_(NULL) {
@@ -251,18 +251,27 @@ class Parser
 // Program
 //   : SourceElements
   FunctionLiteral* ParseProgram() {
-    FunctionLiteral* const global = factory_->NewFunctionLiteral(
-        FunctionLiteral::GLOBAL);
-    global->set_strict(strict_);
+    Identifiers* params = factory_->template NewVector<Identifier*>();
+    Statements* body = factory_->template NewVector<Statement*>();
+    Scope* const scope = factory_->NewScope(FunctionLiteral::GLOBAL);
     assert(target_ == NULL);
     bool error_flag = true;
     bool *res = &error_flag;
-    {
-      const ScopeSwitcher switcher(this, global->scope());
-      Next();
-      ParseSourceElements(Token::EOS, global, CHECK);
-    }
-    return (error_flag) ? global : NULL;
+    const ScopeSwitcher scope_switcher(this, scope);
+    Next();
+    const bool strict = ParseSourceElements(Token::EOS, body, CHECK);
+    const std::size_t end_position = lexer_.end_position();
+    return (error_flag) ?
+        factory_->NewFunctionLiteral(FunctionLiteral::GLOBAL,
+                                     NULL,
+                                     params,
+                                     body,
+                                     scope,
+                                     strict,
+                                     0,
+                                     end_position,
+                                     0,
+                                     end_position) : NULL;
   }
 
 // SourceElements
@@ -273,16 +282,16 @@ class Parser
 //   : Statements
 //   | FunctionDeclaration
   bool ParseSourceElements(Token::Type end,
-                           FunctionLiteral* function,
+                           Statements* body,
                            bool *res) {
     Statement* stmt;
     bool recognize_directive = true;
-    const StrictSwitcher switcher(this);
+    const StrictSwitcher strict_switcher(this);
     while (token_ != end) {
       if (token_ == Token::FUNCTION) {
         // FunctionDeclaration
         stmt = ParseFunctionDeclaration(CHECK);
-        function->AddStatement(stmt);
+        body->push_back(stmt);
         recognize_directive = false;
       } else {
         stmt = ParseStatement(CHECK);
@@ -294,8 +303,7 @@ class Parser
               // expression is directive
               if (expr->AsStringLiteral()->value().compare(
                       ParserData::kUseStrict.data()) == 0) {
-                switcher.SwitchStrictMode();
-                function->set_strict(true);
+                strict_switcher.SwitchStrictMode();
               }
             } else {
               recognize_directive = false;
@@ -304,10 +312,10 @@ class Parser
             recognize_directive = false;
           }
         }
-        function->AddStatement(stmt);
+        body->push_back(stmt);
       }
     }
-    return true;
+    return strict_switcher.IsStrict();
   }
 
 //  Statement
@@ -466,17 +474,19 @@ class Parser
 //    | StatementList Statement
   Block* ParseBlock(bool *res) {
     assert(token_ == Token::LBRACE);
+    const std::size_t begin = lexer_.begin_position();
     Statements* const body = factory_->template NewVector<Statement*>();
-    Statement* stmt;
     Target target(this, Target::kNamedOnlyStatement);
 
     Next();
     while (token_ != Token::RBRACE) {
-      stmt = ParseStatement(CHECK);
+      Statement* const stmt = ParseStatement(CHECK);
       body->push_back(stmt);
     }
     Next();
-    Block* const block = factory_->NewBlock(body);
+    Block* const block = factory_->NewBlock(body,
+                                            begin,
+                                            lexer_.previous_end_position());
     target.set_node(block);
     return block;
   }
@@ -486,10 +496,15 @@ class Parser
 //    : CONST VariableDeclarationList ';'
   Statement* ParseVariableStatement(bool *res) {
     assert(token_ == Token::VAR || token_ == Token::CONST);
+    const Token::Type op = token_;
+    const std::size_t begin = lexer_.begin_position();
     Declarations* const decls = factory_->template NewVector<Declaration*>();
     ParseVariableDeclarations(decls, token_ == Token::CONST, true, CHECK);
     ExpectSemicolon(CHECK);
-    return factory_->NewVariableStatement(token_, decls);
+    return factory_->NewVariableStatement(op,
+                                          decls,
+                                          begin,
+                                          lexer_.previous_end_position());
   }
 
 //  VariableDeclarationList
@@ -552,7 +567,8 @@ class Parser
   Statement* ParseEmptyStatement() {
     assert(token_ == Token::SEMICOLON);
     Next();
-    return factory_->NewEmptyStatement();
+    return factory_->NewEmptyStatement(lexer_.previous_begin_position(),
+                                       lexer_.previous_end_position());
   }
 
 //  IfStatement
@@ -560,6 +576,7 @@ class Parser
 //    | IF '(' Expression ')' Statement
   Statement* ParseIfStatement(bool *res) {
     assert(token_ == Token::IF);
+    const std::size_t begin = lexer_.begin_position();
     Statement* else_statement = NULL;
     Next();
 
@@ -576,7 +593,8 @@ class Parser
     }
     return factory_->NewIfStatement(expr,
                                     then_statement,
-                                    else_statement);
+                                    else_statement,
+                                    begin);
   }
 
 //  IterationStatement
@@ -593,6 +611,7 @@ class Parser
   Statement* ParseDoWhileStatement(bool *res) {
     //  DO Statement WHILE '(' Expression ')' ';'
     assert(token_ == Token::DO);
+    const std::size_t begin = lexer_.begin_position();
     Target target(this, Target::kIterationStatement);
     Next();
 
@@ -614,7 +633,8 @@ class Parser
     if (token_ == Token::SEMICOLON) {
       Next();
     }
-    DoWhileStatement* const dowhile = factory_->NewDoWhileStatement(stmt, expr);
+    DoWhileStatement* const dowhile = factory_->NewDoWhileStatement(
+        stmt, expr, begin, lexer_.previous_end_position());
     target.set_node(dowhile);
     return dowhile;
   }
@@ -622,6 +642,7 @@ class Parser
 //  WHILE '(' Expression ')' Statement
   Statement* ParseWhileStatement(bool *res) {
     assert(token_ == Token::WHILE);
+    const std::size_t begin = lexer_.begin_position();
     Next();
 
     EXPECT(Token::LPAREN);
@@ -632,7 +653,8 @@ class Parser
     EXPECT(Token::RPAREN);
 
     Statement* const stmt = ParseStatement(CHECK);
-    WhileStatement* const whilestmt = factory_->NewWhileStatement(stmt, expr);
+    WhileStatement* const whilestmt = factory_->NewWhileStatement(stmt,
+                                                                  expr, begin);
 
     target.set_node(whilestmt);
     return whilestmt;
@@ -648,6 +670,7 @@ class Parser
 //  FOR '(' VAR VariableDeclarationNoIn IN Expression ')' Statement
   Statement* ParseForStatement(bool *res) {
     assert(token_ == Token::FOR);
+    const std::size_t for_stmt_begin = lexer_.begin_position();
     Next();
 
     EXPECT(Token::LPAREN);
@@ -656,13 +679,18 @@ class Parser
 
     if (token_ != Token::SEMICOLON) {
       if (token_ == Token::VAR || token_ == Token::CONST) {
+        const std::size_t begin = lexer_.begin_position();
+        const Token::Type op = token_;
         Declarations* const decls =
             factory_->template NewVector<Declaration*>();
         ParseVariableDeclarations(decls, token_ == Token::CONST, false, CHECK);
-        VariableStatement* const var =
-            factory_->NewVariableStatement(token_, decls);
-        init = var;
         if (token_ == Token::IN) {
+          VariableStatement* const var =
+              factory_->NewVariableStatement(op,
+                                             decls,
+                                             begin,
+                                             lexer_.previous_end_position());
+          init = var;
           // for in loop
           Next();
           const Declarations& decls = var->decls();
@@ -676,15 +704,21 @@ class Parser
           Target target(this, Target::kIterationStatement);
           Statement* const body = ParseStatement(CHECK);
           ForInStatement* const forstmt =
-              factory_->NewForInStatement(body, init, enumerable);
+              factory_->NewForInStatement(body, init, enumerable,
+                                          for_stmt_begin);
           target.set_node(forstmt);
           return forstmt;
+        } else {
+          init = factory_->NewVariableStatement(op, decls,
+                                                begin,
+                                                lexer_.end_position());
         }
       } else {
         Expression* const init_expr = ParseExpression(false, CHECK);
-        init = factory_->NewExpressionStatement(init_expr);
         if (token_ == Token::IN) {
           // for in loop
+          init = factory_->NewExpressionStatement(init_expr,
+                                                  lexer_.previous_end_position());
           if (!init_expr->IsValidLeftHandSide()) {
             RAISE("invalid for-in left-hand-side");
           }
@@ -694,9 +728,13 @@ class Parser
           Target target(this, Target::kIterationStatement);
           Statement* const body = ParseStatement(CHECK);
           ForInStatement* const forstmt =
-              factory_->NewForInStatement(body, init, enumerable);
+              factory_->NewForInStatement(body, init, enumerable,
+                                          for_stmt_begin);
           target.set_node(forstmt);
           return forstmt;
+        } else {
+          init = factory_->NewExpressionStatement(init_expr,
+                                                  lexer_.end_position());
         }
       }
     }
@@ -717,15 +755,16 @@ class Parser
     if (token_ == Token::RPAREN) {
       Next();
     } else {
-      Expression *next_expr = ParseExpression(true, CHECK);
-      next = factory_->NewExpressionStatement(next_expr);
+      Expression* next_expr = ParseExpression(true, CHECK);
+      next = factory_->NewExpressionStatement(next_expr,
+                                              lexer_.previous_end_position());
       EXPECT(Token::RPAREN);
     }
 
     Target target(this, Target::kIterationStatement);
     Statement* const body = ParseStatement(CHECK);
     ForStatement* const forstmt =
-        factory_->NewForStatement(body, init, cond, next);
+        factory_->NewForStatement(body, init, cond, next, for_stmt_begin);
     target.set_node(forstmt);
     return forstmt;
   }
@@ -734,6 +773,7 @@ class Parser
 //    : CONTINUE Identifier_opt ';'
   Statement* ParseContinueStatement(bool *res) {
     assert(token_ == Token::CONTINUE);
+    const std::size_t begin = lexer_.begin_position();
     Identifier* label = NULL;
     IterationStatement** target;
     Next();
@@ -754,13 +794,15 @@ class Parser
       }
     }
     ExpectSemicolon(CHECK);
-    return factory_->NewContinueStatement(label, target);
+    return factory_->NewContinueStatement(label, target, begin,
+                                          lexer_.previous_end_position());
   }
 
 //  BreakStatement
 //    : BREAK Identifier_opt ';'
   Statement* ParseBreakStatement(bool *res) {
     assert(token_ == Token::BREAK);
+    const std::size_t begin = lexer_.begin_position();
     Identifier* label = NULL;
     BreakableStatement** target = NULL;
     Next();
@@ -794,13 +836,16 @@ class Parser
       }
     }
     ExpectSemicolon(CHECK);
-    return factory_->NewBreakStatement(label, target);
+    return factory_->NewBreakStatement(label, target, begin,
+                                       lexer_.previous_end_position());
   }
 
 //  ReturnStatement
 //    : RETURN Expression_opt ';'
   Statement* ParseReturnStatement(bool *res) {
+    // TODO(Constellation) NewUndefined -> NULL
     assert(token_ == Token::RETURN);
+    const std::size_t begin = lexer_.begin_position();
     Next();
 
     if (scope_->IsGlobal()) {
@@ -814,17 +859,21 @@ class Parser
         token_ == Token::RBRACE ||
         token_ == Token::EOS) {
       ExpectSemicolon(CHECK);
-      return factory_->NewReturnStatement(factory_->NewUndefined());
+      return factory_->NewReturnStatement(factory_->NewUndefined(),
+                                          begin,
+                                          lexer_.previous_end_position());
     }
     Expression *expr = ParseExpression(true, CHECK);
     ExpectSemicolon(CHECK);
-    return factory_->NewReturnStatement(expr);
+    return factory_->NewReturnStatement(expr, begin,
+                                        lexer_.previous_end_position());
   }
 
 //  WithStatement
 //    : WITH '(' Expression ')' Statement
   Statement* ParseWithStatement(bool *res) {
     assert(token_ == Token::WITH);
+    const std::size_t begin = lexer_.begin_position();
     Next();
 
     // section 12.10.1
@@ -840,7 +889,7 @@ class Parser
     EXPECT(Token::RPAREN);
 
     Statement *stmt = ParseStatement(CHECK);
-    return factory_->NewWithStatement(expr, stmt);
+    return factory_->NewWithStatement(expr, stmt, begin);
   }
 
 //  SwitchStatement
@@ -851,6 +900,7 @@ class Parser
 //    | '{' CaseClauses_opt DefaultClause CaseClauses_opt '}'
   Statement* ParseSwitchStatement(bool *res) {
     assert(token_ == Token::SWITCH);
+    const std::size_t begin = lexer_.begin_position();
     CaseClause* case_clause;
     Next();
 
@@ -882,9 +932,10 @@ class Parser
       clauses->push_back(case_clause);
     }
     Next();
-
     SwitchStatement* const switch_stmt =
-        factory_->NewSwitchStatement(expr, clauses);
+        factory_->NewSwitchStatement(expr, clauses,
+                                     begin,
+                                     lexer_.previous_end_position());
     target.set_node(switch_stmt);
     return switch_stmt;
   }
@@ -900,6 +951,7 @@ class Parser
 //    : DEFAULT ':' StatementList_opt
   CaseClause* ParseCaseClause(bool *res) {
     assert(token_ == Token::CASE || token_ == Token::DEFAULT);
+    const std::size_t begin = lexer_.begin_position();
     Expression* expr = NULL;
     Statements* const body = factory_->template NewVector<Statement*>();
 
@@ -919,22 +971,25 @@ class Parser
       body->push_back(stmt);
     }
 
-    return factory_->NewCaseClause(expr == NULL, expr, body);
+    return factory_->NewCaseClause(expr == NULL,
+                                   expr, body,
+                                   begin, lexer_.previous_end_position());
   }
 
 //  ThrowStatement
 //    : THROW Expression ';'
   Statement* ParseThrowStatement(bool *res) {
     assert(token_ == Token::THROW);
+    const std::size_t begin = lexer_.begin_position();
     Next();
     // Throw requires Expression
     if (lexer_.has_line_terminator_before_next()) {
-      // TODO(Constellation) more refined parse error system
       RAISE("missing expression between throw and newline");
     }
     Expression* const expr = ParseExpression(true, CHECK);
     ExpectSemicolon(CHECK);
-    return factory_->NewThrowStatement(expr);
+    return factory_->NewThrowStatement(expr,
+                                       begin, lexer_.previous_end_position());
   }
 
 // TryStatement
@@ -949,6 +1004,7 @@ class Parser
 //    : FINALLY Block
   Statement* ParseTryStatement(bool *res) {
     assert(token_ == Token::TRY);
+    const std::size_t begin = lexer_.begin_position();
     Identifier* name = NULL;
     Block* catch_block = NULL;
     Block* finally_block = NULL;
@@ -998,22 +1054,26 @@ class Parser
     }
 
     return factory_->NewTryStatement(try_block,
-                                     name, catch_block, finally_block);
+                                     name, catch_block,
+                                     finally_block, begin);
   }
 
 //  DebuggerStatement
 //    : DEBUGGER ';'
   Statement* ParseDebuggerStatement(bool *res) {
     assert(token_ == Token::DEBUGGER);
+    const std::size_t begin = lexer_.begin_position();
     Next();
     ExpectSemicolon(CHECK);
-    return factory_->NewDebuggerStatement();
+    return factory_->NewDebuggerStatement(begin,
+                                          lexer_.previous_end_position());
   }
 
   Statement* ParseExpressionStatement(bool *res) {
     Expression* const expr = ParseExpression(true, CHECK);
     ExpectSemicolon(CHECK);
-    return factory_->NewExpressionStatement(expr);
+    return factory_->NewExpressionStatement(expr,
+                                            lexer_.previous_end_position());
   }
 
 //  LabelledStatement
@@ -1040,13 +1100,14 @@ class Parser
         RAISE("duplicate label");
       }
       labels->push_back(label);
-      const LabelScope scope(this, labels, exist_labels);
+      const LabelSwitcher label_switcher(this, labels, exist_labels);
 
       Statement* const stmt = ParseStatement(CHECK);
       return factory_->NewLabelledStatement(expr, stmt);
     }
     ExpectSemicolon(CHECK);
-    return factory_->NewExpressionStatement(expr);
+    return factory_->NewExpressionStatement(expr,
+                                            lexer_.previous_end_position());
   }
 
   template<bool Use>
@@ -1304,33 +1365,33 @@ class Parser
       Expression* res;
       switch (op) {
         case Token::ADD:
-          res = factory_->NewNumberLiteral(l_val + r_val);
+          res = factory_->NewReducedNumberLiteral(l_val + r_val);
           break;
 
         case Token::SUB:
-          res = factory_->NewNumberLiteral(l_val - r_val);
+          res = factory_->NewReducedNumberLiteral(l_val - r_val);
           break;
 
         case Token::MUL:
-          res = factory_->NewNumberLiteral(l_val * r_val);
+          res = factory_->NewReducedNumberLiteral(l_val * r_val);
           break;
 
         case Token::DIV:
-          res = factory_->NewNumberLiteral(l_val / r_val);
+          res = factory_->NewReducedNumberLiteral(l_val / r_val);
           break;
 
         case Token::BIT_OR:
-          res = factory_->NewNumberLiteral(
+          res = factory_->NewReducedNumberLiteral(
               DoubleToInt32(l_val) | DoubleToInt32(r_val));
           break;
 
         case Token::BIT_AND:
-          res = factory_->NewNumberLiteral(
+          res = factory_->NewReducedNumberLiteral(
               DoubleToInt32(l_val) & DoubleToInt32(r_val));
           break;
 
         case Token::BIT_XOR:
-          res = factory_->NewNumberLiteral(
+          res = factory_->NewReducedNumberLiteral(
               DoubleToInt32(l_val) ^ DoubleToInt32(r_val));
           break;
 
@@ -1338,21 +1399,21 @@ class Parser
         case Token::SHL: {
           const int32_t value = DoubleToInt32(l_val)
               << (DoubleToInt32(r_val) & 0x1f);
-          res = factory_->NewNumberLiteral(value);
+          res = factory_->NewReducedNumberLiteral(value);
           break;
         }
 
         case Token::SHR: {
           const uint32_t shift = DoubleToInt32(r_val) & 0x1f;
           const uint32_t value = DoubleToUInt32(l_val) >> shift;
-          res = factory_->NewNumberLiteral(value);
+          res = factory_->NewReducedNumberLiteral(value);
           break;
         }
 
         case Token::SAR: {
           uint32_t shift = DoubleToInt32(r_val) & 0x1f;
           int32_t value = DoubleToInt32(l_val) >> shift;
-          res = factory_->NewNumberLiteral(value);
+          res = factory_->NewReducedNumberLiteral(value);
           break;
         }
 
@@ -1388,13 +1449,14 @@ class Parser
   Expression* ParseUnaryExpression(bool *res) {
     Expression *result, *expr;
     const Token::Type op = token_;
+    const std::size_t begin = lexer_.begin_position();
     switch (token_) {
       case Token::VOID:
       case Token::NOT:
       case Token::TYPEOF:
         Next();
         expr = ParseUnaryExpression(CHECK);
-        result = factory_->NewUnaryOperation(op, expr);
+        result = factory_->NewUnaryOperation(op, expr, begin);
         break;
 
       case Token::DELETE:
@@ -1407,17 +1469,17 @@ class Parser
             expr->AsIdentifier()) {
           RAISE("delete to direct identifier not allowed in strict code");
         }
-        result = factory_->NewUnaryOperation(op, expr);
+        result = factory_->NewUnaryOperation(op, expr, begin);
         break;
 
       case Token::BIT_NOT:
         Next();
         expr = ParseUnaryExpression(CHECK);
-        if (expr->AsNumberLiteral()) {
-          result = factory_->NewNumberLiteral(
+        if (ReduceExpressions && expr->AsNumberLiteral()) {
+          result = factory_->NewReducedNumberLiteral(
               ~DoubleToInt32(expr->AsNumberLiteral()->value()));
         } else {
-          result = factory_->NewUnaryOperation(op, expr);
+          result = factory_->NewUnaryOperation(op, expr, begin);
         }
         break;
 
@@ -1427,18 +1489,18 @@ class Parser
         if (expr->AsNumberLiteral()) {
           result = expr;
         } else {
-          result = factory_->NewUnaryOperation(op, expr);
+          result = factory_->NewUnaryOperation(op, expr, begin);
         }
         break;
 
       case Token::SUB:
         Next();
         expr = ParseUnaryExpression(CHECK);
-        if (expr->AsNumberLiteral()) {
-          result = factory_->NewNumberLiteral(
+        if (ReduceExpressions && expr->AsNumberLiteral()) {
+          result = factory_->NewReducedNumberLiteral(
               -(expr->AsNumberLiteral()->value()));
         } else {
-          result = factory_->NewUnaryOperation(op, expr);
+          result = factory_->NewUnaryOperation(op, expr, begin);
         }
         break;
 
@@ -1464,7 +1526,7 @@ class Parser
             }
           }
         }
-        result = factory_->NewUnaryOperation(op, expr);
+        result = factory_->NewUnaryOperation(op, expr, begin);
         break;
 
       default:
@@ -1499,7 +1561,8 @@ class Parser
           }
         }
       }
-      expr = factory_->NewPostfixExpression(token_, expr);
+      expr = factory_->NewPostfixExpression(token_, expr,
+                                            lexer_.end_position());
       Next();
     }
     return expr;
@@ -1535,7 +1598,7 @@ class Parser
       if (token_ == Token::LPAREN) {
         ParseArguments(args, CHECK);
       }
-      expr = factory_->NewConstructorCall(target, args);
+      expr = factory_->NewConstructorCall(target, args, lexer_.previous_end_position());
     }
     while (true) {
       switch (token_) {
@@ -1560,7 +1623,8 @@ class Parser
             Expressions* const args =
                 factory_->template NewVector<Expression*>();
             ParseArguments(args, CHECK);
-            expr = factory_->NewFunctionCall(expr, args);
+            expr = factory_->NewFunctionCall(expr, args,
+                                             lexer_.previous_end_position());
           } else {
             return expr;
           }
@@ -1591,7 +1655,8 @@ class Parser
     Expression* result = NULL;
     switch (token_) {
       case Token::THIS:
-        result = factory_->NewThisLiteral();
+        result = factory_->NewThisLiteral(lexer_.begin_position(),
+                                          lexer_.end_position());
         Next();
         break;
 
@@ -1600,17 +1665,20 @@ class Parser
         break;
 
       case Token::NULL_LITERAL:
-        result = factory_->NewNullLiteral();
+        result = factory_->NewNullLiteral(lexer_.begin_position(),
+                                          lexer_.end_position());
         Next();
         break;
 
       case Token::TRUE_LITERAL:
-        result = factory_->NewTrueLiteral();
+        result = factory_->NewTrueLiteral(lexer_.begin_position(),
+                                          lexer_.end_position());
         Next();
         break;
 
       case Token::FALSE_LITERAL:
-        result = factory_->NewFalseLiteral();
+        result = factory_->NewFalseLiteral(lexer_.begin_position(),
+                                           lexer_.end_position());
         Next();
         break;
 
@@ -1620,7 +1688,9 @@ class Parser
         if (strict_ && lexer_.NumericType() == lexer_type::OCTAL) {
           RAISE("octal integer literal not allowed in strict code");
         }
-        result = factory_->NewNumberLiteral(lexer_.Numeric());
+        result = factory_->NewNumberLiteral(lexer_.Numeric(),
+                                            lexer_.begin_position(),
+                                            lexer_.end_position());
         Next();
         break;
 
@@ -1630,9 +1700,13 @@ class Parser
           RAISE("octal excape sequence not allowed in strict code");
         }
         if (state == lexer_type::NONE) {
-          result = factory_->NewDirectivable(lexer_.Buffer());
+          result = factory_->NewDirectivable(lexer_.Buffer(),
+                                             lexer_.begin_position(),
+                                             lexer_.end_position());
         } else {
-          result = factory_->NewStringLiteral(lexer_.Buffer());
+          result = factory_->NewStringLiteral(lexer_.Buffer(),
+                                              lexer_.begin_position(),
+                                              lexer_.end_position());
         }
         Next();
         break;
@@ -1696,8 +1770,10 @@ class Parser
       if (!lexer_.ScanRegExpFlags()) {
         RAISE("invalid regular expression flag");
       }
-      RegExpLiteral* const expr =
-          factory_->NewRegExpLiteral(content, lexer_.Buffer());
+      RegExpLiteral* const expr = factory_->NewRegExpLiteral(
+          content, lexer_.Buffer(),
+          lexer_.begin_position(),
+          lexer_.end_position());
       if (!expr) {
         RAISE("invalid regular expression");
       }
@@ -1721,6 +1797,7 @@ class Parser
 //    : ','
 //    | Elision ','
   Expression* ParseArrayLiteral(bool *res) {
+    const std::size_t begin = lexer_.begin_position();
     Expressions* const items = factory_->template NewVector<Expression*>();
     Next();
     while (token_ != Token::RBRACK) {
@@ -1736,7 +1813,8 @@ class Parser
       }
     }
     Next();
-    return factory_->NewArrayLiteral(items);
+    return factory_->NewArrayLiteral(items,
+                                     begin, lexer_.previous_end_position());
   }
 
 
@@ -1768,6 +1846,7 @@ class Parser
     typedef std::tr1::unordered_map<IdentifierKey, int> ObjectMap;
     typedef typename ObjectLiteral::Property Property;
     typedef typename ObjectLiteral::Properties Properties;
+    const std::size_t begin = lexer_.begin_position();
     Properties* const prop = factory_->template NewVector<Property>();
     ObjectMap map;
     Expression* expr;
@@ -1782,8 +1861,10 @@ class Parser
         Next<IgnoreReservedWords>();  // IDENTIFIERNAME
         if (token_ == Token::COLON) {
           // property
-          ident = ParseIdentifier(
-              is_get ? ParserData::kGet : ParserData::kSet);
+          ident = ParseIdentifierWithPosition(
+              is_get ? ParserData::kGet : ParserData::kSet,
+              lexer_.previous_begin_position(),
+              lexer_.previous_end_position());
           expr = ParseAssignmentExpression(true, CHECK);
           ObjectLiteral::AddDataProperty(prop, ident, expr);
           typename ObjectMap::iterator it = map.find(ident);
@@ -1870,8 +1951,9 @@ class Parser
         Next<IgnoreReservedWordsAndIdentifyGetterOrSetter>();
       }
     }
+    const std::size_t end = lexer_.begin_position();
     Next();
-    return factory_->NewObjectLiteral(prop);
+    return factory_->NewObjectLiteral(prop, begin, end);
   }
 
   FunctionLiteral* ParseFunctionLiteral(
@@ -1882,6 +1964,7 @@ class Parser
     // IDENTIFIER_opt
     std::tr1::unordered_set<IdentifierKey> param_set;
     std::size_t throw_error_if_strict_code_line = 0;
+    const std::size_t begin_position = lexer_.begin_position();
     enum {
       kDetectNone = 0,
       kDetectEvalName,
@@ -1892,8 +1975,8 @@ class Parser
       kDetectFutureReservedWords
     } throw_error_if_strict_code = kDetectNone;
 
-    FunctionLiteral* const literal = factory_->NewFunctionLiteral(decl_type);
-    literal->set_strict(strict_);
+    Identifiers* const params = factory_->template NewVector<Identifier*>();
+    Identifier* name = NULL;
 
     if (arg_type == FunctionLiteral::GENERAL) {
       assert(token_ == Token::FUNCTION);
@@ -1901,8 +1984,7 @@ class Parser
       const Token::Type current = token_;
       if (current == Token::IDENTIFIER ||
           Token::IsAddedFutureReservedWordInStrictCode(current)) {
-        Identifier* const name = ParseIdentifier(lexer_.Buffer());
-        literal->SetName(name);
+        name = ParseIdentifier(lexer_.Buffer());
         if (Token::IsAddedFutureReservedWordInStrictCode(current)) {
           throw_error_if_strict_code = kDetectFutureReservedWords;
           throw_error_if_strict_code_line = lexer_.line_number();
@@ -1921,9 +2003,7 @@ class Parser
       }
     }
 
-    const ScopeSwitcher switcher(this, literal->scope());
-    const TargetScope scope(this);
-    literal->set_start_position(lexer_.begin_position());
+    const std::size_t begin_block_position = lexer_.begin_position();
 
     //  '(' FormalParameterList_opt ')'
     IS(Token::LPAREN);
@@ -1954,7 +2034,7 @@ class Parser
           }
         }
       }
-      literal->AddParameter(ident);
+      params->push_back(ident);
       EXPECT(Token::RPAREN);
     } else {
       if (token_ != Token::RPAREN) {
@@ -1984,7 +2064,7 @@ class Parser
               throw_error_if_strict_code_line = lexer_.line_number();
             }
           }
-          literal->AddParameter(ident);
+          params->push_back(ident);
           param_set.insert(ident);
           if (token_ == Token::COMMA) {
             Next(true);
@@ -2003,8 +2083,13 @@ class Parser
     //    | SourceElements
     EXPECT(Token::LBRACE);
 
-    ParseSourceElements(Token::RBRACE, literal, CHECK);
-    if (strict_ || literal->strict()) {
+    Statements* const body = factory_->template NewVector<Statement*>();
+    Scope* const scope = factory_->NewScope(decl_type);
+    const ScopeSwitcher scope_switcher(this, scope);
+    const TargetSwitcher target_switcher(this);
+    const bool function_is_strict =
+        ParseSourceElements(Token::RBRACE, body, CHECK);
+    if (strict_ || function_is_strict) {
       // section 13.1
       // Strict Mode Restrictions
       switch (throw_error_if_strict_code) {
@@ -2042,14 +2127,36 @@ class Parser
           break;
       }
     }
-    literal->set_end_position(lexer_.end_position());
     Next();
-    return literal;
+    const std::size_t end_block_position = lexer_.previous_end_position();
+    return factory_->NewFunctionLiteral(decl_type,
+                                        name,
+                                        params,
+                                        body,
+                                        scope,
+                                        function_is_strict,
+                                        begin_block_position,
+                                        end_block_position,
+                                        begin_position,
+                                        end_block_position);
   }
 
   template<typename Range>
   Identifier* ParseIdentifier(const Range& range) {
-    Identifier* const ident = factory_->NewIdentifier(range);
+    Identifier* const ident = factory_->NewIdentifier(range,
+                                                      lexer_.begin_position(),
+                                                      lexer_.end_position());
+    Next();
+    return ident;
+  }
+
+  template<typename Range>
+  Identifier* ParseIdentifierWithPosition(const Range& range,
+                                          std::size_t begin,
+                                          std::size_t end) {
+    Identifier* const ident = factory_->NewIdentifier(range,
+                                                      begin,
+                                                      end);
     Next();
     return ident;
   }
@@ -2183,8 +2290,8 @@ class Parser
     UNEXPECT(token_);
   }
 
-  inline lexer_type& lexer() {
-    return lexer_;
+  inline lexer_type* lexer() const {
+    return &lexer_;
   }
   template<typename LexType>
   inline Token::Type Next() {
@@ -2249,15 +2356,15 @@ class Parser
     parser_type* parser_;
   };
 
-  class LabelScope : private Noncopyable<LabelScope>::type {
+  class LabelSwitcher : private Noncopyable<LabelSwitcher>::type {
    public:
-    LabelScope(parser_type* parser,
-               Identifiers* labels, bool exist_labels)
+    LabelSwitcher(parser_type* parser,
+                  Identifiers* labels, bool exist_labels)
       : parser_(parser),
         exist_labels_(exist_labels) {
       parser_->set_labels(labels);
     }
-    ~LabelScope() {
+    ~LabelSwitcher() {
       if (!exist_labels_) {
         parser_->set_labels(NULL);
       }
@@ -2279,6 +2386,9 @@ class Parser
     inline void SwitchStrictMode() const {
       parser_->set_strict(true);
     }
+    inline bool IsStrict() const {
+      return parser_->strict();
+    }
    private:
     parser_type* parser_;
     bool prev_;