diff -r 000000000000 -r 6474c204b198 js/src/frontend/ParseNode.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/js/src/frontend/ParseNode.h Wed Dec 31 06:09:35 2014 +0100 @@ -0,0 +1,1508 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * vim: set ts=8 sts=4 et sw=4 tw=99: + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef frontend_ParseNode_h +#define frontend_ParseNode_h + +#include "mozilla/Attributes.h" + +#include "frontend/TokenStream.h" + +namespace js { +namespace frontend { + +template +struct ParseContext; + +class FullParseHandler; +class FunctionBox; +class ObjectBox; + +/* + * Indicates a location in the stack that an upvar value can be retrieved from + * as a two tuple of (level, slot). + * + * Some existing client code uses the level value as a delta, or level "skip" + * quantity. We could probably document that through use of more types at some + * point in the future. + */ +class UpvarCookie +{ + uint32_t level_ : SCOPECOORD_HOPS_BITS; + uint32_t slot_ : SCOPECOORD_SLOT_BITS; + + void checkInvariants() { + static_assert(sizeof(UpvarCookie) == sizeof(uint32_t), + "Not necessary for correctness, but good for ParseNode memory use"); + } + + public: + // Steal one value to represent the sentinel value for UpvarCookie. + static const uint32_t FREE_LEVEL = SCOPECOORD_HOPS_LIMIT - 1; + bool isFree() const { return level_ == FREE_LEVEL; } + + uint32_t level() const { JS_ASSERT(!isFree()); return level_; } + uint32_t slot() const { JS_ASSERT(!isFree()); return slot_; } + + // This fails and issues an error message if newLevel or newSlot are too large. + bool set(TokenStream &ts, unsigned newLevel, uint32_t newSlot) { + if (newLevel >= FREE_LEVEL) + return ts.reportError(JSMSG_TOO_DEEP, js_function_str); + + if (newSlot >= SCOPECOORD_SLOT_LIMIT) + return ts.reportError(JSMSG_TOO_MANY_LOCALS); + + level_ = newLevel; + slot_ = newSlot; + return true; + } + + void makeFree() { + level_ = FREE_LEVEL; + slot_ = 0; // value doesn't matter, won't be used + JS_ASSERT(isFree()); + } +}; + +#define FOR_EACH_PARSE_NODE_KIND(F) \ + F(NOP) \ + F(SEMI) \ + F(COMMA) \ + F(CONDITIONAL) \ + F(COLON) \ + F(POS) \ + F(NEG) \ + F(PREINCREMENT) \ + F(POSTINCREMENT) \ + F(PREDECREMENT) \ + F(POSTDECREMENT) \ + F(DOT) \ + F(ELEM) \ + F(ARRAY) \ + F(ELISION) \ + F(STATEMENTLIST) \ + F(LABEL) \ + F(OBJECT) \ + F(CALL) \ + F(NAME) \ + F(NUMBER) \ + F(STRING) \ + F(REGEXP) \ + F(TRUE) \ + F(FALSE) \ + F(NULL) \ + F(THIS) \ + F(FUNCTION) \ + F(IF) \ + F(ELSE) \ + F(SWITCH) \ + F(CASE) \ + F(DEFAULT) \ + F(WHILE) \ + F(DOWHILE) \ + F(FOR) \ + F(BREAK) \ + F(CONTINUE) \ + F(VAR) \ + F(CONST) \ + F(WITH) \ + F(RETURN) \ + F(NEW) \ + F(DELETE) \ + F(TRY) \ + F(CATCH) \ + F(CATCHLIST) \ + F(FINALLY) \ + F(THROW) \ + F(DEBUGGER) \ + F(YIELD) \ + F(YIELD_STAR) \ + F(GENEXP) \ + F(ARRAYCOMP) \ + F(ARRAYPUSH) \ + F(LEXICALSCOPE) \ + F(LET) \ + F(IMPORT) \ + F(IMPORT_SPEC_LIST) \ + F(IMPORT_SPEC) \ + F(EXPORT) \ + F(EXPORT_FROM) \ + F(EXPORT_SPEC_LIST) \ + F(EXPORT_SPEC) \ + F(EXPORT_BATCH_SPEC) \ + F(SEQ) \ + F(FORIN) \ + F(FOROF) \ + F(FORHEAD) \ + F(ARGSBODY) \ + F(SPREAD) \ + \ + /* Unary operators. */ \ + F(TYPEOF) \ + F(VOID) \ + F(NOT) \ + F(BITNOT) \ + \ + /* \ + * Binary operators. \ + * These must be in the same order as TOK_OR and friends in TokenStream.h. \ + */ \ + F(OR) \ + F(AND) \ + F(BITOR) \ + F(BITXOR) \ + F(BITAND) \ + F(STRICTEQ) \ + F(EQ) \ + F(STRICTNE) \ + F(NE) \ + F(LT) \ + F(LE) \ + F(GT) \ + F(GE) \ + F(INSTANCEOF) \ + F(IN) \ + F(LSH) \ + F(RSH) \ + F(URSH) \ + F(ADD) \ + F(SUB) \ + F(STAR) \ + F(DIV) \ + F(MOD) \ + \ + /* Assignment operators (= += -= etc.). */ \ + /* ParseNode::isAssignment assumes all these are consecutive. */ \ + F(ASSIGN) \ + F(ADDASSIGN) \ + F(SUBASSIGN) \ + F(BITORASSIGN) \ + F(BITXORASSIGN) \ + F(BITANDASSIGN) \ + F(LSHASSIGN) \ + F(RSHASSIGN) \ + F(URSHASSIGN) \ + F(MULASSIGN) \ + F(DIVASSIGN) \ + F(MODASSIGN) + +/* + * Parsing builds a tree of nodes that directs code generation. This tree is + * not a concrete syntax tree in all respects (for example, || and && are left + * associative, but (A && B && C) translates into the right-associated tree + * > so that code generation can emit a left-associative branch + * around when A is false). Nodes are labeled by kind, with a + * secondary JSOp label when needed. + * + * The long comment after this enum block describes the kinds in detail. + */ +enum ParseNodeKind +{ +#define EMIT_ENUM(name) PNK_##name, + FOR_EACH_PARSE_NODE_KIND(EMIT_ENUM) +#undef EMIT_ENUM + PNK_LIMIT, /* domain size */ + PNK_BINOP_FIRST = PNK_OR, + PNK_BINOP_LAST = PNK_MOD, + PNK_ASSIGNMENT_START = PNK_ASSIGN, + PNK_ASSIGNMENT_LAST = PNK_MODASSIGN +}; + +/* + * Label Variant Members + * ----- ------- ------- + * + * PNK_FUNCTION name pn_funbox: ptr to js::FunctionBox holding function + * object containing arg and var properties. We + * create the function object at parse (not emit) + * time to specialize arg and var bytecodes early. + * pn_body: PNK_ARGSBODY, ordinarily; + * PNK_LEXICALSCOPE for implicit function in genexpr + * pn_cookie: static level and var index for function + * pn_dflags: PND_* definition/use flags (see below) + * pn_blockid: block id number + * PNK_ARGSBODY list list of formal parameters followed by: + * PNK_STATEMENTLIST node for function body + * statements, + * PNK_RETURN for expression closure, or + * PNK_SEQ for expression closure with + * destructured formal parameters + * pn_count: 1 + number of formal parameters + * pn_tree: PNK_ARGSBODY or PNK_STATEMENTLIST node + * PNK_SPREAD unary pn_kid: expression being spread + * + * + * PNK_STATEMENTLIST list pn_head: list of pn_count statements + * PNK_IF ternary pn_kid1: cond, pn_kid2: then, pn_kid3: else or null. + * In body of a comprehension or desugared generator + * expression, pn_kid2 is PNK_YIELD, PNK_ARRAYPUSH, + * or (if the push was optimized away) empty + * PNK_STATEMENTLIST. + * PNK_SWITCH binary pn_left: discriminant + * pn_right: list of PNK_CASE nodes, with at most one + * PNK_DEFAULT node, or if there are let bindings + * in the top level of the switch body's cases, a + * PNK_LEXICALSCOPE node that contains the list of + * PNK_CASE nodes. + * PNK_CASE, binary pn_left: case expr + * pn_right: PNK_STATEMENTLIST node for this case's + * statements + * PNK_DEFAULT binary pn_left: null + * pn_right: PNK_STATEMENTLIST node for this default's + * statements + * pn_val: constant value if lookup or table switch + * PNK_WHILE binary pn_left: cond, pn_right: body + * PNK_DOWHILE binary pn_left: body, pn_right: cond + * PNK_FOR binary pn_left: either PNK_FORIN (for-in statement), + * PNK_FOROF (for-of) or PNK_FORHEAD (for(;;)) + * pn_right: body + * PNK_FORIN ternary pn_kid1: PNK_VAR to left of 'in', or nullptr + * its pn_xflags may have PNX_POPVAR + * bit set + * pn_kid2: PNK_NAME or destructuring expr + * to left of 'in'; if pn_kid1, then this + * is a clone of pn_kid1->pn_head + * pn_kid3: object expr to right of 'in' + * PNK_FOROF ternary pn_kid1: PNK_VAR to left of 'of', or nullptr + * its pn_xflags may have PNX_POPVAR + * bit set + * pn_kid2: PNK_NAME or destructuring expr + * to left of 'of'; if pn_kid1, then this + * is a clone of pn_kid1->pn_head + * pn_kid3: expr to right of 'of' + * PNK_FORHEAD ternary pn_kid1: init expr before first ';' or nullptr + * pn_kid2: cond expr before second ';' or nullptr + * pn_kid3: update expr after second ';' or nullptr + * PNK_THROW unary pn_op: JSOP_THROW, pn_kid: exception + * PNK_TRY ternary pn_kid1: try block + * pn_kid2: null or PNK_CATCHLIST list of + * PNK_LEXICALSCOPE nodes, each with pn_expr pointing + * to a PNK_CATCH node + * pn_kid3: null or finally block + * PNK_CATCH ternary pn_kid1: PNK_NAME, PNK_ARRAY, or PNK_OBJECT catch var node + * (PNK_ARRAY or PNK_OBJECT if destructuring) + * pn_kid2: null or the catch guard expression + * pn_kid3: catch block statements + * PNK_BREAK name pn_atom: label or null + * PNK_CONTINUE name pn_atom: label or null + * PNK_WITH binary-obj pn_left: head expr; pn_right: body; pn_binary_obj: StaticWithObject + * PNK_VAR, list pn_head: list of PNK_NAME or PNK_ASSIGN nodes + * PNK_CONST each name node has either + * pn_used: false + * pn_atom: variable name + * pn_expr: initializer or null + * or + * pn_used: true + * pn_atom: variable name + * pn_lexdef: def node + * each assignment node has + * pn_left: PNK_NAME with pn_used true and + * pn_lexdef (NOT pn_expr) set + * pn_right: initializer + * PNK_RETURN unary pn_kid: return expr or null + * PNK_SEMI unary pn_kid: expr or null statement + * pn_prologue: true if Directive Prologue member + * in original source, not introduced via + * constant folding or other tree rewriting + * PNK_LABEL name pn_atom: label, pn_expr: labeled statement + * + * + * All left-associated binary trees of the same type are optimized into lists + * to avoid recursion when processing expression chains. + * PNK_COMMA list pn_head: list of pn_count comma-separated exprs + * PNK_ASSIGN binary pn_left: lvalue, pn_right: rvalue + * PNK_ADDASSIGN, binary pn_left: lvalue, pn_right: rvalue + * PNK_SUBASSIGN, pn_op: JSOP_ADD for +=, etc. + * PNK_BITORASSIGN, + * PNK_BITXORASSIGN, + * PNK_BITANDASSIGN, + * PNK_LSHASSIGN, + * PNK_RSHASSIGN, + * PNK_URSHASSIGN, + * PNK_MULASSIGN, + * PNK_DIVASSIGN, + * PNK_MODASSIGN + * PNK_CONDITIONAL ternary (cond ? trueExpr : falseExpr) + * pn_kid1: cond, pn_kid2: then, pn_kid3: else + * PNK_OR binary pn_left: first in || chain, pn_right: rest of chain + * PNK_AND binary pn_left: first in && chain, pn_right: rest of chain + * PNK_BITOR binary pn_left: left-assoc | expr, pn_right: ^ expr + * PNK_BITXOR binary pn_left: left-assoc ^ expr, pn_right: & expr + * PNK_BITAND binary pn_left: left-assoc & expr, pn_right: EQ expr + * + * PNK_EQ, binary pn_left: left-assoc EQ expr, pn_right: REL expr + * PNK_NE, + * PNK_STRICTEQ, + * PNK_STRICTNE + * PNK_LT, binary pn_left: left-assoc REL expr, pn_right: SH expr + * PNK_LE, + * PNK_GT, + * PNK_GE + * PNK_LSH, binary pn_left: left-assoc SH expr, pn_right: ADD expr + * PNK_RSH, + * PNK_URSH + * PNK_ADD binary pn_left: left-assoc ADD expr, pn_right: MUL expr + * pn_xflags: if a left-associated binary PNK_ADD + * tree has been flattened into a list (see above + * under ), pn_xflags will contain + * PNX_STRCAT if at least one list element is a + * string literal (PNK_STRING); if such a list has + * any non-string, non-number term, pn_xflags will + * contain PNX_CANTFOLD. + * PNK_SUB binary pn_left: left-assoc SH expr, pn_right: ADD expr + * PNK_STAR, binary pn_left: left-assoc MUL expr, pn_right: UNARY expr + * PNK_DIV, pn_op: JSOP_MUL, JSOP_DIV, JSOP_MOD + * PNK_MOD + * PNK_POS, unary pn_kid: UNARY expr + * PNK_NEG + * PNK_TYPEOF, unary pn_kid: UNARY expr + * PNK_VOID, + * PNK_NOT, + * PNK_BITNOT + * PNK_PREINCREMENT, unary pn_kid: MEMBER expr + * PNK_POSTINCREMENT, + * PNK_PREDECREMENT, + * PNK_POSTDECREMENT + * PNK_NEW list pn_head: list of ctor, arg1, arg2, ... argN + * pn_count: 1 + N (where N is number of args) + * ctor is a MEMBER expr + * PNK_DELETE unary pn_kid: MEMBER expr + * PNK_DOT name pn_expr: MEMBER expr to left of . + * pn_atom: name to right of . + * PNK_ELEM binary pn_left: MEMBER expr to left of [ + * pn_right: expr between [ and ] + * PNK_CALL list pn_head: list of call, arg1, arg2, ... argN + * pn_count: 1 + N (where N is number of args) + * call is a MEMBER expr naming a callable object + * PNK_GENEXP list Exactly like PNK_CALL, used for the implicit call + * in the desugaring of a generator-expression. + * PNK_ARRAY list pn_head: list of pn_count array element exprs + * [,,] holes are represented by PNK_ELISION nodes + * pn_xflags: PN_ENDCOMMA if extra comma at end + * PNK_OBJECT list pn_head: list of pn_count binary PNK_COLON nodes + * PNK_COLON binary key-value pair in object initializer or + * destructuring lhs + * pn_left: property id, pn_right: value + * var {x} = object destructuring shorthand shares + * PN_NAME node for x on left and right of PNK_COLON + * node in PNK_OBJECT's list, has PNX_DESTRUCT flag + * PNK_NAME, name pn_atom: name, string, or object atom + * PNK_STRING pn_op: JSOP_NAME, JSOP_STRING, or JSOP_OBJECT + * If JSOP_NAME, pn_op may be JSOP_*ARG or JSOP_*VAR + * with pn_cookie telling (staticLevel, slot) (see + * jsscript.h's UPVAR macros) and pn_dflags telling + * const-ness and static analysis results + * PNK_REGEXP nullary pn_objbox: RegExp model object + * PNK_NAME name If pn_used, PNK_NAME uses the lexdef member instead + * of the expr member it overlays + * PNK_NUMBER dval pn_dval: double value of numeric literal + * PNK_TRUE, nullary pn_op: JSOp bytecode + * PNK_FALSE, + * PNK_NULL, + * PNK_THIS + * + * PNK_LEXICALSCOPE name pn_objbox: block object in ObjectBox holder + * pn_expr: block body + * PNK_ARRAYCOMP list pn_count: 1 + * pn_head: list of 1 element, which is block + * enclosing for loop(s) and optionally + * if-guarded PNK_ARRAYPUSH + * PNK_ARRAYPUSH unary pn_op: JSOP_ARRAYCOMP + * pn_kid: array comprehension expression + * PNK_NOP nullary + */ +enum ParseNodeArity +{ + PN_NULLARY, /* 0 kids, only pn_atom/pn_dval/etc. */ + PN_UNARY, /* one kid, plus a couple of scalars */ + PN_BINARY, /* two kids, plus a couple of scalars */ + PN_BINARY_OBJ, /* two kids, plus an objbox */ + PN_TERNARY, /* three kids */ + PN_CODE, /* module or function definition node */ + PN_LIST, /* generic singly linked list */ + PN_NAME /* name use or definition node */ +}; + +struct Definition; + +class LabeledStatement; +class LoopControlStatement; +class BreakStatement; +class ContinueStatement; +class ConditionalExpression; +class PropertyAccess; + +class ParseNode +{ + uint32_t pn_type : 16, /* PNK_* type */ + pn_op : 8, /* see JSOp enum and jsopcode.tbl */ + pn_arity : 5, /* see ParseNodeArity enum */ + pn_parens : 1, /* this expr was enclosed in parens */ + pn_used : 1, /* name node is on a use-chain */ + pn_defn : 1; /* this node is a Definition */ + + ParseNode(const ParseNode &other) MOZ_DELETE; + void operator=(const ParseNode &other) MOZ_DELETE; + + public: + ParseNode(ParseNodeKind kind, JSOp op, ParseNodeArity arity) + : pn_type(kind), pn_op(op), pn_arity(arity), pn_parens(0), pn_used(0), pn_defn(0), + pn_pos(0, 0), pn_offset(0), pn_next(nullptr), pn_link(nullptr) + { + JS_ASSERT(kind < PNK_LIMIT); + memset(&pn_u, 0, sizeof pn_u); + } + + ParseNode(ParseNodeKind kind, JSOp op, ParseNodeArity arity, const TokenPos &pos) + : pn_type(kind), pn_op(op), pn_arity(arity), pn_parens(0), pn_used(0), pn_defn(0), + pn_pos(pos), pn_offset(0), pn_next(nullptr), pn_link(nullptr) + { + JS_ASSERT(kind < PNK_LIMIT); + memset(&pn_u, 0, sizeof pn_u); + } + + JSOp getOp() const { return JSOp(pn_op); } + void setOp(JSOp op) { pn_op = op; } + bool isOp(JSOp op) const { return getOp() == op; } + + ParseNodeKind getKind() const { + JS_ASSERT(pn_type < PNK_LIMIT); + return ParseNodeKind(pn_type); + } + void setKind(ParseNodeKind kind) { + JS_ASSERT(kind < PNK_LIMIT); + pn_type = kind; + } + bool isKind(ParseNodeKind kind) const { return getKind() == kind; } + + ParseNodeArity getArity() const { return ParseNodeArity(pn_arity); } + bool isArity(ParseNodeArity a) const { return getArity() == a; } + void setArity(ParseNodeArity a) { pn_arity = a; } + + bool isAssignment() const { + ParseNodeKind kind = getKind(); + return PNK_ASSIGNMENT_START <= kind && kind <= PNK_ASSIGNMENT_LAST; + } + + /* Boolean attributes. */ + bool isInParens() const { return pn_parens; } + void setInParens(bool enabled) { pn_parens = enabled; } + bool isUsed() const { return pn_used; } + void setUsed(bool enabled) { pn_used = enabled; } + bool isDefn() const { return pn_defn; } + void setDefn(bool enabled) { pn_defn = enabled; } + + static const unsigned NumDefinitionFlagBits = 10; + static const unsigned NumListFlagBits = 10; + static const unsigned NumBlockIdBits = 22; + static_assert(NumDefinitionFlagBits == NumListFlagBits, + "Assumed below to achieve consistent blockid offset"); + static_assert(NumDefinitionFlagBits + NumBlockIdBits <= 32, + "This is supposed to fit in a single uint32_t"); + + TokenPos pn_pos; /* two 16-bit pairs here, for 64 bits */ + int32_t pn_offset; /* first generated bytecode offset */ + ParseNode *pn_next; /* intrinsic link in parent PN_LIST */ + ParseNode *pn_link; /* def/use link (alignment freebie) */ + + union { + struct { /* list of next-linked nodes */ + ParseNode *head; /* first node in list */ + ParseNode **tail; /* ptr to ptr to last node in list */ + uint32_t count; /* number of nodes in list */ + uint32_t xflags:NumListFlagBits, /* see PNX_* below */ + blockid:NumBlockIdBits; /* see name variant below */ + } list; + struct { /* ternary: if, for(;;), ?: */ + ParseNode *kid1; /* condition, discriminant, etc. */ + ParseNode *kid2; /* then-part, case list, etc. */ + ParseNode *kid3; /* else-part, default case, etc. */ + } ternary; + struct { /* two kids if binary */ + ParseNode *left; + ParseNode *right; + union { + unsigned iflags; /* JSITER_* flags for PNK_FOR node */ + ObjectBox *objbox; /* Only for PN_BINARY_OBJ */ + }; + } binary; + struct { /* one kid if unary */ + ParseNode *kid; + bool prologue; /* directive prologue member (as + pn_prologue) */ + } unary; + struct { /* name, labeled statement, etc. */ + union { + JSAtom *atom; /* lexical name or label atom */ + ObjectBox *objbox; /* block or regexp object */ + FunctionBox *funbox; /* function object */ + }; + union { + ParseNode *expr; /* module or function body, var + initializer, argument default, or + base object of PNK_DOT */ + Definition *lexdef; /* lexical definition for this use */ + }; + UpvarCookie cookie; /* upvar cookie with absolute frame + level (not relative skip), possibly + in current frame */ + uint32_t dflags:NumDefinitionFlagBits, /* see PND_* below */ + blockid:NumBlockIdBits; /* block number, for subset dominance + computation */ + } name; + struct { + double value; /* aligned numeric literal value */ + DecimalPoint decimalPoint; /* Whether the number has a decimal point */ + } number; + class { + friend class LoopControlStatement; + PropertyName *label; /* target of break/continue statement */ + } loopControl; + } pn_u; + +#define pn_modulebox pn_u.name.modulebox +#define pn_funbox pn_u.name.funbox +#define pn_body pn_u.name.expr +#define pn_cookie pn_u.name.cookie +#define pn_dflags pn_u.name.dflags +#define pn_blockid pn_u.name.blockid +#define pn_index pn_u.name.blockid /* reuse as object table index */ +#define pn_head pn_u.list.head +#define pn_tail pn_u.list.tail +#define pn_count pn_u.list.count +#define pn_xflags pn_u.list.xflags +#define pn_kid1 pn_u.ternary.kid1 +#define pn_kid2 pn_u.ternary.kid2 +#define pn_kid3 pn_u.ternary.kid3 +#define pn_left pn_u.binary.left +#define pn_right pn_u.binary.right +#define pn_pval pn_u.binary.pval +#define pn_iflags pn_u.binary.iflags +#define pn_binary_obj pn_u.binary.objbox +#define pn_kid pn_u.unary.kid +#define pn_prologue pn_u.unary.prologue +#define pn_atom pn_u.name.atom +#define pn_objbox pn_u.name.objbox +#define pn_expr pn_u.name.expr +#define pn_lexdef pn_u.name.lexdef +#define pn_dval pn_u.number.value + + protected: + void init(TokenKind type, JSOp op, ParseNodeArity arity) { + pn_type = type; + pn_op = op; + pn_arity = arity; + pn_parens = false; + JS_ASSERT(!pn_used); + JS_ASSERT(!pn_defn); + pn_next = pn_link = nullptr; + } + + static ParseNode *create(ParseNodeKind kind, ParseNodeArity arity, FullParseHandler *handler); + + public: + /* + * Append right to left, forming a list node. |left| must have the given + * kind and op, and op must be left-associative. + */ + static ParseNode * + append(ParseNodeKind tt, JSOp op, ParseNode *left, ParseNode *right, FullParseHandler *handler); + + /* + * Either append right to left, if left meets the conditions necessary to + * append (see append), or form a binary node whose children are right and + * left. + */ + static ParseNode * + newBinaryOrAppend(ParseNodeKind kind, JSOp op, ParseNode *left, ParseNode *right, + FullParseHandler *handler, ParseContext *pc, + bool foldConstants); + + inline PropertyName *name() const; + inline JSAtom *atom() const; + + /* + * The pn_expr and lexdef members are arms of an unsafe union. Unless you + * know exactly what you're doing, use only the following methods to access + * them. For less overhead and assertions for protection, use pn->expr() + * and pn->lexdef(). Otherwise, use pn->maybeExpr() and pn->maybeLexDef(). + */ + ParseNode *expr() const { + JS_ASSERT(!pn_used); + JS_ASSERT(pn_arity == PN_NAME || pn_arity == PN_CODE); + return pn_expr; + } + + Definition *lexdef() const { + JS_ASSERT(pn_used || isDeoptimized()); + JS_ASSERT(pn_arity == PN_NAME); + return pn_lexdef; + } + + ParseNode *maybeExpr() { return pn_used ? nullptr : expr(); } + Definition *maybeLexDef() { return pn_used ? lexdef() : nullptr; } + + Definition *resolve(); + +/* PN_CODE and PN_NAME pn_dflags bits. */ +#define PND_LET 0x01 /* let (block-scoped) binding */ +#define PND_CONST 0x02 /* const binding (orthogonal to let) */ +#define PND_ASSIGNED 0x04 /* set if ever LHS of assignment */ +#define PND_PLACEHOLDER 0x08 /* placeholder definition for lexdep */ +#define PND_BOUND 0x10 /* bound to a stack or global slot */ +#define PND_DEOPTIMIZED 0x20 /* former pn_used name node, pn_lexdef + still valid, but this use no longer + optimizable via an upvar opcode */ +#define PND_CLOSED 0x40 /* variable is closed over */ +#define PND_DEFAULT 0x80 /* definition is an arg with a default */ +#define PND_IMPLICITARGUMENTS 0x100 /* the definition is a placeholder for + 'arguments' that has been converted + into a definition after the function + body has been parsed. */ +#define PND_EMITTEDFUNCTION 0x200 /* hoisted function that was emitted */ + + static_assert(PND_EMITTEDFUNCTION < (1 << NumDefinitionFlagBits), "Not enough bits"); + +/* Flags to propagate from uses to definition. */ +#define PND_USE2DEF_FLAGS (PND_ASSIGNED | PND_CLOSED) + +/* PN_LIST pn_xflags bits. */ +#define PNX_POPVAR 0x01 /* PNK_VAR or PNK_CONST last result + needs popping */ +#define PNX_GROUPINIT 0x02 /* var [a, b] = [c, d]; unit list */ +#define PNX_FUNCDEFS 0x04 /* contains top-level function statements */ +#define PNX_SETCALL 0x08 /* call expression in lvalue context */ +#define PNX_DESTRUCT 0x10 /* destructuring special cases: + 1. shorthand syntax used, at present + object destructuring ({x,y}) only; + 2. code evaluating destructuring + arguments occurs before function + body */ +#define PNX_SPECIALARRAYINIT 0x20 /* one or more of + 1. array initialiser has holes + 2. array initializer has spread node */ +#define PNX_NONCONST 0x40 /* initialiser has non-constants */ + + static_assert(PNX_NONCONST < (1 << NumListFlagBits), "Not enough bits"); + + unsigned frameLevel() const { + JS_ASSERT(pn_arity == PN_CODE || pn_arity == PN_NAME); + return pn_cookie.level(); + } + + uint32_t frameSlot() const { + JS_ASSERT(pn_arity == PN_CODE || pn_arity == PN_NAME); + return pn_cookie.slot(); + } + + bool functionIsHoisted() const { + JS_ASSERT(pn_arity == PN_CODE && getKind() == PNK_FUNCTION); + JS_ASSERT(isOp(JSOP_LAMBDA) || // lambda, genexpr + isOp(JSOP_LAMBDA_ARROW) || // arrow function + isOp(JSOP_DEFFUN) || // non-body-level function statement + isOp(JSOP_NOP) || // body-level function stmt in global code + isOp(JSOP_GETLOCAL) || // body-level function stmt in function code + isOp(JSOP_GETARG)); // body-level function redeclaring formal + return !isOp(JSOP_LAMBDA) && !isOp(JSOP_LAMBDA_ARROW) && !isOp(JSOP_DEFFUN); + } + + /* + * True if this statement node could be a member of a Directive Prologue: an + * expression statement consisting of a single string literal. + * + * This considers only the node and its children, not its context. After + * parsing, check the node's pn_prologue flag to see if it is indeed part of + * a directive prologue. + * + * Note that a Directive Prologue can contain statements that cannot + * themselves be directives (string literals that include escape sequences + * or escaped newlines, say). This member function returns true for such + * nodes; we use it to determine the extent of the prologue. + */ + JSAtom *isStringExprStatement() const { + if (getKind() == PNK_SEMI) { + JS_ASSERT(pn_arity == PN_UNARY); + ParseNode *kid = pn_kid; + if (kid && kid->getKind() == PNK_STRING && !kid->pn_parens) + return kid->pn_atom; + } + return nullptr; + } + + inline bool test(unsigned flag) const; + + bool isLet() const { return test(PND_LET); } + bool isConst() const { return test(PND_CONST); } + bool isPlaceholder() const { return test(PND_PLACEHOLDER); } + bool isDeoptimized() const { return test(PND_DEOPTIMIZED); } + bool isAssigned() const { return test(PND_ASSIGNED); } + bool isClosed() const { return test(PND_CLOSED); } + bool isBound() const { return test(PND_BOUND); } + bool isImplicitArguments() const { return test(PND_IMPLICITARGUMENTS); } + + /* True if pn is a parsenode representing a literal constant. */ + bool isLiteral() const { + return isKind(PNK_NUMBER) || + isKind(PNK_STRING) || + isKind(PNK_TRUE) || + isKind(PNK_FALSE) || + isKind(PNK_NULL); + } + + /* Return true if this node appears in a Directive Prologue. */ + bool isDirectivePrologueMember() const { return pn_prologue; } + +#ifdef JS_HAS_GENERATOR_EXPRS + ParseNode *generatorExpr() const { + JS_ASSERT(isKind(PNK_GENEXP)); + ParseNode *callee = this->pn_head; + ParseNode *body = callee->pn_body; + JS_ASSERT(body->isKind(PNK_LEXICALSCOPE)); + return body->pn_expr; + } +#endif + + inline void markAsAssigned(); + + /* + * Compute a pointer to the last element in a singly-linked list. NB: list + * must be non-empty for correct PN_LAST usage -- this is asserted! + */ + ParseNode *last() const { + JS_ASSERT(pn_arity == PN_LIST); + JS_ASSERT(pn_count != 0); + return (ParseNode *)(uintptr_t(pn_tail) - offsetof(ParseNode, pn_next)); + } + + void initNumber(double value, DecimalPoint decimalPoint) { + JS_ASSERT(pn_arity == PN_NULLARY); + JS_ASSERT(getKind() == PNK_NUMBER); + pn_u.number.value = value; + pn_u.number.decimalPoint = decimalPoint; + } + + void makeEmpty() { + JS_ASSERT(pn_arity == PN_LIST); + pn_head = nullptr; + pn_tail = &pn_head; + pn_count = 0; + pn_xflags = 0; + pn_blockid = 0; + } + + void initList(ParseNode *pn) { + JS_ASSERT(pn_arity == PN_LIST); + if (pn->pn_pos.begin < pn_pos.begin) + pn_pos.begin = pn->pn_pos.begin; + pn_pos.end = pn->pn_pos.end; + pn_head = pn; + pn_tail = &pn->pn_next; + pn_count = 1; + pn_xflags = 0; + pn_blockid = 0; + } + + void append(ParseNode *pn) { + JS_ASSERT(pn_arity == PN_LIST); + JS_ASSERT(pn->pn_pos.begin >= pn_pos.begin); + pn_pos.end = pn->pn_pos.end; + *pn_tail = pn; + pn_tail = &pn->pn_next; + pn_count++; + } + + void checkListConsistency() +#ifndef DEBUG + {} +#endif + ; + + bool getConstantValue(ExclusiveContext *cx, bool strictChecks, MutableHandleValue vp); + inline bool isConstant(); + + template + inline bool is() const { + return NodeType::test(*this); + } + + /* Casting operations. */ + template + inline NodeType &as() { + JS_ASSERT(NodeType::test(*this)); + return *static_cast(this); + } + + template + inline const NodeType &as() const { + JS_ASSERT(NodeType::test(*this)); + return *static_cast(this); + } + +#ifdef DEBUG + void dump(); + void dump(int indent); +#endif +}; + +struct NullaryNode : public ParseNode +{ + NullaryNode(ParseNodeKind kind, const TokenPos &pos) + : ParseNode(kind, JSOP_NOP, PN_NULLARY, pos) {} + NullaryNode(ParseNodeKind kind, JSOp op, const TokenPos &pos) + : ParseNode(kind, op, PN_NULLARY, pos) {} + + // This constructor is for a few mad uses in the emitter. It populates + // the pn_atom field even though that field belongs to a branch in pn_u + // that nullary nodes shouldn't use -- bogus. + NullaryNode(ParseNodeKind kind, JSOp op, const TokenPos &pos, JSAtom *atom) + : ParseNode(kind, op, PN_NULLARY, pos) + { + pn_atom = atom; + } + + static bool test(const ParseNode &node) { + return node.isArity(PN_NULLARY); + } + +#ifdef DEBUG + void dump(); +#endif +}; + +struct UnaryNode : public ParseNode +{ + UnaryNode(ParseNodeKind kind, JSOp op, const TokenPos &pos, ParseNode *kid) + : ParseNode(kind, op, PN_UNARY, pos) + { + pn_kid = kid; + } + + static inline UnaryNode *create(ParseNodeKind kind, FullParseHandler *handler) { + return (UnaryNode *) ParseNode::create(kind, PN_UNARY, handler); + } + + static bool test(const ParseNode &node) { + return node.isArity(PN_UNARY); + } + +#ifdef DEBUG + void dump(int indent); +#endif +}; + +struct BinaryNode : public ParseNode +{ + BinaryNode(ParseNodeKind kind, JSOp op, const TokenPos &pos, ParseNode *left, ParseNode *right) + : ParseNode(kind, op, PN_BINARY, pos) + { + pn_left = left; + pn_right = right; + } + + BinaryNode(ParseNodeKind kind, JSOp op, ParseNode *left, ParseNode *right) + : ParseNode(kind, op, PN_BINARY, TokenPos::box(left->pn_pos, right->pn_pos)) + { + pn_left = left; + pn_right = right; + } + + static inline BinaryNode *create(ParseNodeKind kind, FullParseHandler *handler) { + return (BinaryNode *) ParseNode::create(kind, PN_BINARY, handler); + } + + static bool test(const ParseNode &node) { + return node.isArity(PN_BINARY); + } + +#ifdef DEBUG + void dump(int indent); +#endif +}; + +struct BinaryObjNode : public ParseNode +{ + BinaryObjNode(ParseNodeKind kind, JSOp op, const TokenPos &pos, ParseNode *left, ParseNode *right, + ObjectBox *objbox) + : ParseNode(kind, op, PN_BINARY_OBJ, pos) + { + pn_left = left; + pn_right = right; + pn_binary_obj = objbox; + } + + static inline BinaryObjNode *create(ParseNodeKind kind, FullParseHandler *handler) { + return (BinaryObjNode *) ParseNode::create(kind, PN_BINARY_OBJ, handler); + } + + static bool test(const ParseNode &node) { + return node.isArity(PN_BINARY_OBJ); + } + +#ifdef DEBUG + void dump(int indent); +#endif +}; + +struct TernaryNode : public ParseNode +{ + TernaryNode(ParseNodeKind kind, JSOp op, ParseNode *kid1, ParseNode *kid2, ParseNode *kid3) + : ParseNode(kind, op, PN_TERNARY, + TokenPos((kid1 ? kid1 : kid2 ? kid2 : kid3)->pn_pos.begin, + (kid3 ? kid3 : kid2 ? kid2 : kid1)->pn_pos.end)) + { + pn_kid1 = kid1; + pn_kid2 = kid2; + pn_kid3 = kid3; + } + + TernaryNode(ParseNodeKind kind, JSOp op, ParseNode *kid1, ParseNode *kid2, ParseNode *kid3, + const TokenPos &pos) + : ParseNode(kind, op, PN_TERNARY, pos) + { + pn_kid1 = kid1; + pn_kid2 = kid2; + pn_kid3 = kid3; + } + + static inline TernaryNode *create(ParseNodeKind kind, FullParseHandler *handler) { + return (TernaryNode *) ParseNode::create(kind, PN_TERNARY, handler); + } + + static bool test(const ParseNode &node) { + return node.isArity(PN_TERNARY); + } + +#ifdef DEBUG + void dump(int indent); +#endif +}; + +struct ListNode : public ParseNode +{ + ListNode(ParseNodeKind kind, const TokenPos &pos) + : ParseNode(kind, JSOP_NOP, PN_LIST, pos) + { + makeEmpty(); + } + + ListNode(ParseNodeKind kind, JSOp op, ParseNode *kid) + : ParseNode(kind, op, PN_LIST, kid->pn_pos) + { + initList(kid); + } + + static inline ListNode *create(ParseNodeKind kind, FullParseHandler *handler) { + return (ListNode *) ParseNode::create(kind, PN_LIST, handler); + } + + static bool test(const ParseNode &node) { + return node.isArity(PN_LIST); + } + +#ifdef DEBUG + void dump(int indent); +#endif +}; + +struct CodeNode : public ParseNode +{ + static inline CodeNode *create(ParseNodeKind kind, FullParseHandler *handler) { + return (CodeNode *) ParseNode::create(kind, PN_CODE, handler); + } + + static bool test(const ParseNode &node) { + return node.isArity(PN_CODE); + } + +#ifdef DEBUG + void dump(int indent); +#endif +}; + +struct NameNode : public ParseNode +{ + NameNode(ParseNodeKind kind, JSOp op, JSAtom *atom, uint32_t blockid, + const TokenPos &pos) + : ParseNode(kind, op, PN_NAME, pos) + { + pn_atom = atom; + pn_expr = nullptr; + pn_cookie.makeFree(); + pn_dflags = 0; + pn_blockid = blockid; + JS_ASSERT(pn_blockid == blockid); // check for bitfield overflow + } + + static bool test(const ParseNode &node) { + return node.isArity(PN_NAME); + } + +#ifdef DEBUG + void dump(int indent); +#endif +}; + +struct LexicalScopeNode : public ParseNode +{ + static inline LexicalScopeNode *create(ParseNodeKind kind, FullParseHandler *handler) { + return (LexicalScopeNode *) ParseNode::create(kind, PN_NAME, handler); + } +}; + +class LabeledStatement : public ParseNode +{ + public: + LabeledStatement(PropertyName *label, ParseNode *stmt, uint32_t begin) + : ParseNode(PNK_LABEL, JSOP_NOP, PN_NAME, TokenPos(begin, stmt->pn_pos.end)) + { + pn_atom = label; + pn_expr = stmt; + } + + PropertyName *label() const { + return pn_atom->asPropertyName(); + } + + ParseNode *statement() const { + return pn_expr; + } + + static bool test(const ParseNode &node) { + bool match = node.isKind(PNK_LABEL); + JS_ASSERT_IF(match, node.isArity(PN_NAME)); + JS_ASSERT_IF(match, node.isOp(JSOP_NOP)); + return match; + } +}; + +class LoopControlStatement : public ParseNode +{ + protected: + LoopControlStatement(ParseNodeKind kind, PropertyName *label, const TokenPos &pos) + : ParseNode(kind, JSOP_NOP, PN_NULLARY, pos) + { + JS_ASSERT(kind == PNK_BREAK || kind == PNK_CONTINUE); + pn_u.loopControl.label = label; + } + + public: + /* Label associated with this break/continue statement, if any. */ + PropertyName *label() const { + return pn_u.loopControl.label; + } + + static bool test(const ParseNode &node) { + bool match = node.isKind(PNK_BREAK) || node.isKind(PNK_CONTINUE); + JS_ASSERT_IF(match, node.isArity(PN_NULLARY)); + JS_ASSERT_IF(match, node.isOp(JSOP_NOP)); + return match; + } +}; + +class BreakStatement : public LoopControlStatement +{ + public: + BreakStatement(PropertyName *label, const TokenPos &pos) + : LoopControlStatement(PNK_BREAK, label, pos) + { } + + static bool test(const ParseNode &node) { + bool match = node.isKind(PNK_BREAK); + JS_ASSERT_IF(match, node.isArity(PN_NULLARY)); + JS_ASSERT_IF(match, node.isOp(JSOP_NOP)); + return match; + } +}; + +class ContinueStatement : public LoopControlStatement +{ + public: + ContinueStatement(PropertyName *label, const TokenPos &pos) + : LoopControlStatement(PNK_CONTINUE, label, pos) + { } + + static bool test(const ParseNode &node) { + bool match = node.isKind(PNK_CONTINUE); + JS_ASSERT_IF(match, node.isArity(PN_NULLARY)); + JS_ASSERT_IF(match, node.isOp(JSOP_NOP)); + return match; + } +}; + +class DebuggerStatement : public ParseNode +{ + public: + DebuggerStatement(const TokenPos &pos) + : ParseNode(PNK_DEBUGGER, JSOP_NOP, PN_NULLARY, pos) + { } +}; + +class ConditionalExpression : public ParseNode +{ + public: + ConditionalExpression(ParseNode *condition, ParseNode *thenExpr, ParseNode *elseExpr) + : ParseNode(PNK_CONDITIONAL, JSOP_NOP, PN_TERNARY, + TokenPos(condition->pn_pos.begin, elseExpr->pn_pos.end)) + { + JS_ASSERT(condition); + JS_ASSERT(thenExpr); + JS_ASSERT(elseExpr); + pn_u.ternary.kid1 = condition; + pn_u.ternary.kid2 = thenExpr; + pn_u.ternary.kid3 = elseExpr; + } + + ParseNode &condition() const { + return *pn_u.ternary.kid1; + } + + ParseNode &thenExpression() const { + return *pn_u.ternary.kid2; + } + + ParseNode &elseExpression() const { + return *pn_u.ternary.kid3; + } + + static bool test(const ParseNode &node) { + bool match = node.isKind(PNK_CONDITIONAL); + JS_ASSERT_IF(match, node.isArity(PN_TERNARY)); + JS_ASSERT_IF(match, node.isOp(JSOP_NOP)); + return match; + } +}; + +class ThisLiteral : public ParseNode +{ + public: + ThisLiteral(const TokenPos &pos) : ParseNode(PNK_THIS, JSOP_THIS, PN_NULLARY, pos) { } +}; + +class NullLiteral : public ParseNode +{ + public: + NullLiteral(const TokenPos &pos) : ParseNode(PNK_NULL, JSOP_NULL, PN_NULLARY, pos) { } +}; + +class BooleanLiteral : public ParseNode +{ + public: + BooleanLiteral(bool b, const TokenPos &pos) + : ParseNode(b ? PNK_TRUE : PNK_FALSE, b ? JSOP_TRUE : JSOP_FALSE, PN_NULLARY, pos) + { } +}; + +class RegExpLiteral : public NullaryNode +{ + public: + RegExpLiteral(ObjectBox *reobj, const TokenPos &pos) + : NullaryNode(PNK_REGEXP, JSOP_REGEXP, pos) + { + pn_objbox = reobj; + } + + ObjectBox *objbox() const { return pn_objbox; } + + static bool test(const ParseNode &node) { + bool match = node.isKind(PNK_REGEXP); + JS_ASSERT_IF(match, node.isArity(PN_NULLARY)); + JS_ASSERT_IF(match, node.isOp(JSOP_REGEXP)); + return match; + } +}; + +class PropertyAccess : public ParseNode +{ + public: + PropertyAccess(ParseNode *lhs, PropertyName *name, uint32_t begin, uint32_t end) + : ParseNode(PNK_DOT, JSOP_NOP, PN_NAME, TokenPos(begin, end)) + { + JS_ASSERT(lhs != nullptr); + JS_ASSERT(name != nullptr); + pn_u.name.expr = lhs; + pn_u.name.atom = name; + } + + static bool test(const ParseNode &node) { + bool match = node.isKind(PNK_DOT); + JS_ASSERT_IF(match, node.isArity(PN_NAME)); + return match; + } + + ParseNode &expression() const { + return *pn_u.name.expr; + } + + PropertyName &name() const { + return *pn_u.name.atom->asPropertyName(); + } +}; + +class PropertyByValue : public ParseNode +{ + public: + PropertyByValue(ParseNode *lhs, ParseNode *propExpr, uint32_t begin, uint32_t end) + : ParseNode(PNK_ELEM, JSOP_NOP, PN_BINARY, TokenPos(begin, end)) + { + pn_u.binary.left = lhs; + pn_u.binary.right = propExpr; + } +}; + +#ifdef DEBUG +void DumpParseTree(ParseNode *pn, int indent = 0); +#endif + +/* + * js::Definition is a degenerate subtype of the PN_FUNC and PN_NAME variants + * of js::ParseNode, allocated only for function, var, const, and let + * declarations that define truly lexical bindings. This means that a child of + * a PNK_VAR list may be a Definition as well as a ParseNode. The pn_defn bit + * is set for all Definitions, clear otherwise. + * + * In an upvars list, defn->resolve() is the outermost definition the + * name may reference. If a with block or a function that calls eval encloses + * the use, the name may end up referring to something else at runtime. + * + * Note that not all var declarations are definitions: JS allows multiple var + * declarations in a function or script, but only the first creates the hoisted + * binding. JS programmers do redeclare variables for good refactoring reasons, + * for example: + * + * function foo() { + * ... + * for (var i ...) ...; + * ... + * for (var i ...) ...; + * ... + * } + * + * Not all definitions bind lexical variables, alas. In global and eval code + * var may re-declare a pre-existing property having any attributes, with or + * without JSPROP_PERMANENT. In eval code, indeed, ECMA-262 Editions 1 through + * 3 require function and var to bind deletable bindings. Global vars thus are + * properties of the global object, so they can be aliased even if they can't + * be deleted. + * + * Only bindings within function code may be treated as lexical, of course with + * the caveat that hoisting means use before initialization is allowed. We deal + * with use before declaration in one pass as follows (error checking elided): + * + * for (each use of unqualified name x in parse order) { + * if (this use of x is a declaration) { + * if (x in pc->decls) { // redeclaring + * pn = allocate a PN_NAME ParseNode; + * } else { // defining + * dn = lookup x in pc->lexdeps; + * if (dn) // use before def + * remove x from pc->lexdeps; + * else // def before use + * dn = allocate a PN_NAME Definition; + * map x to dn via pc->decls; + * pn = dn; + * } + * insert pn into its parent PNK_VAR/PNK_CONST list; + * } else { + * pn = allocate a ParseNode for this reference to x; + * dn = lookup x in pc's lexical scope chain; + * if (!dn) { + * dn = lookup x in pc->lexdeps; + * if (!dn) { + * dn = pre-allocate a Definition for x; + * map x to dn in pc->lexdeps; + * } + * } + * append pn to dn's use chain; + * } + * } + * + * See frontend/BytecodeEmitter.h for js::ParseContext and its top*Stmt, + * decls, and lexdeps members. + * + * Notes: + * + * 0. To avoid bloating ParseNode, we steal a bit from pn_arity for pn_defn + * and set it on a ParseNode instead of allocating a Definition. + * + * 1. Due to hoisting, a definition cannot be eliminated even if its "Variable + * statement" (ECMA-262 12.2) can be proven to be dead code. RecycleTree in + * ParseNode.cpp will not recycle a node whose pn_defn bit is set. + * + * 2. "lookup x in pc's lexical scope chain" gives up on def/use chaining if a + * with statement is found along the the scope chain, which includes pc, + * pc->parent, etc. Thus we eagerly connect an inner function's use of an + * outer's var x if the var x was parsed before the inner function. + * + * 3. A use may be eliminated as dead by the constant folder, which therefore + * must remove the dead name node from its singly-linked use chain, which + * would mean hashing to find the definition node and searching to update + * the pn_link pointing at the use to be removed. This is costly, so as for + * dead definitions, we do not recycle dead pn_used nodes. + * + * At the end of parsing a function body or global or eval program, pc->lexdeps + * holds the lexical dependencies of the parsed unit. The name to def/use chain + * mappings are then merged into the parent pc->lexdeps. + * + * Thus if a later var x is parsed in the outer function satisfying an earlier + * inner function's use of x, we will remove dn from pc->lexdeps and re-use it + * as the new definition node in the outer function's parse tree. + * + * When the compiler unwinds from the outermost pc, pc->lexdeps contains the + * definition nodes with use chains for all free variables. These are either + * global variables or reference errors. + */ +#define dn_uses pn_link + +struct Definition : public ParseNode +{ + bool isFreeVar() const { + JS_ASSERT(isDefn()); + return pn_cookie.isFree(); + } + + enum Kind { MISSING = 0, VAR, CONST, LET, ARG, NAMED_LAMBDA, PLACEHOLDER }; + + bool canHaveInitializer() { return int(kind()) <= int(ARG); } + + static const char *kindString(Kind kind); + + Kind kind() { + if (getKind() == PNK_FUNCTION) { + if (isOp(JSOP_GETARG)) + return ARG; + return VAR; + } + JS_ASSERT(getKind() == PNK_NAME); + if (isOp(JSOP_CALLEE)) + return NAMED_LAMBDA; + if (isPlaceholder()) + return PLACEHOLDER; + if (isOp(JSOP_GETARG)) + return ARG; + if (isConst()) + return CONST; + if (isLet()) + return LET; + return VAR; + } +}; + +class ParseNodeAllocator +{ + public: + explicit ParseNodeAllocator(ExclusiveContext *cx, LifoAlloc &alloc) + : cx(cx), alloc(alloc), freelist(nullptr) + {} + + void *allocNode(); + void freeNode(ParseNode *pn); + ParseNode *freeTree(ParseNode *pn); + void prepareNodeForMutation(ParseNode *pn); + + private: + ExclusiveContext *cx; + LifoAlloc &alloc; + ParseNode *freelist; +}; + +inline bool +ParseNode::test(unsigned flag) const +{ + JS_ASSERT(pn_defn || pn_arity == PN_CODE || pn_arity == PN_NAME); +#ifdef DEBUG + if ((flag & PND_ASSIGNED) && pn_defn && !(pn_dflags & flag)) { + for (ParseNode *pn = ((Definition *) this)->dn_uses; pn; pn = pn->pn_link) { + JS_ASSERT(!pn->pn_defn); + JS_ASSERT(!(pn->pn_dflags & flag)); + } + } +#endif + return !!(pn_dflags & flag); +} + +inline void +ParseNode::markAsAssigned() +{ + JS_ASSERT(js_CodeSpec[pn_op].format & JOF_NAME); + if (isUsed()) + pn_lexdef->pn_dflags |= PND_ASSIGNED; + pn_dflags |= PND_ASSIGNED; +} + +inline Definition * +ParseNode::resolve() +{ + if (isDefn()) + return (Definition *)this; + JS_ASSERT(lexdef()->isDefn()); + return (Definition *)lexdef(); +} + +inline bool +ParseNode::isConstant() +{ + switch (pn_type) { + case PNK_NUMBER: + case PNK_STRING: + case PNK_NULL: + case PNK_FALSE: + case PNK_TRUE: + return true; + case PNK_ARRAY: + case PNK_OBJECT: + JS_ASSERT(isOp(JSOP_NEWINIT)); + return !(pn_xflags & PNX_NONCONST); + default: + return false; + } +} + +class ObjectBox +{ + public: + JSObject *object; + + ObjectBox(JSObject *object, ObjectBox *traceLink); + bool isFunctionBox() { return object->is(); } + FunctionBox *asFunctionBox(); + void trace(JSTracer *trc); + + protected: + friend struct CGObjectList; + + ObjectBox *traceLink; + ObjectBox *emitLink; + + ObjectBox(JSFunction *function, ObjectBox *traceLink); +}; + +enum ParseReportKind +{ + ParseError, + ParseWarning, + ParseExtraWarning, + ParseStrictError +}; + +enum FunctionSyntaxKind { Expression, Statement, Arrow }; + +static inline ParseNode * +FunctionArgsList(ParseNode *fn, unsigned *numFormals) +{ + JS_ASSERT(fn->isKind(PNK_FUNCTION)); + ParseNode *argsBody = fn->pn_body; + JS_ASSERT(argsBody->isKind(PNK_ARGSBODY)); + *numFormals = argsBody->pn_count; + if (*numFormals > 0 && argsBody->last()->isKind(PNK_STATEMENTLIST)) + (*numFormals)--; + JS_ASSERT(argsBody->isArity(PN_LIST)); + return argsBody->pn_head; +} + +} /* namespace frontend */ +} /* namespace js */ + +#endif /* frontend_ParseNode_h */