vm: lower Foo::\$bar OP= rhs to OP_STATIC_PROP_COMPOUND_ASSIGN

Mirrors the OP_OBJECT_COMPOUND_ASSIGN landed in the prior commit.

Encoding:
  A = const-pool name index (ZString varName, w/o leading $)
  B = tokenizer ItemType (op token)
  C bit 0 = keep-value-on-stack (expr vs stmt context)

Stack: pops rhs, pops class-source. Handler:
  cur, _ := EvalClassStaticVarRead(ctx, class-source, name, loc)
  cur := cur.Dup()
  res := compoundOp(op)(cur, rhs)
  AssignClassStaticProp(ctx, class-source, name, res)
  if C&1 { push(res) }

Both helpers already exist and carry LSB-aware class resolution,
read-side and asymmetric write-side visibility checks, and typed-prop
coercion. The native path inherits those unchanged.

Verified locally:
  Counter::\$n += 5    -> 15
  Counter::\$n *= 2    -> 26
  Counter::\$s .= ' world' -> 'hi world'
  Expr ctx: \$x = (Counter::\$n += 100) -> both 126
  LSB:  Parent1::bump() bumps Parent1::\$cnt,
        Child1::bump()  bumps Child1::\$cnt
        (static::\$cnt picks up the called class)

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: MagicalTux

core/vm/opcode.go

@@ -487,6 +487,17 @@ const (
 	// Pushes the post-op value back when keep-flag is set.
 	OpObjectCompoundAssign
 
+	// `Foo::$bar OP= rhs` static-property compound assign. Encoding
+	// mirrors OP_OBJECT_COMPOUND_ASSIGN:
+	//   A = const-pool name index (ZString varName, w/o leading $)
+	//   B = tokenizer ItemType
+	//   C bit 0 = keep-value-on-stack flag
+	// Stack: pops rhs, pops class-source. Reads via
+	// EvalClassStaticVarRead, applies compoundOp, writes back via
+	// AssignClassStaticProp. The two helpers carry the LSB-aware
+	// class resolution, visibility checks, and typed-prop coercion.
+	OpStaticPropCompoundAssign
+
 	// Sentinel — keep last.
 	opLast
 )
@@ -625,4 +636,5 @@ var opNames = [...]string{
 	OpEmptyObjProp:        "EMPTY_OBJ_PROP",
 	OpUnsetObjProp:        "UNSET_OBJ_PROP",
 	OpObjectCompoundAssign: "OBJECT_COMPOUND_ASSIGN",
+	OpStaticPropCompoundAssign: "STATIC_PROP_COMPOUND_ASSIGN",
 }

core/vm/vm.go

@@ -1596,6 +1596,38 @@ func (f *Frame) runUntilError(ctx phpv.Context) (retVal *phpv.ZVal, finished boo
 				f.push(val)
 			}
 
+		// --- `Foo::$bar OP= rhs` static-prop compound assign --------
+		case OpStaticPropCompoundAssign:
+			rhs := f.pop()
+			classV := f.pop()
+			varName, ok := f.fn.Consts[ins.A()].(phpv.ZString)
+			if !ok {
+				return nil, false, fmt.Errorf("vm: OP_STATIC_PROP_COMPOUND_ASSIGN name const is %T not ZString", f.fn.Consts[ins.A()])
+			}
+			op := tokenizer.ItemType(ins.B())
+			fn := compoundOp(op)
+			if fn == nil {
+				return nil, false, fmt.Errorf("vm: OP_STATIC_PROP_COMPOUND_ASSIGN unknown op %d", ins.B())
+			}
+			cur, err := compiler.EvalClassStaticVarRead(ctx, classV, varName, f.fn.LocAt(f.pc-1))
+			if err != nil {
+				return nil, false, err
+			}
+			if cur == nil {
+				cur = phpv.ZNULL.ZVal()
+			}
+			cur = cur.Dup()
+			res, err := fn(ctx, cur, rhs)
+			if err != nil {
+				return nil, false, err
+			}
+			if err := compiler.AssignClassStaticProp(ctx, classV, varName, res); err != nil {
+				return nil, false, err
+			}
+			if ins.C()&1 != 0 {
+				f.push(res)
+			}
+
 		// --- typed-return non-strict coercion -----------------------
 		case OpCoerceReturn:
 			ret := f.pop()

core/vm/vmcompiler/emit_expr.go

@@ -966,6 +966,33 @@ func (e *emitter) emitCompoundAssign(n operatorNode, op tokenizer.ItemType) erro
 			return e.emitAssignViaAST(n)
 		}
 		if compiler.IsStaticPropertyTarget(n.OperatorA()) {
+			// `Foo::$bar OP= rhs`: emit natively when the LHS is the
+			// static-name form. The handler dispatches read +
+			// compoundOp + write via the existing AssignClassStaticProp
+			// + EvalClassStaticVarRead helpers.
+			if compiler.IsClassStaticVarReadNode(n.OperatorA()) {
+				classExpr := n.OperatorA().(interface{ ClassStaticVarReadClassExpr() phpv.Runnable }).ClassStaticVarReadClassExpr()
+				varName := n.OperatorA().(interface{ ClassStaticVarReadName() phpv.ZString }).ClassStaticVarReadName()
+				stmtCtx := e.stmtCtx
+				if err := e.withSubexpr(func() error { return e.emitExpr(classExpr) }); err != nil {
+					return err
+				}
+				if err := e.withSubexpr(func() error { return e.emitExpr(n.OperatorB()) }); err != nil {
+					return err
+				}
+				nameIdx := e.constIndex(varName)
+				var c int32
+				if !stmtCtx {
+					c = 1
+				}
+				e.emit(vm.OpStaticPropCompoundAssign, nameIdx, uint16(op), c)
+				if stmtCtx {
+					e.popStack(2)
+				} else {
+					e.popStack(1)
+				}
+				return nil
+			}
 			return e.emitAssignViaAST(n)
 		}
 		return unsupportedf("compound assign to non-variable target %T", n.OperatorA())