Attachment #707411 for bug #568953

Attachment #707411: Reflect support for export declarations + tests for bug #568953

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





load(libdir + "asserts.js");

assertThrowsInstanceOf(function () {
    Reflect.parse("export var x;");
}, SyntaxError);

assertThrowsInstanceOf(function () {
    Reflect.parse("module 'foo' { export get function() {}; }");
}, SyntaxError);

assertThrowsInstanceOf(function () {
    Reflect.parse("module 'foo' { export set function(x) {}; }");
}, SyntaxError);

assertThrowsInstanceOf(function () {
    Reflect.parse("module 'foo' { export 42; }");
}, SyntaxError);

function test(string, type) {
    var node = Reflect.parse(string);
    node = node.body[0].body.body[0];
    assertEq(typeof node == "object" && node != null, true);
    assertEq(node.type, "ExportStatement");
    node = node.expr;
    assertEq(typeof node == "object" && node != null, true);
    assertEq(node.type, type);
};

test("module 'foo' { export function f() {}; }", "FunctionDeclaration");
test("module 'foo' { export var x; }", "VariableDeclaration");
test("module 'foo' { export const x; }", "VariableDeclaration");
test("module 'foo' { export let x; }", "VariableDeclaration");





ASTDEF(AST_YIELD_EXPR,            "YieldExpression",               "yieldExpression")
ASTDEF(AST_LET_EXPR,              "LetExpression",                 "letExpression")

ASTDEF(AST_EMPTY_STMT,            "EmptyStatement",                 "emptyStatement")
ASTDEF(AST_BLOCK_STMT,            "BlockStatement",                 "blockStatement")
ASTDEF(AST_EXPR_STMT,             "ExpressionStatement",            "expressionStatement")
ASTDEF(AST_LAB_STMT,              "LabeledStatement",               "labeledStatement")
ASTDEF(AST_IF_STMT,               "IfStatement",                    "ifStatement")
ASTDEF(AST_EXPORT_STMT,           "ExportStatement",                "exportStatement")
ASTDEF(AST_SWITCH_STMT,           "SwitchStatement",                "switchStatement")
ASTDEF(AST_WHILE_STMT,            "WhileStatement",                 "whileStatement")
ASTDEF(AST_DO_STMT,               "DoWhileStatement",               "doWhileStatement")
ASTDEF(AST_FOR_STMT,              "ForStatement",                   "forStatement")
ASTDEF(AST_FOR_IN_STMT,           "ForInStatement",                 "forInStatement")
ASTDEF(AST_FOR_OF_STMT,           "ForOfStatement",                 "forOfStatement")
ASTDEF(AST_BREAK_STMT,            "BreakStatement",                 "breakStatement")
ASTDEF(AST_CONTINUE_STMT,         "ContinueStatement",              "continueStatement")






    bool withStatement(HandleValue expr, HandleValue stmt, TokenPos *pos, MutableHandleValue dst);

    bool whileStatement(HandleValue test, HandleValue stmt, TokenPos *pos, MutableHandleValue dst);

    bool doWhileStatement(HandleValue stmt, HandleValue test, TokenPos *pos,
                          MutableHandleValue dst);

    bool exportStatement(HandleValue expr, TokenPos *pos, MutableHandleValue dst);

    bool switchStatement(HandleValue disc, NodeVector &elts, bool lexical, TokenPos *pos,
                         MutableHandleValue dst);

    bool tryStatement(HandleValue body, NodeVector &guarded, HandleValue unguarded,
                      HandleValue finally, TokenPos *pos, MutableHandleValue dst);

    bool debuggerStatement(TokenPos *pos, MutableHandleValue dst);



    return newNode(AST_DO_STMT, pos,
                   "body", stmt,
                   "test", test,
                   dst);
}

bool
NodeBuilder::exportStatement(HandleValue expr, TokenPos *pos, MutableHandleValue dst)
{
    RootedValue cb(cx, callbacks[AST_EXPORT_STMT]);
    if (!cb.isNull())
        return callback(cb, expr, pos, dst);

    return newNode(AST_EXPORT_STMT, pos,
                   "expr", expr,
                   dst);
}

bool
NodeBuilder::switchStatement(HandleValue disc, NodeVector &elts, bool lexical, TokenPos *pos,
                             MutableHandleValue dst)
{
    RootedValue array(cx);
    if (!newArray(elts, &array))
        return false;

    RootedValue lexicalVal(cx, BooleanValue(lexical));

        return statement(pn, dst);
    }

    bool forInit(ParseNode *pn, MutableHandleValue dst);
    bool forOfOrIn(ParseNode *loop, ParseNode *head, HandleValue var, HandleValue stmt,
                   MutableHandleValue dst);
    bool statement(ParseNode *pn, MutableHandleValue dst);
    bool blockStatement(ParseNode *pn, MutableHandleValue dst);
    bool exportStatement(ParseNode *pn, MutableHandleValue dst);
    bool switchStatement(ParseNode *pn, MutableHandleValue dst);
    bool switchCase(ParseNode *pn, MutableHandleValue dst);
    bool tryStatement(ParseNode *pn, MutableHandleValue dst);
    bool catchClause(ParseNode *pn, bool *isGuarded, MutableHandleValue dst);

    bool optExpression(ParseNode *pn, MutableHandleValue dst) {
        if (!pn) {
            dst.setMagic(JS_SERIALIZE_NO_NODE);

    RootedValue expr(cx);

    return optExpression(pn->pn_left, &expr) &&
           statements(pn->pn_right, stmts) &&
           builder.switchCase(expr, stmts, &pn->pn_pos, dst);
}

bool
ASTSerializer::exportStatement(ParseNode *pn, MutableHandleValue dst)
{
    RootedValue expr(cx);
    return declaration(pn->pn_kid, &expr)
        && builder.exportStatement(expr, &pn->pn_pos, dst);
}

bool
ASTSerializer::switchStatement(ParseNode *pn, MutableHandleValue dst)
{
    JS_ASSERT(pn->pn_pos.encloses(pn->pn_left->pn_pos));
    JS_ASSERT(pn->pn_pos.encloses(pn->pn_right->pn_pos));

    RootedValue disc(cx);

    if (!expression(pn->pn_left, &disc))

        RootedValue test(cx), cons(cx), alt(cx);

        return expression(pn->pn_kid1, &test) &&
               statement(pn->pn_kid2, &cons) &&
               optStatement(pn->pn_kid3, &alt) &&
               builder.ifStatement(test, cons, alt, &pn->pn_pos, dst);
      }

      case PNK_EXPORT:
        return exportStatement(pn, dst);

      case PNK_SWITCH:
        return switchStatement(pn, dst);

      case PNK_TRY:
        return tryStatement(pn, dst);

      case PNK_WITH:
      case PNK_WHILE:

Return to bug 568953