vnfmarket/src/main/webapp/vnfmarket/node_modules/esprima/test/reflect.js

   1 // This is modified from Mozilla Reflect.parse test suite (the file is located
   2 // at js/src/tests/js1_8_5/extensions/reflect-parse.js in the source tree).
   3 //
   4 // Some notable changes:
   5 //   * Removed unsupported features (destructuring, let, comprehensions...).
   6 //   * Removed tests for E4X (ECMAScript for XML).
   7 //   * Removed everything related to builder.
   8 //   * Enclosed every 'Pattern' construct with a scope.
   9 //   * Tweaked some expected tree to remove generator field.
  10 //   * Removed the test for bug 632030 and bug 632024.
  11
  12 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
  13 /*
  14  * Any copyright is dedicated to the Public Domain.
  15  * http://creativecommons.org/licenses/publicdomain/
  16  */
  17
  18 (function (exports) {
  19
  20 function testReflect(Reflect, Pattern) {
  21
  22 function program(elts) { return Pattern({ type: "Program", body: elts }) }
  23 function exprStmt(expr) { return Pattern({ type: "ExpressionStatement", expression: expr }) }
  24 function throwStmt(expr) { return Pattern({ type: "ThrowStatement", argument: expr }) }
  25 function returnStmt(expr) { return Pattern({ type: "ReturnStatement", argument: expr }) }
  26 function yieldExpr(expr) { return Pattern({ type: "YieldExpression", argument: expr }) }
  27 function lit(val) { return Pattern({ type: "Literal", value: val }) }
  28 var thisExpr = Pattern({ type: "ThisExpression" });
  29 function funDecl(id, params, body) { return Pattern({ type: "FunctionDeclaration",
  30                                              id: id,
  31                                              params: params,
  32                                              defaults: [],
  33                                              body: body,
  34                                              rest: null,
  35                                              generator: false,
  36                                              expression: false
  37                                              }) }
  38 function genFunDecl(id, params, body) { return Pattern({ type: "FunctionDeclaration",
  39                                                 id: id,
  40                                                 params: params,
  41                                                 defaults: [],
  42                                                 body: body,
  43                                                 rest: null,
  44                                                 generator: false,
  45                                                 expression: false
  46                                                 }) }
  47 function declarator(id, init) { return Pattern({ type: "VariableDeclarator", id: id, init: init }) }
  48 function varDecl(decls) { return Pattern({ type: "VariableDeclaration", declarations: decls, kind: "var" }) }
  49 function letDecl(decls) { return Pattern({ type: "VariableDeclaration", declarations: decls, kind: "let" }) }
  50 function constDecl(decls) { return Pattern({ type: "VariableDeclaration", declarations: decls, kind: "const" }) }
  51 function ident(name) { return Pattern({ type: "Identifier", name: name }) }
  52 function dotExpr(obj, id) { return Pattern({ type: "MemberExpression", computed: false, object: obj, property: id }) }
  53 function memExpr(obj, id) { return Pattern({ type: "MemberExpression", computed: true, object: obj, property: id }) }
  54 function forStmt(init, test, update, body) { return Pattern({ type: "ForStatement", init: init, test: test, update: update, body: body }) }
  55 function forInStmt(lhs, rhs, body) { return Pattern({ type: "ForInStatement", left: lhs, right: rhs, body: body, each: false }) }
  56 function forEachInStmt(lhs, rhs, body) { return Pattern({ type: "ForInStatement", left: lhs, right: rhs, body: body, each: true }) }
  57 function breakStmt(lab) { return Pattern({ type: "BreakStatement", label: lab }) }
  58 function continueStmt(lab) { return Pattern({ type: "ContinueStatement", label: lab }) }
  59 function blockStmt(body) { return Pattern({ type: "BlockStatement", body: body }) }
  60 var emptyStmt = Pattern({ type: "EmptyStatement" });
  61 function ifStmt(test, cons, alt) { return Pattern({ type: "IfStatement", test: test, alternate: alt, consequent: cons }) }
  62 function labStmt(lab, stmt) { return Pattern({ type: "LabeledStatement", label: lab, body: stmt }) }
  63 function withStmt(obj, stmt) { return Pattern({ type: "WithStatement", object: obj, body: stmt }) }
  64 function whileStmt(test, stmt) { return Pattern({ type: "WhileStatement", test: test, body: stmt }) }
  65 function doStmt(stmt, test) { return Pattern({ type: "DoWhileStatement", test: test, body: stmt }) }
  66 function switchStmt(disc, cases) { return Pattern({ type: "SwitchStatement", discriminant: disc, cases: cases }) }
  67 function caseClause(test, stmts) { return Pattern({ type: "SwitchCase", test: test, consequent: stmts }) }
  68 function defaultClause(stmts) { return Pattern({ type: "SwitchCase", test: null, consequent: stmts }) }
  69 function catchClause(id, guard, body) { if (guard) { return Pattern({ type: "GuardedCatchClause", param: id, guard: guard, body: body }) } else { return Pattern({ type: "CatchClause", param: id, body: body }) } }
  70 function tryStmt(body, guarded, catches, fin) { return Pattern({ type: "TryStatement", block: body, guardedHandlers: guarded, handlers: catches, finalizer: fin }) }
  71 function letStmt(head, body) { return Pattern({ type: "LetStatement", head: head, body: body }) }
  72 function funExpr(id, args, body, gen) { return Pattern({ type: "FunctionExpression",
  73                                                 id: id,
  74                                                 params: args,
  75                                                 defaults: [],
  76                                                 body: body,
  77                                                 rest: null,
  78                                                 generator: false,
  79                                                 expression: false
  80                                                 }) }
  81 function genFunExpr(id, args, body) { return Pattern({ type: "FunctionExpression",
  82                                               id: id,
  83                                               params: args,
  84                                               defaults: [],
  85                                               body: body,
  86                                               rest: null,
  87                                               generator: false,
  88                                               expression: false
  89                                               }) }
  90
  91 function unExpr(op, arg) { return Pattern({ type: "UnaryExpression", operator: op, argument: arg, prefix: true }) }
  92 function binExpr(op, left, right) { return Pattern({ type: "BinaryExpression", operator: op, left: left, right: right }) }
  93 function aExpr(op, left, right) { return Pattern({ type: "AssignmentExpression", operator: op, left: left, right: right }) }
  94 function updExpr(op, arg, prefix) { return Pattern({ type: "UpdateExpression", operator: op, argument: arg, prefix: prefix }) }
  95 function logExpr(op, left, right) { return Pattern({ type: "LogicalExpression", operator: op, left: left, right: right }) }
  96
  97 function condExpr(test, cons, alt) { return Pattern({ type: "ConditionalExpression", test: test, consequent: cons, alternate: alt }) }
  98 function seqExpr(exprs) { return Pattern({ type: "SequenceExpression", expressions: exprs }) }
  99 function newExpr(callee, args) { return Pattern({ type: "NewExpression", callee: callee, arguments: args }) }
 100 function callExpr(callee, args) { return Pattern({ type: "CallExpression", callee: callee, arguments: args }) }
 101 function arrExpr(elts) { return Pattern({ type: "ArrayExpression", elements: elts }) }
 102 function objExpr(elts) { return Pattern({ type: "ObjectExpression", properties: elts }) }
 103 function objProp(key, value, kind) { return Pattern({ type: "Property", key: key, value: value, kind: kind }) }
 104
 105 function arrPatt(elts) { return Pattern({ type: "ArrayPattern", elements: elts }) }
 106 function objPatt(elts) { return Pattern({ type: "ObjectPattern", properties: elts }) }
 107
 108 function localSrc(src) { return "(function(){ " + src + " })" }
 109 function localPatt(patt) { return program([exprStmt(funExpr(null, [], blockStmt([patt])))]) }
 110 function blockSrc(src) { return "(function(){ { " + src + " } })" }
 111 function blockPatt(patt) { return program([exprStmt(funExpr(null, [], blockStmt([blockStmt([patt])])))]) }
 112
 113 function assertBlockStmt(src, patt) {
 114     blockPatt(patt).assert(Reflect.parse(blockSrc(src)));
 115 }
 116
 117 function assertBlockExpr(src, patt) {
 118     assertBlockStmt(src, exprStmt(patt));
 119 }
 120
 121 function assertBlockDecl(src, patt, builder) {
 122     blockPatt(patt).assert(Reflect.parse(blockSrc(src), {builder: builder}));
 123 }
 124
 125 function assertLocalStmt(src, patt) {
 126     localPatt(patt).assert(Reflect.parse(localSrc(src)));
 127 }
 128
 129 function assertLocalExpr(src, patt) {
 130     assertLocalStmt(src, exprStmt(patt));
 131 }
 132
 133 function assertLocalDecl(src, patt) {
 134     localPatt(patt).assert(Reflect.parse(localSrc(src)));
 135 }
 136
 137 function assertGlobalStmt(src, patt, builder) {
 138     program([patt]).assert(Reflect.parse(src, {builder: builder}));
 139 }
 140
 141 function assertGlobalExpr(src, patt, builder) {
 142     program([exprStmt(patt)]).assert(Reflect.parse(src, {builder: builder}));
 143     //assertStmt(src, exprStmt(patt));
 144 }
 145
 146 function assertGlobalDecl(src, patt) {
 147     program([patt]).assert(Reflect.parse(src));
 148 }
 149
 150 function assertProg(src, patt) {
 151     program(patt).assert(Reflect.parse(src));
 152 }
 153
 154 function assertStmt(src, patt) {
 155     assertLocalStmt(src, patt);
 156     assertGlobalStmt(src, patt);
 157     assertBlockStmt(src, patt);
 158 }
 159
 160 function assertExpr(src, patt) {
 161     assertLocalExpr(src, patt);
 162     assertGlobalExpr(src, patt);
 163     assertBlockExpr(src, patt);
 164 }
 165
 166 function assertDecl(src, patt) {
 167     assertLocalDecl(src, patt);
 168     assertGlobalDecl(src, patt);
 169     assertBlockDecl(src, patt);
 170 }
 171
 172 function assertError(src, errorType) {
 173     try {
 174         Reflect.parse(src);
 175     } catch (e) {
 176         return;
 177     }
 178     throw new Error("expected " + errorType.name + " for " + uneval(src));
 179 }
 180
 181
 182 // general tests
 183
 184 // NB: These are useful but for now jit-test doesn't do I/O reliably.
 185
 186 //program(_).assert(Reflect.parse(snarf('data/flapjax.txt')));
 187 //program(_).assert(Reflect.parse(snarf('data/jquery-1.4.2.txt')));
 188 //program(_).assert(Reflect.parse(snarf('data/prototype.js')));
 189 //program(_).assert(Reflect.parse(snarf('data/dojo.js.uncompressed.js')));
 190 //program(_).assert(Reflect.parse(snarf('data/mootools-1.2.4-core-nc.js')));
 191
 192
 193 // declarations
 194
 195 assertDecl("var x = 1, y = 2, z = 3",
 196            varDecl([declarator(ident("x"), lit(1)),
 197                     declarator(ident("y"), lit(2)),
 198                     declarator(ident("z"), lit(3))]));
 199 assertDecl("var x, y, z",
 200            varDecl([declarator(ident("x"), null),
 201                     declarator(ident("y"), null),
 202                     declarator(ident("z"), null)]));
 203 assertDecl("function foo() { }",
 204            funDecl(ident("foo"), [], blockStmt([])));
 205 assertDecl("function foo() { return 42 }",
 206            funDecl(ident("foo"), [], blockStmt([returnStmt(lit(42))])));
 207
 208
 209 // Bug 591437: rebound args have their defs turned into uses
 210 assertDecl("function f(a) { function a() { } }",
 211            funDecl(ident("f"), [ident("a")], blockStmt([funDecl(ident("a"), [], blockStmt([]))])));
 212 assertDecl("function f(a,b,c) { function b() { } }",
 213            funDecl(ident("f"), [ident("a"),ident("b"),ident("c")], blockStmt([funDecl(ident("b"), [], blockStmt([]))])));
 214
 215 // expressions
 216
 217 assertExpr("true", lit(true));
 218 assertExpr("false", lit(false));
 219 assertExpr("42", lit(42));
 220 assertExpr("(/asdf/)", lit(/asdf/));
 221 assertExpr("this", thisExpr);
 222 assertExpr("foo", ident("foo"));
 223 assertExpr("foo.bar", dotExpr(ident("foo"), ident("bar")));
 224 assertExpr("foo[bar]", memExpr(ident("foo"), ident("bar")));
 225 assertExpr("(function(){})", funExpr(null, [], blockStmt([])));
 226 assertExpr("(function f() {})", funExpr(ident("f"), [], blockStmt([])));
 227 assertExpr("(function f(x,y,z) {})", funExpr(ident("f"), [ident("x"),ident("y"),ident("z")], blockStmt([])));
 228 assertExpr("(++x)", updExpr("++", ident("x"), true));
 229 assertExpr("(x++)", updExpr("++", ident("x"), false));
 230 assertExpr("(+x)", unExpr("+", ident("x")));
 231 assertExpr("(-x)", unExpr("-", ident("x")));
 232 assertExpr("(!x)", unExpr("!", ident("x")));
 233 assertExpr("(~x)", unExpr("~", ident("x")));
 234 assertExpr("(delete x)", unExpr("delete", ident("x")));
 235 assertExpr("(typeof x)", unExpr("typeof", ident("x")));
 236 assertExpr("(void x)", unExpr("void", ident("x")));
 237 assertExpr("(x == y)", binExpr("==", ident("x"), ident("y")));
 238 assertExpr("(x != y)", binExpr("!=", ident("x"), ident("y")));
 239 assertExpr("(x === y)", binExpr("===", ident("x"), ident("y")));
 240 assertExpr("(x !== y)", binExpr("!==", ident("x"), ident("y")));
 241 assertExpr("(x < y)", binExpr("<", ident("x"), ident("y")));
 242 assertExpr("(x <= y)", binExpr("<=", ident("x"), ident("y")));
 243 assertExpr("(x > y)", binExpr(">", ident("x"), ident("y")));
 244 assertExpr("(x >= y)", binExpr(">=", ident("x"), ident("y")));
 245 assertExpr("(x << y)", binExpr("<<", ident("x"), ident("y")));
 246 assertExpr("(x >> y)", binExpr(">>", ident("x"), ident("y")));
 247 assertExpr("(x >>> y)", binExpr(">>>", ident("x"), ident("y")));
 248 assertExpr("(x + y)", binExpr("+", ident("x"), ident("y")));
 249 assertExpr("(w + x + y + z)", binExpr("+", binExpr("+", binExpr("+", ident("w"), ident("x")), ident("y")), ident("z")));
 250 assertExpr("(x - y)", binExpr("-", ident("x"), ident("y")));
 251 assertExpr("(w - x - y - z)", binExpr("-", binExpr("-", binExpr("-", ident("w"), ident("x")), ident("y")), ident("z")));
 252 assertExpr("(x * y)", binExpr("*", ident("x"), ident("y")));
 253 assertExpr("(x / y)", binExpr("/", ident("x"), ident("y")));
 254 assertExpr("(x % y)", binExpr("%", ident("x"), ident("y")));
 255 assertExpr("(x | y)", binExpr("|", ident("x"), ident("y")));
 256 assertExpr("(x ^ y)", binExpr("^", ident("x"), ident("y")));
 257 assertExpr("(x & y)", binExpr("&", ident("x"), ident("y")));
 258 assertExpr("(x in y)", binExpr("in", ident("x"), ident("y")));
 259 assertExpr("(x instanceof y)", binExpr("instanceof", ident("x"), ident("y")));
 260 assertExpr("(x = y)", aExpr("=", ident("x"), ident("y")));
 261 assertExpr("(x += y)", aExpr("+=", ident("x"), ident("y")));
 262 assertExpr("(x -= y)", aExpr("-=", ident("x"), ident("y")));
 263 assertExpr("(x *= y)", aExpr("*=", ident("x"), ident("y")));
 264 assertExpr("(x /= y)", aExpr("/=", ident("x"), ident("y")));
 265 assertExpr("(x %= y)", aExpr("%=", ident("x"), ident("y")));
 266 assertExpr("(x <<= y)", aExpr("<<=", ident("x"), ident("y")));
 267 assertExpr("(x >>= y)", aExpr(">>=", ident("x"), ident("y")));
 268 assertExpr("(x >>>= y)", aExpr(">>>=", ident("x"), ident("y")));
 269 assertExpr("(x |= y)", aExpr("|=", ident("x"), ident("y")));
 270 assertExpr("(x ^= y)", aExpr("^=", ident("x"), ident("y")));
 271 assertExpr("(x &= y)", aExpr("&=", ident("x"), ident("y")));
 272 assertExpr("(x || y)", logExpr("||", ident("x"), ident("y")));
 273 assertExpr("(x && y)", logExpr("&&", ident("x"), ident("y")));
 274 assertExpr("(w || x || y || z)", logExpr("||", logExpr("||", logExpr("||", ident("w"), ident("x")), ident("y")), ident("z")))
 275 assertExpr("(x ? y : z)", condExpr(ident("x"), ident("y"), ident("z")));
 276 assertExpr("(x,y)", seqExpr([ident("x"),ident("y")]))
 277 assertExpr("(x,y,z)", seqExpr([ident("x"),ident("y"),ident("z")]))
 278 assertExpr("(a,b,c,d,e,f,g)", seqExpr([ident("a"),ident("b"),ident("c"),ident("d"),ident("e"),ident("f"),ident("g")]));
 279 assertExpr("(new Object)", newExpr(ident("Object"), []));
 280 assertExpr("(new Object())", newExpr(ident("Object"), []));
 281 assertExpr("(new Object(42))", newExpr(ident("Object"), [lit(42)]));
 282 assertExpr("(new Object(1,2,3))", newExpr(ident("Object"), [lit(1),lit(2),lit(3)]));
 283 assertExpr("(String())", callExpr(ident("String"), []));
 284 assertExpr("(String(42))", callExpr(ident("String"), [lit(42)]));
 285 assertExpr("(String(1,2,3))", callExpr(ident("String"), [lit(1),lit(2),lit(3)]));
 286 assertExpr("[]", arrExpr([]));
 287 assertExpr("[1]", arrExpr([lit(1)]));
 288 assertExpr("[1,2]", arrExpr([lit(1),lit(2)]));
 289 assertExpr("[1,2,3]", arrExpr([lit(1),lit(2),lit(3)]));
 290 assertExpr("[1,,2,3]", arrExpr([lit(1),,lit(2),lit(3)]));
 291 assertExpr("[1,,,2,3]", arrExpr([lit(1),,,lit(2),lit(3)]));
 292 assertExpr("[1,,,2,,3]", arrExpr([lit(1),,,lit(2),,lit(3)]));
 293 assertExpr("[1,,,2,,,3]", arrExpr([lit(1),,,lit(2),,,lit(3)]));
 294 assertExpr("[,1,2,3]", arrExpr([,lit(1),lit(2),lit(3)]));
 295 assertExpr("[,,1,2,3]", arrExpr([,,lit(1),lit(2),lit(3)]));
 296 assertExpr("[,,,1,2,3]", arrExpr([,,,lit(1),lit(2),lit(3)]));
 297 assertExpr("[,,,1,2,3,]", arrExpr([,,,lit(1),lit(2),lit(3)]));
 298 assertExpr("[,,,1,2,3,,]", arrExpr([,,,lit(1),lit(2),lit(3),undefined]));
 299 assertExpr("[,,,1,2,3,,,]", arrExpr([,,,lit(1),lit(2),lit(3),undefined,undefined]));
 300 assertExpr("[,,,,,]", arrExpr([undefined,undefined,undefined,undefined,undefined]));
 301 assertExpr("({})", objExpr([]));
 302 assertExpr("({x:1})", objExpr([objProp(ident("x"), lit(1), "init")]));
 303 assertExpr("({x:1, y:2})", objExpr([objProp(ident("x"), lit(1), "init"),
 304                                     objProp(ident("y"), lit(2), "init")]));
 305 assertExpr("({x:1, y:2, z:3})", objExpr([objProp(ident("x"), lit(1), "init"),
 306                                          objProp(ident("y"), lit(2), "init"),
 307                                          objProp(ident("z"), lit(3), "init") ]));
 308 assertExpr("({x:1, 'y':2, z:3})", objExpr([objProp(ident("x"), lit(1), "init"),
 309                                            objProp(lit("y"), lit(2), "init"),
 310                                            objProp(ident("z"), lit(3), "init") ]));
 311 assertExpr("({'x':1, 'y':2, z:3})", objExpr([objProp(lit("x"), lit(1), "init"),
 312                                              objProp(lit("y"), lit(2), "init"),
 313                                              objProp(ident("z"), lit(3), "init") ]));
 314 assertExpr("({'x':1, 'y':2, 3:3})", objExpr([objProp(lit("x"), lit(1), "init"),
 315                                              objProp(lit("y"), lit(2), "init"),
 316                                              objProp(lit(3), lit(3), "init") ]));
 317
 318 // Bug 571617: eliminate constant-folding
 319 assertExpr("2 + 3", binExpr("+", lit(2), lit(3)));
 320
 321 // Bug 632026: constant-folding
 322 assertExpr("typeof(0?0:a)", unExpr("typeof", condExpr(lit(0), lit(0), ident("a"))));
 323
 324 // Bug 632056: constant-folding
 325 program([exprStmt(ident("f")),
 326          ifStmt(lit(1),
 327                 funDecl(ident("f"), [], blockStmt([])),
 328                 null)]).assert(Reflect.parse("f; if (1) function f(){}"));
 329
 330 // statements
 331
 332 assertStmt("throw 42", throwStmt(lit(42)));
 333 assertStmt("for (;;) break", forStmt(null, null, null, breakStmt(null)));
 334 assertStmt("for (x; y; z) break", forStmt(ident("x"), ident("y"), ident("z"), breakStmt(null)));
 335 assertStmt("for (var x; y; z) break", forStmt(varDecl([declarator(ident("x"), null)]), ident("y"), ident("z"), breakStmt(null)));
 336 assertStmt("for (var x = 42; y; z) break", forStmt(varDecl([declarator(ident("x"), lit(42))]), ident("y"), ident("z"), breakStmt(null)));
 337 assertStmt("for (x; ; z) break", forStmt(ident("x"), null, ident("z"), breakStmt(null)));
 338 assertStmt("for (var x; ; z) break", forStmt(varDecl([declarator(ident("x"), null)]), null, ident("z"), breakStmt(null)));
 339 assertStmt("for (var x = 42; ; z) break", forStmt(varDecl([declarator(ident("x"), lit(42))]), null, ident("z"), breakStmt(null)));
 340 assertStmt("for (x; y; ) break", forStmt(ident("x"), ident("y"), null, breakStmt(null)));
 341 assertStmt("for (var x; y; ) break", forStmt(varDecl([declarator(ident("x"), null)]), ident("y"), null, breakStmt(null)));
 342 assertStmt("for (var x = 42; y; ) break", forStmt(varDecl([declarator(ident("x"),lit(42))]), ident("y"), null, breakStmt(null)));
 343 assertStmt("for (var x in y) break", forInStmt(varDecl([declarator(ident("x"),null)]), ident("y"), breakStmt(null)));
 344 assertStmt("for (x in y) break", forInStmt(ident("x"), ident("y"), breakStmt(null)));
 345 assertStmt("{ }", blockStmt([]));
 346 assertStmt("{ throw 1; throw 2; throw 3; }", blockStmt([ throwStmt(lit(1)), throwStmt(lit(2)), throwStmt(lit(3))]));
 347 assertStmt(";", emptyStmt);
 348 assertStmt("if (foo) throw 42;", ifStmt(ident("foo"), throwStmt(lit(42)), null));
 349 assertStmt("if (foo) throw 42; else true;", ifStmt(ident("foo"), throwStmt(lit(42)), exprStmt(lit(true))));
 350 assertStmt("if (foo) { throw 1; throw 2; throw 3; }",
 351            ifStmt(ident("foo"),
 352                   blockStmt([throwStmt(lit(1)), throwStmt(lit(2)), throwStmt(lit(3))]),
 353                   null));
 354 assertStmt("if (foo) { throw 1; throw 2; throw 3; } else true;",
 355            ifStmt(ident("foo"),
 356                   blockStmt([throwStmt(lit(1)), throwStmt(lit(2)), throwStmt(lit(3))]),
 357                   exprStmt(lit(true))));
 358 assertStmt("foo: for(;;) break foo;", labStmt(ident("foo"), forStmt(null, null, null, breakStmt(ident("foo")))));
 359 assertStmt("foo: for(;;) continue foo;", labStmt(ident("foo"), forStmt(null, null, null, continueStmt(ident("foo")))));
 360 assertStmt("with (obj) { }", withStmt(ident("obj"), blockStmt([])));
 361 assertStmt("with (obj) { obj; }", withStmt(ident("obj"), blockStmt([exprStmt(ident("obj"))])));
 362 assertStmt("while (foo) { }", whileStmt(ident("foo"), blockStmt([])));
 363 assertStmt("while (foo) { foo; }", whileStmt(ident("foo"), blockStmt([exprStmt(ident("foo"))])));
 364 assertStmt("do { } while (foo);", doStmt(blockStmt([]), ident("foo")));
 365 assertStmt("do { foo; } while (foo)", doStmt(blockStmt([exprStmt(ident("foo"))]), ident("foo")));
 366 assertStmt("switch (foo) { case 1: 1; break; case 2: 2; break; default: 3; }",
 367            switchStmt(ident("foo"),
 368                       [ caseClause(lit(1), [ exprStmt(lit(1)), breakStmt(null) ]),
 369                         caseClause(lit(2), [ exprStmt(lit(2)), breakStmt(null) ]),
 370                         defaultClause([ exprStmt(lit(3)) ]) ]));
 371 assertStmt("switch (foo) { case 1: 1; break; case 2: 2; break; default: 3; case 42: 42; }",
 372            switchStmt(ident("foo"),
 373                       [ caseClause(lit(1), [ exprStmt(lit(1)), breakStmt(null) ]),
 374                         caseClause(lit(2), [ exprStmt(lit(2)), breakStmt(null) ]),
 375                         defaultClause([ exprStmt(lit(3)) ]),
 376                         caseClause(lit(42), [ exprStmt(lit(42)) ]) ]));
 377 assertStmt("try { } catch (e) { }",
 378            tryStmt(blockStmt([]),
 379                    [],
 380                    [ catchClause(ident("e"), null, blockStmt([])) ],
 381                    null));
 382 assertStmt("try { } catch (e) { } finally { }",
 383            tryStmt(blockStmt([]),
 384                    [],
 385                    [ catchClause(ident("e"), null, blockStmt([])) ],
 386                    blockStmt([])));
 387 assertStmt("try { } finally { }",
 388            tryStmt(blockStmt([]),
 389                    [],
 390                    [],
 391                    blockStmt([])));
 392
 393 // redeclarations (TOK_NAME nodes with lexdef)
 394
 395 assertStmt("function f() { function g() { } function g() { } }",
 396            funDecl(ident("f"), [], blockStmt([funDecl(ident("g"), [], blockStmt([])),
 397                                               funDecl(ident("g"), [], blockStmt([]))])));
 398
 399 assertStmt("function f() { function g() { } function g() { return 42 } }",
 400            funDecl(ident("f"), [], blockStmt([funDecl(ident("g"), [], blockStmt([])),
 401                                               funDecl(ident("g"), [], blockStmt([returnStmt(lit(42))]))])));
 402
 403 assertStmt("function f() { var x = 42; var x = 43; }",
 404            funDecl(ident("f"), [], blockStmt([varDecl([declarator(ident("x"),lit(42))]),
 405                                               varDecl([declarator(ident("x"),lit(43))])])));
 406
 407 // getters and setters
 408
 409  assertExpr("({ get x() { return 42 } })",
 410             objExpr([ objProp(ident("x"),
 411                               funExpr(null, [], blockStmt([returnStmt(lit(42))])),
 412                               "get" ) ]));
 413  assertExpr("({ set x(v) { return 42 } })",
 414             objExpr([ objProp(ident("x"),
 415                               funExpr(null, [ident("v")], blockStmt([returnStmt(lit(42))])),
 416                               "set" ) ]));
 417
 418 }
 419
 420 exports.testReflect = testReflect;
 421
 422 }(typeof exports === 'undefined' ? this : exports));