} else if (node instanceof AST_Unary) {
if (node.write_only) sym = node.expression;
}
- if (/strict/.test(compressor.option("pure_getters"))) {
- while (sym instanceof AST_PropAccess && !sym.expression.may_throw_on_access(compressor)) {
- if (sym instanceof AST_Sub) props.unshift(sym.property);
- sym = sym.expression;
- nested = true;
- }
- }
+ if (/strict/.test(compressor.option("pure_getters"))) sym = extract_reference(sym, props);
if (!(sym instanceof AST_SymbolRef)) return;
var def = sym.definition();
if (export_defaults[def.id]) return;
if (compressor.exposed(def)) return;
if (!can_drop_symbol(sym, compressor, nested)) return;
return sym;
+
+ function extract_reference(node, props) {
+ if (node instanceof AST_PropAccess) {
+ var expr = node.expression;
+ if (!expr.may_throw_on_access(compressor)) {
+ nested = true;
+ if (props && node instanceof AST_Sub) props.unshift(node.property);
+ return extract_reference(expr, props);
+ }
+ } else if (node instanceof AST_Assign && node.operator == "=") {
+ var ref = extract_reference(node.right);
+ if (props) props.assign = node;
+ return ref;
+ }
+ return node;
+ }
};
var assign_in_use = Object.create(null);
var export_defaults = Object.create(null);
}
}, true);
}))) {
+ if (props.assign) {
+ props.assign.write_only = true;
+ props.assign.walk(tw);
+ delete props.assign.write_only;
+ }
props.forEach(function(prop) {
prop.walk(tw);
});
if (SUPPORT.class_field && rng(2)) {
s += internal || createObjectKey(recurmax, stmtDepth, canThrow);
if (rng(5)) {
- async = bug_async_class_await && fixed;
+ async = bug_async_class_await && fixed && 0;
generator = false;
s += " = " + createExpression(recurmax, NO_COMMA, stmtDepth, fixed ? canThrow : CANNOT_THROW);
generator = save_generator;
case "arguments":
return in_class;
case "await":
- return async;
+ return async !== false;
case "yield":
return generator || in_class;
}