The Tor Browser: js/src/frontend/ParseNode.h@6474c204b198 (annotated)

js/src/frontend/ParseNode.h@6474c204b198 (annotated)

js/src/frontend/ParseNode.h

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- 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 <typename ParseHandler>
 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
  * <A && <B && C>> so that code generation can emit a left-associative branch
  * around <B && C> 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
  * -----        -------     -------
  * <Definitions>
  * 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
  *
  * <Statements>
  * 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
  *
  * <Expressions>
  * 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 <Expressions>), 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<FullParseHandler> *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:
 . shorthand syntax used, at present
                                               object destructuring ({x,y}) only;
 . code evaluating destructuring
                                               arguments occurs before function
                                               body */
 #define PNX_SPECIALARRAYINIT 0x20       /* one or more of
 . array initialiser has holes
 . 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 <class NodeType>
     inline bool is() const {
         return NodeType::test(*this);
     }
     /* Casting operations. */
     template <class NodeType>
     inline NodeType &as() {
         JS_ASSERT(NodeType::test(*this));
         return *static_cast<NodeType *>(this);
     }
     template <class NodeType>
     inline const NodeType &as() const {
         JS_ASSERT(NodeType::test(*this));
         return *static_cast<const NodeType *>(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<JSFunction>(); }
     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 */

The Tor Browser / annotate

js/src/frontend/ParseNode.h@6474c204b198 (annotated)

js/src/frontend/ParseNode.h