Attachment #706903 for bug #568953

Attachment #706903: Parser support for module declarations for bug #568953

View | Details | Raw Unified | Return to bug 568953
Collapse All | Expand All





    bool ok;
    ParseNode *pn2;

    ok = true;
    if (!pn || *answer)
        return ok;

    switch (pn->getArity()) {
      case PN_MODULE:
        *answer = false;
        break;

      case PN_FUNC:
        /*
         * A named function, contrary to ES3, is no longer useful, because we
         * bind its name lexically (using JSOP_CALLEE) instead of creating an
         * Object instance and binding a readonly, permanent property in it
         * (the object and binding can be detected and hijacked or captured).
         * This is a bug fix to ES3; it is fixed in ES3.1 drafts.
         */





                        bool inCond)
{
    ParseNode *pn = *pnp;
    ParseNode *pn1 = NULL, *pn2 = NULL, *pn3 = NULL;

    JS_CHECK_RECURSION(cx, return false);

    switch (pn->getArity()) {
      case PN_MODULE:
        if (!FoldConstants(cx, pn->pn_body, parser))
            return false;
        break;

      case PN_FUNC:
        if (!FoldConstants(cx, &pn->pn_body, parser, pn->pn_funbox->inGenexpLambda))
            return false;
        break;

      case PN_LIST:
      {
        /* Propagate inCond through logical connectives. */





                if (cur->pn_left != cur->pn_right)
                    resolve(cur->pn_right, prefix);
                break;
            case PN_TERNARY:
                resolve(cur->pn_kid1, prefix);
                resolve(cur->pn_kid2, prefix);
                resolve(cur->pn_kid3, prefix);
                break;
            case PN_MODULE:
                JS_ASSERT(cur->isKind(PNK_MODULE));
                resolve(cur->pn_body, prefix);
                break;
            case PN_FUNC:
                JS_ASSERT(cur->isKind(PNK_FUNCTION));
                resolve(cur->pn_body, prefix);
                break;
            case PN_LIST:
                for (ParseNode *nxt = cur->pn_head; nxt; nxt = nxt->pn_next)
                    resolve(nxt, prefix);
                break;





        return NULL;
    pn->setInParens(opn->isInParens());
    pn->setDefn(opn->isDefn());
    pn->setUsed(opn->isUsed());

    switch (pn->getArity()) {
#define NULLCHECK(e)    JS_BEGIN_MACRO if (!(e)) return NULL; JS_END_MACRO

      case PN_MODULE:
        NULLCHECK(pn->pn_modulebox = parser->newModuleBox(opn->pn_modulebox->module(), pc));
        NULLCHECK(pn->pn_body = CloneParseTree(opn->pn_body, parser));
        break;

      case PN_FUNC:
        NULLCHECK(pn->pn_funbox =
                  parser->newFunctionBox(opn->pn_funbox->function(), pc, opn->pn_funbox->strict));
        NULLCHECK(pn->pn_body = CloneParseTree(opn->pn_body, parser));
        pn->pn_cookie = opn->pn_cookie;
        pn->pn_dflags = opn->pn_dflags;
        pn->pn_blockid = opn->pn_blockid;
        break;





    F(ARRAYPUSH) \
    F(LEXICALSCOPE) \
    F(LET) \
    F(SEQ) \
    F(FORIN) \
    F(FORHEAD) \
    F(ARGSBODY) \
    F(SPREAD) \
    F(MODULE) \
    \
    /* Equality operators. */ \
    F(STRICTEQ) \
    F(EQ) \
    F(STRICTNE) \
    F(NE) \
    \
    /* Unary operators. */ \

 *                              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_TERNARY,                         /* three kids */
    PN_MODULE,                          /* module definition node */
    PN_FUNC,                            /* function definition node */
    PN_LIST,                            /* generic singly linked list */
    PN_NAME                             /* name use or definition node */
};

struct Definition;

class LoopControlStatement;
class BreakStatement;
class ContinueStatement;
class XMLProcessingInstruction;
class ConditionalExpression;
class PropertyAccess;
class ModuleBox;

struct ParseNode {
  private:
    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 */

        struct {                        /* one kid if unary */
            ParseNode   *kid;
            bool        hidden;         /* hidden genexp-induced JSOP_YIELD
                                           or 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 */
                ModuleBox   *modulebox; /* module object */
                FunctionBox *funbox;    /* function object */
            };
            union {
                ParseNode   *expr;      /* 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:12,      /* definition/use flags, see below */
                        blockid:20;     /* block number, for subset dominance
                                           computation */
        } name;

        } loopControl;
        class {                         /* E4X <?target data?> XML PI */
            friend class XMLProcessingInstruction;
            PropertyName     *target;   /* non-empty */
            JSAtom           *data;     /* may be empty, never null */
        } xmlpi;
    } 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

        return node.isArity(PN_LIST);
    }

#ifdef DEBUG
    void dump(int indent);
#endif
};

struct ModuleNode : public ParseNode {
    static inline ModuleNode *create(ParseNodeKind kind, Parser *parser) {
        return (ModuleNode *) ParseNode::create(kind, PN_MODULE, parser);
    }

    static bool test(const ParseNode &node) {
        return node.isArity(PN_MODULE);
    }
};

struct FunctionNode : public ParseNode {
    static inline FunctionNode *create(ParseNodeKind kind, Parser *parser) {
        return (FunctionNode *) ParseNode::create(kind, PN_FUNC, parser);
    }

    static bool test(const ParseNode &node) {
        return node.isArity(PN_FUNC);
    }






    if (!LeaveFunction(pn, this, funName, kind))
        return false;

    return true;
}

ParseNode *
Parser::moduleStmt()
{
    JS_ASSERT(versionNumber() == JSVERSION_ECMA_5);
    JS_ASSERT(tokenStream.currentToken().name() == context->runtime->atomState.module);
    if (!((pc->sc->isGlobalSharedContext() || pc->sc->isModuleBox()) && pc->atBodyLevel()))
    {
        reportError(NULL, JSMSG_MODULE_STATEMENT);
        return NULL;
    }

    ParseNode *pn = ModuleNode::create(PNK_MODULE, this);
    if (!pn)
        return NULL;
    JS_ALWAYS_TRUE(tokenStream.matchToken(TOK_STRING));
    Module *module = js_NewModule(context, tokenStream.currentToken().atom());
    if (!module)
        return NULL;
    ModuleBox *modulebox = newModuleBox(module, pc);
    if (!modulebox)
        return NULL;
    pn->pn_modulebox = modulebox;

    ParseContext modulepc(this, modulebox, pc->staticLevel + 1, pc->blockidGen);
    if (!modulepc.init())
        return NULL;
    MUST_MATCH_TOKEN(TOK_LC, JSMSG_CURLY_BEFORE_MODULE);
    pn->pn_body = statements();
    MUST_MATCH_TOKEN(TOK_RC, JSMSG_CURLY_AFTER_MODULE);

    return pn;
}

ParseNode *
Parser::functionStmt()
{
    JS_ASSERT(tokenStream.currentToken().type == TOK_FUNCTION);
    RootedPropertyName name(context);
    if (tokenStream.getToken(TSF_KEYWORD_IS_NAME) == TOK_NAME) {
        name = tokenStream.currentToken().name();
    } else {
        /* Unnamed function expressions are forbidden in statement context. */

        pn->pn_kid = pn2;
        break;
      }
#endif

      case TOK_ERROR:
        return NULL;

      case TOK_NAME:
        if (versionNumber() == JSVERSION_ECMA_5 &&
            tokenStream.currentToken().name() == context->names().module &&
            tokenStream.peekTokenSameLine(TSF_OPERAND) == TOK_STRING)
        {
            return moduleStmt();
        }

      default:
        return expressionStatement();
    }

    /* Check termination of this primitive statement. */
    return MatchOrInsertSemicolon(context, &tokenStream) ? pn : NULL;
}


        }
        break;

      case PN_UNARY:
        if (!transplant(pn->pn_kid))
            return false;
        break;

      case PN_MODULE:
      case PN_FUNC:
      case PN_NAME:
        if (!transplant(pn->maybeExpr()))
            return false;

        if (pn->isDefn()) {
            if (genexp && !BumpStaticLevel(pn, pc))
                return false;





     * Parsers whose name has a '1' suffix leave the TokenStream state
     * pointing to the token one past the end of the parsed fragment.  For a
     * number of the parsers this is convenient and avoids a lot of
     * unnecessary ungetting and regetting of tokens.
     *
     * Some parsers have two versions:  an always-inlined version (with an 'i'
     * suffix) and a never-inlined version (with an 'n' suffix).
     */
    ParseNode *moduleStmt();
    ParseNode *functionStmt();
    ParseNode *functionExpr();
    ParseNode *statements(bool *hasFunctionStmt = NULL);

    ParseNode *switchStatement();
    ParseNode *forStatement();
    ParseNode *tryStatement();
    ParseNode *withStatement();

(-)a/js/src/js.msg (+3 lines)

Line	Link Here

Lines 383-390 MSG_DEF(JSMSG_INVALID_LANGUAGE_TAG, 32	Link Here

383

MSG_DEF(JSMSG_INVALID_LOCALE_MATCHER, 330, 1, JSEXN_RANGEERR, "invalid locale matcher in supportedLocalesOf(): {0}")

383

MSG_DEF(JSMSG_INVALID_LOCALE_MATCHER, 330, 1, JSEXN_RANGEERR, "invalid locale matcher in supportedLocalesOf(): {0}")

384

MSG_DEF(JSMSG_INVALID_OPTION_VALUE,   331, 2, JSEXN_RANGEERR, "invalid value {1} for option {0}")

384

MSG_DEF(JSMSG_INVALID_OPTION_VALUE,   331, 2, JSEXN_RANGEERR, "invalid value {1} for option {0}")

385

MSG_DEF(JSMSG_INVALID_DIGITS_VALUE,   332, 1, JSEXN_RANGEERR, "invalid digits value: {0}")

385

MSG_DEF(JSMSG_INVALID_DIGITS_VALUE,   332, 1, JSEXN_RANGEERR, "invalid digits value: {0}")

386

MSG_DEF(JSMSG_INTL_OBJECT_REINITED,   333, 0, JSEXN_TYPEERR, "can't initialize object twice as an object of an Intl constructor")

386

MSG_DEF(JSMSG_INTL_OBJECT_REINITED,   333, 0, JSEXN_TYPEERR, "can't initialize object twice as an object of an Intl constructor")

387

MSG_DEF(JSMSG_INVALID_CURRENCY_CODE,  334, 1, JSEXN_RANGEERR, "invalid currency code in NumberFormat(): {0}")

387

MSG_DEF(JSMSG_INVALID_CURRENCY_CODE,  334, 1, JSEXN_RANGEERR, "invalid currency code in NumberFormat(): {0}")

388

MSG_DEF(JSMSG_UNDEFINED_CURRENCY,     335, 0, JSEXN_TYPEERR, "undefined currency in NumberFormat() with currency style")

388

MSG_DEF(JSMSG_UNDEFINED_CURRENCY,     335, 0, JSEXN_TYPEERR, "undefined currency in NumberFormat() with currency style")

389

MSG_DEF(JSMSG_INVALID_TIME_ZONE,      336, 1, JSEXN_RANGEERR, "invalid time zone in DateTimeFormat(): {0}")

389

MSG_DEF(JSMSG_INVALID_TIME_ZONE,      336, 1, JSEXN_RANGEERR, "invalid time zone in DateTimeFormat(): {0}")

390

MSG_DEF(JSMSG_DATE_NOT_FINITE,        337, 0, JSEXN_RANGEERR, "date value is not finite in DateTimeFormat.format()")

390

MSG_DEF(JSMSG_DATE_NOT_FINITE,        337, 0, JSEXN_RANGEERR, "date value is not finite in DateTimeFormat.format()")

391

MSG_DEF(JSMSG_MODULE_STATEMENT,       338, 0, JSEXN_SYNTAXERR, "module declarations may only appear at the top level of a program or module body")

392

MSG_DEF(JSMSG_CURLY_BEFORE_MODULE,    339, 0, JSEXN_SYNTAXERR, "missing { before module body")

393

MSG_DEF(JSMSG_CURLY_AFTER_MODULE,     340, 0, JSEXN_SYNTAXERR, "missing } after module body")





    macro(lastIndex, lastIndex, "lastIndex") \
    macro(length, length, "length") \
    macro(line, line, "line") \
    macro(lineNumber, lineNumber, "lineNumber") \
    macro(loc, loc, "loc") \
    macro(lookupGetter, lookupGetter, "__lookupGetter__") \
    macro(lookupSetter, lookupSetter, "__lookupSetter__") \
    macro(message, message, "message") \
    macro(module, module, "module") \
    macro(multiline, multiline, "multiline") \
    macro(name, name, "name") \
    macro(NaN, NaN, "NaN") \
    macro(next, next, "next") \
    macro(noSuchMethod, noSuchMethod, "__noSuchMethod__") \
    macro(NumberFormat, NumberFormat, "NumberFormat") \
    macro(NumberFormatFormat, NumberFormatFormat, "Intl_NumberFormat_format") \
    macro(objectNull, objectNull, "[object Null]") \

Return to bug 568953