Support ++, --, compound assignment, and unary + operators

[keyboardDrummer-bot]

Summary

Implements the near-term (pure J-side) part of #396: lowering ++, --, compound assignments (+=, -=, *=, /=, %=), and unary + in JavaToLaurelCompiler using existing Laurel IR operations. No IR changes needed.

Changes

JavaToLaurelCompiler.java:

• convertExpression: added JCTree.JCAssignOp case dispatching to new convertCompoundAssign method
• convertUnary: added POS (identity), PREINC/POSTINC (lower to x = x + 1), PREDEC/POSTDEC (lower to x = x - 1)
• New convertCompoundAssign: lowers x op= y to x = x op y for +, -, *, /, %

Test:

• Unskipped VerifyNumericOperators (exercises all newly supported operators)

Not addressed (Tail — requires Laurel IR extension)

Bitwise (&, |, ^, ~) and shift (<<, >>, >>>) operators and their compound assignment variants remain unsupported. These need BvType operations in the Laurel IR.

Semantic note

Both prefix and postfix increment/decrement are lowered identically to x = x ± 1. The expression value is the new value in both cases. This matches the existing test expectations (ImpureNumericOperatorsVerification).

Closes the near-term part of #396.

[olivier-aws]

@keyboardDrummer-bot can you add tests that verify that the ++ operators interact well with statements. For example:

x = 0;
l = 0;
x = l++;
assert(x==0);
assert(l==1);

and

x = 0;
l = 0;
x = ++l;
assert(x==1);
assert(l==1);

[keyboardDrummer-bot]

@olivier-aws The current implementation lowers both prefix and postfix ++/-- identically — the expression value is always the new value. This means x = l++ would currently give x the new value (1), not the old value (0) as Java semantics require.

The test you want for postfix (x = l++; assert(x==0)) would fail with the current implementation.

Should I:

1. Add both tests but mark the postfix one with skip (documenting it as a known limitation), or
2. Fix the implementation to correctly distinguish prefix vs postfix semantics (postfix returns old value, prefix returns new value), and add both tests as passing?

[olivier-aws]

@keyboardDrummer-bot you need to fix the implementation so that the ++ operator is correctly modeled, either as suffix or prefix. Please add those tests and other you can think of (e.g. ++ on arguments of calls).

[keyboardDrummer-bot]

Fixed the implementation to correctly distinguish prefix vs postfix increment/decrement semantics:

Implementation (JavaToLaurelCompiler.java):

• Prefix (++x, --x): assign(x, x ± 1) — expression value is the new value
• Postfix (x++, x--): Lowered to a block that saves the old value in a temp variable, performs the assignment, then returns the temp — expression value is the old value

Test fixes:

• ImpureNumericOperatorsVerification: Corrected expectations — l++ now correctly returns the old value (3), not the new value (4)

New test (IncrementDecrementVerification):

• Postfix ++ as argument to a call (passes old value)
• Prefix ++ as argument to a call (passes new value)
• Multiple increments in a single call (add(a++, ++b))
• Prefix and postfix decrement in assignments