Destructuring consistency fixes (#1417)
- Use AST_Destructuring for lhf assignment patterns - Use AST_DefaultAssign for default assignments - Add more checks for lhs expressions - Add lots of testing - Cleanup ast (e.g. remove default property) - Fix #1402 based on a patch from @kzc - Refine spread allowance in array destructring pattern - Add destructuring AST tree checker
This commit is contained in:
Anthony Van de Gejuchte
committed by
Alex Lam S.L
Alex Lam S.L
parent
85c1cba760
commit
07734b000a
@@ -27,4 +27,253 @@ describe("arguments", function() {
|
||||
assert.strictEqual(ast.body[0].body[0].uses_arguments, true);
|
||||
assert.strictEqual(ast.body[0].body[0].body[0].uses_arguments, false);
|
||||
});
|
||||
});
|
||||
|
||||
it("Should parse a function containing default assignment correctly", function() {
|
||||
var ast = UglifyJS.parse("function foo(a = 123) {}");
|
||||
assert(ast.body[0] instanceof UglifyJS.AST_Defun);
|
||||
assert.strictEqual(ast.body[0].argnames.length, 1);
|
||||
|
||||
// First argument
|
||||
assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_DefaultAssign);
|
||||
assert(ast.body[0].argnames[0].left instanceof UglifyJS.AST_SymbolFunarg);
|
||||
assert.strictEqual(ast.body[0].argnames[0].operator, "=");
|
||||
assert(ast.body[0].argnames[0].right instanceof UglifyJS.AST_Number);
|
||||
|
||||
ast = UglifyJS.parse("function foo(a = a) {}");
|
||||
assert(ast.body[0] instanceof UglifyJS.AST_Defun);
|
||||
assert.strictEqual(ast.body[0].argnames.length, 1);
|
||||
|
||||
// First argument
|
||||
assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_DefaultAssign);
|
||||
assert(ast.body[0].argnames[0].left instanceof UglifyJS.AST_SymbolFunarg);
|
||||
assert.strictEqual(ast.body[0].argnames[0].operator, "=");
|
||||
assert(ast.body[0].argnames[0].right instanceof UglifyJS.AST_SymbolRef);
|
||||
});
|
||||
|
||||
it("Should parse a function containing default assignments in destructuring correctly", function() {
|
||||
var ast = UglifyJS.parse("function foo([a = 123]) {}");
|
||||
assert(ast.body[0] instanceof UglifyJS.AST_Defun);
|
||||
assert.strictEqual(ast.body[0].argnames.length, 1);
|
||||
|
||||
// First argument
|
||||
assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].argnames[0].is_array, true);
|
||||
assert.strictEqual(ast.body[0].argnames[0].names.length, 1);
|
||||
assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_DefaultAssign);
|
||||
assert(ast.body[0].argnames[0].names[0].left instanceof UglifyJS.AST_SymbolFunarg);
|
||||
assert.strictEqual(ast.body[0].argnames[0].names[0].operator, "=");
|
||||
assert(ast.body[0].argnames[0].names[0].right instanceof UglifyJS.AST_Number);
|
||||
|
||||
|
||||
ast = UglifyJS.parse("function foo({a = 123}) {}");
|
||||
assert(ast.body[0] instanceof UglifyJS.AST_Defun);
|
||||
assert.strictEqual(ast.body[0].argnames.length, 1);
|
||||
|
||||
// First argument
|
||||
assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].argnames[0].is_array, false);
|
||||
assert.strictEqual(ast.body[0].argnames[0].names.length, 1);
|
||||
assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_ObjectKeyVal);
|
||||
assert.strictEqual(ast.body[0].argnames[0].names[0].key, "a");
|
||||
|
||||
// Property a of first argument
|
||||
assert(ast.body[0].argnames[0].names[0].value instanceof UglifyJS.AST_DefaultAssign);
|
||||
assert(ast.body[0].argnames[0].names[0].value.left instanceof UglifyJS.AST_SymbolFunarg);
|
||||
assert.strictEqual(ast.body[0].argnames[0].names[0].value.operator, "=");
|
||||
assert(ast.body[0].argnames[0].names[0].value.right instanceof UglifyJS.AST_Number);
|
||||
|
||||
|
||||
ast = UglifyJS.parse("function foo({a: a = 123}) {}");
|
||||
assert(ast.body[0] instanceof UglifyJS.AST_Defun);
|
||||
assert.strictEqual(ast.body[0].argnames.length, 1);
|
||||
|
||||
// First argument
|
||||
assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].argnames[0].is_array, false);
|
||||
assert.strictEqual(ast.body[0].argnames[0].names.length, 1);
|
||||
|
||||
// Content destructuring of first argument
|
||||
assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_ObjectKeyVal);
|
||||
assert.strictEqual(ast.body[0].argnames[0].names[0].key, "a");
|
||||
assert(ast.body[0].argnames[0].names[0].value instanceof UglifyJS.AST_DefaultAssign);
|
||||
|
||||
// Property a of first argument
|
||||
assert(ast.body[0].argnames[0].names[0].value instanceof UglifyJS.AST_DefaultAssign);
|
||||
assert(ast.body[0].argnames[0].names[0].value.left instanceof UglifyJS.AST_SymbolFunarg);
|
||||
assert.strictEqual(ast.body[0].argnames[0].names[0].value.operator, "=");
|
||||
assert(ast.body[0].argnames[0].names[0].value.right instanceof UglifyJS.AST_Number);
|
||||
});
|
||||
|
||||
it("Should parse a function containing default assignments in complex destructuring correctly", function() {
|
||||
var ast = UglifyJS.parse("function foo([a, [b = 123]]){}");
|
||||
assert(ast.body[0] instanceof UglifyJS.AST_Defun);
|
||||
assert.strictEqual(ast.body[0].argnames.length, 1);
|
||||
|
||||
// Check first argument
|
||||
assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].argnames[0].is_array, true);
|
||||
assert.strictEqual(ast.body[0].argnames[0].names.length, 2);
|
||||
|
||||
// Check whole destructuring structure of first argument
|
||||
assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_SymbolFunarg);
|
||||
assert(ast.body[0].argnames[0].names[1] instanceof UglifyJS.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].argnames[0].names[1].is_array, true);
|
||||
|
||||
// Check content of second destructuring element (which is the nested destructuring pattern)
|
||||
assert(ast.body[0].argnames[0].names[1].names[0] instanceof UglifyJS.AST_DefaultAssign);
|
||||
assert(ast.body[0].argnames[0].names[1].names[0].left instanceof UglifyJS.AST_SymbolFunarg);
|
||||
assert.strictEqual(ast.body[0].argnames[0].names[1].names[0].operator, "=");
|
||||
assert(ast.body[0].argnames[0].names[1].names[0].right instanceof UglifyJS.AST_Number);
|
||||
|
||||
|
||||
ast = UglifyJS.parse("function foo([a, {b: c = 123}]){}");
|
||||
assert(ast.body[0] instanceof UglifyJS.AST_Defun);
|
||||
assert.strictEqual(ast.body[0].argnames.length, 1);
|
||||
|
||||
// Check first argument
|
||||
assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].argnames[0].is_array, true);
|
||||
assert.strictEqual(ast.body[0].argnames[0].names.length, 2);
|
||||
|
||||
// Check whole destructuring structure of first argument
|
||||
assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_SymbolFunarg);
|
||||
assert(ast.body[0].argnames[0].names[1] instanceof UglifyJS.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].argnames[0].names[1].is_array, false);
|
||||
|
||||
// Check content of second destructuring element (which is the nested destructuring pattern)
|
||||
assert(ast.body[0].argnames[0].names[1].names[0] instanceof UglifyJS.AST_ObjectKeyVal);
|
||||
assert.strictEqual(ast.body[0].argnames[0].names[1].names[0].key, "b");
|
||||
assert(ast.body[0].argnames[0].names[1].names[0].value instanceof UglifyJS.AST_DefaultAssign);
|
||||
|
||||
// Property b of second argument
|
||||
assert(ast.body[0].argnames[0].names[1].names[0].value instanceof UglifyJS.AST_DefaultAssign);
|
||||
assert(ast.body[0].argnames[0].names[1].names[0].value.left instanceof UglifyJS.AST_SymbolFunarg);
|
||||
assert.strictEqual(ast.body[0].argnames[0].names[1].names[0].value.operator, "=");
|
||||
assert(ast.body[0].argnames[0].names[1].names[0].value.right instanceof UglifyJS.AST_Number);
|
||||
|
||||
|
||||
ast = UglifyJS.parse("function foo({a, b: {b = 123}}){}");
|
||||
assert(ast.body[0] instanceof UglifyJS.AST_Defun);
|
||||
assert.strictEqual(ast.body[0].argnames.length, 1);
|
||||
|
||||
// Check first argument
|
||||
assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].argnames[0].is_array, false);
|
||||
assert.strictEqual(ast.body[0].argnames[0].names.length, 2);
|
||||
|
||||
// Check whole destructuring structure of first argument
|
||||
assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_ObjectKeyVal);
|
||||
assert.strictEqual(ast.body[0].argnames[0].names[0].key, "a");
|
||||
assert(ast.body[0].argnames[0].names[0].value instanceof UglifyJS.AST_SymbolFunarg);
|
||||
assert(ast.body[0].argnames[0].names[1] instanceof UglifyJS.AST_ObjectKeyVal);
|
||||
assert.strictEqual(ast.body[0].argnames[0].names[1].key, "b");
|
||||
assert(ast.body[0].argnames[0].names[1].value instanceof UglifyJS.AST_Destructuring);
|
||||
|
||||
// Check content of nested destructuring in first parameter
|
||||
var content = ast.body[0].argnames[0].names[1].value
|
||||
assert.strictEqual(content.is_array, false);
|
||||
assert.strictEqual(content.names.length, 1);
|
||||
assert(content.names[0] instanceof UglifyJS.AST_ObjectKeyVal);
|
||||
assert.strictEqual(content.names[0].key, "b");
|
||||
assert(content.names[0].value instanceof UglifyJS.AST_DefaultAssign);
|
||||
assert(content.names[0].value.left instanceof UglifyJS.AST_SymbolFunarg);
|
||||
assert.strictEqual(content.names[0].value.operator, "=");
|
||||
assert(content.names[0].value.right instanceof UglifyJS.AST_Number);
|
||||
|
||||
|
||||
ast = UglifyJS.parse("function foo({a: {b = 123}}){}");
|
||||
assert(ast.body[0] instanceof UglifyJS.AST_Defun);
|
||||
assert.strictEqual(ast.body[0].argnames.length, 1);
|
||||
|
||||
// Check first argument
|
||||
assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].argnames[0].is_array, false);
|
||||
assert.strictEqual(ast.body[0].argnames[0].names.length, 1);
|
||||
|
||||
// Check whole destructuring structure of first argument
|
||||
assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_ObjectKeyVal);
|
||||
assert.strictEqual(ast.body[0].argnames[0].names[0].key, "a");
|
||||
assert(ast.body[0].argnames[0].names[0].value instanceof UglifyJS.AST_Destructuring);
|
||||
|
||||
// Check content of nested destructuring
|
||||
content = ast.body[0].argnames[0].names[0].value
|
||||
assert.strictEqual(content.is_array, false);
|
||||
assert.strictEqual(content.names.length, 1);
|
||||
assert(content.names[0] instanceof UglifyJS.AST_ObjectKeyVal);
|
||||
assert.strictEqual(content.names[0].key, "b");
|
||||
assert(content.names[0].value instanceof UglifyJS.AST_DefaultAssign);
|
||||
assert(content.names[0].value.left instanceof UglifyJS.AST_SymbolFunarg);
|
||||
assert.strictEqual(content.names[0].value.operator, "=");
|
||||
assert(content.names[0].value.right instanceof UglifyJS.AST_Number);
|
||||
});
|
||||
|
||||
it("Should parse spread correctly", function() {
|
||||
var ast = UglifyJS.parse("function foo(a, b, ...c){}");
|
||||
assert(ast.body[0] instanceof UglifyJS.AST_Defun);
|
||||
assert.strictEqual(ast.body[0].argnames.length, 3);
|
||||
|
||||
// Check parameters
|
||||
assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_SymbolFunarg);
|
||||
assert(ast.body[0].argnames[1] instanceof UglifyJS.AST_SymbolFunarg);
|
||||
assert(ast.body[0].argnames[2] instanceof UglifyJS.AST_Expansion);
|
||||
assert(ast.body[0].argnames[2].expression instanceof UglifyJS.AST_SymbolFunarg);
|
||||
|
||||
|
||||
ast = UglifyJS.parse("function foo([a, b, ...c]){}");
|
||||
assert(ast.body[0] instanceof UglifyJS.AST_Defun);
|
||||
assert.strictEqual(ast.body[0].argnames.length, 1);
|
||||
|
||||
// Check first parameter
|
||||
assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].argnames[0].is_array, true);
|
||||
|
||||
// Check content first parameter
|
||||
assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_SymbolFunarg);
|
||||
assert(ast.body[0].argnames[0].names[1] instanceof UglifyJS.AST_SymbolFunarg);
|
||||
assert(ast.body[0].argnames[0].names[2] instanceof UglifyJS.AST_Expansion);
|
||||
assert(ast.body[0].argnames[0].names[2].expression instanceof UglifyJS.AST_SymbolFunarg);
|
||||
|
||||
|
||||
ast = UglifyJS.parse("function foo([a, b, [c, ...d]]){}");
|
||||
assert(ast.body[0] instanceof UglifyJS.AST_Defun);
|
||||
assert.strictEqual(ast.body[0].argnames.length, 1);
|
||||
|
||||
// Check first parameter
|
||||
assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].argnames[0].is_array, true);
|
||||
|
||||
// Check content outer destructuring array
|
||||
assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_SymbolFunarg);
|
||||
assert(ast.body[0].argnames[0].names[1] instanceof UglifyJS.AST_SymbolFunarg);
|
||||
assert(ast.body[0].argnames[0].names[2] instanceof UglifyJS.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].argnames[0].names[2].is_array, true);
|
||||
|
||||
// Check content nested destructuring array
|
||||
assert.strictEqual(ast.body[0].argnames[0].names[2].names.length, 2);
|
||||
assert(ast.body[0].argnames[0].names[2].names[0] instanceof UglifyJS.AST_SymbolFunarg);
|
||||
assert(ast.body[0].argnames[0].names[2].names[1] instanceof UglifyJS.AST_Expansion);
|
||||
assert(ast.body[0].argnames[0].names[2].names[1].expression instanceof UglifyJS.AST_SymbolFunarg);
|
||||
|
||||
|
||||
ast = UglifyJS.parse("function foo({a: [b, ...c]}){}");
|
||||
assert(ast.body[0] instanceof UglifyJS.AST_Defun);
|
||||
assert.strictEqual(ast.body[0].argnames.length, 1);
|
||||
|
||||
// Check first parameter
|
||||
assert(ast.body[0].argnames[0] instanceof UglifyJS.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].argnames[0].is_array, false);
|
||||
|
||||
// Check outer destructuring object
|
||||
assert.strictEqual(ast.body[0].argnames[0].names.length, 1);
|
||||
assert(ast.body[0].argnames[0].names[0] instanceof UglifyJS.AST_ObjectKeyVal);
|
||||
assert.strictEqual(ast.body[0].argnames[0].names[0].key, "a");
|
||||
assert(ast.body[0].argnames[0].names[0].value instanceof UglifyJS.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].argnames[0].names[0].value.is_array, true);
|
||||
|
||||
// Check content nested destructuring array
|
||||
assert.strictEqual(ast.body[0].argnames[0].names[0].value.names.length, 2);
|
||||
assert(ast.body[0].argnames[0].names[0].value.names[0] instanceof UglifyJS.AST_SymbolFunarg);
|
||||
assert(ast.body[0].argnames[0].names[0].value.names[1] instanceof UglifyJS.AST_Expansion);
|
||||
assert(ast.body[0].argnames[0].names[0].value.names[1].expression instanceof UglifyJS.AST_SymbolFunarg);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -80,4 +80,306 @@ describe("Arrow functions", function() {
|
||||
assert.throws(test(tests[i]), error);
|
||||
}
|
||||
});
|
||||
|
||||
it("Should parse a function containing default assignment correctly", function() {
|
||||
var ast = uglify.parse("var a = (a = 123) => {}");
|
||||
assert(ast.body[0] instanceof uglify.AST_Var);
|
||||
assert.strictEqual(ast.body[0].definitions.length, 1);
|
||||
assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
|
||||
assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
|
||||
assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
|
||||
|
||||
// First argument
|
||||
assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_DefaultAssign);
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].left instanceof uglify.AST_SymbolFunarg);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].operator, "=");
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].right instanceof uglify.AST_Number);
|
||||
|
||||
ast = uglify.parse("var a = (a = a) => {}");
|
||||
assert(ast.body[0] instanceof uglify.AST_Var);
|
||||
assert.strictEqual(ast.body[0].definitions.length, 1);
|
||||
assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
|
||||
assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
|
||||
assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
|
||||
|
||||
// First argument
|
||||
assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_DefaultAssign);
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].left instanceof uglify.AST_SymbolFunarg);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].operator, "=");
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].right instanceof uglify.AST_SymbolRef);
|
||||
});
|
||||
|
||||
it("Should parse a function containing default assignments in destructuring correctly", function() {
|
||||
var ast = uglify.parse("var a = ([a = 123]) => {}");
|
||||
assert(ast.body[0] instanceof uglify.AST_Var);
|
||||
assert.strictEqual(ast.body[0].definitions.length, 1);
|
||||
assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
|
||||
assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
|
||||
assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
|
||||
|
||||
// First argument
|
||||
assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, true);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names.length, 1);
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_DefaultAssign);
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[0].left instanceof uglify.AST_SymbolFunarg);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].operator, "=");
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[0].right instanceof uglify.AST_Number);
|
||||
|
||||
|
||||
ast = uglify.parse("var a = ({a = 123}) => {}");
|
||||
assert(ast.body[0] instanceof uglify.AST_Var);
|
||||
assert.strictEqual(ast.body[0].definitions.length, 1);
|
||||
assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
|
||||
assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
|
||||
assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
|
||||
|
||||
// First argument
|
||||
assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, false);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names.length, 1);
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_ObjectKeyVal);
|
||||
|
||||
// First object element in first argument
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].key, "a");
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[0].value instanceof uglify.AST_DefaultAssign);
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[0].value.left instanceof uglify.AST_SymbolFunarg);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].value.operator, "=");
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[0].value.right instanceof uglify.AST_Number);
|
||||
|
||||
|
||||
ast = uglify.parse("var a = ({a: a = 123}) => {}");
|
||||
assert(ast.body[0] instanceof uglify.AST_Var);
|
||||
assert.strictEqual(ast.body[0].definitions.length, 1);
|
||||
assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
|
||||
assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
|
||||
assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
|
||||
|
||||
// First argument
|
||||
assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, false);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names.length, 1);
|
||||
|
||||
// Content destructuring of first argument
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_ObjectProperty);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].key, "a");
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[0].value instanceof uglify.AST_DefaultAssign);
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[0].value.left instanceof uglify.AST_SymbolFunarg);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].value.operator, "=");
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[0].value.right instanceof uglify.AST_Number);
|
||||
});
|
||||
|
||||
it("Should parse a function containing default assignments in complex destructuring correctly", function() {
|
||||
var ast = uglify.parse("var a = ([a, [b = 123]]) => {}");
|
||||
assert(ast.body[0] instanceof uglify.AST_Var);
|
||||
assert.strictEqual(ast.body[0].definitions.length, 1);
|
||||
assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
|
||||
assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
|
||||
assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
|
||||
|
||||
// Check first argument
|
||||
assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, true);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names.length, 2);
|
||||
|
||||
// Check whole destructuring structure of first argument
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_SymbolFunarg);
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[1] instanceof uglify.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[1].is_array, true);
|
||||
|
||||
// Check content of second destructuring element (which is the nested destructuring pattern)
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[1].names[0] instanceof uglify.AST_DefaultAssign);
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[1].names[0].left instanceof uglify.AST_SymbolFunarg);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[1].names[0].operator, "=");
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[1].names[0].right instanceof uglify.AST_Number);
|
||||
|
||||
|
||||
ast = uglify.parse("var a = ([a, {b: c = 123}]) => {}");
|
||||
assert(ast.body[0] instanceof uglify.AST_Var);
|
||||
assert.strictEqual(ast.body[0].definitions.length, 1);
|
||||
assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
|
||||
assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
|
||||
assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
|
||||
|
||||
// Check first argument
|
||||
assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, true);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names.length, 2);
|
||||
|
||||
// Check whole destructuring structure of first argument
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_SymbolFunarg);
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[1] instanceof uglify.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[1].is_array, false);
|
||||
|
||||
// Check content of second destructuring element (which is the nested destructuring pattern)
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[1].names[0] instanceof uglify.AST_ObjectKeyVal);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[1].names[0].key, "b");
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[1].names[0].value instanceof uglify.AST_DefaultAssign);
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[1].names[0].value.left instanceof uglify.AST_SymbolFunarg);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[1].names[0].value.operator, "=");
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[1].names[0].value.right instanceof uglify.AST_Number);
|
||||
|
||||
|
||||
ast = uglify.parse("var a = ({a, b: {b = 123}}) => {}");
|
||||
assert(ast.body[0] instanceof uglify.AST_Var);
|
||||
assert.strictEqual(ast.body[0].definitions.length, 1);
|
||||
assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
|
||||
assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
|
||||
assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
|
||||
|
||||
// Check first argument
|
||||
assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, false);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names.length, 2);
|
||||
|
||||
// First argument, property 1
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_ObjectKeyVal);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].key, "a");
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[0].value instanceof uglify.AST_SymbolFunarg);
|
||||
|
||||
// First argument, property 2
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[1] instanceof uglify.AST_ObjectKeyVal);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[1].key, "b");
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[1].value instanceof uglify.AST_Destructuring);
|
||||
|
||||
// Check content of nested destructuring
|
||||
var content = ast.body[0].definitions[0].value.argnames[0].names[1].value
|
||||
assert.strictEqual(content.is_array, false);
|
||||
assert.strictEqual(content.names.length, 1);
|
||||
assert(content.names[0] instanceof uglify.AST_ObjectKeyVal);
|
||||
|
||||
// Content of first property in nested destructuring
|
||||
assert.strictEqual(content.names[0].key, "b");
|
||||
assert(content.names[0].value instanceof uglify.AST_DefaultAssign);
|
||||
assert(content.names[0].value.left instanceof uglify.AST_SymbolFunarg);
|
||||
assert.strictEqual(content.names[0].value.operator, "=");
|
||||
assert(content.names[0].value.right instanceof uglify.AST_Number);
|
||||
|
||||
|
||||
ast = uglify.parse("var a = ({a: {b = 123}}) => {}");
|
||||
assert(ast.body[0] instanceof uglify.AST_Var);
|
||||
assert.strictEqual(ast.body[0].definitions.length, 1);
|
||||
assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
|
||||
assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
|
||||
assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
|
||||
|
||||
// Check first argument
|
||||
assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, false);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names.length, 1);
|
||||
|
||||
// Check whole destructuring structure of first argument
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_ObjectKeyVal);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].key, "a");
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[0].value instanceof uglify.AST_Destructuring);
|
||||
|
||||
// Check content of nested destructuring
|
||||
content = ast.body[0].definitions[0].value.argnames[0].names[0].value
|
||||
assert.strictEqual(content.is_array, false);
|
||||
assert.strictEqual(content.names.length, 1);
|
||||
assert(content.names[0] instanceof uglify.AST_ObjectKeyVal);
|
||||
|
||||
// Check first property of nested destructuring
|
||||
assert.strictEqual(content.names[0].key, "b");
|
||||
assert(content.names[0].value instanceof uglify.AST_DefaultAssign);
|
||||
assert(content.names[0].value.left instanceof uglify.AST_SymbolFunarg);
|
||||
assert.strictEqual(content.names[0].value.operator, "=");
|
||||
assert(content.names[0].value.right instanceof uglify.AST_Number);
|
||||
});
|
||||
|
||||
it("Should parse spread correctly", function() {
|
||||
var ast = uglify.parse("var a = (a, b, ...c) => {}");
|
||||
assert(ast.body[0] instanceof uglify.AST_Var);
|
||||
assert.strictEqual(ast.body[0].definitions.length, 1);
|
||||
assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
|
||||
assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
|
||||
assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 3);
|
||||
|
||||
// Check parameters
|
||||
assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_SymbolFunarg);
|
||||
assert(ast.body[0].definitions[0].value.argnames[1] instanceof uglify.AST_SymbolFunarg);
|
||||
assert(ast.body[0].definitions[0].value.argnames[2] instanceof uglify.AST_Expansion);
|
||||
assert(ast.body[0].definitions[0].value.argnames[2].expression instanceof uglify.AST_SymbolFunarg);
|
||||
|
||||
|
||||
ast = uglify.parse("var a = ([a, b, ...c]) => {}");
|
||||
assert(ast.body[0] instanceof uglify.AST_Var);
|
||||
assert.strictEqual(ast.body[0].definitions.length, 1);
|
||||
assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
|
||||
assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
|
||||
assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
|
||||
|
||||
// Check first parameter
|
||||
assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, true);
|
||||
|
||||
// Check content first parameter
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_SymbolFunarg);
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[1] instanceof uglify.AST_SymbolFunarg);
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[2] instanceof uglify.AST_Expansion);
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[2].expression instanceof uglify.AST_SymbolFunarg);
|
||||
|
||||
|
||||
ast = uglify.parse("var a = ([a, b, [c, ...d]]) => {}");
|
||||
assert(ast.body[0] instanceof uglify.AST_Var);
|
||||
assert.strictEqual(ast.body[0].definitions.length, 1);
|
||||
assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
|
||||
assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
|
||||
assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
|
||||
|
||||
// Check first parameter
|
||||
assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, true);
|
||||
|
||||
// Check content outer destructuring array
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_SymbolFunarg);
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[1] instanceof uglify.AST_SymbolFunarg);
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[2] instanceof uglify.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[2].is_array, true);
|
||||
|
||||
// Check content nested destructuring array
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[2].names.length, 2);
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[2].names[0] instanceof uglify.AST_SymbolFunarg);
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[2].names[1] instanceof uglify.AST_Expansion);
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[2].names[1].expression instanceof uglify.AST_SymbolFunarg);
|
||||
|
||||
|
||||
ast = uglify.parse("var a = ({a: [b, ...c]}) => {}");
|
||||
assert(ast.body[0] instanceof uglify.AST_Var);
|
||||
assert.strictEqual(ast.body[0].definitions.length, 1);
|
||||
assert(ast.body[0].definitions[0] instanceof uglify.AST_VarDef);
|
||||
assert(ast.body[0].definitions[0].name instanceof uglify.AST_SymbolVar);
|
||||
assert(ast.body[0].definitions[0].value instanceof uglify.AST_Arrow);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames.length, 1);
|
||||
|
||||
// Check first parameter
|
||||
assert(ast.body[0].definitions[0].value.argnames[0] instanceof uglify.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].is_array, false);
|
||||
|
||||
// Check outer destructuring object
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names.length, 1);
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[0] instanceof uglify.AST_ObjectKeyVal);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].key, "a");
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[0].value instanceof uglify.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].value.is_array, true);
|
||||
|
||||
// Check content nested destructuring array
|
||||
assert.strictEqual(ast.body[0].definitions[0].value.argnames[0].names[0].value.names.length, 2);
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[0].value.names[0] instanceof uglify.AST_SymbolFunarg);
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[0].value.names[1] instanceof uglify.AST_Expansion);
|
||||
assert(ast.body[0].definitions[0].value.argnames[0].names[0].value.names[1].expression instanceof uglify.AST_SymbolFunarg);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
138
test/mocha/destructuring.js
Normal file
138
test/mocha/destructuring.js
Normal file
@@ -0,0 +1,138 @@
|
||||
var assert = require("assert");
|
||||
var uglify = require("../../");
|
||||
|
||||
describe("Destructuring", function() {
|
||||
it("Should generate similar trees for destructuring in left hand side expressions, definitions, functions and arrow functions", function() {
|
||||
var patterns = [
|
||||
"[]",
|
||||
"{}",
|
||||
|
||||
"[a, b, c]",
|
||||
"{a: b, c: d}",
|
||||
"{a}",
|
||||
"{a, b}",
|
||||
|
||||
"{a: {}}",
|
||||
"{a: []}",
|
||||
"[{}]",
|
||||
"[[]]",
|
||||
"{a: {b}}",
|
||||
|
||||
// Can't do `a = 123` with lhs expression, so only test in destructuring
|
||||
"[foo = bar]",
|
||||
"{a = 123}",
|
||||
"[{foo: abc = 123}]",
|
||||
"{foo: [abc = 123]}",
|
||||
|
||||
"[...foo]",
|
||||
"[...{}]",
|
||||
"[...[]]"
|
||||
|
||||
// Can't do `...` because that is an invalid lhs expression, spread in array destructuring should be fine though
|
||||
];
|
||||
|
||||
var types = [
|
||||
{
|
||||
name: "lhs",
|
||||
symbolType: uglify.AST_SymbolRef,
|
||||
tree: function (ast) {
|
||||
return ast.body[0].body.left;
|
||||
},
|
||||
generate: function (code) {
|
||||
return "(" + code + " = a)";
|
||||
}
|
||||
},
|
||||
{
|
||||
name: "var",
|
||||
symbolType: uglify.AST_SymbolVar,
|
||||
tree: function (ast) {
|
||||
return ast.body[0].definitions[0].name;
|
||||
},
|
||||
generate: function (code) {
|
||||
return "var " + code + " = a";
|
||||
}
|
||||
},
|
||||
{
|
||||
name: "function",
|
||||
symbolType: uglify.AST_SymbolFunarg,
|
||||
tree: function (ast) {
|
||||
return ast.body[0].argnames[0];
|
||||
},
|
||||
generate: function (code) {
|
||||
return "function a(" + code + ") {}";
|
||||
}
|
||||
},
|
||||
{
|
||||
name: "arrow",
|
||||
symbolType: uglify.AST_SymbolFunarg,
|
||||
tree: function (ast) {
|
||||
return ast.body[0].definitions[0].value.argnames[0];
|
||||
},
|
||||
generate: function (code) {
|
||||
return "var a = (" + code + ") => {}";
|
||||
}
|
||||
}
|
||||
];
|
||||
|
||||
var walker = function(type, ref, code, result) {
|
||||
var w = new uglify.TreeWalker(function(node) {
|
||||
if (w.parent() instanceof uglify.AST_DefaultAssign &&
|
||||
w.parent().right === node
|
||||
) {
|
||||
return true; // Don't check the content of the default assignment
|
||||
|
||||
} else if (node instanceof uglify.AST_Symbol) {
|
||||
assert(node instanceof type.symbolType,
|
||||
node.TYPE + " while " + type.symbolType.TYPE + " expected at pos " +
|
||||
node.start.pos + " in `" + code + "` (" + ref + ")"
|
||||
);
|
||||
|
||||
result.push([
|
||||
new uglify.AST_Symbol({
|
||||
start: node.start,
|
||||
name: node.name,
|
||||
end: node.end
|
||||
}),
|
||||
w.parent()
|
||||
]);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
result.push([node, w.parent()]);
|
||||
});
|
||||
|
||||
return w;
|
||||
};
|
||||
|
||||
var getNodeType = function(node) {
|
||||
return node[0].TYPE + (node[1] ? " " + node[1].TYPE : "");
|
||||
}
|
||||
|
||||
for (var i = 0; i < patterns.length; i++) {
|
||||
var results = [];
|
||||
|
||||
for (var j = 0; j < types.length; j++) {
|
||||
var code = types[j].generate(patterns[i])
|
||||
var ast = types[j].tree(
|
||||
uglify.parse(code)
|
||||
);
|
||||
results.push([]);
|
||||
ast.walk(walker(
|
||||
types[j],
|
||||
"`" + patterns[i] + "` on " + types[j].name,
|
||||
code,
|
||||
results[j]
|
||||
));
|
||||
|
||||
if (j > 0) {
|
||||
assert.deepEqual(
|
||||
results[0].map(getNodeType),
|
||||
results[j].map(getNodeType),
|
||||
"AST disagree on " + patterns[i] + " with " + types[j].name
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -47,64 +47,83 @@ describe("Function", function() {
|
||||
assert.equal(destruct3.is_array, false);
|
||||
assert.equal(destruct4.is_array, true);
|
||||
|
||||
var aAndB = [
|
||||
['SymbolFunarg', 'a'],
|
||||
['SymbolFunarg', 'b']
|
||||
];
|
||||
|
||||
// destruct 1
|
||||
assert.deepEqual(
|
||||
[
|
||||
destruct1.names[0].TYPE,
|
||||
destruct1.names[0].name
|
||||
destruct1.names[0].key,
|
||||
destruct1.names[0].value.name
|
||||
],
|
||||
aAndB[0]);
|
||||
['ObjectKeyVal', 'a', 'a']
|
||||
);
|
||||
assert.deepEqual(
|
||||
[
|
||||
destruct1.names[1].TYPE,
|
||||
destruct1.names[1].name
|
||||
destruct1.names[1].key,
|
||||
destruct1.names[1].value.name
|
||||
],
|
||||
aAndB[1]);
|
||||
['ObjectKeyVal', 'b', 'b']
|
||||
);
|
||||
|
||||
// destruct 2
|
||||
assert.deepEqual(
|
||||
[
|
||||
destruct2.names[0].TYPE,
|
||||
destruct2.names[0].name
|
||||
],
|
||||
aAndB[0]);
|
||||
['SymbolFunarg', 'a']
|
||||
);
|
||||
assert.deepEqual(
|
||||
[
|
||||
destruct2.names[1].names[0].TYPE,
|
||||
destruct2.names[1].names[0].name
|
||||
],
|
||||
aAndB[1]);
|
||||
['SymbolFunarg', 'b']
|
||||
);
|
||||
|
||||
// destruct 3
|
||||
assert.strictEqual(typeof destruct3.names[0].key, "string");
|
||||
assert.strictEqual(destruct3.names[0].key, "a");
|
||||
assert.strictEqual(destruct3.names[0].value.TYPE, "SymbolFunarg");
|
||||
assert.strictEqual(destruct3.names[0].value.name, "a");
|
||||
assert.strictEqual(typeof destruct3.names[1].key, "string");
|
||||
assert.strictEqual(destruct3.names[1].key, "b");
|
||||
assert.strictEqual(destruct3.names[1].value.TYPE, "SymbolFunarg");
|
||||
assert.strictEqual(destruct3.names[1].value.name, "b");
|
||||
|
||||
// destruct 4
|
||||
assert.deepEqual(
|
||||
[
|
||||
destruct4.names[0].TYPE,
|
||||
destruct4.names[0].name
|
||||
],
|
||||
aAndB[0]);
|
||||
['SymbolFunarg', 'a']
|
||||
);
|
||||
assert.strictEqual(destruct4.names[1].TYPE, "Destructuring");
|
||||
assert.deepEqual(
|
||||
[
|
||||
destruct4.names[1].names[0].TYPE,
|
||||
destruct4.names[1].names[0].name
|
||||
],
|
||||
aAndB[1]);
|
||||
['SymbolFunarg', 'b']
|
||||
);
|
||||
|
||||
assert.deepEqual(
|
||||
get_args(destr_fun1.args_as_names()),
|
||||
aAndB);
|
||||
[['SymbolFunarg', 'a'], ['SymbolFunarg', 'b']]
|
||||
);
|
||||
assert.deepEqual(
|
||||
get_args(destr_fun2.args_as_names()),
|
||||
aAndB);
|
||||
[['SymbolFunarg', 'a'], ['SymbolFunarg', 'b']]
|
||||
);
|
||||
assert.deepEqual(
|
||||
get_args(destr_fun3.args_as_names()),
|
||||
aAndB);
|
||||
[['SymbolFunarg', 'a'], ['SymbolFunarg', 'b']]
|
||||
);
|
||||
assert.deepEqual(
|
||||
get_args(destr_fun4.args_as_names()),
|
||||
aAndB);
|
||||
[['SymbolFunarg', 'a'], ['SymbolFunarg', 'b']]
|
||||
);
|
||||
|
||||
// Making sure we don't accidentally accept things which
|
||||
// Aren't argument destructurings
|
||||
|
||||
@@ -7,17 +7,26 @@ describe("Left-hand side expressions", function () {
|
||||
|
||||
assert.equal(decls.body[0].TYPE, 'Var');
|
||||
assert.equal(decls.body[0].definitions.length, 2);
|
||||
|
||||
// Item 1
|
||||
assert.equal(decls.body[0].definitions[0].name.TYPE, 'Destructuring');
|
||||
assert.equal(decls.body[0].definitions[0].value.TYPE, 'SymbolRef');
|
||||
|
||||
// Item 2
|
||||
assert.equal(decls.body[0].definitions[1].name.TYPE, 'Destructuring');
|
||||
assert.equal(decls.body[0].definitions[1].value.TYPE, 'SymbolRef');
|
||||
|
||||
var nested_def = uglify.parse('var [{x}] = foo').body[0].definitions[0];
|
||||
|
||||
assert.equal(nested_def.name.names[0].names[0].TYPE, 'SymbolVar');
|
||||
assert.equal(nested_def.name.names[0].names[0].name, 'x');
|
||||
assert.equal(nested_def.name.names[0].names[0].TYPE, 'ObjectKeyVal');
|
||||
assert.equal(nested_def.name.names[0].names[0].value.TYPE, 'SymbolVar');
|
||||
assert.equal(nested_def.name.names[0].names[0].key, 'x');
|
||||
assert.equal(nested_def.name.names[0].names[0].value.name, 'x');
|
||||
|
||||
var holey_def = uglify.parse('const [,,third] = [1,2,3]').body[0].definitions[0];
|
||||
|
||||
assert.equal(holey_def.name.names[0].TYPE, 'Hole');
|
||||
assert.equal(holey_def.name.names[1].TYPE, 'Hole');
|
||||
assert.equal(holey_def.name.names[2].TYPE, 'SymbolConst');
|
||||
|
||||
var expanding_def = uglify.parse('var [first, ...rest] = [1,2,3]').body[0].definitions[0];
|
||||
@@ -26,4 +35,231 @@ describe("Left-hand side expressions", function () {
|
||||
assert.equal(expanding_def.name.names[1].TYPE, 'Expansion');
|
||||
assert.equal(expanding_def.name.names[1].expression.TYPE, 'SymbolVar');
|
||||
});
|
||||
|
||||
it("Parser should use AST_Array for array literals", function() {
|
||||
var ast = uglify.parse('["foo", "bar"]');
|
||||
assert(ast.body[0] instanceof uglify.AST_SimpleStatement);
|
||||
assert(ast.body[0].body instanceof uglify.AST_Array);
|
||||
|
||||
ast = uglify.parse('a = ["foo"]');
|
||||
assert(ast.body[0] instanceof uglify.AST_SimpleStatement);
|
||||
|
||||
assert(ast.body[0].body instanceof uglify.AST_Assign);
|
||||
assert(ast.body[0].body.left instanceof uglify.AST_SymbolRef);
|
||||
assert.equal(ast.body[0].body.operator, "=");
|
||||
assert(ast.body[0].body.right instanceof uglify.AST_Array);
|
||||
});
|
||||
|
||||
it("Parser should use AST_Object for object literals", function() {
|
||||
var ast = uglify.parse('({foo: "bar"})');
|
||||
assert(ast.body[0] instanceof uglify.AST_SimpleStatement);
|
||||
assert(ast.body[0].body instanceof uglify.AST_Object);
|
||||
|
||||
// This example should be fine though
|
||||
ast = uglify.parse('a = {foo: "bar"}');
|
||||
assert(ast.body[0] instanceof uglify.AST_SimpleStatement);
|
||||
|
||||
assert(ast.body[0].body instanceof uglify.AST_Assign);
|
||||
assert(ast.body[0].body.left instanceof uglify.AST_SymbolRef);
|
||||
assert.equal(ast.body[0].body.operator, "=");
|
||||
assert(ast.body[0].body.right instanceof uglify.AST_Object);
|
||||
});
|
||||
|
||||
it("Parser should use AST_Destructuring for array assignment patterns", function() {
|
||||
var ast = uglify.parse('[foo, bar] = [1, 2]');
|
||||
assert(ast.body[0] instanceof uglify.AST_SimpleStatement);
|
||||
|
||||
assert(ast.body[0].body instanceof uglify.AST_Assign);
|
||||
assert(ast.body[0].body.left instanceof uglify.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].body.left.is_array, true);
|
||||
assert.equal(ast.body[0].body.operator, "=");
|
||||
assert(ast.body[0].body.right instanceof uglify.AST_Array);
|
||||
});
|
||||
|
||||
it("Parser should use AST_Destructuring for object assignment patterns", function() {
|
||||
var ast = uglify.parse('({a: b, b: c} = {b: "c", c: "d"})');
|
||||
assert(ast.body[0] instanceof uglify.AST_SimpleStatement);
|
||||
|
||||
assert(ast.body[0].body instanceof uglify.AST_Assign);
|
||||
assert(ast.body[0].body.left instanceof uglify.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].body.left.is_array, false);
|
||||
assert.equal(ast.body[0].body.operator, "=");
|
||||
assert(ast.body[0].body.right instanceof uglify.AST_Object);
|
||||
});
|
||||
|
||||
it("Parser should be able to handle nested destructuring", function() {
|
||||
var ast = uglify.parse('[{a,b},[d, e, f, {g, h}]] = [{a: 1, b: 2}, [3, 4, 5, {g: 6, h: 7}]]');
|
||||
assert(ast.body[0] instanceof uglify.AST_SimpleStatement);
|
||||
|
||||
assert(ast.body[0].body instanceof uglify.AST_Assign);
|
||||
assert(ast.body[0].body.left instanceof uglify.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].body.left.is_array, true);
|
||||
assert.equal(ast.body[0].body.operator, "=");
|
||||
assert(ast.body[0].body.right instanceof uglify.AST_Array);
|
||||
|
||||
assert(ast.body[0].body.left.names[0] instanceof uglify.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].body.left.names[0].is_array, false);
|
||||
|
||||
assert(ast.body[0].body.left.names[1] instanceof uglify.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].body.left.names[1].is_array, true);
|
||||
|
||||
assert(ast.body[0].body.left.names[1].names[3] instanceof uglify.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].body.left.names[1].names[3].is_array, false);
|
||||
});
|
||||
|
||||
it("Should handle spread operator in destructuring", function() {
|
||||
var ast = uglify.parse("[a, b, ...c] = [1, 2, 3, 4, 5]");
|
||||
assert(ast.body[0] instanceof uglify.AST_SimpleStatement);
|
||||
|
||||
assert(ast.body[0].body instanceof uglify.AST_Assign);
|
||||
assert(ast.body[0].body.left instanceof uglify.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].body.left.is_array, true);
|
||||
assert.equal(ast.body[0].body.operator, "=");
|
||||
assert(ast.body[0].body.right instanceof uglify.AST_Array);
|
||||
|
||||
assert(ast.body[0].body.left.names[0] instanceof uglify.AST_SymbolRef);
|
||||
assert(ast.body[0].body.left.names[1] instanceof uglify.AST_SymbolRef);
|
||||
|
||||
assert(ast.body[0].body.left.names[2] instanceof uglify.AST_Expansion);
|
||||
});
|
||||
|
||||
it("Should handle default assignments in destructuring", function() {
|
||||
var ast = uglify.parse("({x: v, z = z + 5} = obj);");
|
||||
assert(ast.body[0] instanceof uglify.AST_SimpleStatement);
|
||||
|
||||
assert(ast.body[0].body instanceof uglify.AST_Assign);
|
||||
assert(ast.body[0].body.left instanceof uglify.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].body.left.is_array, false);
|
||||
assert.equal(ast.body[0].body.operator, "=");
|
||||
assert(ast.body[0].body.right instanceof uglify.AST_SymbolRef);
|
||||
|
||||
assert(ast.body[0].body.left.names[0].value instanceof uglify.AST_SymbolRef);
|
||||
assert.strictEqual(ast.body[0].body.left.names[0].start.value, "x");
|
||||
|
||||
assert(ast.body[0].body.left.names[1].value instanceof uglify.AST_DefaultAssign);
|
||||
assert.strictEqual(ast.body[0].body.left.names[1].start.value, "z");
|
||||
assert(ast.body[0].body.left.names[1].value.left instanceof uglify.AST_SymbolRef);
|
||||
assert.strictEqual(ast.body[0].body.left.names[1].value.operator, "=");
|
||||
assert(ast.body[0].body.left.names[1].value.right instanceof uglify.AST_Binary);
|
||||
|
||||
|
||||
ast = uglify.parse("({x = 123} = obj);");
|
||||
assert(ast.body[0] instanceof uglify.AST_SimpleStatement);
|
||||
assert(ast.body[0].body instanceof uglify.AST_Assign);
|
||||
assert(ast.body[0].body.left instanceof uglify.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].body.left.is_array, false);
|
||||
assert.equal(ast.body[0].body.operator, "=");
|
||||
assert(ast.body[0].body.right instanceof uglify.AST_SymbolRef);
|
||||
|
||||
assert(ast.body[0].body.left.names[0].value instanceof uglify.AST_DefaultAssign);
|
||||
assert.strictEqual(ast.body[0].body.left.names[0].value.operator, "=");
|
||||
assert(ast.body[0].body.left.names[0].value.left instanceof uglify.AST_SymbolRef);
|
||||
|
||||
|
||||
ast = uglify.parse("[x, y = 5] = foo");
|
||||
assert(ast.body[0] instanceof uglify.AST_SimpleStatement);
|
||||
|
||||
assert(ast.body[0].body instanceof uglify.AST_Assign);
|
||||
assert(ast.body[0].body.left instanceof uglify.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].body.left.is_array, true);
|
||||
assert.equal(ast.body[0].body.operator, "=");
|
||||
assert(ast.body[0].body.right instanceof uglify.AST_SymbolRef);
|
||||
|
||||
assert(ast.body[0].body.left.names[0] instanceof uglify.AST_SymbolRef);
|
||||
assert.strictEqual(ast.body[0].body.left.names[0].start.value, "x");
|
||||
|
||||
assert(ast.body[0].body.left.names[1] instanceof uglify.AST_DefaultAssign);
|
||||
assert(ast.body[0].body.left.names[1].left instanceof uglify.AST_SymbolRef);
|
||||
assert.strictEqual(ast.body[0].body.left.names[1].start.value, "y");
|
||||
});
|
||||
|
||||
it("Should handle default assignments containing assignments in a destructuring", function() {
|
||||
var ast = uglify.parse("[x, y = z = 2] = a;");
|
||||
assert(ast.body[0] instanceof uglify.AST_SimpleStatement);
|
||||
|
||||
assert(ast.body[0].body instanceof uglify.AST_Assign);
|
||||
assert(ast.body[0].body.left instanceof uglify.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].body.left.is_array, true);
|
||||
assert.equal(ast.body[0].body.operator, "=");
|
||||
assert(ast.body[0].body.right instanceof uglify.AST_SymbolRef);
|
||||
|
||||
assert(ast.body[0].body.left.names[0] instanceof uglify.AST_SymbolRef);
|
||||
|
||||
assert(ast.body[0].body.left.names[1] instanceof uglify.AST_DefaultAssign);
|
||||
assert(ast.body[0].body.left.names[1].left instanceof uglify.AST_SymbolRef);
|
||||
assert.equal(ast.body[0].body.left.names[1].operator, "=");
|
||||
assert(ast.body[0].body.left.names[1].right instanceof uglify.AST_Assign);
|
||||
|
||||
assert(ast.body[0].body.left.names[1].right.left instanceof uglify.AST_SymbolRef);
|
||||
assert.equal(ast.body[0].body.left.names[1].right.operator, "=");
|
||||
assert(ast.body[0].body.left.names[1].right.right instanceof uglify.AST_Number);
|
||||
|
||||
ast = uglify.parse("({a: a = 123} = obj)");
|
||||
assert(ast.body[0] instanceof uglify.AST_SimpleStatement);
|
||||
|
||||
assert(ast.body[0].body instanceof uglify.AST_Assign);
|
||||
assert(ast.body[0].body.left instanceof uglify.AST_Destructuring);
|
||||
assert.strictEqual(ast.body[0].body.left.is_array, false);
|
||||
assert.equal(ast.body[0].body.operator, "=");
|
||||
assert(ast.body[0].body.right instanceof uglify.AST_SymbolRef);
|
||||
|
||||
assert(ast.body[0].body.left.names[0] instanceof uglify.AST_ObjectProperty);
|
||||
assert.strictEqual(ast.body[0].body.left.names[0].key, "a");
|
||||
assert(ast.body[0].body.left.names[0].value instanceof uglify.AST_DefaultAssign);
|
||||
assert(ast.body[0].body.left.names[0].value.left instanceof uglify.AST_SymbolRef);
|
||||
assert.strictEqual(ast.body[0].body.left.names[0].value.operator, "=");
|
||||
assert(ast.body[0].body.left.names[0].value.right instanceof uglify.AST_Number);
|
||||
});
|
||||
|
||||
it("Should allow multiple spread in array literals", function() {
|
||||
var ast = uglify.parse("var a = [1, 2, 3], b = [4, 5, 6], joined; joined = [...a, ...b]");
|
||||
assert(ast.body[0] instanceof uglify.AST_Var);
|
||||
assert(ast.body[1] instanceof uglify.AST_SimpleStatement);
|
||||
|
||||
// Check statement containing array with spreads
|
||||
assert(ast.body[1].body instanceof uglify.AST_Assign);
|
||||
assert(ast.body[1].body.left instanceof uglify.AST_SymbolRef);
|
||||
assert.equal(ast.body[1].body.operator, "=");
|
||||
assert(ast.body[1].body.right instanceof uglify.AST_Array);
|
||||
|
||||
// Check array content
|
||||
assert.strictEqual(ast.body[1].body.right.elements.length, 2);
|
||||
assert(ast.body[1].body.right.elements[0] instanceof uglify.AST_Expansion);
|
||||
assert(ast.body[1].body.right.elements[0].expression instanceof uglify.AST_SymbolRef);
|
||||
assert(ast.body[1].body.right.elements[0].expression.name, "a");
|
||||
assert(ast.body[1].body.right.elements[1] instanceof uglify.AST_Expansion);
|
||||
assert(ast.body[1].body.right.elements[1].expression instanceof uglify.AST_SymbolRef);
|
||||
assert(ast.body[1].body.right.elements[1].expression.name, "b");
|
||||
});
|
||||
|
||||
it("Should not allow spread on invalid locations", function() {
|
||||
var expect = function(input, expected) {
|
||||
var execute = function(input) {
|
||||
return function() {
|
||||
uglify.parse(input);
|
||||
}
|
||||
}
|
||||
var check = function(e) {
|
||||
return e instanceof uglify.JS_Parse_Error &&
|
||||
e.message === expected;
|
||||
}
|
||||
|
||||
assert.throws(execute(input), check);
|
||||
}
|
||||
|
||||
// Spreads are not allowed in destructuring array if it's not the last element
|
||||
expect("[...a, ...b] = [1, 2, 3, 4]", "SyntaxError: Spread must the be last element in destructuring array");
|
||||
|
||||
// Multiple spreads are not allowed in destructuring array
|
||||
expect("[...a, ...b] = [1, 2, 3, 4]", "SyntaxError: Spread must the be last element in destructuring array");
|
||||
|
||||
// Spread in obvious object pattern
|
||||
expect("({...a} = foo)", "SyntaxError: Unexpected token: expand (...)");
|
||||
|
||||
// Spread in block should not be allowed
|
||||
expect("{...a} = foo", "SyntaxError: Unexpected token: expand (...)");
|
||||
|
||||
// Not in standard yet
|
||||
expect("let foo = {bar: 42}, bar; bar = {...foo}", "SyntaxError: Unexpected token: expand (...)");
|
||||
});
|
||||
});
|
||||
|
||||
Reference in New Issue
Block a user