Ignore:
Timestamp:
Oct 31, 2011, 3:13:01 PM (14 years ago)
Author:
[email protected]
Message:

Towards 8-bit Strings: Move Lexer and Parser Objects out of JSGlobalData
​https://bugs.webkit.org/show_bug.cgi?id=71138

Restructure and movement of Lexer and Parser code.
Moved Lexer and Parser objects out of JSGlobalData.
Added a new ParserTokens class and instance to JSGlobalData that
have JavaScript token related definitions.
Replaced JSGlobalData arguments to Node classes with lineNumber,
as that was the only use of the JSGlobalData.
Combined JSParser and Parser classes into one class,
eliminating JSParser.h and .cpp.
Various supporting #include changes.

These mostly mechanical changes are done in preparation to
making the Lexer and Parser template classes.

Reviewed by Darin Adler.

(JSC::ArrayNode::toArgumentList):
(JSC::ApplyFunctionCallDotNode::emitBytecode):

  • parser/ASTBuilder.h:

(JSC::ASTBuilder::ASTBuilder):
(JSC::ASTBuilder::createSourceElements):
(JSC::ASTBuilder::createCommaExpr):
(JSC::ASTBuilder::createLogicalNot):
(JSC::ASTBuilder::createUnaryPlus):
(JSC::ASTBuilder::createVoid):
(JSC::ASTBuilder::thisExpr):
(JSC::ASTBuilder::createResolve):
(JSC::ASTBuilder::createObjectLiteral):
(JSC::ASTBuilder::createArray):
(JSC::ASTBuilder::createNumberExpr):
(JSC::ASTBuilder::createString):
(JSC::ASTBuilder::createBoolean):
(JSC::ASTBuilder::createNull):
(JSC::ASTBuilder::createBracketAccess):
(JSC::ASTBuilder::createDotAccess):
(JSC::ASTBuilder::createRegExp):
(JSC::ASTBuilder::createNewExpr):
(JSC::ASTBuilder::createConditionalExpr):
(JSC::ASTBuilder::createAssignResolve):
(JSC::ASTBuilder::createFunctionExpr):
(JSC::ASTBuilder::createFunctionBody):
(JSC::ASTBuilder::createGetterOrSetterProperty):
(JSC::ASTBuilder::createArguments):
(JSC::ASTBuilder::createArgumentsList):
(JSC::ASTBuilder::createPropertyList):
(JSC::ASTBuilder::createElementList):
(JSC::ASTBuilder::createFormalParameterList):
(JSC::ASTBuilder::createClause):
(JSC::ASTBuilder::createClauseList):
(JSC::ASTBuilder::createFuncDeclStatement):
(JSC::ASTBuilder::createBlockStatement):
(JSC::ASTBuilder::createExprStatement):
(JSC::ASTBuilder::createIfStatement):
(JSC::ASTBuilder::createForLoop):
(JSC::ASTBuilder::createForInLoop):
(JSC::ASTBuilder::createEmptyStatement):
(JSC::ASTBuilder::createVarStatement):
(JSC::ASTBuilder::createReturnStatement):
(JSC::ASTBuilder::createBreakStatement):
(JSC::ASTBuilder::createContinueStatement):
(JSC::ASTBuilder::createTryStatement):
(JSC::ASTBuilder::createSwitchStatement):
(JSC::ASTBuilder::createWhileStatement):
(JSC::ASTBuilder::createDoWhileStatement):
(JSC::ASTBuilder::createLabelStatement):
(JSC::ASTBuilder::createWithStatement):
(JSC::ASTBuilder::createThrowStatement):
(JSC::ASTBuilder::createDebugger):
(JSC::ASTBuilder::createConstStatement):
(JSC::ASTBuilder::appendConstDecl):
(JSC::ASTBuilder::combineCommaNodes):
(JSC::ASTBuilder::appendBinaryOperation):
(JSC::ASTBuilder::createAssignment):
(JSC::ASTBuilder::createNumber):
(JSC::ASTBuilder::makeTypeOfNode):
(JSC::ASTBuilder::makeDeleteNode):
(JSC::ASTBuilder::makeNegateNode):
(JSC::ASTBuilder::makeBitwiseNotNode):
(JSC::ASTBuilder::makeMultNode):
(JSC::ASTBuilder::makeDivNode):
(JSC::ASTBuilder::makeModNode):
(JSC::ASTBuilder::makeAddNode):
(JSC::ASTBuilder::makeSubNode):
(JSC::ASTBuilder::makeLeftShiftNode):
(JSC::ASTBuilder::makeRightShiftNode):
(JSC::ASTBuilder::makeURightShiftNode):
(JSC::ASTBuilder::makeBitOrNode):
(JSC::ASTBuilder::makeBitAndNode):
(JSC::ASTBuilder::makeBitXOrNode):
(JSC::ASTBuilder::makeFunctionCallNode):
(JSC::ASTBuilder::makeBinaryNode):
(JSC::ASTBuilder::makeAssignNode):
(JSC::ASTBuilder::makePrefixNode):
(JSC::ASTBuilder::makePostfixNode):

  • parser/JSParser.cpp: Removed.
  • parser/JSParser.h: Removed.
  • parser/Lexer.cpp:

(JSC::Keywords::Keywords):
(JSC::Lexer::Lexer):
(JSC::Lexer::~Lexer):
(JSC::Lexer::setCode):
(JSC::Lexer::parseIdentifier):

  • parser/Lexer.h:

(JSC::Keywords::isKeyword):
(JSC::Keywords::getKeyword):
(JSC::Keywords::~Keywords):
(JSC::Lexer::setIsReparsing):
(JSC::Lexer::isReparsing):
(JSC::Lexer::lineNumber):
(JSC::Lexer::setLastLineNumber):
(JSC::Lexer::lastLineNumber):
(JSC::Lexer::prevTerminator):
(JSC::Lexer::sawError):
(JSC::Lexer::getErrorMessage):
(JSC::Lexer::currentOffset):
(JSC::Lexer::setOffset):
(JSC::Lexer::setLineNumber):
(JSC::Lexer::sourceProvider):
(JSC::Lexer::isWhiteSpace):
(JSC::Lexer::isLineTerminator):
(JSC::Lexer::convertHex):
(JSC::Lexer::convertUnicode):
(JSC::Lexer::makeIdentifier):
(JSC::Lexer::lexExpectIdentifier):

  • parser/NodeConstructors.h:

(JSC::ParserArenaFreeable::operator new):
(JSC::ParserArenaDeletable::operator new):
(JSC::ParserArenaRefCounted::ParserArenaRefCounted):
(JSC::Node::Node):
(JSC::ExpressionNode::ExpressionNode):
(JSC::StatementNode::StatementNode):
(JSC::NullNode::NullNode):
(JSC::BooleanNode::BooleanNode):
(JSC::NumberNode::NumberNode):
(JSC::StringNode::StringNode):
(JSC::RegExpNode::RegExpNode):
(JSC::ThisNode::ThisNode):
(JSC::ResolveNode::ResolveNode):
(JSC::ElementNode::ElementNode):
(JSC::ArrayNode::ArrayNode):
(JSC::PropertyNode::PropertyNode):
(JSC::PropertyListNode::PropertyListNode):
(JSC::ObjectLiteralNode::ObjectLiteralNode):
(JSC::BracketAccessorNode::BracketAccessorNode):
(JSC::DotAccessorNode::DotAccessorNode):
(JSC::ArgumentListNode::ArgumentListNode):
(JSC::ArgumentsNode::ArgumentsNode):
(JSC::NewExprNode::NewExprNode):
(JSC::EvalFunctionCallNode::EvalFunctionCallNode):
(JSC::FunctionCallValueNode::FunctionCallValueNode):
(JSC::FunctionCallResolveNode::FunctionCallResolveNode):
(JSC::FunctionCallBracketNode::FunctionCallBracketNode):
(JSC::FunctionCallDotNode::FunctionCallDotNode):
(JSC::CallFunctionCallDotNode::CallFunctionCallDotNode):
(JSC::ApplyFunctionCallDotNode::ApplyFunctionCallDotNode):
(JSC::PrePostResolveNode::PrePostResolveNode):
(JSC::PostfixResolveNode::PostfixResolveNode):
(JSC::PostfixBracketNode::PostfixBracketNode):
(JSC::PostfixDotNode::PostfixDotNode):
(JSC::PostfixErrorNode::PostfixErrorNode):
(JSC::DeleteResolveNode::DeleteResolveNode):
(JSC::DeleteBracketNode::DeleteBracketNode):
(JSC::DeleteDotNode::DeleteDotNode):
(JSC::DeleteValueNode::DeleteValueNode):
(JSC::VoidNode::VoidNode):
(JSC::TypeOfResolveNode::TypeOfResolveNode):
(JSC::TypeOfValueNode::TypeOfValueNode):
(JSC::PrefixResolveNode::PrefixResolveNode):
(JSC::PrefixBracketNode::PrefixBracketNode):
(JSC::PrefixDotNode::PrefixDotNode):
(JSC::PrefixErrorNode::PrefixErrorNode):
(JSC::UnaryOpNode::UnaryOpNode):
(JSC::UnaryPlusNode::UnaryPlusNode):
(JSC::NegateNode::NegateNode):
(JSC::BitwiseNotNode::BitwiseNotNode):
(JSC::LogicalNotNode::LogicalNotNode):
(JSC::BinaryOpNode::BinaryOpNode):
(JSC::MultNode::MultNode):
(JSC::DivNode::DivNode):
(JSC::ModNode::ModNode):
(JSC::AddNode::AddNode):
(JSC::SubNode::SubNode):
(JSC::LeftShiftNode::LeftShiftNode):
(JSC::RightShiftNode::RightShiftNode):
(JSC::UnsignedRightShiftNode::UnsignedRightShiftNode):
(JSC::LessNode::LessNode):
(JSC::GreaterNode::GreaterNode):
(JSC::LessEqNode::LessEqNode):
(JSC::GreaterEqNode::GreaterEqNode):
(JSC::ThrowableBinaryOpNode::ThrowableBinaryOpNode):
(JSC::InstanceOfNode::InstanceOfNode):
(JSC::InNode::InNode):
(JSC::EqualNode::EqualNode):
(JSC::NotEqualNode::NotEqualNode):
(JSC::StrictEqualNode::StrictEqualNode):
(JSC::NotStrictEqualNode::NotStrictEqualNode):
(JSC::BitAndNode::BitAndNode):
(JSC::BitOrNode::BitOrNode):
(JSC::BitXOrNode::BitXOrNode):
(JSC::LogicalOpNode::LogicalOpNode):
(JSC::ConditionalNode::ConditionalNode):
(JSC::ReadModifyResolveNode::ReadModifyResolveNode):
(JSC::AssignResolveNode::AssignResolveNode):
(JSC::ReadModifyBracketNode::ReadModifyBracketNode):
(JSC::AssignBracketNode::AssignBracketNode):
(JSC::AssignDotNode::AssignDotNode):
(JSC::ReadModifyDotNode::ReadModifyDotNode):
(JSC::AssignErrorNode::AssignErrorNode):
(JSC::CommaNode::CommaNode):
(JSC::ConstStatementNode::ConstStatementNode):
(JSC::SourceElements::SourceElements):
(JSC::EmptyStatementNode::EmptyStatementNode):
(JSC::DebuggerStatementNode::DebuggerStatementNode):
(JSC::ExprStatementNode::ExprStatementNode):
(JSC::VarStatementNode::VarStatementNode):
(JSC::IfNode::IfNode):
(JSC::IfElseNode::IfElseNode):
(JSC::DoWhileNode::DoWhileNode):
(JSC::WhileNode::WhileNode):
(JSC::ForNode::ForNode):
(JSC::ContinueNode::ContinueNode):
(JSC::BreakNode::BreakNode):
(JSC::ReturnNode::ReturnNode):
(JSC::WithNode::WithNode):
(JSC::LabelNode::LabelNode):
(JSC::ThrowNode::ThrowNode):
(JSC::TryNode::TryNode):
(JSC::ParameterNode::ParameterNode):
(JSC::FuncExprNode::FuncExprNode):
(JSC::FuncDeclNode::FuncDeclNode):
(JSC::CaseClauseNode::CaseClauseNode):
(JSC::ClauseListNode::ClauseListNode):
(JSC::CaseBlockNode::CaseBlockNode):
(JSC::SwitchNode::SwitchNode):
(JSC::ConstDeclNode::ConstDeclNode):
(JSC::BlockNode::BlockNode):
(JSC::ForInNode::ForInNode):

  • parser/NodeInfo.h:
  • parser/Nodes.cpp:

(JSC::StatementNode::setLoc):
(JSC::ScopeNode::ScopeNode):
(JSC::ProgramNode::ProgramNode):
(JSC::ProgramNode::create):
(JSC::EvalNode::EvalNode):
(JSC::EvalNode::create):
(JSC::FunctionBodyNode::FunctionBodyNode):
(JSC::FunctionBodyNode::create):

  • parser/Nodes.h:

(JSC::Node::lineNo):

  • parser/Parser.cpp:

(JSC::Parser::Parser):
(JSC::Parser::~Parser):
(JSC::Parser::parseInner):
(JSC::Parser::allowAutomaticSemicolon):
(JSC::Parser::parseSourceElements):
(JSC::Parser::parseVarDeclaration):
(JSC::Parser::parseConstDeclaration):
(JSC::Parser::parseDoWhileStatement):
(JSC::Parser::parseWhileStatement):
(JSC::Parser::parseVarDeclarationList):
(JSC::Parser::parseConstDeclarationList):
(JSC::Parser::parseForStatement):
(JSC::Parser::parseBreakStatement):
(JSC::Parser::parseContinueStatement):
(JSC::Parser::parseReturnStatement):
(JSC::Parser::parseThrowStatement):
(JSC::Parser::parseWithStatement):
(JSC::Parser::parseSwitchStatement):
(JSC::Parser::parseSwitchClauses):
(JSC::Parser::parseSwitchDefaultClause):
(JSC::Parser::parseTryStatement):
(JSC::Parser::parseDebuggerStatement):
(JSC::Parser::parseBlockStatement):
(JSC::Parser::parseStatement):
(JSC::Parser::parseFormalParameters):
(JSC::Parser::parseFunctionBody):
(JSC::Parser::parseFunctionInfo):
(JSC::Parser::parseFunctionDeclaration):
(JSC::LabelInfo::LabelInfo):
(JSC::Parser::parseExpressionOrLabelStatement):
(JSC::Parser::parseExpressionStatement):
(JSC::Parser::parseIfStatement):
(JSC::Parser::parseExpression):
(JSC::Parser::parseAssignmentExpression):
(JSC::Parser::parseConditionalExpression):
(JSC::isUnaryOp):
(JSC::Parser::isBinaryOperator):
(JSC::Parser::parseBinaryExpression):
(JSC::Parser::parseProperty):
(JSC::Parser::parseObjectLiteral):
(JSC::Parser::parseStrictObjectLiteral):
(JSC::Parser::parseArrayLiteral):
(JSC::Parser::parsePrimaryExpression):
(JSC::Parser::parseArguments):
(JSC::Parser::parseMemberExpression):
(JSC::Parser::parseUnaryExpression):

  • parser/Parser.h:

(JSC::isEvalNode):
(JSC::EvalNode):
(JSC::DepthManager::DepthManager):
(JSC::DepthManager::~DepthManager):
(JSC::ScopeLabelInfo::ScopeLabelInfo):
(JSC::Scope::Scope):
(JSC::Scope::startSwitch):
(JSC::Scope::endSwitch):
(JSC::Scope::startLoop):
(JSC::Scope::endLoop):
(JSC::Scope::inLoop):
(JSC::Scope::breakIsValid):
(JSC::Scope::continueIsValid):
(JSC::Scope::pushLabel):
(JSC::Scope::popLabel):
(JSC::Scope::getLabel):
(JSC::Scope::setIsFunction):
(JSC::Scope::isFunction):
(JSC::Scope::isFunctionBoundary):
(JSC::Scope::declareVariable):
(JSC::Scope::declareWrite):
(JSC::Scope::preventNewDecls):
(JSC::Scope::allowsNewDecls):
(JSC::Scope::declareParameter):
(JSC::Scope::useVariable):
(JSC::Scope::setNeedsFullActivation):
(JSC::Scope::collectFreeVariables):
(JSC::Scope::getUncapturedWrittenVariables):
(JSC::Scope::getCapturedVariables):
(JSC::Scope::setStrictMode):
(JSC::Scope::strictMode):
(JSC::Scope::isValidStrictMode):
(JSC::Scope::shadowsArguments):
(JSC::Scope::copyCapturedVariablesToVector):
(JSC::Scope::saveFunctionInfo):
(JSC::Scope::restoreFunctionInfo):
(JSC::ScopeRef::ScopeRef):
(JSC::ScopeRef::operator->):
(JSC::ScopeRef::index):
(JSC::ScopeRef::hasContainingScope):
(JSC::ScopeRef::containingScope):
(JSC::Parser::AllowInOverride::AllowInOverride):
(JSC::Parser::AllowInOverride::~AllowInOverride):
(JSC::Parser::AutoPopScopeRef::AutoPopScopeRef):
(JSC::Parser::AutoPopScopeRef::~AutoPopScopeRef):
(JSC::Parser::AutoPopScopeRef::setPopped):
(JSC::Parser::currentScope):
(JSC::Parser::pushScope):
(JSC::Parser::popScopeInternal):
(JSC::Parser::popScope):
(JSC::Parser::declareVariable):
(JSC::Parser::declareWrite):
(JSC::Parser::findCachedFunctionInfo):
(JSC::Parser::isFunctionBodyNode):
(JSC::Parser::next):
(JSC::Parser::nextExpectIdentifier):
(JSC::Parser::nextTokenIsColon):
(JSC::Parser::consume):
(JSC::Parser::getToken):
(JSC::Parser::match):
(JSC::Parser::tokenStart):
(JSC::Parser::tokenLine):
(JSC::Parser::tokenEnd):
(JSC::Parser::getTokenName):
(JSC::Parser::updateErrorMessageSpecialCase):
(JSC::Parser::updateErrorMessage):
(JSC::Parser::updateErrorWithNameAndMessage):
(JSC::Parser::startLoop):
(JSC::Parser::endLoop):
(JSC::Parser::startSwitch):
(JSC::Parser::endSwitch):
(JSC::Parser::setStrictMode):
(JSC::Parser::strictMode):
(JSC::Parser::isValidStrictMode):
(JSC::Parser::declareParameter):
(JSC::Parser::breakIsValid):
(JSC::Parser::continueIsValid):
(JSC::Parser::pushLabel):
(JSC::Parser::popLabel):
(JSC::Parser::getLabel):
(JSC::Parser::autoSemiColon):
(JSC::Parser::canRecurse):
(JSC::Parser::lastTokenEnd):
(JSC::Parser::DepthManager::DepthManager):
(JSC::Parser::DepthManager::~DepthManager):
(JSC::Parser::parse):
(JSC::parse):

  • parser/ParserTokens.h: Added.

(JSC::JSTokenInfo::JSTokenInfo):

  • parser/SourceCode.h:

(JSC::SourceCode::subExpression):

  • parser/SourceProviderCacheItem.h:
  • parser/SyntaxChecker.h:

(JSC::SyntaxChecker::SyntaxChecker):
(JSC::SyntaxChecker::makeFunctionCallNode):
(JSC::SyntaxChecker::createCommaExpr):
(JSC::SyntaxChecker::makeAssignNode):
(JSC::SyntaxChecker::makePrefixNode):
(JSC::SyntaxChecker::makePostfixNode):
(JSC::SyntaxChecker::makeTypeOfNode):
(JSC::SyntaxChecker::makeDeleteNode):
(JSC::SyntaxChecker::makeNegateNode):
(JSC::SyntaxChecker::makeBitwiseNotNode):
(JSC::SyntaxChecker::createLogicalNot):
(JSC::SyntaxChecker::createUnaryPlus):
(JSC::SyntaxChecker::createVoid):
(JSC::SyntaxChecker::thisExpr):
(JSC::SyntaxChecker::createResolve):
(JSC::SyntaxChecker::createObjectLiteral):
(JSC::SyntaxChecker::createArray):
(JSC::SyntaxChecker::createNumberExpr):
(JSC::SyntaxChecker::createString):
(JSC::SyntaxChecker::createBoolean):
(JSC::SyntaxChecker::createNull):
(JSC::SyntaxChecker::createBracketAccess):
(JSC::SyntaxChecker::createDotAccess):
(JSC::SyntaxChecker::createRegExp):
(JSC::SyntaxChecker::createNewExpr):
(JSC::SyntaxChecker::createConditionalExpr):
(JSC::SyntaxChecker::createAssignResolve):
(JSC::SyntaxChecker::createFunctionExpr):
(JSC::SyntaxChecker::createFunctionBody):
(JSC::SyntaxChecker::createArguments):
(JSC::SyntaxChecker::createArgumentsList):
(JSC::SyntaxChecker::createProperty):
(JSC::SyntaxChecker::createPropertyList):
(JSC::SyntaxChecker::createFuncDeclStatement):
(JSC::SyntaxChecker::createBlockStatement):
(JSC::SyntaxChecker::createExprStatement):
(JSC::SyntaxChecker::createIfStatement):
(JSC::SyntaxChecker::createForLoop):
(JSC::SyntaxChecker::createForInLoop):
(JSC::SyntaxChecker::createEmptyStatement):
(JSC::SyntaxChecker::createVarStatement):
(JSC::SyntaxChecker::createReturnStatement):
(JSC::SyntaxChecker::createBreakStatement):
(JSC::SyntaxChecker::createContinueStatement):
(JSC::SyntaxChecker::createTryStatement):
(JSC::SyntaxChecker::createSwitchStatement):
(JSC::SyntaxChecker::createWhileStatement):
(JSC::SyntaxChecker::createWithStatement):
(JSC::SyntaxChecker::createDoWhileStatement):
(JSC::SyntaxChecker::createLabelStatement):
(JSC::SyntaxChecker::createThrowStatement):
(JSC::SyntaxChecker::createDebugger):
(JSC::SyntaxChecker::createConstStatement):
(JSC::SyntaxChecker::appendConstDecl):
(JSC::SyntaxChecker::createGetterOrSetterProperty):
(JSC::SyntaxChecker::combineCommaNodes):
(JSC::SyntaxChecker::operatorStackPop):

  • runtime/Executable.cpp:

(JSC::EvalExecutable::compileInternal):
(JSC::ProgramExecutable::checkSyntax):
(JSC::ProgramExecutable::compileInternal):
(JSC::FunctionExecutable::produceCodeBlockFor):
(JSC::FunctionExecutable::fromGlobalCode):

  • runtime/JSGlobalData.cpp:

(JSC::JSGlobalData::JSGlobalData):
(JSC::JSGlobalData::~JSGlobalData):

  • runtime/JSGlobalData.h:
  • runtime/LiteralParser.cpp:

(JSC::LiteralParser::tryJSONPParse):

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/parser/ASTBuilder.h

    r95901 r98887  
    7474    };
    7575public:
    76     ASTBuilder(JSGlobalData* globalData, Lexer* lexer)
     76    ASTBuilder(JSGlobalData* globalData, SourceCode* sourceCode)
    7777        : m_globalData(globalData)
    78         , m_lexer(lexer)
     78        , m_sourceCode(sourceCode)
    7979        , m_scope(globalData)
    8080        , m_evalCount(0)
    … …  
    113113    static const int  DontBuildStrings = 0;
    114114
    115     ExpressionNode* makeBinaryNode(int token, std::pair<ExpressionNode*, BinaryOpInfo>, std::pair<ExpressionNode*, BinaryOpInfo>);
    116     ExpressionNode* makeFunctionCallNode(ExpressionNode* func, ArgumentsNode* args, int start, int divot, int end);
    117 
    118     JSC::SourceElements* createSourceElements() { return new (m_globalData) JSC::SourceElements(m_globalData); }
     115    ExpressionNode* makeBinaryNode(int lineNumber, int token, std::pair<ExpressionNode*, BinaryOpInfo>, std::pair<ExpressionNode*, BinaryOpInfo>);
     116    ExpressionNode* makeFunctionCallNode(int lineNumber, ExpressionNode* func, ArgumentsNode* args, int start, int divot, int end);
     117
     118    JSC::SourceElements* createSourceElements() { return new (m_globalData) JSC::SourceElements(); }
    119119
    120120    ParserArenaData<DeclarationStacks::VarStack>* varDeclarations() { return m_scope.m_varDeclarations; }
    … …  
    125125    void appendToComma(CommaNode* commaNode, ExpressionNode* expr) { commaNode->append(expr); }
    126126
    127     CommaNode* createCommaExpr(ExpressionNode* lhs, ExpressionNode* rhs) { return new (m_globalData) CommaNode(m_globalData, lhs, rhs); }
    128 
    129     ExpressionNode* makeAssignNode(ExpressionNode* left, Operator, ExpressionNode* right, bool leftHasAssignments, bool rightHasAssignments, int start, int divot, int end);
    130     ExpressionNode* makePrefixNode(ExpressionNode*, Operator, int start, int divot, int end);
    131     ExpressionNode* makePostfixNode(ExpressionNode*, Operator, int start, int divot, int end);
    132     ExpressionNode* makeTypeOfNode(ExpressionNode*);
    133     ExpressionNode* makeDeleteNode(ExpressionNode*, int start, int divot, int end);
    134     ExpressionNode* makeNegateNode(ExpressionNode*);
    135     ExpressionNode* makeBitwiseNotNode(ExpressionNode*);
    136     ExpressionNode* makeMultNode(ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
    137     ExpressionNode* makeDivNode(ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
    138     ExpressionNode* makeModNode(ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
    139     ExpressionNode* makeAddNode(ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
    140     ExpressionNode* makeSubNode(ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
    141     ExpressionNode* makeBitXOrNode(ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
    142     ExpressionNode* makeBitAndNode(ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
    143     ExpressionNode* makeBitOrNode(ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
    144     ExpressionNode* makeLeftShiftNode(ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
    145     ExpressionNode* makeRightShiftNode(ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
    146     ExpressionNode* makeURightShiftNode(ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
    147 
    148     ExpressionNode* createLogicalNot(ExpressionNode* expr) { return new (m_globalData) LogicalNotNode(m_globalData, expr); }
    149     ExpressionNode* createUnaryPlus(ExpressionNode* expr) { return new (m_globalData) UnaryPlusNode(m_globalData, expr); }
    150     ExpressionNode* createVoid(ExpressionNode* expr)
     127    CommaNode* createCommaExpr(int lineNumber, ExpressionNode* lhs, ExpressionNode* rhs) { return new (m_globalData) CommaNode(lineNumber, lhs, rhs); }
     128
     129    ExpressionNode* makeAssignNode(int lineNumber, ExpressionNode* left, Operator, ExpressionNode* right, bool leftHasAssignments, bool rightHasAssignments, int start, int divot, int end);
     130    ExpressionNode* makePrefixNode(int lineNumber, ExpressionNode*, Operator, int start, int divot, int end);
     131    ExpressionNode* makePostfixNode(int lineNumber, ExpressionNode*, Operator, int start, int divot, int end);
     132    ExpressionNode* makeTypeOfNode(int lineNumber, ExpressionNode*);
     133    ExpressionNode* makeDeleteNode(int lineNumber, ExpressionNode*, int start, int divot, int end);
     134    ExpressionNode* makeNegateNode(int lineNumber, ExpressionNode*);
     135    ExpressionNode* makeBitwiseNotNode(int lineNumber, ExpressionNode*);
     136    ExpressionNode* makeMultNode(int lineNumber, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
     137    ExpressionNode* makeDivNode(int lineNumber, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
     138    ExpressionNode* makeModNode(int lineNumber, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
     139    ExpressionNode* makeAddNode(int lineNumber, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
     140    ExpressionNode* makeSubNode(int lineNumber, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
     141    ExpressionNode* makeBitXOrNode(int lineNumber, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
     142    ExpressionNode* makeBitAndNode(int lineNumber, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
     143    ExpressionNode* makeBitOrNode(int lineNumber, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
     144    ExpressionNode* makeLeftShiftNode(int lineNumber, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
     145    ExpressionNode* makeRightShiftNode(int lineNumber, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
     146    ExpressionNode* makeURightShiftNode(int lineNumber, ExpressionNode* left, ExpressionNode* right, bool rightHasAssignments);
     147
     148    ExpressionNode* createLogicalNot(int lineNumber, ExpressionNode* expr) { return new (m_globalData) LogicalNotNode(lineNumber, expr); }
     149    ExpressionNode* createUnaryPlus(int lineNumber, ExpressionNode* expr) { return new (m_globalData) UnaryPlusNode(lineNumber, expr); }
     150    ExpressionNode* createVoid(int lineNumber, ExpressionNode* expr)
    151151    {
    152152        incConstants();
    153         return new (m_globalData) VoidNode(m_globalData, expr);
    154     }
    155     ExpressionNode* thisExpr()
     153        return new (m_globalData) VoidNode(lineNumber, expr);
     154    }
     155    ExpressionNode* thisExpr(int lineNumber)
    156156    {
    157157        usesThis();
    158         return new (m_globalData) ThisNode(m_globalData);
    159     }
    160     ExpressionNode* createResolve(const Identifier* ident, int start)
     158        return new (m_globalData) ThisNode(lineNumber);
     159    }
     160    ExpressionNode* createResolve(int lineNumber, const Identifier* ident, int start)
    161161    {
    162162        if (m_globalData->propertyNames->arguments == *ident)
    163163            usesArguments();
    164         return new (m_globalData) ResolveNode(m_globalData, *ident, start);
    165     }
    166     ExpressionNode* createObjectLiteral() { return new (m_globalData) ObjectLiteralNode(m_globalData); }
    167     ExpressionNode* createObjectLiteral(PropertyListNode* properties) { return new (m_globalData) ObjectLiteralNode(m_globalData, properties); }
    168 
    169     ExpressionNode* createArray(int elisions)
     164        return new (m_globalData) ResolveNode(lineNumber, *ident, start);
     165    }
     166    ExpressionNode* createObjectLiteral(int lineNumber) { return new (m_globalData) ObjectLiteralNode(lineNumber); }
     167    ExpressionNode* createObjectLiteral(int lineNumber, PropertyListNode* properties) { return new (m_globalData) ObjectLiteralNode(lineNumber, properties); }
     168
     169    ExpressionNode* createArray(int lineNumber, int elisions)
    170170    {
    171171        if (elisions)
    172172            incConstants();
    173         return new (m_globalData) ArrayNode(m_globalData, elisions);
    174     }
    175 
    176     ExpressionNode* createArray(ElementNode* elems) { return new (m_globalData) ArrayNode(m_globalData, elems); }
    177     ExpressionNode* createArray(int elisions, ElementNode* elems)
     173        return new (m_globalData) ArrayNode(lineNumber, elisions);
     174    }
     175
     176    ExpressionNode* createArray(int lineNumber, ElementNode* elems) { return new (m_globalData) ArrayNode(lineNumber, elems); }
     177    ExpressionNode* createArray(int lineNumber, int elisions, ElementNode* elems)
    178178    {
    179179        if (elisions)
    180180            incConstants();
    181         return new (m_globalData) ArrayNode(m_globalData, elisions, elems);
    182     }
    183     ExpressionNode* createNumberExpr(double d)
     181        return new (m_globalData) ArrayNode(lineNumber, elisions, elems);
     182    }
     183    ExpressionNode* createNumberExpr(int lineNumber, double d)
    184184    {
    185185        incConstants();
    186         return new (m_globalData) NumberNode(m_globalData, d);
    187     }
    188 
    189     ExpressionNode* createString(const Identifier* string)
     186        return new (m_globalData) NumberNode(lineNumber, d);
     187    }
     188
     189    ExpressionNode* createString(int lineNumber, const Identifier* string)
    190190    {
    191191        incConstants();
    192         return new (m_globalData) StringNode(m_globalData, *string);
    193     }
    194 
    195     ExpressionNode* createBoolean(bool b)
     192        return new (m_globalData) StringNode(lineNumber, *string);
     193    }
     194
     195    ExpressionNode* createBoolean(int lineNumber, bool b)
    196196    {
    197197        incConstants();
    198         return new (m_globalData) BooleanNode(m_globalData, b);
    199     }
    200 
    201     ExpressionNode* createNull()
     198        return new (m_globalData) BooleanNode(lineNumber, b);
     199    }
     200
     201    ExpressionNode* createNull(int lineNumber)
    202202    {
    203203        incConstants();
    204         return new (m_globalData) NullNode(m_globalData);
    205     }
    206 
    207     ExpressionNode* createBracketAccess(ExpressionNode* base, ExpressionNode* property, bool propertyHasAssignments, int start, int divot, int end)
    208     {
    209         BracketAccessorNode* node = new (m_globalData) BracketAccessorNode(m_globalData, base, property, propertyHasAssignments);
     204        return new (m_globalData) NullNode(lineNumber);
     205    }
     206
     207    ExpressionNode* createBracketAccess(int lineNumber, ExpressionNode* base, ExpressionNode* property, bool propertyHasAssignments, int start, int divot, int end)
     208    {
     209        BracketAccessorNode* node = new (m_globalData) BracketAccessorNode(lineNumber, base, property, propertyHasAssignments);
    210210        setExceptionLocation(node, start, divot, end);
    211211        return node;
    212212    }
    213213
    214     ExpressionNode* createDotAccess(ExpressionNode* base, const Identifier* property, int start, int divot, int end)
    215     {
    216         DotAccessorNode* node = new (m_globalData) DotAccessorNode(m_globalData, base, *property);
     214    ExpressionNode* createDotAccess(int lineNumber, ExpressionNode* base, const Identifier* property, int start, int divot, int end)
     215    {
     216        DotAccessorNode* node = new (m_globalData) DotAccessorNode(lineNumber, base, *property);
    217217        setExceptionLocation(node, start, divot, end);
    218218        return node;
    219219    }
    220220
    221     ExpressionNode* createRegExp(const Identifier& pattern, const Identifier& flags, int start)
     221    ExpressionNode* createRegExp(int lineNumber, const Identifier& pattern, const Identifier& flags, int start)
    222222    {
    223223        if (Yarr::checkSyntax(pattern.ustring()))
    224224            return 0;
    225         RegExpNode* node = new (m_globalData) RegExpNode(m_globalData, pattern, flags);
     225        RegExpNode* node = new (m_globalData) RegExpNode(lineNumber, pattern, flags);
    226226        int size = pattern.length() + 2; // + 2 for the two /'s
    227227        setExceptionLocation(node, start, start + size, start + size);
    … …  
    229229    }
    230230
    231     ExpressionNode* createNewExpr(ExpressionNode* expr, ArgumentsNode* arguments, int start, int divot, int end)
    232     {
    233         NewExprNode* node = new (m_globalData) NewExprNode(m_globalData, expr, arguments);
     231    ExpressionNode* createNewExpr(int lineNumber, ExpressionNode* expr, ArgumentsNode* arguments, int start, int divot, int end)
     232    {
     233        NewExprNode* node = new (m_globalData) NewExprNode(lineNumber, expr, arguments);
    234234        setExceptionLocation(node, start, divot, end);
    235235        return node;
    236236    }
    237237
    238     ExpressionNode* createNewExpr(ExpressionNode* expr, int start, int end)
    239     {
    240         NewExprNode* node = new (m_globalData) NewExprNode(m_globalData, expr);
     238    ExpressionNode* createNewExpr(int lineNumber, ExpressionNode* expr, int start, int end)
     239    {
     240        NewExprNode* node = new (m_globalData) NewExprNode(lineNumber, expr);
    241241        setExceptionLocation(node, start, end, end);
    242242        return node;
    243243    }
    244244
    245     ExpressionNode* createConditionalExpr(ExpressionNode* condition, ExpressionNode* lhs, ExpressionNode* rhs)
    246     {
    247         return new (m_globalData) ConditionalNode(m_globalData, condition, lhs, rhs);
    248     }
    249 
    250     ExpressionNode* createAssignResolve(const Identifier& ident, ExpressionNode* rhs, bool rhsHasAssignment, int start, int divot, int end)
    251     {
    252         AssignResolveNode* node = new (m_globalData) AssignResolveNode(m_globalData, ident, rhs, rhsHasAssignment);
     245    ExpressionNode* createConditionalExpr(int lineNumber, ExpressionNode* condition, ExpressionNode* lhs, ExpressionNode* rhs)
     246    {
     247        return new (m_globalData) ConditionalNode(lineNumber, condition, lhs, rhs);
     248    }
     249
     250    ExpressionNode* createAssignResolve(int lineNumber, const Identifier& ident, ExpressionNode* rhs, bool rhsHasAssignment, int start, int divot, int end)
     251    {
     252        AssignResolveNode* node = new (m_globalData) AssignResolveNode(lineNumber, ident, rhs, rhsHasAssignment);
    253253        setExceptionLocation(node, start, divot, end);
    254254        return node;
    255255    }
    256256
    257     ExpressionNode* createFunctionExpr(const Identifier* name, FunctionBodyNode* body, ParameterNode* parameters, int openBracePos, int closeBracePos, int bodyStartLine, int bodyEndLine)
    258     {
    259         FuncExprNode* result = new (m_globalData) FuncExprNode(m_globalData, *name, body, m_lexer->sourceCode(openBracePos, closeBracePos, bodyStartLine), parameters);
     257    ExpressionNode* createFunctionExpr(int lineNumber, const Identifier* name, FunctionBodyNode* body, ParameterNode* parameters, int openBracePos, int closeBracePos, int bodyStartLine, int bodyEndLine)
     258    {
     259        FuncExprNode* result = new (m_globalData) FuncExprNode(lineNumber, *name, body, m_sourceCode->subExpression(openBracePos, closeBracePos, bodyStartLine), parameters);
    260260        body->setLoc(bodyStartLine, bodyEndLine);
    261261        return result;
    262262    }
    263263
    264     FunctionBodyNode* createFunctionBody(bool inStrictContext)
     264    FunctionBodyNode* createFunctionBody(int lineNumber, bool inStrictContext)
    265265    {
    266266        usesClosures();
    267         return FunctionBodyNode::create(m_globalData, inStrictContext);
    268     }
    269    
    270     template <bool> PropertyNode* createGetterOrSetterProperty(PropertyNode::Type type, const Identifier* name, ParameterNode* params, FunctionBodyNode* body, int openBracePos, int closeBracePos, int bodyStartLine, int bodyEndLine)
     267        return FunctionBodyNode::create(m_globalData, lineNumber, inStrictContext);
     268    }
     269   
     270    template <bool> PropertyNode* createGetterOrSetterProperty(int lineNumber, PropertyNode::Type type, const Identifier* name, ParameterNode* params, FunctionBodyNode* body, int openBracePos, int closeBracePos, int bodyStartLine, int bodyEndLine)
    271271    {
    272272        ASSERT(name);
    273273        body->setLoc(bodyStartLine, bodyEndLine);
    274         return new (m_globalData) PropertyNode(m_globalData, *name, new (m_globalData) FuncExprNode(m_globalData, m_globalData->propertyNames->nullIdentifier, body, m_lexer->sourceCode(openBracePos, closeBracePos, bodyStartLine), params), type);
    275     }
    276    
    277 
    278     ArgumentsNode* createArguments() { return new (m_globalData) ArgumentsNode(m_globalData); }
    279     ArgumentsNode* createArguments(ArgumentListNode* args) { return new (m_globalData) ArgumentsNode(m_globalData, args); }
    280     ArgumentListNode* createArgumentsList(ExpressionNode* arg) { return new (m_globalData) ArgumentListNode(m_globalData, arg); }
    281     ArgumentListNode* createArgumentsList(ArgumentListNode* args, ExpressionNode* arg) { return new (m_globalData) ArgumentListNode(m_globalData, args, arg); }
     274        return new (m_globalData) PropertyNode(m_globalData, *name, new (m_globalData) FuncExprNode(lineNumber, m_globalData->propertyNames->nullIdentifier, body, m_sourceCode->subExpression(openBracePos, closeBracePos, bodyStartLine), params), type);
     275    }
     276   
     277
     278    ArgumentsNode* createArguments() { return new (m_globalData) ArgumentsNode(); }
     279    ArgumentsNode* createArguments(ArgumentListNode* args) { return new (m_globalData) ArgumentsNode(args); }
     280    ArgumentListNode* createArgumentsList(int lineNumber, ExpressionNode* arg) { return new (m_globalData) ArgumentListNode(lineNumber, arg); }
     281    ArgumentListNode* createArgumentsList(int lineNumber, ArgumentListNode* args, ExpressionNode* arg) { return new (m_globalData) ArgumentListNode(lineNumber, args, arg); }
    282282
    283283    template <bool> PropertyNode* createProperty(const Identifier* propertyName, ExpressionNode* node, PropertyNode::Type type) { return new (m_globalData) PropertyNode(m_globalData, *propertyName, node, type); }
    284284    template <bool> PropertyNode* createProperty(JSGlobalData*, double propertyName, ExpressionNode* node, PropertyNode::Type type) { return new (m_globalData) PropertyNode(m_globalData, propertyName, node, type); }
    285     PropertyListNode* createPropertyList(PropertyNode* property) { return new (m_globalData) PropertyListNode(m_globalData, property); }
    286     PropertyListNode* createPropertyList(PropertyNode* property, PropertyListNode* tail) { return new (m_globalData) PropertyListNode(m_globalData, property, tail); }
    287 
    288     ElementNode* createElementList(int elisions, ExpressionNode* expr) { return new (m_globalData) ElementNode(m_globalData, elisions, expr); }
    289     ElementNode* createElementList(ElementNode* elems, int elisions, ExpressionNode* expr) { return new (m_globalData) ElementNode(m_globalData, elems, elisions, expr); }
    290 
    291     ParameterNode* createFormalParameterList(const Identifier& ident) { return new (m_globalData) ParameterNode(m_globalData, ident); }
    292     ParameterNode* createFormalParameterList(ParameterNode* list, const Identifier& ident) { return new (m_globalData) ParameterNode(m_globalData, list, ident); }
    293 
    294     CaseClauseNode* createClause(ExpressionNode* expr, JSC::SourceElements* statements) { return new (m_globalData) CaseClauseNode(m_globalData, expr, statements); }
    295     ClauseListNode* createClauseList(CaseClauseNode* clause) { return new (m_globalData) ClauseListNode(m_globalData, clause); }
    296     ClauseListNode* createClauseList(ClauseListNode* tail, CaseClauseNode* clause) { return new (m_globalData) ClauseListNode(m_globalData, tail, clause); }
     285    PropertyListNode* createPropertyList(int lineNumber, PropertyNode* property) { return new (m_globalData) PropertyListNode(lineNumber, property); }
     286    PropertyListNode* createPropertyList(int lineNumber, PropertyNode* property, PropertyListNode* tail) { return new (m_globalData) PropertyListNode(lineNumber, property, tail); }
     287
     288    ElementNode* createElementList(int elisions, ExpressionNode* expr) { return new (m_globalData) ElementNode(elisions, expr); }
     289    ElementNode* createElementList(ElementNode* elems, int elisions, ExpressionNode* expr) { return new (m_globalData) ElementNode(elems, elisions, expr); }
     290
     291    ParameterNode* createFormalParameterList(const Identifier& ident) { return new (m_globalData) ParameterNode(ident); }
     292    ParameterNode* createFormalParameterList(ParameterNode* list, const Identifier& ident) { return new (m_globalData) ParameterNode(list, ident); }
     293
     294    CaseClauseNode* createClause(ExpressionNode* expr, JSC::SourceElements* statements) { return new (m_globalData) CaseClauseNode(expr, statements); }
     295    ClauseListNode* createClauseList(CaseClauseNode* clause) { return new (m_globalData) ClauseListNode(clause); }
     296    ClauseListNode* createClauseList(ClauseListNode* tail, CaseClauseNode* clause) { return new (m_globalData) ClauseListNode(tail, clause); }
    297297
    298298    void setUsesArguments(FunctionBodyNode* node) { node->setUsesArguments(); }
    299299
    300     StatementNode* createFuncDeclStatement(const Identifier* name, FunctionBodyNode* body, ParameterNode* parameters, int openBracePos, int closeBracePos, int bodyStartLine, int bodyEndLine)
    301     {
    302         FuncDeclNode* decl = new (m_globalData) FuncDeclNode(m_globalData, *name, body, m_lexer->sourceCode(openBracePos, closeBracePos, bodyStartLine), parameters);
     300    StatementNode* createFuncDeclStatement(int lineNumber, const Identifier* name, FunctionBodyNode* body, ParameterNode* parameters, int openBracePos, int closeBracePos, int bodyStartLine, int bodyEndLine)
     301    {
     302        FuncDeclNode* decl = new (m_globalData) FuncDeclNode(lineNumber, *name, body, m_sourceCode->subExpression(openBracePos, closeBracePos, bodyStartLine), parameters);
    303303        if (*name == m_globalData->propertyNames->arguments)
    304304            usesArguments();
    … …  
    308308    }
    309309
    310     StatementNode* createBlockStatement(JSC::SourceElements* elements, int startLine, int endLine)
    311     {
    312         BlockNode* block = new (m_globalData) BlockNode(m_globalData, elements);
     310    StatementNode* createBlockStatement(int lineNumber, JSC::SourceElements* elements, int startLine, int endLine)
     311    {
     312        BlockNode* block = new (m_globalData) BlockNode(lineNumber, elements);
    313313        block->setLoc(startLine, endLine);
    314314        return block;
    315315    }
    316316
    317     StatementNode* createExprStatement(ExpressionNode* expr, int start, int end)
    318     {
    319         ExprStatementNode* result = new (m_globalData) ExprStatementNode(m_globalData, expr);
     317    StatementNode* createExprStatement(int lineNumber, ExpressionNode* expr, int start, int end)
     318    {
     319        ExprStatementNode* result = new (m_globalData) ExprStatementNode(lineNumber, expr);
    320320        result->setLoc(start, end);
    321321        return result;
    322322    }
    323323
    324     StatementNode* createIfStatement(ExpressionNode* condition, StatementNode* trueBlock, int start, int end)
    325     {
    326         IfNode* result = new (m_globalData) IfNode(m_globalData, condition, trueBlock);
     324    StatementNode* createIfStatement(int lineNumber, ExpressionNode* condition, StatementNode* trueBlock, int start, int end)
     325    {
     326        IfNode* result = new (m_globalData) IfNode(lineNumber, condition, trueBlock);
    327327        result->setLoc(start, end);
    328328        return result;
    329329    }
    330330
    331     StatementNode* createIfStatement(ExpressionNode* condition, StatementNode* trueBlock, StatementNode* falseBlock, int start, int end)
    332     {
    333         IfNode* result = new (m_globalData) IfElseNode(m_globalData, condition, trueBlock, falseBlock);
     331    StatementNode* createIfStatement(int lineNumber, ExpressionNode* condition, StatementNode* trueBlock, StatementNode* falseBlock, int start, int end)
     332    {
     333        IfNode* result = new (m_globalData) IfElseNode(lineNumber, condition, trueBlock, falseBlock);
    334334        result->setLoc(start, end);
    335335        return result;
    336336    }
    337337
    338     StatementNode* createForLoop(ExpressionNode* initializer, ExpressionNode* condition, ExpressionNode* iter, StatementNode* statements, bool b, int start, int end)
    339     {
    340         ForNode* result = new (m_globalData) ForNode(m_globalData, initializer, condition, iter, statements, b);
     338    StatementNode* createForLoop(int lineNumber, ExpressionNode* initializer, ExpressionNode* condition, ExpressionNode* iter, StatementNode* statements, bool b, int start, int end)
     339    {
     340        ForNode* result = new (m_globalData) ForNode(lineNumber, initializer, condition, iter, statements, b);
    341341        result->setLoc(start, end);
    342342        return result;
    343343    }
    344344
    345     StatementNode* createForInLoop(const Identifier* ident, ExpressionNode* initializer, ExpressionNode* iter, StatementNode* statements, int start, int divot, int end, int initStart, int initEnd, int startLine, int endLine)
    346     {
    347         ForInNode* result = new (m_globalData) ForInNode(m_globalData, *ident, initializer, iter, statements, initStart, initStart - start, initEnd - initStart);
     345    StatementNode* createForInLoop(int lineNumber, const Identifier* ident, ExpressionNode* initializer, ExpressionNode* iter, StatementNode* statements, int start, int divot, int end, int initStart, int initEnd, int startLine, int endLine)
     346    {
     347        ForInNode* result = new (m_globalData) ForInNode(m_globalData, lineNumber, *ident, initializer, iter, statements, initStart, initStart - start, initEnd - initStart);
    348348        result->setLoc(startLine, endLine);
    349349        setExceptionLocation(result, start, divot + 1, end);
    … …  
    351351    }
    352352
    353     StatementNode* createForInLoop(ExpressionNode* lhs, ExpressionNode* iter, StatementNode* statements, int eStart, int eDivot, int eEnd, int start, int end)
    354     {
    355         ForInNode* result = new (m_globalData) ForInNode(m_globalData, lhs, iter, statements);
     353    StatementNode* createForInLoop(int lineNumber, ExpressionNode* lhs, ExpressionNode* iter, StatementNode* statements, int eStart, int eDivot, int eEnd, int start, int end)
     354    {
     355        ForInNode* result = new (m_globalData) ForInNode(m_globalData, lineNumber, lhs, iter, statements);
    356356        result->setLoc(start, end);
    357357        setExceptionLocation(result, eStart, eDivot, eEnd);
    … …  
    359359    }
    360360
    361     StatementNode* createEmptyStatement() { return new (m_globalData) EmptyStatementNode(m_globalData); }
    362 
    363     StatementNode* createVarStatement(ExpressionNode* expr, int start, int end)
     361    StatementNode* createEmptyStatement(int lineNumber) { return new (m_globalData) EmptyStatementNode(lineNumber); }
     362
     363    StatementNode* createVarStatement(int lineNumber, ExpressionNode* expr, int start, int end)
    364364    {
    365365        StatementNode* result;
    366366        if (!expr)
    367             result = new (m_globalData) EmptyStatementNode(m_globalData);
     367            result = new (m_globalData) EmptyStatementNode(lineNumber);
    368368        else
    369             result = new (m_globalData) VarStatementNode(m_globalData, expr);
     369            result = new (m_globalData) VarStatementNode(lineNumber, expr);
    370370        result->setLoc(start, end);
    371371        return result;
    372372    }
    373373
    374     StatementNode* createReturnStatement(ExpressionNode* expression, int eStart, int eEnd, int startLine, int endLine)
    375     {
    376         ReturnNode* result = new (m_globalData) ReturnNode(m_globalData, expression);
     374    StatementNode* createReturnStatement(int lineNumber, ExpressionNode* expression, int eStart, int eEnd, int startLine, int endLine)
     375    {
     376        ReturnNode* result = new (m_globalData) ReturnNode(lineNumber, expression);
    377377        setExceptionLocation(result, eStart, eEnd, eEnd);
    378378        result->setLoc(startLine, endLine);
    … …  
    380380    }
    381381
    382     StatementNode* createBreakStatement(int eStart, int eEnd, int startLine, int endLine)
    383     {
    384         BreakNode* result = new (m_globalData) BreakNode(m_globalData);
     382    StatementNode* createBreakStatement(int lineNumber, int eStart, int eEnd, int startLine, int endLine)
     383    {
     384        BreakNode* result = new (m_globalData) BreakNode(m_globalData, lineNumber);
    385385        setExceptionLocation(result, eStart, eEnd, eEnd);
    386386        result->setLoc(startLine, endLine);
    … …  
    388388    }
    389389
    390     StatementNode* createBreakStatement(const Identifier* ident, int eStart, int eEnd, int startLine, int endLine)
    391     {
    392         BreakNode* result = new (m_globalData) BreakNode(m_globalData, *ident);
     390    StatementNode* createBreakStatement(int lineNumber, const Identifier* ident, int eStart, int eEnd, int startLine, int endLine)
     391    {
     392        BreakNode* result = new (m_globalData) BreakNode(lineNumber, *ident);
    393393        setExceptionLocation(result, eStart, eEnd, eEnd);
    394394        result->setLoc(startLine, endLine);
    … …  
    396396    }
    397397
    398     StatementNode* createContinueStatement(int eStart, int eEnd, int startLine, int endLine)
    399     {
    400         ContinueNode* result = new (m_globalData) ContinueNode(m_globalData);
     398    StatementNode* createContinueStatement(int lineNumber, int eStart, int eEnd, int startLine, int endLine)
     399    {
     400        ContinueNode* result = new (m_globalData) ContinueNode(m_globalData, lineNumber);
    401401        setExceptionLocation(result, eStart, eEnd, eEnd);
    402402        result->setLoc(startLine, endLine);
    … …  
    404404    }
    405405
    406     StatementNode* createContinueStatement(const Identifier* ident, int eStart, int eEnd, int startLine, int endLine)
    407     {
    408         ContinueNode* result = new (m_globalData) ContinueNode(m_globalData, *ident);
     406    StatementNode* createContinueStatement(int lineNumber, const Identifier* ident, int eStart, int eEnd, int startLine, int endLine)
     407    {
     408        ContinueNode* result = new (m_globalData) ContinueNode(lineNumber, *ident);
    409409        setExceptionLocation(result, eStart, eEnd, eEnd);
    410410        result->setLoc(startLine, endLine);
    … …  
    412412    }
    413413
    414     StatementNode* createTryStatement(StatementNode* tryBlock, const Identifier* ident, bool catchHasEval, StatementNode* catchBlock, StatementNode* finallyBlock, int startLine, int endLine)
    415     {
    416         TryNode* result = new (m_globalData) TryNode(m_globalData, tryBlock, *ident, catchHasEval, catchBlock, finallyBlock);
     414    StatementNode* createTryStatement(int lineNumber, StatementNode* tryBlock, const Identifier* ident, bool catchHasEval, StatementNode* catchBlock, StatementNode* finallyBlock, int startLine, int endLine)
     415    {
     416        TryNode* result = new (m_globalData) TryNode(lineNumber, tryBlock, *ident, catchHasEval, catchBlock, finallyBlock);
    417417        if (catchBlock)
    418418            usesCatch();
    … …  
    421421    }
    422422
    423     StatementNode* createSwitchStatement(ExpressionNode* expr, ClauseListNode* firstClauses, CaseClauseNode* defaultClause, ClauseListNode* secondClauses, int startLine, int endLine)
    424     {
    425         CaseBlockNode* cases = new (m_globalData) CaseBlockNode(m_globalData, firstClauses, defaultClause, secondClauses);
    426         SwitchNode* result = new (m_globalData) SwitchNode(m_globalData, expr, cases);
    427         result->setLoc(startLine, endLine);
    428         return result;
    429     }
    430 
    431     StatementNode* createWhileStatement(ExpressionNode* expr, StatementNode* statement, int startLine, int endLine)
    432     {
    433         WhileNode* result = new (m_globalData) WhileNode(m_globalData, expr, statement);
    434         result->setLoc(startLine, endLine);
    435         return result;
    436     }
    437 
    438     StatementNode* createDoWhileStatement(StatementNode* statement, ExpressionNode* expr, int startLine, int endLine)
    439     {
    440         DoWhileNode* result = new (m_globalData) DoWhileNode(m_globalData, statement, expr);
    441         result->setLoc(startLine, endLine);
    442         return result;
    443     }
    444 
    445     StatementNode* createLabelStatement(const Identifier* ident, StatementNode* statement, int start, int end)
    446     {
    447         LabelNode* result = new (m_globalData) LabelNode(m_globalData, *ident, statement);
     423    StatementNode* createSwitchStatement(int lineNumber, ExpressionNode* expr, ClauseListNode* firstClauses, CaseClauseNode* defaultClause, ClauseListNode* secondClauses, int startLine, int endLine)
     424    {
     425        CaseBlockNode* cases = new (m_globalData) CaseBlockNode(firstClauses, defaultClause, secondClauses);
     426        SwitchNode* result = new (m_globalData) SwitchNode(lineNumber, expr, cases);
     427        result->setLoc(startLine, endLine);
     428        return result;
     429    }
     430
     431    StatementNode* createWhileStatement(int lineNumber, ExpressionNode* expr, StatementNode* statement, int startLine, int endLine)
     432    {
     433        WhileNode* result = new (m_globalData) WhileNode(lineNumber, expr, statement);
     434        result->setLoc(startLine, endLine);
     435        return result;
     436    }
     437
     438    StatementNode* createDoWhileStatement(int lineNumber, StatementNode* statement, ExpressionNode* expr, int startLine, int endLine)
     439    {
     440        DoWhileNode* result = new (m_globalData) DoWhileNode(lineNumber, statement, expr);
     441        result->setLoc(startLine, endLine);
     442        return result;
     443    }
     444
     445    StatementNode* createLabelStatement(int lineNumber, const Identifier* ident, StatementNode* statement, int start, int end)
     446    {
     447        LabelNode* result = new (m_globalData) LabelNode(lineNumber, *ident, statement);
    448448        setExceptionLocation(result, start, end, end);
    449449        return result;
    450450    }
    451451
    452     StatementNode* createWithStatement(ExpressionNode* expr, StatementNode* statement, int start, int end, int startLine, int endLine)
     452    StatementNode* createWithStatement(int lineNumber, ExpressionNode* expr, StatementNode* statement, int start, int end, int startLine, int endLine)
    453453    {
    454454        usesWith();
    455         WithNode* result = new (m_globalData) WithNode(m_globalData, expr, statement, end, end - start);
     455        WithNode* result = new (m_globalData) WithNode(lineNumber, expr, statement, end, end - start);
    456456        result->setLoc(startLine, endLine);
    457457        return result;
    458458    }   
    459459   
    460     StatementNode* createThrowStatement(ExpressionNode* expr, int start, int end, int startLine, int endLine)
    461     {
    462         ThrowNode* result = new (m_globalData) ThrowNode(m_globalData, expr);
     460    StatementNode* createThrowStatement(int lineNumber, ExpressionNode* expr, int start, int end, int startLine, int endLine)
     461    {
     462        ThrowNode* result = new (m_globalData) ThrowNode(lineNumber, expr);
    463463        result->setLoc(startLine, endLine);
    464464        setExceptionLocation(result, start, end, end);
    … …  
    466466    }
    467467   
    468     StatementNode* createDebugger(int startLine, int endLine)
    469     {
    470         DebuggerStatementNode* result = new (m_globalData) DebuggerStatementNode(m_globalData);
    471         result->setLoc(startLine, endLine);
    472         return result;
    473     }
    474    
    475     StatementNode* createConstStatement(ConstDeclNode* decls, int startLine, int endLine)
    476     {
    477         ConstStatementNode* result = new (m_globalData) ConstStatementNode(m_globalData, decls);
    478         result->setLoc(startLine, endLine);
    479         return result;
    480     }
    481 
    482     ConstDeclNode* appendConstDecl(ConstDeclNode* tail, const Identifier* name, ExpressionNode* initializer)
    483     {
    484         ConstDeclNode* result = new (m_globalData) ConstDeclNode(m_globalData, *name, initializer);
     468    StatementNode* createDebugger(int lineNumber, int startLine, int endLine)
     469    {
     470        DebuggerStatementNode* result = new (m_globalData) DebuggerStatementNode(lineNumber);
     471        result->setLoc(startLine, endLine);
     472        return result;
     473    }
     474   
     475    StatementNode* createConstStatement(int lineNumber, ConstDeclNode* decls, int startLine, int endLine)
     476    {
     477        ConstStatementNode* result = new (m_globalData) ConstStatementNode(lineNumber, decls);
     478        result->setLoc(startLine, endLine);
     479        return result;
     480    }
     481
     482    ConstDeclNode* appendConstDecl(int lineNumber, ConstDeclNode* tail, const Identifier* name, ExpressionNode* initializer)
     483    {
     484        ConstDeclNode* result = new (m_globalData) ConstDeclNode(lineNumber, *name, initializer);
    485485        if (tail)
    486486            tail->m_next = result;
    … …  
    500500    }
    501501
    502     ExpressionNode* combineCommaNodes(ExpressionNode* list, ExpressionNode* init)
     502    ExpressionNode* combineCommaNodes(int lineNumber, ExpressionNode* list, ExpressionNode* init)
    503503    {
    504504        if (!list)
    … …  
    508508            return list;
    509509        }
    510         return new (m_globalData) CommaNode(m_globalData, list, init);
     510        return new (m_globalData) CommaNode(lineNumber, list, init);
    511511    }
    512512
    … …  
    536536        m_binaryOperandStack.resize(m_binaryOperandStack.size() - amount);
    537537    }
    538     void appendBinaryOperation(int& operandStackDepth, int&, const BinaryOperand& lhs, const BinaryOperand& rhs)
     538    void appendBinaryOperation(int lineNumber, int& operandStackDepth, int&, const BinaryOperand& lhs, const BinaryOperand& rhs)
    539539    {
    540540        operandStackDepth++;
    541         m_binaryOperandStack.append(std::make_pair(makeBinaryNode(m_binaryOperatorStack.last().first, lhs, rhs), BinaryOpInfo(lhs.second, rhs.second)));
     541        m_binaryOperandStack.append(std::make_pair(makeBinaryNode(lineNumber, m_binaryOperatorStack.last().first, lhs, rhs), BinaryOpInfo(lhs.second, rhs.second)));
    542542    }
    543543    void operatorStackAppend(int& operatorStackDepth, int op, int precedence)
    … …  
    581581    }
    582582
    583     ExpressionNode* createAssignment(int& assignmentStackDepth, ExpressionNode* rhs, int initialAssignmentCount, int currentAssignmentCount, int lastTokenEnd)
    584     {
    585         ExpressionNode* result = makeAssignNode(m_assignmentInfoStack.last().m_node, m_assignmentInfoStack.last().m_op, rhs, m_assignmentInfoStack.last().m_initAssignments != initialAssignmentCount, m_assignmentInfoStack.last().m_initAssignments != currentAssignmentCount, m_assignmentInfoStack.last().m_start, m_assignmentInfoStack.last().m_divot + 1, lastTokenEnd);
     583    ExpressionNode* createAssignment(int lineNumber, int& assignmentStackDepth, ExpressionNode* rhs, int initialAssignmentCount, int currentAssignmentCount, int lastTokenEnd)
     584    {
     585        ExpressionNode* result = makeAssignNode(lineNumber, m_assignmentInfoStack.last().m_node, m_assignmentInfoStack.last().m_op, rhs, m_assignmentInfoStack.last().m_initAssignments != initialAssignmentCount, m_assignmentInfoStack.last().m_initAssignments != currentAssignmentCount, m_assignmentInfoStack.last().m_start, m_assignmentInfoStack.last().m_divot + 1, lastTokenEnd);
    586586        m_assignmentInfoStack.removeLast();
    587587        assignmentStackDepth--;
    … …  
    626626        m_scope.m_features |= EvalFeature;
    627627    }
    628     ExpressionNode* createNumber(double d)
    629     {
    630         return new (m_globalData) NumberNode(m_globalData, d);
     628    ExpressionNode* createNumber(int lineNumber, double d)
     629    {
     630        return new (m_globalData) NumberNode(lineNumber, d);
    631631    }
    632632   
    633633    JSGlobalData* m_globalData;
    634     Lexer* m_lexer;
     634    SourceCode* m_sourceCode;
    635635    Scope m_scope;
    636636    Vector<BinaryOperand, 10> m_binaryOperandStack;
    … …  
    641641};
    642642
    643 ExpressionNode* ASTBuilder::makeTypeOfNode(ExpressionNode* expr)
     643ExpressionNode* ASTBuilder::makeTypeOfNode(int lineNumber, ExpressionNode* expr)
    644644{
    645645    if (expr->isResolveNode()) {
    646646        ResolveNode* resolve = static_cast<ResolveNode*>(expr);
    647         return new (m_globalData) TypeOfResolveNode(m_globalData, resolve->identifier());
    648     }
    649     return new (m_globalData) TypeOfValueNode(m_globalData, expr);
    650 }
    651 
    652 ExpressionNode* ASTBuilder::makeDeleteNode(ExpressionNode* expr, int start, int divot, int end)
     647        return new (m_globalData) TypeOfResolveNode(lineNumber, resolve->identifier());
     648    }
     649    return new (m_globalData) TypeOfValueNode(lineNumber, expr);
     650}
     651
     652ExpressionNode* ASTBuilder::makeDeleteNode(int lineNumber, ExpressionNode* expr, int start, int divot, int end)
    653653{
    654654    if (!expr->isLocation())
    655         return new (m_globalData) DeleteValueNode(m_globalData, expr);
     655        return new (m_globalData) DeleteValueNode(lineNumber, expr);
    656656    if (expr->isResolveNode()) {
    657657        ResolveNode* resolve = static_cast<ResolveNode*>(expr);
    658         return new (m_globalData) DeleteResolveNode(m_globalData, resolve->identifier(), divot, divot - start, end - divot);
     658        return new (m_globalData) DeleteResolveNode(lineNumber, resolve->identifier(), divot, divot - start, end - divot);
    659659    }
    660660    if (expr->isBracketAccessorNode()) {
    661661        BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(expr);
    662         return new (m_globalData) DeleteBracketNode(m_globalData, bracket->base(), bracket->subscript(), divot, divot - start, end - divot);
     662        return new (m_globalData) DeleteBracketNode(lineNumber, bracket->base(), bracket->subscript(), divot, divot - start, end - divot);
    663663    }
    664664    ASSERT(expr->isDotAccessorNode());
    665665    DotAccessorNode* dot = static_cast<DotAccessorNode*>(expr);
    666     return new (m_globalData) DeleteDotNode(m_globalData, dot->base(), dot->identifier(), divot, divot - start, end - divot);
    667 }
    668 
    669 ExpressionNode* ASTBuilder::makeNegateNode(ExpressionNode* n)
     666    return new (m_globalData) DeleteDotNode(lineNumber, dot->base(), dot->identifier(), divot, divot - start, end - divot);
     667}
     668
     669ExpressionNode* ASTBuilder::makeNegateNode(int lineNumber, ExpressionNode* n)
    670670{
    671671    if (n->isNumber()) {
    … …  
    675675    }
    676676
    677     return new (m_globalData) NegateNode(m_globalData, n);
    678 }
    679 
    680 ExpressionNode* ASTBuilder::makeBitwiseNotNode(ExpressionNode* expr)
     677    return new (m_globalData) NegateNode(lineNumber, n);
     678}
     679
     680ExpressionNode* ASTBuilder::makeBitwiseNotNode(int lineNumber, ExpressionNode* expr)
    681681{
    682682    if (expr->isNumber())
    683         return createNumber(~toInt32(static_cast<NumberNode*>(expr)->value()));
    684     return new (m_globalData) BitwiseNotNode(m_globalData, expr);
    685 }
    686 
    687 ExpressionNode* ASTBuilder::makeMultNode(ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     683        return createNumber(lineNumber, ~toInt32(static_cast<NumberNode*>(expr)->value()));
     684    return new (m_globalData) BitwiseNotNode(lineNumber, expr);
     685}
     686
     687ExpressionNode* ASTBuilder::makeMultNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
    688688{
    689689    expr1 = expr1->stripUnaryPlus();
    … …  
    691691
    692692    if (expr1->isNumber() && expr2->isNumber())
    693         return createNumber(static_cast<NumberNode*>(expr1)->value() * static_cast<NumberNode*>(expr2)->value());
     693        return createNumber(lineNumber, static_cast<NumberNode*>(expr1)->value() * static_cast<NumberNode*>(expr2)->value());
    694694
    695695    if (expr1->isNumber() && static_cast<NumberNode*>(expr1)->value() == 1)
    696         return new (m_globalData) UnaryPlusNode(m_globalData, expr2);
     696        return new (m_globalData) UnaryPlusNode(lineNumber, expr2);
    697697
    698698    if (expr2->isNumber() && static_cast<NumberNode*>(expr2)->value() == 1)
    699         return new (m_globalData) UnaryPlusNode(m_globalData, expr1);
    700 
    701     return new (m_globalData) MultNode(m_globalData, expr1, expr2, rightHasAssignments);
    702 }
    703 
    704 ExpressionNode* ASTBuilder::makeDivNode(ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     699        return new (m_globalData) UnaryPlusNode(lineNumber, expr1);
     700
     701    return new (m_globalData) MultNode(lineNumber, expr1, expr2, rightHasAssignments);
     702}
     703
     704ExpressionNode* ASTBuilder::makeDivNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
    705705{
    706706    expr1 = expr1->stripUnaryPlus();
    … …  
    708708
    709709    if (expr1->isNumber() && expr2->isNumber())
    710         return createNumber(static_cast<NumberNode*>(expr1)->value() / static_cast<NumberNode*>(expr2)->value());
    711     return new (m_globalData) DivNode(m_globalData, expr1, expr2, rightHasAssignments);
    712 }
    713 
    714 ExpressionNode* ASTBuilder::makeModNode(ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     710        return createNumber(lineNumber, static_cast<NumberNode*>(expr1)->value() / static_cast<NumberNode*>(expr2)->value());
     711    return new (m_globalData) DivNode(lineNumber, expr1, expr2, rightHasAssignments);
     712}
     713
     714ExpressionNode* ASTBuilder::makeModNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
    715715{
    716716    expr1 = expr1->stripUnaryPlus();
    … …  
    718718   
    719719    if (expr1->isNumber() && expr2->isNumber())
    720         return createNumber(fmod(static_cast<NumberNode*>(expr1)->value(), static_cast<NumberNode*>(expr2)->value()));
    721     return new (m_globalData) ModNode(m_globalData, expr1, expr2, rightHasAssignments);
    722 }
    723 
    724 ExpressionNode* ASTBuilder::makeAddNode(ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
    725 {
    726     if (expr1->isNumber() && expr2->isNumber())
    727         return createNumber(static_cast<NumberNode*>(expr1)->value() + static_cast<NumberNode*>(expr2)->value());
    728     return new (m_globalData) AddNode(m_globalData, expr1, expr2, rightHasAssignments);
    729 }
    730 
    731 ExpressionNode* ASTBuilder::makeSubNode(ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     720        return createNumber(lineNumber, fmod(static_cast<NumberNode*>(expr1)->value(), static_cast<NumberNode*>(expr2)->value()));
     721    return new (m_globalData) ModNode(lineNumber, expr1, expr2, rightHasAssignments);
     722}
     723
     724ExpressionNode* ASTBuilder::makeAddNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     725{
     726    if (expr1->isNumber() && expr2->isNumber())
     727        return createNumber(lineNumber, static_cast<NumberNode*>(expr1)->value() + static_cast<NumberNode*>(expr2)->value());
     728    return new (m_globalData) AddNode(lineNumber, expr1, expr2, rightHasAssignments);
     729}
     730
     731ExpressionNode* ASTBuilder::makeSubNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
    732732{
    733733    expr1 = expr1->stripUnaryPlus();
    … …  
    735735
    736736    if (expr1->isNumber() && expr2->isNumber())
    737         return createNumber(static_cast<NumberNode*>(expr1)->value() - static_cast<NumberNode*>(expr2)->value());
    738     return new (m_globalData) SubNode(m_globalData, expr1, expr2, rightHasAssignments);
    739 }
    740 
    741 ExpressionNode* ASTBuilder::makeLeftShiftNode(ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
    742 {
    743     if (expr1->isNumber() && expr2->isNumber())
    744         return createNumber(toInt32(static_cast<NumberNode*>(expr1)->value()) << (toUInt32(static_cast<NumberNode*>(expr2)->value()) & 0x1f));
    745     return new (m_globalData) LeftShiftNode(m_globalData, expr1, expr2, rightHasAssignments);
    746 }
    747 
    748 ExpressionNode* ASTBuilder::makeRightShiftNode(ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
    749 {
    750     if (expr1->isNumber() && expr2->isNumber())
    751         return createNumber(toInt32(static_cast<NumberNode*>(expr1)->value()) >> (toUInt32(static_cast<NumberNode*>(expr2)->value()) & 0x1f));
    752     return new (m_globalData) RightShiftNode(m_globalData, expr1, expr2, rightHasAssignments);
    753 }
    754 
    755 ExpressionNode* ASTBuilder::makeURightShiftNode(ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
    756 {
    757     if (expr1->isNumber() && expr2->isNumber())
    758         return createNumber(toUInt32(static_cast<NumberNode*>(expr1)->value()) >> (toUInt32(static_cast<NumberNode*>(expr2)->value()) & 0x1f));
    759     return new (m_globalData) UnsignedRightShiftNode(m_globalData, expr1, expr2, rightHasAssignments);
    760 }
    761 
    762 ExpressionNode* ASTBuilder::makeBitOrNode(ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
    763 {
    764     if (expr1->isNumber() && expr2->isNumber())
    765         return createNumber(toInt32(static_cast<NumberNode*>(expr1)->value()) | toInt32(static_cast<NumberNode*>(expr2)->value()));
    766     return new (m_globalData) BitOrNode(m_globalData, expr1, expr2, rightHasAssignments);
    767 }
    768 
    769 ExpressionNode* ASTBuilder::makeBitAndNode(ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
    770 {
    771     if (expr1->isNumber() && expr2->isNumber())
    772         return createNumber(toInt32(static_cast<NumberNode*>(expr1)->value()) & toInt32(static_cast<NumberNode*>(expr2)->value()));
    773     return new (m_globalData) BitAndNode(m_globalData, expr1, expr2, rightHasAssignments);
    774 }
    775 
    776 ExpressionNode* ASTBuilder::makeBitXOrNode(ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
    777 {
    778     if (expr1->isNumber() && expr2->isNumber())
    779         return createNumber(toInt32(static_cast<NumberNode*>(expr1)->value()) ^ toInt32(static_cast<NumberNode*>(expr2)->value()));
    780     return new (m_globalData) BitXOrNode(m_globalData, expr1, expr2, rightHasAssignments);
    781 }
    782 
    783 ExpressionNode* ASTBuilder::makeFunctionCallNode(ExpressionNode* func, ArgumentsNode* args, int start, int divot, int end)
     737        return createNumber(lineNumber, static_cast<NumberNode*>(expr1)->value() - static_cast<NumberNode*>(expr2)->value());
     738    return new (m_globalData) SubNode(lineNumber, expr1, expr2, rightHasAssignments);
     739}
     740
     741ExpressionNode* ASTBuilder::makeLeftShiftNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     742{
     743    if (expr1->isNumber() && expr2->isNumber())
     744        return createNumber(lineNumber, toInt32(static_cast<NumberNode*>(expr1)->value()) << (toUInt32(static_cast<NumberNode*>(expr2)->value()) & 0x1f));
     745    return new (m_globalData) LeftShiftNode(lineNumber, expr1, expr2, rightHasAssignments);
     746}
     747
     748ExpressionNode* ASTBuilder::makeRightShiftNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     749{
     750    if (expr1->isNumber() && expr2->isNumber())
     751        return createNumber(lineNumber, toInt32(static_cast<NumberNode*>(expr1)->value()) >> (toUInt32(static_cast<NumberNode*>(expr2)->value()) & 0x1f));
     752    return new (m_globalData) RightShiftNode(lineNumber, expr1, expr2, rightHasAssignments);
     753}
     754
     755ExpressionNode* ASTBuilder::makeURightShiftNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     756{
     757    if (expr1->isNumber() && expr2->isNumber())
     758        return createNumber(lineNumber, toUInt32(static_cast<NumberNode*>(expr1)->value()) >> (toUInt32(static_cast<NumberNode*>(expr2)->value()) & 0x1f));
     759    return new (m_globalData) UnsignedRightShiftNode(lineNumber, expr1, expr2, rightHasAssignments);
     760}
     761
     762ExpressionNode* ASTBuilder::makeBitOrNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     763{
     764    if (expr1->isNumber() && expr2->isNumber())
     765        return createNumber(lineNumber, toInt32(static_cast<NumberNode*>(expr1)->value()) | toInt32(static_cast<NumberNode*>(expr2)->value()));
     766    return new (m_globalData) BitOrNode(lineNumber, expr1, expr2, rightHasAssignments);
     767}
     768
     769ExpressionNode* ASTBuilder::makeBitAndNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     770{
     771    if (expr1->isNumber() && expr2->isNumber())
     772        return createNumber(lineNumber, toInt32(static_cast<NumberNode*>(expr1)->value()) & toInt32(static_cast<NumberNode*>(expr2)->value()));
     773    return new (m_globalData) BitAndNode(lineNumber, expr1, expr2, rightHasAssignments);
     774}
     775
     776ExpressionNode* ASTBuilder::makeBitXOrNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
     777{
     778    if (expr1->isNumber() && expr2->isNumber())
     779        return createNumber(lineNumber, toInt32(static_cast<NumberNode*>(expr1)->value()) ^ toInt32(static_cast<NumberNode*>(expr2)->value()));
     780    return new (m_globalData) BitXOrNode(lineNumber, expr1, expr2, rightHasAssignments);
     781}
     782
     783ExpressionNode* ASTBuilder::makeFunctionCallNode(int lineNumber, ExpressionNode* func, ArgumentsNode* args, int start, int divot, int end)
    784784{
    785785    if (!func->isLocation())
    786         return new (m_globalData) FunctionCallValueNode(m_globalData, func, args, divot, divot - start, end - divot);
     786        return new (m_globalData) FunctionCallValueNode(lineNumber, func, args, divot, divot - start, end - divot);
    787787    if (func->isResolveNode()) {
    788788        ResolveNode* resolve = static_cast<ResolveNode*>(func);
    … …  
    790790        if (identifier == m_globalData->propertyNames->eval) {
    791791            usesEval();
    792             return new (m_globalData) EvalFunctionCallNode(m_globalData, args, divot, divot - start, end - divot);
     792            return new (m_globalData) EvalFunctionCallNode(lineNumber, args, divot, divot - start, end - divot);
    793793        }
    794         return new (m_globalData) FunctionCallResolveNode(m_globalData, identifier, args, divot, divot - start, end - divot);
     794        return new (m_globalData) FunctionCallResolveNode(lineNumber, identifier, args, divot, divot - start, end - divot);
    795795    }
    796796    if (func->isBracketAccessorNode()) {
    797797        BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(func);
    798         FunctionCallBracketNode* node = new (m_globalData) FunctionCallBracketNode(m_globalData, bracket->base(), bracket->subscript(), args, divot, divot - start, end - divot);
     798        FunctionCallBracketNode* node = new (m_globalData) FunctionCallBracketNode(lineNumber, bracket->base(), bracket->subscript(), args, divot, divot - start, end - divot);
    799799        node->setSubexpressionInfo(bracket->divot(), bracket->endOffset());
    800800        return node;
    … …  
    804804    FunctionCallDotNode* node;
    805805    if (dot->identifier() == m_globalData->propertyNames->call)
    806         node = new (m_globalData) CallFunctionCallDotNode(m_globalData, dot->base(), dot->identifier(), args, divot, divot - start, end - divot);
     806        node = new (m_globalData) CallFunctionCallDotNode(lineNumber, dot->base(), dot->identifier(), args, divot, divot - start, end - divot);
    807807    else if (dot->identifier() == m_globalData->propertyNames->apply)
    808         node = new (m_globalData) ApplyFunctionCallDotNode(m_globalData, dot->base(), dot->identifier(), args, divot, divot - start, end - divot);
     808        node = new (m_globalData) ApplyFunctionCallDotNode(lineNumber, dot->base(), dot->identifier(), args, divot, divot - start, end - divot);
    809809    else
    810         node = new (m_globalData) FunctionCallDotNode(m_globalData, dot->base(), dot->identifier(), args, divot, divot - start, end - divot);
     810        node = new (m_globalData) FunctionCallDotNode(lineNumber, dot->base(), dot->identifier(), args, divot, divot - start, end - divot);
    811811    node->setSubexpressionInfo(dot->divot(), dot->endOffset());
    812812    return node;
    813813}
    814814
    815 ExpressionNode* ASTBuilder::makeBinaryNode(int token, pair<ExpressionNode*, BinaryOpInfo> lhs, pair<ExpressionNode*, BinaryOpInfo> rhs)
     815ExpressionNode* ASTBuilder::makeBinaryNode(int lineNumber, int token, pair<ExpressionNode*, BinaryOpInfo> lhs, pair<ExpressionNode*, BinaryOpInfo> rhs)
    816816{
    817817    switch (token) {
    818818    case OR:
    819         return new (m_globalData) LogicalOpNode(m_globalData, lhs.first, rhs.first, OpLogicalOr);
     819        return new (m_globalData) LogicalOpNode(lineNumber, lhs.first, rhs.first, OpLogicalOr);
    820820
    821821    case AND:
    822         return new (m_globalData) LogicalOpNode(m_globalData, lhs.first, rhs.first, OpLogicalAnd);
     822        return new (m_globalData) LogicalOpNode(lineNumber, lhs.first, rhs.first, OpLogicalAnd);
    823823
    824824    case BITOR:
    825         return makeBitOrNode(lhs.first, rhs.first, rhs.second.hasAssignment);
     825        return makeBitOrNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
    826826
    827827    case BITXOR:
    828         return makeBitXOrNode(lhs.first, rhs.first, rhs.second.hasAssignment);
     828        return makeBitXOrNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
    829829
    830830    case BITAND:
    831         return makeBitAndNode(lhs.first, rhs.first, rhs.second.hasAssignment);
     831        return makeBitAndNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
    832832
    833833    case EQEQ:
    834         return new (m_globalData) EqualNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
     834        return new (m_globalData) EqualNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
    835835
    836836    case NE:
    837         return new (m_globalData) NotEqualNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
     837        return new (m_globalData) NotEqualNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
    838838
    839839    case STREQ:
    840         return new (m_globalData) StrictEqualNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
     840        return new (m_globalData) StrictEqualNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
    841841
    842842    case STRNEQ:
    843         return new (m_globalData) NotStrictEqualNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
     843        return new (m_globalData) NotStrictEqualNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
    844844
    845845    case LT:
    846         return new (m_globalData) LessNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
     846        return new (m_globalData) LessNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
    847847
    848848    case GT:
    849         return new (m_globalData) GreaterNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
     849        return new (m_globalData) GreaterNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
    850850
    851851    case LE:
    852         return new (m_globalData) LessEqNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
     852        return new (m_globalData) LessEqNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
    853853
    854854    case GE:
    855         return new (m_globalData) GreaterEqNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
     855        return new (m_globalData) GreaterEqNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
    856856
    857857    case INSTANCEOF: {
    858         InstanceOfNode* node = new (m_globalData) InstanceOfNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
     858        InstanceOfNode* node = new (m_globalData) InstanceOfNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
    859859        setExceptionLocation(node, lhs.second.start, rhs.second.start, rhs.second.end);
    860860        return node;
    … …  
    862862
    863863    case INTOKEN: {
    864         InNode* node = new (m_globalData) InNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
     864        InNode* node = new (m_globalData) InNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
    865865        setExceptionLocation(node, lhs.second.start, rhs.second.start, rhs.second.end);
    866866        return node;
    … …  
    868868
    869869    case LSHIFT:
    870         return makeLeftShiftNode(lhs.first, rhs.first, rhs.second.hasAssignment);
     870        return makeLeftShiftNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
    871871
    872872    case RSHIFT:
    873         return makeRightShiftNode(lhs.first, rhs.first, rhs.second.hasAssignment);
     873        return makeRightShiftNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
    874874
    875875    case URSHIFT:
    876         return makeURightShiftNode(lhs.first, rhs.first, rhs.second.hasAssignment);
     876        return makeURightShiftNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
    877877
    878878    case PLUS:
    879         return makeAddNode(lhs.first, rhs.first, rhs.second.hasAssignment);
     879        return makeAddNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
    880880
    881881    case MINUS:
    882         return makeSubNode(lhs.first, rhs.first, rhs.second.hasAssignment);
     882        return makeSubNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
    883883
    884884    case TIMES:
    885         return makeMultNode(lhs.first, rhs.first, rhs.second.hasAssignment);
     885        return makeMultNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
    886886
    887887    case DIVIDE:
    888         return makeDivNode(lhs.first, rhs.first, rhs.second.hasAssignment);
     888        return makeDivNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
    889889
    890890    case MOD:
    891         return makeModNode(lhs.first, rhs.first, rhs.second.hasAssignment);
     891        return makeModNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
    892892    }
    893893    CRASH();
    … …  
    895895}
    896896
    897 ExpressionNode* ASTBuilder::makeAssignNode(ExpressionNode* loc, Operator op, ExpressionNode* expr, bool locHasAssignments, bool exprHasAssignments, int start, int divot, int end)
     897ExpressionNode* ASTBuilder::makeAssignNode(int lineNumber, ExpressionNode* loc, Operator op, ExpressionNode* expr, bool locHasAssignments, bool exprHasAssignments, int start, int divot, int end)
    898898{
    899899    usesAssignment();
    900900    if (!loc->isLocation())
    901         return new (m_globalData) AssignErrorNode(m_globalData, loc, op, expr, divot, divot - start, end - divot);
     901        return new (m_globalData) AssignErrorNode(lineNumber, loc, op, expr, divot, divot - start, end - divot);
    902902
    903903    if (loc->isResolveNode()) {
    904904        ResolveNode* resolve = static_cast<ResolveNode*>(loc);
    905905        if (op == OpEqual) {
    906             AssignResolveNode* node = new (m_globalData) AssignResolveNode(m_globalData, resolve->identifier(), expr, exprHasAssignments);
     906            AssignResolveNode* node = new (m_globalData) AssignResolveNode(lineNumber, resolve->identifier(), expr, exprHasAssignments);
    907907            setExceptionLocation(node, start, divot, end);
    908908            return node;
    909909        }
    910         return new (m_globalData) ReadModifyResolveNode(m_globalData, resolve->identifier(), op, expr, exprHasAssignments, divot, divot - start, end - divot);
     910        return new (m_globalData) ReadModifyResolveNode(lineNumber, resolve->identifier(), op, expr, exprHasAssignments, divot, divot - start, end - divot);
    911911    }
    912912    if (loc->isBracketAccessorNode()) {
    913913        BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(loc);
    914914        if (op == OpEqual)
    915             return new (m_globalData) AssignBracketNode(m_globalData, bracket->base(), bracket->subscript(), expr, locHasAssignments, exprHasAssignments, bracket->divot(), bracket->divot() - start, end - bracket->divot());
    916         ReadModifyBracketNode* node = new (m_globalData) ReadModifyBracketNode(m_globalData, bracket->base(), bracket->subscript(), op, expr, locHasAssignments, exprHasAssignments, divot, divot - start, end - divot);
     915            return new (m_globalData) AssignBracketNode(lineNumber, bracket->base(), bracket->subscript(), expr, locHasAssignments, exprHasAssignments, bracket->divot(), bracket->divot() - start, end - bracket->divot());
     916        ReadModifyBracketNode* node = new (m_globalData) ReadModifyBracketNode(lineNumber, bracket->base(), bracket->subscript(), op, expr, locHasAssignments, exprHasAssignments, divot, divot - start, end - divot);
    917917        node->setSubexpressionInfo(bracket->divot(), bracket->endOffset());
    918918        return node;
    … …  
    921921    DotAccessorNode* dot = static_cast<DotAccessorNode*>(loc);
    922922    if (op == OpEqual)
    923         return new (m_globalData) AssignDotNode(m_globalData, dot->base(), dot->identifier(), expr, exprHasAssignments, dot->divot(), dot->divot() - start, end - dot->divot());
    924 
    925     ReadModifyDotNode* node = new (m_globalData) ReadModifyDotNode(m_globalData, dot->base(), dot->identifier(), op, expr, exprHasAssignments, divot, divot - start, end - divot);
     923        return new (m_globalData) AssignDotNode(lineNumber, dot->base(), dot->identifier(), expr, exprHasAssignments, dot->divot(), dot->divot() - start, end - dot->divot());
     924
     925    ReadModifyDotNode* node = new (m_globalData) ReadModifyDotNode(lineNumber, dot->base(), dot->identifier(), op, expr, exprHasAssignments, divot, divot - start, end - divot);
    926926    node->setSubexpressionInfo(dot->divot(), dot->endOffset());
    927927    return node;
    928928}
    929929
    930 ExpressionNode* ASTBuilder::makePrefixNode(ExpressionNode* expr, Operator op, int start, int divot, int end)
     930ExpressionNode* ASTBuilder::makePrefixNode(int lineNumber, ExpressionNode* expr, Operator op, int start, int divot, int end)
    931931{
    932932    usesAssignment();
    933933    if (!expr->isLocation())
    934         return new (m_globalData) PrefixErrorNode(m_globalData, expr, op, divot, divot - start, end - divot);
     934        return new (m_globalData) PrefixErrorNode(lineNumber, expr, op, divot, divot - start, end - divot);
    935935
    936936    if (expr->isResolveNode()) {
    937937        ResolveNode* resolve = static_cast<ResolveNode*>(expr);
    938         return new (m_globalData) PrefixResolveNode(m_globalData, resolve->identifier(), op, divot, divot - start, end - divot);
     938        return new (m_globalData) PrefixResolveNode(lineNumber, resolve->identifier(), op, divot, divot - start, end - divot);
    939939    }
    940940    if (expr->isBracketAccessorNode()) {
    941941        BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(expr);
    942         PrefixBracketNode* node = new (m_globalData) PrefixBracketNode(m_globalData, bracket->base(), bracket->subscript(), op, divot, divot - start, end - divot);
     942        PrefixBracketNode* node = new (m_globalData) PrefixBracketNode(lineNumber, bracket->base(), bracket->subscript(), op, divot, divot - start, end - divot);
    943943        node->setSubexpressionInfo(bracket->divot(), bracket->startOffset());
    944944        return node;
    … …  
    946946    ASSERT(expr->isDotAccessorNode());
    947947    DotAccessorNode* dot = static_cast<DotAccessorNode*>(expr);
    948     PrefixDotNode* node = new (m_globalData) PrefixDotNode(m_globalData, dot->base(), dot->identifier(), op, divot, divot - start, end - divot);
     948    PrefixDotNode* node = new (m_globalData) PrefixDotNode(lineNumber, dot->base(), dot->identifier(), op, divot, divot - start, end - divot);
    949949    node->setSubexpressionInfo(dot->divot(), dot->startOffset());
    950950    return node;
    951951}
    952952
    953 ExpressionNode* ASTBuilder::makePostfixNode(ExpressionNode* expr, Operator op, int start, int divot, int end)
     953ExpressionNode* ASTBuilder::makePostfixNode(int lineNumber, ExpressionNode* expr, Operator op, int start, int divot, int end)
    954954{
    955955    usesAssignment();
    956956    if (!expr->isLocation())
    957         return new (m_globalData) PostfixErrorNode(m_globalData, expr, op, divot, divot - start, end - divot);
     957        return new (m_globalData) PostfixErrorNode(lineNumber, expr, op, divot, divot - start, end - divot);
    958958
    959959    if (expr->isResolveNode()) {
    960960        ResolveNode* resolve = static_cast<ResolveNode*>(expr);
    961         return new (m_globalData) PostfixResolveNode(m_globalData, resolve->identifier(), op, divot, divot - start, end - divot);
     961        return new (m_globalData) PostfixResolveNode(lineNumber, resolve->identifier(), op, divot, divot - start, end - divot);
    962962    }
    963963    if (expr->isBracketAccessorNode()) {
    964964        BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(expr);
    965         PostfixBracketNode* node = new (m_globalData) PostfixBracketNode(m_globalData, bracket->base(), bracket->subscript(), op, divot, divot - start, end - divot);
     965        PostfixBracketNode* node = new (m_globalData) PostfixBracketNode(lineNumber, bracket->base(), bracket->subscript(), op, divot, divot - start, end - divot);
    966966        node->setSubexpressionInfo(bracket->divot(), bracket->endOffset());
    967967        return node;
    … …  
    970970    ASSERT(expr->isDotAccessorNode());
    971971    DotAccessorNode* dot = static_cast<DotAccessorNode*>(expr);
    972     PostfixDotNode* node = new (m_globalData) PostfixDotNode(m_globalData, dot->base(), dot->identifier(), op, divot, divot - start, end - divot);
     972    PostfixDotNode* node = new (m_globalData) PostfixDotNode(lineNumber, dot->base(), dot->identifier(), op, divot, divot - start, end - divot);
    973973    node->setSubexpressionInfo(dot->divot(), dot->endOffset());
    974974    return node;
Note: See TracChangeset for help on using the changeset viewer.