ctor.prototype._validate.call(this);
} while (ctor = ctor.BASE);
},
+ validate_ast: function() {
+ var marker = {};
+ this.walk(new TreeWalker(function(node) {
+ if (node.validate_visited === marker) throw new Error("invalid node reuse: " + node);
+ node.validate_visited = marker;
+ }));
+ },
}, null);
(AST_Node.log_function = function(fn, verbose) {
(function(def) {
function to_node(value, orig) {
- if (value instanceof AST_Node) return make_node(value.CTOR, orig, value);
+ if (value instanceof AST_Node) return value.clone(true);
if (Array.isArray(value)) return make_node(AST_Array, orig, {
elements: value.map(function(value) {
return to_node(value, orig);
single_use = false;
} else if (recursive_ref(compressor, def)) {
single_use = false;
+ } else if (compressor.option("ie8") && fixed.name && def !== fixed.name.definition()) {
+ single_use = false;
} else if (def.scope !== self.scope || def.orig[0] instanceof AST_SymbolFunarg) {
single_use = fixed.is_constant_expression(self.scope);
if (single_use == "f") {
scope.inlined = true;
} while (scope = scope.parent_scope);
}
- } else if (compressor.option("ie8") && fixed.name && def !== fixed.name.definition()) {
- single_use = false;
}
if (single_use) fixed.parent_scope = self.scope;
} else if (!fixed || !fixed.is_constant_expression()) {
toplevel = toplevel[action](option);
files[toplevel.start.file] = toplevel.print_to_string().replace(orig, "");
});
+ if (options.validate) toplevel.validate_ast();
if (timings) timings.rename = Date.now();
if (options.rename) {
toplevel.figure_out_scope(options.mangle);
toplevel.expand_names(options.mangle);
}
if (timings) timings.compress = Date.now();
- if (options.compress) toplevel = new Compressor(options.compress).compress(toplevel);
+ if (options.compress) {
+ toplevel = new Compressor(options.compress).compress(toplevel);
+ if (options.validate) toplevel.validate_ast();
+ }
if (timings) timings.scope = Date.now();
if (options.mangle) toplevel.figure_out_scope(options.mangle);
if (timings) timings.mangle = Date.now();
quote_style: 3,
});
try {
+ input.validate_ast();
U.parse(input_code);
} catch (ex) {
log([
output = U.mangle_properties(output, test.mangle.properties);
}
}
- output = make_code(output, output_options);
- if (expect != output) {
+ var output_code = make_code(output, output_options);
+ if (expect != output_code) {
log([
"!!! failed",
"---INPUT---",
"",
].join("\n"), {
input: input_formatted,
- output: output,
+ output: output_code,
expected: expect
});
return false;
}
// expect == output
try {
- U.parse(output);
+ output.validate_ast();
+ U.parse(output_code);
} catch (ex) {
log([
"!!! Test matched expected result but cannot parse output",
"",
].join("\n"), {
input: input_formatted,
- output: output,
+ output: output_code,
error: ex,
});
return false;
});
return false;
}
- actual = run_code(output, toplevel);
+ actual = run_code(output_code, toplevel);
if (!sandbox.same_stdout(test.expect_stdout, actual)) {
log([
"!!! failed",
}
}
+repeated_nodes: {
+ options = {
+ global_defs: {
+ "@N": "rand()",
+ },
+ }
+ input: {
+ console.log(N, N);
+ }
+ expect: {
+ console.log(rand(), rand());
+ }
+}
+
keyword: {
options = {
global_defs: {
}
expect_stdout: "string"
}
+
+issue_2737: {
+ options = {
+ ie8: true,
+ reduce_vars: true,
+ unused: true,
+ }
+ input: {
+ (function(a) {
+ a();
+ })(function f() {
+ console.log(typeof f);
+ });
+ }
+ expect: {
+ (function(a) {
+ a();
+ })(function f() {
+ console.log(typeof f);
+ });
+ }
+ expect_stdout: "function"
+}
}
}
errorln("//-------------------------------------------------------------");
- var reduced = reduce_test(original_code, JSON.parse(options), {
+ var reduce_options = JSON.parse(options);
+ reduce_options.validate = true;
+ var reduced = reduce_test(original_code, reduce_options, {
verbose: false,
}).code;
if (reduced) {