Attachment 732401 Details for Bug 568953

[patch] Reflect support for export declarations + test

patch (text/plain), 9.88 KB, created by Eddy Bruel [:ejpbruel]

(hide)

Description:

Filename:

MIME Type:

Creator: Eddy Bruel [:ejpbruel]

Size: 9.88 KB

patch

obsolete

>diff -r e7fae1e5c9ac js/src/jit-test/tests/modules/exportDeclaration.js
>--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
>+++ b/js/src/jit-test/tests/modules/exportDeclaration.js	Tue Apr 02 19:05:41 2013 +0200
>@@ -0,0 +1,52 @@
>+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, "ExportDeclaration");
>+    node = node.declaration;
>+    assertEq(typeof node == "object" && node != null, true);
>+    assertEq(node.type, type);
>+    return node;
>+};
>+
>+var node = test("module 'foo' { export { a, b : c } }", "ExportSpecifierSet").specifiers;
>+assertEq(typeof node == "object" && node != null, true);
>+assertEq(node.length, 2);
>+var ident = node[0];
>+assertEq(typeof ident == "object" && ident != null, true);
>+assertEq(ident.type, "Identifier");
>+assertEq(ident.name, "a");
>+var spec = node[1];
>+assertEq(typeof spec == "object" && spec != null, true);
>+assertEq(spec.type, "ExportSpecifier");
>+var left = spec.left;
>+assertEq(typeof left == "object" && left != null, true);
>+assertEq(left.type, "Identifier");
>+assertEq(left.name, "b");
>+var right = spec.right;
>+assertEq(typeof right == "object" && right != null, true);
>+assertEq(right.type, "Identifier");
>+assertEq(right.name, "c");
>+
>+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");
>diff -r e7fae1e5c9ac js/src/jsast.tbl
>--- a/js/src/jsast.tbl	Tue Apr 02 18:56:50 2013 +0200
>+++ b/js/src/jsast.tbl	Tue Apr 02 19:05:41 2013 +0200
>@@ -52,16 +52,19 @@ ASTDEF(AST_FOR_OF_STMT,           "ForOf
> ASTDEF(AST_BREAK_STMT,            "BreakStatement",                 "breakStatement")
> ASTDEF(AST_CONTINUE_STMT,         "ContinueStatement",              "continueStatement")
> ASTDEF(AST_WITH_STMT,             "WithStatement",                  "withStatement")
> ASTDEF(AST_RETURN_STMT,           "ReturnStatement",                "returnStatement")
> ASTDEF(AST_TRY_STMT,              "TryStatement",                   "tryStatement")
> ASTDEF(AST_THROW_STMT,            "ThrowStatement",                 "throwStatement")
> ASTDEF(AST_DEBUGGER_STMT,         "DebuggerStatement",              "debuggerStatement")
> ASTDEF(AST_LET_STMT,              "LetStatement",                   "letStatement")
>+ASTDEF(AST_EXPORT_DECL,           "ExportDeclaration",              "exportDeclaration")
>+ASTDEF(AST_EXPORT_SPEC_SET,       "ExportSpecifierSet",             "exportSpecifierSet")
>+ASTDEF(AST_EXPORT_SPEC,           "ExportSpecifier",                "exportSpecifier")
> 
> ASTDEF(AST_CASE,                  "SwitchCase",                     "switchCase")
> ASTDEF(AST_CATCH,                 "CatchClause",                    "catchClause")
> ASTDEF(AST_COMP_BLOCK,            "ComprehensionBlock",             "comprehensionBlock")
> 
> ASTDEF(AST_ARRAY_PATT,            "ArrayPattern",                   "arrayPattern")
> ASTDEF(AST_OBJECT_PATT,           "ObjectPattern",                  "objectPattern")
> ASTDEF(AST_PROP_PATT,             "Property",                       "propertyPattern")
>diff -r e7fae1e5c9ac js/src/jsreflect.cpp
>--- a/js/src/jsreflect.cpp	Tue Apr 02 18:56:50 2013 +0200
>+++ b/js/src/jsreflect.cpp	Tue Apr 02 19:05:41 2013 +0200
>@@ -545,16 +545,22 @@ class NodeBuilder
> 
>     bool tryStatement(HandleValue body, NodeVector &guarded, HandleValue unguarded,
>                       HandleValue finally, TokenPos *pos, MutableHandleValue dst);
> 
>     bool debuggerStatement(TokenPos *pos, MutableHandleValue dst);
> 
>     bool letStatement(NodeVector &head, HandleValue stmt, TokenPos *pos, MutableHandleValue dst);
> 
>+    bool exportDeclaration(HandleValue expr, TokenPos *pos, MutableHandleValue dst);
>+
>+    bool exportSpecifierSet(NodeVector &elts, TokenPos *pos, MutableHandleValue dst);
>+
>+    bool exportSpecifier(HandleValue left, HandleValue right, TokenPos *pos, MutableHandleValue dst);
>+
>     /*
>      * expressions
>      */
> 
>     bool binaryExpression(BinaryOperator op, HandleValue left, HandleValue right, TokenPos *pos,
>                           MutableHandleValue dst);
> 
>     bool unaryExpression(UnaryOperator op, HandleValue expr, TokenPos *pos, MutableHandleValue dst);
>@@ -972,16 +978,48 @@ NodeBuilder::debuggerStatement(TokenPos 
>     RootedValue cb(cx, callbacks[AST_DEBUGGER_STMT]);
>     if (!cb.isNull())
>         return callback(cb, pos, dst);
> 
>     return newNode(AST_DEBUGGER_STMT, pos, dst);
> }
> 
> bool
>+NodeBuilder::exportDeclaration(HandleValue decl, TokenPos *pos, MutableHandleValue dst)
>+{
>+    RootedValue cb(cx, callbacks[AST_EXPORT_DECL]);
>+    if (!cb.isNull())
>+        return callback(cb, decl, pos, dst);
>+
>+    return newNode(AST_EXPORT_DECL, pos,
>+                   "declaration", decl,
>+                   dst);
>+}
>+
>+bool
>+NodeBuilder::exportSpecifierSet(NodeVector &elts, TokenPos *pos, MutableHandleValue dst)
>+{
>+    return listNode(AST_EXPORT_SPEC_SET, "specifiers", elts, pos, dst);
>+}
>+
>+bool
>+NodeBuilder::exportSpecifier(HandleValue left, HandleValue right, TokenPos *pos,
>+                             MutableHandleValue dst)
>+{
>+    RootedValue cb(cx, callbacks[AST_EXPORT_SPEC]);
>+    if (!cb.isNull())
>+        return callback(cb, left, right, pos, dst);
>+
>+    return newNode(AST_EXPORT_SPEC, pos,
>+                   "left", left,
>+                   "right", right,
>+                   dst);
>+}
>+
>+bool
> NodeBuilder::binaryExpression(BinaryOperator op, HandleValue left, HandleValue right, TokenPos *pos,
>                               MutableHandleValue dst)
> {
>     JS_ASSERT(op > BINOP_ERR && op < BINOP_LIMIT);
> 
>     RootedValue opName(cx);
>     if (!atomValue(binopNames[op], &opName))
>         return false;
>@@ -1521,16 +1559,19 @@ class ASTSerializer
>     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 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 exportDeclaration(ParseNode *pn, MutableHandleValue dst);
>+    bool exportSpecifierSet(ParseNode *pn, MutableHandleValue dst);
>+    bool exportSpecifier(ParseNode *pn, MutableHandleValue dst);
> 
>     bool optExpression(ParseNode *pn, MutableHandleValue dst) {
>         if (!pn) {
>             dst.setMagic(JS_SERIALIZE_NO_NODE);
>             return true;
>         }
>         return expression(pn, dst);
>     }
>@@ -1713,16 +1754,77 @@ ASTSerializer::statements(ParseNode *pn,
>             return false;
>         elts.infallibleAppend(elt);
>     }
> 
>     return true;
> }
> 
> bool
>+ASTSerializer::exportDeclaration(ParseNode *pn, MutableHandleValue dst)
>+{
>+    RootedValue expr(cx);
>+    ParseNode *pnkid = pn->pn_kid;
>+    switch (pnkid->getKind()) {
>+      case PNK_EXPORTLIST:
>+        if (!exportSpecifierSet(pnkid, &expr))
>+            return false;
>+        break;
>+
>+      case PNK_FUNCTION:
>+      case PNK_VAR:
>+      case PNK_CONST:
>+        if (!declaration(pnkid, &expr))
>+            return false;
>+        break;
>+
>+      default:
>+        LOCAL_NOT_REACHED("unexpected statement type");
>+    }
>+    return builder.exportDeclaration(expr, &pn->pn_pos, dst);
>+}
>+
>+bool
>+ASTSerializer::exportSpecifierSet(ParseNode *pn, MutableHandleValue dst)
>+{
>+    NodeVector elts(cx);
>+    if (!elts.reserve(pn->pn_count))
>+        return false;
>+    for (ParseNode *next = pn->pn_head; next; next = next->pn_next) {
>+        RootedValue elt(cx);
>+        switch (next->getKind()) {
>+          case PNK_NAME:
>+            if (!identifier(next, &elt))
>+                return false;
>+            break;
>+
>+          case PNK_COLON:
>+            if (!exportSpecifier(next, &elt))
>+                return false;
>+            break;
>+
>+          default:
>+            LOCAL_NOT_REACHED("unexpected export specifier type");
>+        };
>+        elts.infallibleAppend(elt);
>+    } 
>+    return builder.exportSpecifierSet(elts, &pn->pn_pos, dst);
>+}
>+
>+bool
>+ASTSerializer::exportSpecifier(ParseNode *pn, MutableHandleValue dst)
>+{
>+    RootedValue left(cx);
>+    RootedValue right(cx);
>+    return identifier(pn->pn_left, &left) &&
>+           identifier(pn->pn_right, &right) &&
>+           builder.exportSpecifier(left, right, &pn->pn_pos, dst);
>+}
>+
>+bool
> ASTSerializer::expressions(ParseNode *pn, NodeVector &elts)
> {
>     if (!elts.reserve(pn->pn_count))
>         return false;
> 
>     for (ParseNode *next = pn->pn_head; next; next = next->pn_next) {
>         JS_ASSERT(pn->pn_pos.encloses(next->pn_pos));
> 
>@@ -2184,16 +2286,19 @@ ASTSerializer::statement(ParseNode *pn, 
>         RootedValue arg(cx);
> 
>         return optExpression(pn->pn_kid, &arg) &&
>                (pn->isKind(PNK_THROW)
>                 ? builder.throwStatement(arg, &pn->pn_pos, dst)
>                 : builder.returnStatement(arg, &pn->pn_pos, dst));
>       }
> 
>+      case PNK_EXPORT:
>+        return exportDeclaration(pn, dst);
>+
>       case PNK_DEBUGGER:
>         return builder.debuggerStatement(&pn->pn_pos, dst);
> 
>       case PNK_NOP:
>         return builder.emptyStatement(&pn->pn_pos, dst);
> 
>       default:
>         LOCAL_NOT_REACHED("unexpected statement type");

Flags:

jorendorff: review+

Actions: View | Diff | Review

Attachments on bug 568953: 687721 | 702250 | 702254 | 702255 | 702262 | 702295 | 702298 | 703910 | 704548 | 704949 | 704952 | 706900 | 706903 | 706904 | 707407 | 707409 | 707410 | 707411 | 709113 | 709114 | 709118 | 709121 | 709122 | 709124 | 732393 | 732401 | 732432 | 732433 | 779831 | 779834 | 817414 | 8874471