return node;
}
+ function replace_ref(ref, fixed) {
+ return function() {
+ var node = make_ref(ref, fixed);
+ var def = ref.definition();
+ def.references.push(node);
+ def.replaced++;
+ return node;
+ };
+ }
+
function ref_once(compressor, def) {
return compressor.option("unused")
&& !def.scope.pinned()
};
left.fixed.assigns = !fixed || !fixed.assigns ? [] : fixed.assigns.slice();
left.fixed.assigns.push(node);
+ left.fixed.to_binary = replace_ref(left, fixed);
} else {
left.walk(tw);
ld.fixed = false;
operator: node.operator.slice(0, -1),
left: make_node(AST_UnaryPrefix, node, {
operator: "+",
- expression: make_ref(exp, fixed)
+ expression: make_ref(exp, fixed),
}),
right: make_node(AST_Number, node, { value: 1 }),
});
});
};
exp.fixed.assigns = fixed && fixed.assigns;
+ exp.fixed.to_prefix = replace_ref(exp, d.fixed);
}
} else {
exp.walk(tw);
col: node.start.col,
});
can_replace = false;
+ lvalues = get_lvalues(lhs);
node.right.transform(scanner);
clear_write_only(candidate);
var folded;
folded = candidate;
} else {
abort = true;
- lhs.definition().fixed = false;
folded = make_node(AST_Binary, candidate, {
operator: compound,
- left: lhs,
+ left: lhs.fixed ? lhs.fixed.to_binary() : lhs,
right: rvalue,
});
}
alternative: node,
}),
});
- if (candidate instanceof AST_UnaryPostfix) {
- if (lhs instanceof AST_SymbolRef) lhs.definition().fixed = false;
- return make_node(AST_UnaryPrefix, candidate, candidate);
- }
+ if (candidate instanceof AST_UnaryPostfix) return make_node(AST_UnaryPrefix, candidate, {
+ operator: candidate.operator,
+ expression: lhs.fixed ? lhs.fixed.to_prefix() : lhs,
+ });
if (candidate instanceof AST_VarDef) {
var def = candidate.name.definition();
if (def.references.length - def.replaced == 1 && !compressor.exposed(def)) {
var value = rvalue === rhs_value ? null : make_sequence(rhs_value, rhs_value.expressions.slice(0, -1));
var index = expr.name_index;
if (index >= 0) {
- var argname = scope.argnames[index];
+ var args, argname = scope.argnames[index];
if (argname instanceof AST_DefaultValue) {
+ scope.argnames[index] = argname = argname.clone();
argname.value = value || make_node(AST_Number, argname, { value: 0 });
- argname.name.definition().fixed = false;
- } else {
- var args = compressor.parent().args;
- if (args[index]) {
- args[index] = value || make_node(AST_Number, args[index], { value: 0 });
- argname.definition().fixed = false;
- }
+ } else if ((args = compressor.parent().args)[index]) {
+ scope.argnames[index] = argname.clone();
+ args[index] = value || make_node(AST_Number, args[index], { value: 0 });
}
return;
}
&& indexOf_assign(node.expression.definition(), node) < 0) {
return make_node(AST_UnaryPrefix, node, {
operator: "+",
- expression: node.expression
+ expression: node.expression,
});
}
}
}
if (compressor.option("assignments")) {
if (self.operator == "=" && self.left instanceof AST_SymbolRef && self.right instanceof AST_Binary) {
+ var ref;
// x = expr1 OP expr2
- if (self.right.left instanceof AST_SymbolRef
- && self.right.left.name == self.left.name
+ if ((ref = self.right.left) instanceof AST_SymbolRef
+ && ref.name == self.left.name
&& ASSIGN_OPS[self.right.operator]) {
// x = x - 2 ---> x -= 2
+ if (self.left.fixed) self.left.fixed.to_binary = function() {
+ return ref;
+ };
return make_node(AST_Assign, self, {
operator: self.right.operator + "=",
left: self.left,
right: self.right.right,
});
}
- if (self.right.right instanceof AST_SymbolRef
- && self.right.right.name == self.left.name
+ if ((ref = self.right.right) instanceof AST_SymbolRef
+ && ref.name == self.left.name
&& ASSIGN_OPS_COMMUTATIVE[self.right.operator]
&& !self.right.left.has_side_effects(compressor)) {
// x = 2 & x ---> x &= 2
+ if (self.left.fixed) self.left.fixed.to_binary = function() {
+ return ref;
+ };
return make_node(AST_Assign, self, {
operator: self.right.operator + "=",
left: self.left,