parser/ASTBuilder.h

   1 /*
   2  * Copyright (C) 2010 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  23  * THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef ASTBuilder_h
  27 #define ASTBuilder_h
  28
  29 #include "NodeConstructors.h"
  30 #include "SyntaxChecker.h"
  31 #include <utility>
  32
  33 namespace JSC {
  34
  35 class ASTBuilder {
  36     struct BinaryOpInfo {
  37         BinaryOpInfo() {}
  38         BinaryOpInfo(int s, int d, int e, bool r)
  39             : start(s)
  40             , divot(d)
  41             , end(e)
  42             , hasAssignment(r)
  43         {
  44         }
  45         BinaryOpInfo(const BinaryOpInfo& lhs, const BinaryOpInfo& rhs)
  46             : start(lhs.start)
  47             , divot(rhs.start)
  48             , end(rhs.end)
  49             , hasAssignment(lhs.hasAssignment || rhs.hasAssignment)
  50         {
  51         }
  52         int start;
  53         int divot;
  54         int end;
  55         bool hasAssignment;
  56     };
  57
  58
  59     struct AssignmentInfo {
  60         AssignmentInfo() {}
  61         AssignmentInfo(ExpressionNode* node, int start, int divot, int initAssignments, Operator op)
  62             : m_node(node)
  63             , m_start(start)
  64             , m_divot(divot)
  65             , m_initAssignments(initAssignments)
  66             , m_op(op)
  67         {
  68         }
  69         ExpressionNode* m_node;
  70         int m_start;
  71         int m_divot;
  72         int m_initAssignments;
  73         Operator m_op;
  74     };
  75 public:
  76     ASTBuilder(JSGlobalData* globalData, SourceCode* sourceCode)
  77         : m_globalData(globalData)
  78         , m_sourceCode(sourceCode)
  79         , m_scope(globalData)
  80         , m_evalCount(0)
  81     {
  82     }
  83
  84     struct BinaryExprContext {
  85         BinaryExprContext(ASTBuilder&) {}
  86     };
  87     struct UnaryExprContext {
  88         UnaryExprContext(ASTBuilder&) {}
  89     };
  90
  91     typedef SyntaxChecker FunctionBodyBuilder;
  92
  93     typedef ExpressionNode* Expression;
  94     typedef JSC::SourceElements* SourceElements;
  95     typedef ArgumentsNode* Arguments;
  96     typedef CommaNode* Comma;
  97     typedef PropertyNode* Property;
  98     typedef PropertyListNode* PropertyList;
  99     typedef ElementNode* ElementList;
 100     typedef ArgumentListNode* ArgumentsList;
 101     typedef ParameterNode* FormalParameterList;
 102     typedef FunctionBodyNode* FunctionBody;
 103     typedef StatementNode* Statement;
 104     typedef ClauseListNode* ClauseList;
 105     typedef CaseClauseNode* Clause;
 106     typedef ConstDeclNode* ConstDeclList;
 107     typedef std::pair<ExpressionNode*, BinaryOpInfo> BinaryOperand;
 108
 109     static const bool CreatesAST = true;
 110     static const bool NeedsFreeVariableInfo = true;
 111     static const bool CanUseFunctionCache = true;
 112     static const int  DontBuildKeywords = 0;
 113     static const int  DontBuildStrings = 0;
 114
 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(); }
 119
 120     ParserArenaData<DeclarationStacks::VarStack>* varDeclarations() { return m_scope.m_varDeclarations; }
 121     ParserArenaData<DeclarationStacks::FunctionStack>* funcDeclarations() { return m_scope.m_funcDeclarations; }
 122     int features() const { return m_scope.m_features; }
 123     int numConstants() const { return m_scope.m_numConstants; }
 124
 125     void appendToComma(CommaNode* commaNode, ExpressionNode* expr) { commaNode->append(expr); }
 126
 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)
 151     {
 152         incConstants();
 153         return new (m_globalData) VoidNode(lineNumber, expr);
 154     }
 155     ExpressionNode* thisExpr(int lineNumber)
 156     {
 157         usesThis();
 158         return new (m_globalData) ThisNode(lineNumber);
 159     }
 160     ExpressionNode* createResolve(int lineNumber, const Identifier* ident, int start)
 161     {
 162         if (m_globalData->propertyNames->arguments == *ident)
 163             usesArguments();
 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)
 170     {
 171         if (elisions)
 172             incConstants();
 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)
 178     {
 179         if (elisions)
 180             incConstants();
 181         return new (m_globalData) ArrayNode(lineNumber, elisions, elems);
 182     }
 183     ExpressionNode* createNumberExpr(int lineNumber, double d)
 184     {
 185         incConstants();
 186         return new (m_globalData) NumberNode(lineNumber, d);
 187     }
 188
 189     ExpressionNode* createString(int lineNumber, const Identifier* string)
 190     {
 191         incConstants();
 192         return new (m_globalData) StringNode(lineNumber, *string);
 193     }
 194
 195     ExpressionNode* createBoolean(int lineNumber, bool b)
 196     {
 197         incConstants();
 198         return new (m_globalData) BooleanNode(lineNumber, b);
 199     }
 200
 201     ExpressionNode* createNull(int lineNumber)
 202     {
 203         incConstants();
 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);
 210         setExceptionLocation(node, start, divot, end);
 211         return node;
 212     }
 213
 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);
 217         setExceptionLocation(node, start, divot, end);
 218         return node;
 219     }
 220
 221     ExpressionNode* createRegExp(int lineNumber, const Identifier& pattern, const Identifier& flags, int start)
 222     {
 223         if (Yarr::checkSyntax(pattern.ustring()))
 224             return 0;
 225         RegExpNode* node = new (m_globalData) RegExpNode(lineNumber, pattern, flags);
 226         int size = pattern.length() + 2; // + 2 for the two /'s
 227         setExceptionLocation(node, start, start + size, start + size);
 228         return node;
 229     }
 230
 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);
 234         setExceptionLocation(node, start, divot, end);
 235         return node;
 236     }
 237
 238     ExpressionNode* createNewExpr(int lineNumber, ExpressionNode* expr, int start, int end)
 239     {
 240         NewExprNode* node = new (m_globalData) NewExprNode(lineNumber, expr);
 241         setExceptionLocation(node, start, end, end);
 242         return node;
 243     }
 244
 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         if (rhs->isFuncExprNode())
 253             static_cast<FuncExprNode*>(rhs)->body()->setInferredName(ident);
 254         AssignResolveNode* node = new (m_globalData) AssignResolveNode(lineNumber, ident, rhs, rhsHasAssignment);
 255         setExceptionLocation(node, start, divot, end);
 256         return node;
 257     }
 258
 259     ExpressionNode* createFunctionExpr(int lineNumber, const Identifier* name, FunctionBodyNode* body, ParameterNode* parameters, int openBracePos, int closeBracePos, int bodyStartLine, int bodyEndLine)
 260     {
 261         FuncExprNode* result = new (m_globalData) FuncExprNode(lineNumber, *name, body, m_sourceCode->subExpression(openBracePos, closeBracePos, bodyStartLine), parameters);
 262         body->setLoc(bodyStartLine, bodyEndLine);
 263         return result;
 264     }
 265
 266     FunctionBodyNode* createFunctionBody(int lineNumber, bool inStrictContext)
 267     {
 268         return FunctionBodyNode::create(m_globalData, lineNumber, inStrictContext);
 269     }
 270
 271     template <bool> PropertyNode* createGetterOrSetterProperty(int lineNumber, PropertyNode::Type type, const Identifier* name, ParameterNode* params, FunctionBodyNode* body, int openBracePos, int closeBracePos, int bodyStartLine, int bodyEndLine)
 272     {
 273         ASSERT(name);
 274         body->setLoc(bodyStartLine, bodyEndLine);
 275         body->setInferredName(*name);
 276         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);
 277     }
 278
 279     template <bool> PropertyNode* createGetterOrSetterProperty(JSGlobalData*, int lineNumber, PropertyNode::Type type, double name, ParameterNode* params, FunctionBodyNode* body, int openBracePos, int closeBracePos, int bodyStartLine, int bodyEndLine)
 280     {
 281         body->setLoc(bodyStartLine, bodyEndLine);
 282         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);
 283     }
 284
 285     ArgumentsNode* createArguments() { return new (m_globalData) ArgumentsNode(); }
 286     ArgumentsNode* createArguments(ArgumentListNode* args) { return new (m_globalData) ArgumentsNode(args); }
 287     ArgumentListNode* createArgumentsList(int lineNumber, ExpressionNode* arg) { return new (m_globalData) ArgumentListNode(lineNumber, arg); }
 288     ArgumentListNode* createArgumentsList(int lineNumber, ArgumentListNode* args, ExpressionNode* arg) { return new (m_globalData) ArgumentListNode(lineNumber, args, arg); }
 289
 290     template <bool> PropertyNode* createProperty(const Identifier* propertyName, ExpressionNode* node, PropertyNode::Type type)
 291     {
 292         if (node->isFuncExprNode())
 293             static_cast<FuncExprNode*>(node)->body()->setInferredName(*propertyName);
 294         return new (m_globalData) PropertyNode(m_globalData, *propertyName, node, type);
 295     }
 296     template <bool> PropertyNode* createProperty(JSGlobalData*, double propertyName, ExpressionNode* node, PropertyNode::Type type) { return new (m_globalData) PropertyNode(m_globalData, propertyName, node, type); }
 297     PropertyListNode* createPropertyList(int lineNumber, PropertyNode* property) { return new (m_globalData) PropertyListNode(lineNumber, property); }
 298     PropertyListNode* createPropertyList(int lineNumber, PropertyNode* property, PropertyListNode* tail) { return new (m_globalData) PropertyListNode(lineNumber, property, tail); }
 299
 300     ElementNode* createElementList(int elisions, ExpressionNode* expr) { return new (m_globalData) ElementNode(elisions, expr); }
 301     ElementNode* createElementList(ElementNode* elems, int elisions, ExpressionNode* expr) { return new (m_globalData) ElementNode(elems, elisions, expr); }
 302
 303     ParameterNode* createFormalParameterList(const Identifier& ident) { return new (m_globalData) ParameterNode(ident); }
 304     ParameterNode* createFormalParameterList(ParameterNode* list, const Identifier& ident) { return new (m_globalData) ParameterNode(list, ident); }
 305
 306     CaseClauseNode* createClause(ExpressionNode* expr, JSC::SourceElements* statements) { return new (m_globalData) CaseClauseNode(expr, statements); }
 307     ClauseListNode* createClauseList(CaseClauseNode* clause) { return new (m_globalData) ClauseListNode(clause); }
 308     ClauseListNode* createClauseList(ClauseListNode* tail, CaseClauseNode* clause) { return new (m_globalData) ClauseListNode(tail, clause); }
 309
 310     void setUsesArguments(FunctionBodyNode* node) { node->setUsesArguments(); }
 311
 312     StatementNode* createFuncDeclStatement(int lineNumber, const Identifier* name, FunctionBodyNode* body, ParameterNode* parameters, int openBracePos, int closeBracePos, int bodyStartLine, int bodyEndLine)
 313     {
 314         FuncDeclNode* decl = new (m_globalData) FuncDeclNode(lineNumber, *name, body, m_sourceCode->subExpression(openBracePos, closeBracePos, bodyStartLine), parameters);
 315         if (*name == m_globalData->propertyNames->arguments)
 316             usesArguments();
 317         m_scope.m_funcDeclarations->data.append(decl->body());
 318         body->setLoc(bodyStartLine, bodyEndLine);
 319         return decl;
 320     }
 321
 322     StatementNode* createBlockStatement(int lineNumber, JSC::SourceElements* elements, int startLine, int endLine)
 323     {
 324         BlockNode* block = new (m_globalData) BlockNode(lineNumber, elements);
 325         block->setLoc(startLine, endLine);
 326         return block;
 327     }
 328
 329     StatementNode* createExprStatement(int lineNumber, ExpressionNode* expr, int start, int end)
 330     {
 331         ExprStatementNode* result = new (m_globalData) ExprStatementNode(lineNumber, expr);
 332         result->setLoc(start, end);
 333         return result;
 334     }
 335
 336     StatementNode* createIfStatement(int lineNumber, ExpressionNode* condition, StatementNode* trueBlock, int start, int end)
 337     {
 338         IfNode* result = new (m_globalData) IfNode(lineNumber, condition, trueBlock);
 339         result->setLoc(start, end);
 340         return result;
 341     }
 342
 343     StatementNode* createIfStatement(int lineNumber, ExpressionNode* condition, StatementNode* trueBlock, StatementNode* falseBlock, int start, int end)
 344     {
 345         IfNode* result = new (m_globalData) IfElseNode(lineNumber, condition, trueBlock, falseBlock);
 346         result->setLoc(start, end);
 347         return result;
 348     }
 349
 350     StatementNode* createForLoop(int lineNumber, ExpressionNode* initializer, ExpressionNode* condition, ExpressionNode* iter, StatementNode* statements, bool b, int start, int end)
 351     {
 352         ForNode* result = new (m_globalData) ForNode(lineNumber, initializer, condition, iter, statements, b);
 353         result->setLoc(start, end);
 354         return result;
 355     }
 356
 357     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)
 358     {
 359         ForInNode* result = new (m_globalData) ForInNode(m_globalData, lineNumber, *ident, initializer, iter, statements, initStart, initStart - start, initEnd - initStart);
 360         result->setLoc(startLine, endLine);
 361         setExceptionLocation(result, start, divot + 1, end);
 362         return result;
 363     }
 364
 365     StatementNode* createForInLoop(int lineNumber, ExpressionNode* lhs, ExpressionNode* iter, StatementNode* statements, int eStart, int eDivot, int eEnd, int start, int end)
 366     {
 367         ForInNode* result = new (m_globalData) ForInNode(m_globalData, lineNumber, lhs, iter, statements);
 368         result->setLoc(start, end);
 369         setExceptionLocation(result, eStart, eDivot, eEnd);
 370         return result;
 371     }
 372
 373     StatementNode* createEmptyStatement(int lineNumber) { return new (m_globalData) EmptyStatementNode(lineNumber); }
 374
 375     StatementNode* createVarStatement(int lineNumber, ExpressionNode* expr, int start, int end)
 376     {
 377         StatementNode* result;
 378         if (!expr)
 379             result = new (m_globalData) EmptyStatementNode(lineNumber);
 380         else
 381             result = new (m_globalData) VarStatementNode(lineNumber, expr);
 382         result->setLoc(start, end);
 383         return result;
 384     }
 385
 386     StatementNode* createReturnStatement(int lineNumber, ExpressionNode* expression, int eStart, int eEnd, int startLine, int endLine)
 387     {
 388         ReturnNode* result = new (m_globalData) ReturnNode(lineNumber, expression);
 389         setExceptionLocation(result, eStart, eEnd, eEnd);
 390         result->setLoc(startLine, endLine);
 391         return result;
 392     }
 393
 394     StatementNode* createBreakStatement(int lineNumber, int eStart, int eEnd, int startLine, int endLine)
 395     {
 396         BreakNode* result = new (m_globalData) BreakNode(m_globalData, lineNumber);
 397         setExceptionLocation(result, eStart, eEnd, eEnd);
 398         result->setLoc(startLine, endLine);
 399         return result;
 400     }
 401
 402     StatementNode* createBreakStatement(int lineNumber, const Identifier* ident, int eStart, int eEnd, int startLine, int endLine)
 403     {
 404         BreakNode* result = new (m_globalData) BreakNode(lineNumber, *ident);
 405         setExceptionLocation(result, eStart, eEnd, eEnd);
 406         result->setLoc(startLine, endLine);
 407         return result;
 408     }
 409
 410     StatementNode* createContinueStatement(int lineNumber, int eStart, int eEnd, int startLine, int endLine)
 411     {
 412         ContinueNode* result = new (m_globalData) ContinueNode(m_globalData, lineNumber);
 413         setExceptionLocation(result, eStart, eEnd, eEnd);
 414         result->setLoc(startLine, endLine);
 415         return result;
 416     }
 417
 418     StatementNode* createContinueStatement(int lineNumber, const Identifier* ident, int eStart, int eEnd, int startLine, int endLine)
 419     {
 420         ContinueNode* result = new (m_globalData) ContinueNode(lineNumber, *ident);
 421         setExceptionLocation(result, eStart, eEnd, eEnd);
 422         result->setLoc(startLine, endLine);
 423         return result;
 424     }
 425
 426     StatementNode* createTryStatement(int lineNumber, StatementNode* tryBlock, const Identifier* ident, StatementNode* catchBlock, StatementNode* finallyBlock, int startLine, int endLine)
 427     {
 428         TryNode* result = new (m_globalData) TryNode(lineNumber, tryBlock, *ident, catchBlock, finallyBlock);
 429         if (catchBlock)
 430             usesCatch();
 431         result->setLoc(startLine, endLine);
 432         return result;
 433     }
 434
 435     StatementNode* createSwitchStatement(int lineNumber, ExpressionNode* expr, ClauseListNode* firstClauses, CaseClauseNode* defaultClause, ClauseListNode* secondClauses, int startLine, int endLine)
 436     {
 437         CaseBlockNode* cases = new (m_globalData) CaseBlockNode(firstClauses, defaultClause, secondClauses);
 438         SwitchNode* result = new (m_globalData) SwitchNode(lineNumber, expr, cases);
 439         result->setLoc(startLine, endLine);
 440         return result;
 441     }
 442
 443     StatementNode* createWhileStatement(int lineNumber, ExpressionNode* expr, StatementNode* statement, int startLine, int endLine)
 444     {
 445         WhileNode* result = new (m_globalData) WhileNode(lineNumber, expr, statement);
 446         result->setLoc(startLine, endLine);
 447         return result;
 448     }
 449
 450     StatementNode* createDoWhileStatement(int lineNumber, StatementNode* statement, ExpressionNode* expr, int startLine, int endLine)
 451     {
 452         DoWhileNode* result = new (m_globalData) DoWhileNode(lineNumber, statement, expr);
 453         result->setLoc(startLine, endLine);
 454         return result;
 455     }
 456
 457     StatementNode* createLabelStatement(int lineNumber, const Identifier* ident, StatementNode* statement, int start, int end)
 458     {
 459         LabelNode* result = new (m_globalData) LabelNode(lineNumber, *ident, statement);
 460         setExceptionLocation(result, start, end, end);
 461         return result;
 462     }
 463
 464     StatementNode* createWithStatement(int lineNumber, ExpressionNode* expr, StatementNode* statement, int start, int end, int startLine, int endLine)
 465     {
 466         usesWith();
 467         WithNode* result = new (m_globalData) WithNode(lineNumber, expr, statement, end, end - start);
 468         result->setLoc(startLine, endLine);
 469         return result;
 470     }
 471
 472     StatementNode* createThrowStatement(int lineNumber, ExpressionNode* expr, int start, int end, int startLine, int endLine)
 473     {
 474         ThrowNode* result = new (m_globalData) ThrowNode(lineNumber, expr);
 475         result->setLoc(startLine, endLine);
 476         setExceptionLocation(result, start, end, end);
 477         return result;
 478     }
 479
 480     StatementNode* createDebugger(int lineNumber, int startLine, int endLine)
 481     {
 482         DebuggerStatementNode* result = new (m_globalData) DebuggerStatementNode(lineNumber);
 483         result->setLoc(startLine, endLine);
 484         return result;
 485     }
 486
 487     StatementNode* createConstStatement(int lineNumber, ConstDeclNode* decls, int startLine, int endLine)
 488     {
 489         ConstStatementNode* result = new (m_globalData) ConstStatementNode(lineNumber, decls);
 490         result->setLoc(startLine, endLine);
 491         return result;
 492     }
 493
 494     ConstDeclNode* appendConstDecl(int lineNumber, ConstDeclNode* tail, const Identifier* name, ExpressionNode* initializer)
 495     {
 496         ConstDeclNode* result = new (m_globalData) ConstDeclNode(lineNumber, *name, initializer);
 497         if (tail)
 498             tail->m_next = result;
 499         return result;
 500     }
 501
 502     void appendStatement(JSC::SourceElements* elements, JSC::StatementNode* statement)
 503     {
 504         elements->append(statement);
 505     }
 506
 507     void addVar(const Identifier* ident, int attrs)
 508     {
 509         if (m_globalData->propertyNames->arguments == *ident)
 510             usesArguments();
 511         m_scope.m_varDeclarations->data.append(std::make_pair(ident, attrs));
 512     }
 513
 514     ExpressionNode* combineCommaNodes(int lineNumber, ExpressionNode* list, ExpressionNode* init)
 515     {
 516         if (!list)
 517             return init;
 518         if (list->isCommaNode()) {
 519             static_cast<CommaNode*>(list)->append(init);
 520             return list;
 521         }
 522         return new (m_globalData) CommaNode(lineNumber, list, init);
 523     }
 524
 525     int evalCount() const { return m_evalCount; }
 526
 527     void appendBinaryExpressionInfo(int& operandStackDepth, ExpressionNode* current, int exprStart, int lhs, int rhs, bool hasAssignments)
 528     {
 529         operandStackDepth++;
 530         m_binaryOperandStack.append(std::make_pair(current, BinaryOpInfo(exprStart, lhs, rhs, hasAssignments)));
 531     }
 532
 533     // Logic to handle datastructures used during parsing of binary expressions
 534     void operatorStackPop(int& operatorStackDepth)
 535     {
 536         operatorStackDepth--;
 537         m_binaryOperatorStack.removeLast();
 538     }
 539     bool operatorStackHasHigherPrecedence(int&, int precedence)
 540     {
 541         return precedence <= m_binaryOperatorStack.last().second;
 542     }
 543     const BinaryOperand& getFromOperandStack(int i) { return m_binaryOperandStack[m_binaryOperandStack.size() + i]; }
 544     void shrinkOperandStackBy(int& operandStackDepth, int amount)
 545     {
 546         operandStackDepth -= amount;
 547         ASSERT(operandStackDepth >= 0);
 548         m_binaryOperandStack.resize(m_binaryOperandStack.size() - amount);
 549     }
 550     void appendBinaryOperation(int lineNumber, int& operandStackDepth, int&, const BinaryOperand& lhs, const BinaryOperand& rhs)
 551     {
 552         operandStackDepth++;
 553         m_binaryOperandStack.append(std::make_pair(makeBinaryNode(lineNumber, m_binaryOperatorStack.last().first, lhs, rhs), BinaryOpInfo(lhs.second, rhs.second)));
 554     }
 555     void operatorStackAppend(int& operatorStackDepth, int op, int precedence)
 556     {
 557         operatorStackDepth++;
 558         m_binaryOperatorStack.append(std::make_pair(op, precedence));
 559     }
 560     ExpressionNode* popOperandStack(int&)
 561     {
 562         ExpressionNode* result = m_binaryOperandStack.last().first;
 563         m_binaryOperandStack.removeLast();
 564         return result;
 565     }
 566
 567     void appendUnaryToken(int& tokenStackDepth, int type, int start)
 568     {
 569         tokenStackDepth++;
 570         m_unaryTokenStack.append(std::make_pair(type, start));
 571     }
 572
 573     int unaryTokenStackLastType(int&)
 574     {
 575         return m_unaryTokenStack.last().first;
 576     }
 577
 578     int unaryTokenStackLastStart(int&)
 579     {
 580         return m_unaryTokenStack.last().second;
 581     }
 582
 583     void unaryTokenStackRemoveLast(int& tokenStackDepth)
 584     {
 585         tokenStackDepth--;
 586         m_unaryTokenStack.removeLast();
 587     }
 588
 589     void assignmentStackAppend(int& assignmentStackDepth, ExpressionNode* node, int start, int divot, int assignmentCount, Operator op)
 590     {
 591         assignmentStackDepth++;
 592         m_assignmentInfoStack.append(AssignmentInfo(node, start, divot, assignmentCount, op));
 593     }
 594
 595     ExpressionNode* createAssignment(int lineNumber, int& assignmentStackDepth, ExpressionNode* rhs, int initialAssignmentCount, int currentAssignmentCount, int lastTokenEnd)
 596     {
 597         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);
 598         m_assignmentInfoStack.removeLast();
 599         assignmentStackDepth--;
 600         return result;
 601     }
 602
 603     const Identifier& getName(Property property) const { return property->name(); }
 604     PropertyNode::Type getType(Property property) const { return property->type(); }
 605
 606     bool isResolve(ExpressionNode* expr) const { return expr->isResolveNode(); }
 607
 608 private:
 609     struct Scope {
 610         Scope(JSGlobalData* globalData)
 611             : m_varDeclarations(new (globalData) ParserArenaData<DeclarationStacks::VarStack>)
 612             , m_funcDeclarations(new (globalData) ParserArenaData<DeclarationStacks::FunctionStack>)
 613             , m_features(0)
 614             , m_numConstants(0)
 615         {
 616         }
 617         ParserArenaData<DeclarationStacks::VarStack>* m_varDeclarations;
 618         ParserArenaData<DeclarationStacks::FunctionStack>* m_funcDeclarations;
 619         int m_features;
 620         int m_numConstants;
 621     };
 622
 623     static void setExceptionLocation(ThrowableExpressionData* node, unsigned start, unsigned divot, unsigned end)
 624     {
 625         node->setExceptionSourceCode(divot, divot - start, end - divot);
 626     }
 627
 628     void incConstants() { m_scope.m_numConstants++; }
 629     void usesThis() { m_scope.m_features |= ThisFeature; }
 630     void usesCatch() { m_scope.m_features |= CatchFeature; }
 631     void usesArguments() { m_scope.m_features |= ArgumentsFeature; }
 632     void usesWith() { m_scope.m_features |= WithFeature; }
 633     void usesEval()
 634     {
 635         m_evalCount++;
 636         m_scope.m_features |= EvalFeature;
 637     }
 638     ExpressionNode* createNumber(int lineNumber, double d)
 639     {
 640         return new (m_globalData) NumberNode(lineNumber, d);
 641     }
 642
 643     JSGlobalData* m_globalData;
 644     SourceCode* m_sourceCode;
 645     Scope m_scope;
 646     Vector<BinaryOperand, 10> m_binaryOperandStack;
 647     Vector<AssignmentInfo, 10> m_assignmentInfoStack;
 648     Vector<pair<int, int>, 10> m_binaryOperatorStack;
 649     Vector<pair<int, int>, 10> m_unaryTokenStack;
 650     int m_evalCount;
 651 };
 652
 653 ExpressionNode* ASTBuilder::makeTypeOfNode(int lineNumber, ExpressionNode* expr)
 654 {
 655     if (expr->isResolveNode()) {
 656         ResolveNode* resolve = static_cast<ResolveNode*>(expr);
 657         return new (m_globalData) TypeOfResolveNode(lineNumber, resolve->identifier());
 658     }
 659     return new (m_globalData) TypeOfValueNode(lineNumber, expr);
 660 }
 661
 662 ExpressionNode* ASTBuilder::makeDeleteNode(int lineNumber, ExpressionNode* expr, int start, int divot, int end)
 663 {
 664     if (!expr->isLocation())
 665         return new (m_globalData) DeleteValueNode(lineNumber, expr);
 666     if (expr->isResolveNode()) {
 667         ResolveNode* resolve = static_cast<ResolveNode*>(expr);
 668         return new (m_globalData) DeleteResolveNode(lineNumber, resolve->identifier(), divot, divot - start, end - divot);
 669     }
 670     if (expr->isBracketAccessorNode()) {
 671         BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(expr);
 672         return new (m_globalData) DeleteBracketNode(lineNumber, bracket->base(), bracket->subscript(), divot, divot - start, end - divot);
 673     }
 674     ASSERT(expr->isDotAccessorNode());
 675     DotAccessorNode* dot = static_cast<DotAccessorNode*>(expr);
 676     return new (m_globalData) DeleteDotNode(lineNumber, dot->base(), dot->identifier(), divot, divot - start, end - divot);
 677 }
 678
 679 ExpressionNode* ASTBuilder::makeNegateNode(int lineNumber, ExpressionNode* n)
 680 {
 681     if (n->isNumber()) {
 682         NumberNode* numberNode = static_cast<NumberNode*>(n);
 683         numberNode->setValue(-numberNode->value());
 684         return numberNode;
 685     }
 686
 687     return new (m_globalData) NegateNode(lineNumber, n);
 688 }
 689
 690 ExpressionNode* ASTBuilder::makeBitwiseNotNode(int lineNumber, ExpressionNode* expr)
 691 {
 692     if (expr->isNumber())
 693         return createNumber(lineNumber, ~toInt32(static_cast<NumberNode*>(expr)->value()));
 694     return new (m_globalData) BitwiseNotNode(lineNumber, expr);
 695 }
 696
 697 ExpressionNode* ASTBuilder::makeMultNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
 698 {
 699     expr1 = expr1->stripUnaryPlus();
 700     expr2 = expr2->stripUnaryPlus();
 701
 702     if (expr1->isNumber() && expr2->isNumber())
 703         return createNumber(lineNumber, static_cast<NumberNode*>(expr1)->value() * static_cast<NumberNode*>(expr2)->value());
 704
 705     if (expr1->isNumber() && static_cast<NumberNode*>(expr1)->value() == 1)
 706         return new (m_globalData) UnaryPlusNode(lineNumber, expr2);
 707
 708     if (expr2->isNumber() && static_cast<NumberNode*>(expr2)->value() == 1)
 709         return new (m_globalData) UnaryPlusNode(lineNumber, expr1);
 710
 711     return new (m_globalData) MultNode(lineNumber, expr1, expr2, rightHasAssignments);
 712 }
 713
 714 ExpressionNode* ASTBuilder::makeDivNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
 715 {
 716     expr1 = expr1->stripUnaryPlus();
 717     expr2 = expr2->stripUnaryPlus();
 718
 719     if (expr1->isNumber() && expr2->isNumber())
 720         return createNumber(lineNumber, static_cast<NumberNode*>(expr1)->value() / static_cast<NumberNode*>(expr2)->value());
 721     return new (m_globalData) DivNode(lineNumber, expr1, expr2, rightHasAssignments);
 722 }
 723
 724 ExpressionNode* ASTBuilder::makeModNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
 725 {
 726     expr1 = expr1->stripUnaryPlus();
 727     expr2 = expr2->stripUnaryPlus();
 728
 729     if (expr1->isNumber() && expr2->isNumber())
 730         return createNumber(lineNumber, fmod(static_cast<NumberNode*>(expr1)->value(), static_cast<NumberNode*>(expr2)->value()));
 731     return new (m_globalData) ModNode(lineNumber, expr1, expr2, rightHasAssignments);
 732 }
 733
 734 ExpressionNode* ASTBuilder::makeAddNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
 735 {
 736     if (expr1->isNumber() && expr2->isNumber())
 737         return createNumber(lineNumber, static_cast<NumberNode*>(expr1)->value() + static_cast<NumberNode*>(expr2)->value());
 738     return new (m_globalData) AddNode(lineNumber, expr1, expr2, rightHasAssignments);
 739 }
 740
 741 ExpressionNode* ASTBuilder::makeSubNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
 742 {
 743     expr1 = expr1->stripUnaryPlus();
 744     expr2 = expr2->stripUnaryPlus();
 745
 746     if (expr1->isNumber() && expr2->isNumber())
 747         return createNumber(lineNumber, static_cast<NumberNode*>(expr1)->value() - static_cast<NumberNode*>(expr2)->value());
 748     return new (m_globalData) SubNode(lineNumber, expr1, expr2, rightHasAssignments);
 749 }
 750
 751 ExpressionNode* ASTBuilder::makeLeftShiftNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
 752 {
 753     if (expr1->isNumber() && expr2->isNumber())
 754         return createNumber(lineNumber, toInt32(static_cast<NumberNode*>(expr1)->value()) << (toUInt32(static_cast<NumberNode*>(expr2)->value()) & 0x1f));
 755     return new (m_globalData) LeftShiftNode(lineNumber, expr1, expr2, rightHasAssignments);
 756 }
 757
 758 ExpressionNode* ASTBuilder::makeRightShiftNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
 759 {
 760     if (expr1->isNumber() && expr2->isNumber())
 761         return createNumber(lineNumber, toInt32(static_cast<NumberNode*>(expr1)->value()) >> (toUInt32(static_cast<NumberNode*>(expr2)->value()) & 0x1f));
 762     return new (m_globalData) RightShiftNode(lineNumber, expr1, expr2, rightHasAssignments);
 763 }
 764
 765 ExpressionNode* ASTBuilder::makeURightShiftNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
 766 {
 767     if (expr1->isNumber() && expr2->isNumber())
 768         return createNumber(lineNumber, toUInt32(static_cast<NumberNode*>(expr1)->value()) >> (toUInt32(static_cast<NumberNode*>(expr2)->value()) & 0x1f));
 769     return new (m_globalData) UnsignedRightShiftNode(lineNumber, expr1, expr2, rightHasAssignments);
 770 }
 771
 772 ExpressionNode* ASTBuilder::makeBitOrNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
 773 {
 774     if (expr1->isNumber() && expr2->isNumber())
 775         return createNumber(lineNumber, toInt32(static_cast<NumberNode*>(expr1)->value()) | toInt32(static_cast<NumberNode*>(expr2)->value()));
 776     return new (m_globalData) BitOrNode(lineNumber, expr1, expr2, rightHasAssignments);
 777 }
 778
 779 ExpressionNode* ASTBuilder::makeBitAndNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
 780 {
 781     if (expr1->isNumber() && expr2->isNumber())
 782         return createNumber(lineNumber, toInt32(static_cast<NumberNode*>(expr1)->value()) & toInt32(static_cast<NumberNode*>(expr2)->value()));
 783     return new (m_globalData) BitAndNode(lineNumber, expr1, expr2, rightHasAssignments);
 784 }
 785
 786 ExpressionNode* ASTBuilder::makeBitXOrNode(int lineNumber, ExpressionNode* expr1, ExpressionNode* expr2, bool rightHasAssignments)
 787 {
 788     if (expr1->isNumber() && expr2->isNumber())
 789         return createNumber(lineNumber, toInt32(static_cast<NumberNode*>(expr1)->value()) ^ toInt32(static_cast<NumberNode*>(expr2)->value()));
 790     return new (m_globalData) BitXOrNode(lineNumber, expr1, expr2, rightHasAssignments);
 791 }
 792
 793 ExpressionNode* ASTBuilder::makeFunctionCallNode(int lineNumber, ExpressionNode* func, ArgumentsNode* args, int start, int divot, int end)
 794 {
 795     if (!func->isLocation())
 796         return new (m_globalData) FunctionCallValueNode(lineNumber, func, args, divot, divot - start, end - divot);
 797     if (func->isResolveNode()) {
 798         ResolveNode* resolve = static_cast<ResolveNode*>(func);
 799         const Identifier& identifier = resolve->identifier();
 800         if (identifier == m_globalData->propertyNames->eval) {
 801             usesEval();
 802             return new (m_globalData) EvalFunctionCallNode(lineNumber, args, divot, divot - start, end - divot);
 803         }
 804         return new (m_globalData) FunctionCallResolveNode(lineNumber, identifier, args, divot, divot - start, end - divot);
 805     }
 806     if (func->isBracketAccessorNode()) {
 807         BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(func);
 808         FunctionCallBracketNode* node = new (m_globalData) FunctionCallBracketNode(lineNumber, bracket->base(), bracket->subscript(), args, divot, divot - start, end - divot);
 809         node->setSubexpressionInfo(bracket->divot(), bracket->endOffset());
 810         return node;
 811     }
 812     ASSERT(func->isDotAccessorNode());
 813     DotAccessorNode* dot = static_cast<DotAccessorNode*>(func);
 814     FunctionCallDotNode* node;
 815     if (dot->identifier() == m_globalData->propertyNames->call)
 816         node = new (m_globalData) CallFunctionCallDotNode(lineNumber, dot->base(), dot->identifier(), args, divot, divot - start, end - divot);
 817     else if (dot->identifier() == m_globalData->propertyNames->apply)
 818         node = new (m_globalData) ApplyFunctionCallDotNode(lineNumber, dot->base(), dot->identifier(), args, divot, divot - start, end - divot);
 819     else
 820         node = new (m_globalData) FunctionCallDotNode(lineNumber, dot->base(), dot->identifier(), args, divot, divot - start, end - divot);
 821     node->setSubexpressionInfo(dot->divot(), dot->endOffset());
 822     return node;
 823 }
 824
 825 ExpressionNode* ASTBuilder::makeBinaryNode(int lineNumber, int token, pair<ExpressionNode*, BinaryOpInfo> lhs, pair<ExpressionNode*, BinaryOpInfo> rhs)
 826 {
 827     switch (token) {
 828     case OR:
 829         return new (m_globalData) LogicalOpNode(lineNumber, lhs.first, rhs.first, OpLogicalOr);
 830
 831     case AND:
 832         return new (m_globalData) LogicalOpNode(lineNumber, lhs.first, rhs.first, OpLogicalAnd);
 833
 834     case BITOR:
 835         return makeBitOrNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 836
 837     case BITXOR:
 838         return makeBitXOrNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 839
 840     case BITAND:
 841         return makeBitAndNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 842
 843     case EQEQ:
 844         return new (m_globalData) EqualNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 845
 846     case NE:
 847         return new (m_globalData) NotEqualNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 848
 849     case STREQ:
 850         return new (m_globalData) StrictEqualNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 851
 852     case STRNEQ:
 853         return new (m_globalData) NotStrictEqualNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 854
 855     case LT:
 856         return new (m_globalData) LessNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 857
 858     case GT:
 859         return new (m_globalData) GreaterNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 860
 861     case LE:
 862         return new (m_globalData) LessEqNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 863
 864     case GE:
 865         return new (m_globalData) GreaterEqNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 866
 867     case INSTANCEOF: {
 868         InstanceOfNode* node = new (m_globalData) InstanceOfNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 869         setExceptionLocation(node, lhs.second.start, rhs.second.start, rhs.second.end);
 870         return node;
 871     }
 872
 873     case INTOKEN: {
 874         InNode* node = new (m_globalData) InNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 875         setExceptionLocation(node, lhs.second.start, rhs.second.start, rhs.second.end);
 876         return node;
 877     }
 878
 879     case LSHIFT:
 880         return makeLeftShiftNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 881
 882     case RSHIFT:
 883         return makeRightShiftNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 884
 885     case URSHIFT:
 886         return makeURightShiftNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 887
 888     case PLUS:
 889         return makeAddNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 890
 891     case MINUS:
 892         return makeSubNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 893
 894     case TIMES:
 895         return makeMultNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 896
 897     case DIVIDE:
 898         return makeDivNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 899
 900     case MOD:
 901         return makeModNode(lineNumber, lhs.first, rhs.first, rhs.second.hasAssignment);
 902     }
 903     CRASH();
 904     return 0;
 905 }
 906
 907 ExpressionNode* ASTBuilder::makeAssignNode(int lineNumber, ExpressionNode* loc, Operator op, ExpressionNode* expr, bool locHasAssignments, bool exprHasAssignments, int start, int divot, int end)
 908 {
 909     if (!loc->isLocation())
 910         return new (m_globalData) AssignErrorNode(lineNumber, loc, op, expr, divot, divot - start, end - divot);
 911
 912     if (loc->isResolveNode()) {
 913         ResolveNode* resolve = static_cast<ResolveNode*>(loc);
 914         if (op == OpEqual) {
 915             if (expr->isFuncExprNode())
 916                 static_cast<FuncExprNode*>(expr)->body()->setInferredName(resolve->identifier());
 917             AssignResolveNode* node = new (m_globalData) AssignResolveNode(lineNumber, resolve->identifier(), expr, exprHasAssignments);
 918             setExceptionLocation(node, start, divot, end);
 919             return node;
 920         }
 921         return new (m_globalData) ReadModifyResolveNode(lineNumber, resolve->identifier(), op, expr, exprHasAssignments, divot, divot - start, end - divot);
 922     }
 923     if (loc->isBracketAccessorNode()) {
 924         BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(loc);
 925         if (op == OpEqual)
 926             return new (m_globalData) AssignBracketNode(lineNumber, bracket->base(), bracket->subscript(), expr, locHasAssignments, exprHasAssignments, bracket->divot(), bracket->divot() - start, end - bracket->divot());
 927         ReadModifyBracketNode* node = new (m_globalData) ReadModifyBracketNode(lineNumber, bracket->base(), bracket->subscript(), op, expr, locHasAssignments, exprHasAssignments, divot, divot - start, end - divot);
 928         node->setSubexpressionInfo(bracket->divot(), bracket->endOffset());
 929         return node;
 930     }
 931     ASSERT(loc->isDotAccessorNode());
 932     DotAccessorNode* dot = static_cast<DotAccessorNode*>(loc);
 933     if (op == OpEqual) {
 934         if (expr->isFuncExprNode())
 935             static_cast<FuncExprNode*>(expr)->body()->setInferredName(dot->identifier());
 936         return new (m_globalData) AssignDotNode(lineNumber, dot->base(), dot->identifier(), expr, exprHasAssignments, dot->divot(), dot->divot() - start, end - dot->divot());
 937     }
 938
 939     ReadModifyDotNode* node = new (m_globalData) ReadModifyDotNode(lineNumber, dot->base(), dot->identifier(), op, expr, exprHasAssignments, divot, divot - start, end - divot);
 940     node->setSubexpressionInfo(dot->divot(), dot->endOffset());
 941     return node;
 942 }
 943
 944 ExpressionNode* ASTBuilder::makePrefixNode(int lineNumber, ExpressionNode* expr, Operator op, int start, int divot, int end)
 945 {
 946     if (!expr->isLocation())
 947         return new (m_globalData) PrefixErrorNode(lineNumber, expr, op, divot, divot - start, end - divot);
 948
 949     if (expr->isResolveNode()) {
 950         ResolveNode* resolve = static_cast<ResolveNode*>(expr);
 951         return new (m_globalData) PrefixResolveNode(lineNumber, resolve->identifier(), op, divot, divot - start, end - divot);
 952     }
 953     if (expr->isBracketAccessorNode()) {
 954         BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(expr);
 955         PrefixBracketNode* node = new (m_globalData) PrefixBracketNode(lineNumber, bracket->base(), bracket->subscript(), op, divot, divot - start, end - divot);
 956         node->setSubexpressionInfo(bracket->divot(), bracket->startOffset());
 957         return node;
 958     }
 959     ASSERT(expr->isDotAccessorNode());
 960     DotAccessorNode* dot = static_cast<DotAccessorNode*>(expr);
 961     PrefixDotNode* node = new (m_globalData) PrefixDotNode(lineNumber, dot->base(), dot->identifier(), op, divot, divot - start, end - divot);
 962     node->setSubexpressionInfo(dot->divot(), dot->startOffset());
 963     return node;
 964 }
 965
 966 ExpressionNode* ASTBuilder::makePostfixNode(int lineNumber, ExpressionNode* expr, Operator op, int start, int divot, int end)
 967 {
 968     if (!expr->isLocation())
 969         return new (m_globalData) PostfixErrorNode(lineNumber, expr, op, divot, divot - start, end - divot);
 970
 971     if (expr->isResolveNode()) {
 972         ResolveNode* resolve = static_cast<ResolveNode*>(expr);
 973         return new (m_globalData) PostfixResolveNode(lineNumber, resolve->identifier(), op, divot, divot - start, end - divot);
 974     }
 975     if (expr->isBracketAccessorNode()) {
 976         BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(expr);
 977         PostfixBracketNode* node = new (m_globalData) PostfixBracketNode(lineNumber, bracket->base(), bracket->subscript(), op, divot, divot - start, end - divot);
 978         node->setSubexpressionInfo(bracket->divot(), bracket->endOffset());
 979         return node;
 980
 981     }
 982     ASSERT(expr->isDotAccessorNode());
 983     DotAccessorNode* dot = static_cast<DotAccessorNode*>(expr);
 984     PostfixDotNode* node = new (m_globalData) PostfixDotNode(lineNumber, dot->base(), dot->identifier(), op, divot, divot - start, end - divot);
 985     node->setSubexpressionInfo(dot->divot(), dot->endOffset());
 986     return node;
 987 }
 988
 989 }
 990
 991 #endif