feat: Implement negative constants

Co-authored-by: Copilot <copilot@github.com>

Author: smokku

crates/core/src/ast/mod.rs

@@ -528,6 +528,7 @@ pub enum ExprUnaryOp {
     WordLittleEndian,
     FarLittleEndian,
     EvalBracketed,
+    Negate,
 }
 
 #[derive(Debug, Clone)]

crates/core/src/emit_object.rs

@@ -565,13 +565,39 @@ pub fn emit_object(
                 match &instruction.operand {
                     None => {}
                     Some(OperandOp::Immediate(value)) => {
-                        if let Ok(raw) = u32::try_from(*value) {
-                            emit_literal(segment, raw, width, op.span, &mut diagnostics);
+                        // Positive values flow through emit_literal's existing
+                        // unsigned range check. Negative values that fit the
+                        // operand's signed range wrap as two's complement to
+                        // the operand width (per docs/syntax-reference.md).
+                        let v = *value;
+                        if v >= 0 {
+                            match u32::try_from(v) {
+                                Ok(raw) => emit_literal(
+                                    segment, raw, width, op.span, &mut diagnostics,
+                                ),
+                                Err(_) => diagnostics.push(Diagnostic::error(
+                                    op.span,
+                                    "immediate value out of range",
+                                )),
+                            }
                         } else {
-                            diagnostics.push(Diagnostic::error(
-                                op.span,
-                                "immediate value cannot be negative",
-                            ));
+                            let (min, mask): (i64, u32) = match width {
+                                1 => (-(1i64 << 7), 0xFF),
+                                2 => (-(1i64 << 15), 0xFFFF),
+                                3 => (-(1i64 << 23), 0xFF_FFFF),
+                                _ => (0, 0),
+                            };
+                            if v >= min {
+                                let raw = (v as u32) & mask;
+                                emit_literal(
+                                    segment, raw, width, op.span, &mut diagnostics,
+                                );
+                            } else {
+                                diagnostics.push(Diagnostic::error(
+                                    op.span,
+                                    "immediate value cannot be negative",
+                                ));
+                            }
                         }
                     }
                     Some(OperandOp::ImmediateByteRelocation { kind, label }) => {

crates/core/src/lower.rs

@@ -3594,13 +3594,13 @@ fn capitalize(text: &str) -> String {
 }
 
 fn value_fits_reg_width(value: i64, width: RegWidth) -> bool {
-    if value < 0 {
-        return false;
-    }
-    match width {
-        RegWidth::W8 => value <= i64::from(u8::MAX),
-        RegWidth::W16 => value <= i64::from(u16::MAX),
-    }
+    let bits = match width {
+        RegWidth::W8 => 8,
+        RegWidth::W16 => 16,
+    };
+    let min = -(1i64 << (bits - 1));
+    let max = (1i64 << bits) - 1;
+    (min..=max).contains(&value)
 }
 
 fn immediate_width_error(span: Span, value: i64, width: RegWidth, mnemonic: &str) -> Diagnostic {
@@ -4185,6 +4185,10 @@ fn eval_to_number_strict(
                 ExprUnaryOp::HighByte => Some((value >> 8) & 0xFF),
                 ExprUnaryOp::WordLittleEndian | ExprUnaryOp::FarLittleEndian => Some(value),
                 ExprUnaryOp::EvalBracketed => Some(value),
+                ExprUnaryOp::Negate => value.checked_neg().or_else(|| {
+                    diagnostics.push(Diagnostic::error(span, "arithmetic overflow"));
+                    None
+                }),
             }
         }
         Expr::TypedView { expr, .. } | Expr::AddressHint { expr, .. } => {
@@ -4364,7 +4368,8 @@ fn resolve_symbolic_byte_relocation(
         ExprUnaryOp::HighByte => ByteRelocationKind::HighByte,
         ExprUnaryOp::WordLittleEndian
         | ExprUnaryOp::FarLittleEndian
-        | ExprUnaryOp::EvalBracketed => return None,
+        | ExprUnaryOp::EvalBracketed
+        | ExprUnaryOp::Negate => return None,
     };
 
     let symbol = expr_ident_name(expr.as_ref())?;
@@ -5196,6 +5201,10 @@ fn eval_to_number(
                 ExprUnaryOp::HighByte => Some((value >> 8) & 0xFF),
                 ExprUnaryOp::WordLittleEndian | ExprUnaryOp::FarLittleEndian => Some(value),
                 ExprUnaryOp::EvalBracketed => Some(value),
+                ExprUnaryOp::Negate => value.checked_neg().or_else(|| {
+                    diagnostics.push(Diagnostic::error(span, "arithmetic overflow"));
+                    None
+                }),
             }
         }
         Expr::TypedView { expr, .. } | Expr::AddressHint { expr, .. } => {
@@ -5599,6 +5608,70 @@ mod tests {
         assert!(matches!(operand, OperandOp::Immediate(0x34)));
     }
 
+    #[test]
+    fn resolves_negative_const_operand_to_signed_immediate() {
+        let source = "const A = -1\nfunc main @a8 {\n  lda #A\n}\n";
+        let file = parse(SourceId(0), source).expect("parse");
+        let sema = analyze(&file).expect("analyze");
+        let fs = StdAssetFS;
+        let program = lower(&file, &sema, &fs, None).expect("lower");
+
+        let operand = program
+            .ops
+            .iter()
+            .find_map(|op| match &op.node {
+                Op::Instruction(instruction) if instruction.mnemonic == "lda" => {
+                    instruction.operand.as_ref()
+                }
+                _ => None,
+            })
+            .expect("lda operand");
+
+        assert!(matches!(operand, OperandOp::Immediate(-1)));
+    }
+
+    #[test]
+    fn accepts_immediate_at_signed_lower_bound_a8() {
+        // -128 fits the signed range of 8-bit accumulator immediates.
+        let source = "func main @a8 {\n  lda #-128\n}\n";
+        let file = parse(SourceId(0), source).expect("parse");
+        let sema = analyze(&file).expect("analyze");
+        let fs = StdAssetFS;
+        lower(&file, &sema, &fs, None).expect("lower");
+    }
+
+    #[test]
+    fn rejects_immediate_below_signed_lower_bound_a8() {
+        // -129 falls outside both i8 and u8 — error.
+        let source = "func main @a8 {\n  lda #-129\n}\n";
+        let file = parse(SourceId(0), source).expect("parse");
+        let sema = analyze(&file).expect("analyze");
+        let fs = StdAssetFS;
+        let errors = lower(&file, &sema, &fs, None).expect_err("must fail");
+        assert!(
+            errors
+                .iter()
+                .any(|e| e.message.contains("does not fit in @a8")),
+            "expected @a8 width error, got {errors:?}"
+        );
+    }
+
+    #[test]
+    fn rejects_immediate_above_unsigned_upper_bound_a8() {
+        // 256 fits neither i8 nor u8 — error.
+        let source = "func main @a8 {\n  lda #256\n}\n";
+        let file = parse(SourceId(0), source).expect("parse");
+        let sema = analyze(&file).expect("analyze");
+        let fs = StdAssetFS;
+        let errors = lower(&file, &sema, &fs, None).expect_err("must fail");
+        assert!(
+            errors
+                .iter()
+                .any(|e| e.message.contains("does not fit in @a8")),
+            "expected @a8 width error, got {errors:?}"
+        );
+    }
+
     #[test]
     fn resolves_bare_const_operand_to_immediate_value() {
         let source = "const LIMIT = 0x34\nfunc main {\n  lda LIMIT\n}\n";

crates/core/src/parser/expr.rs

@@ -135,12 +135,31 @@ where
             })
             .boxed();
 
-        let mul_expr = unary
+        // Unary minus: numeric negation prefix. Sits outside the `&` address-of
+        // chain and inside `mul_expr`, so `5 - -1` parses as binary-sub of 5
+        // and Negate(1): the add-level loop greedily takes the binary `-`,
+        // and `signed_unary` then consumes the second `-`.
+        let signed_unary = just(TokenKind::Minus)
+            .repeated()
+            .count()
+            .then(unary)
+            .map(|(minus_count, mut inner)| {
+                for _ in 0..minus_count {
+                    inner = Expr::Unary {
+                        op: ExprUnaryOp::Negate,
+                        expr: Box::new(inner),
+                    };
+                }
+                inner
+            })
+            .boxed();
+
+        let mul_expr = signed_unary
             .clone()
             .then(
                 just(TokenKind::Star)
                     .to(ExprBinaryOp::Mul)
-                    .then(unary)
+                    .then(signed_unary)
                     .repeated()
                     .collect::<Vec<_>>(),
             )
@@ -365,6 +384,7 @@ pub(super) fn eval_static_expr(expr: &Expr) -> Option<i64> {
                 ExprUnaryOp::HighByte => Some((value >> 8) & 0xFF),
                 ExprUnaryOp::WordLittleEndian | ExprUnaryOp::FarLittleEndian => Some(value),
                 ExprUnaryOp::EvalBracketed => Some(value),
+                ExprUnaryOp::Negate => value.checked_neg(),
             }
         }
         Expr::TypedView { expr, .. } | Expr::AddressHint { expr, .. } => eval_static_expr(expr),

crates/core/src/parser/tests.rs

@@ -17,6 +17,20 @@ fn assert_add_one_from(expr: &Expr, previous: &str) {
     ));
 }
 
+fn assert_negate_of(expr: &Expr, expected_inner: i64) {
+    let Expr::Unary {
+        op: ExprUnaryOp::Negate,
+        expr: inner,
+    } = expr
+    else {
+        panic!("expected Unary(Negate, ...), got {expr:?}");
+    };
+    assert!(
+        matches!(inner.as_ref(), Expr::Number(n, _) if *n == expected_inner),
+        "expected Negate of Number({expected_inner}), got Negate of {inner:?}",
+    );
+}
+
 #[test]
 fn parses_far_function_and_call() {
     let source = "far func target {\n nop\n}\nfunc main {\n call target\n}\n";
@@ -73,6 +87,40 @@ fn parses_expression_fragment_with_address_hint_suffix() {
     ));
 }
 
+#[test]
+fn parses_unary_minus_on_number() {
+    let expr = parse_expression_fragment(SourceId(0), "-1").expect("parse");
+    assert_negate_of(&expr.node, 1);
+}
+
+#[test]
+fn parses_binary_minus_with_unary_minus_rhs() {
+    let expr = parse_expression_fragment(SourceId(0), "5 - -1").expect("parse");
+    let Expr::Binary {
+        op: ExprBinaryOp::Sub,
+        lhs,
+        rhs,
+    } = &expr.node
+    else {
+        panic!("expected Binary(Sub, ...), got {:?}", expr.node);
+    };
+    assert!(matches!(lhs.as_ref(), Expr::Number(5, _)));
+    assert_negate_of(rhs.as_ref(), 1);
+}
+
+#[test]
+fn parses_repeated_unary_minus() {
+    let expr = parse_expression_fragment(SourceId(0), "--1").expect("parse");
+    let Expr::Unary {
+        op: ExprUnaryOp::Negate,
+        expr: inner,
+    } = &expr.node
+    else {
+        panic!("expected outer Unary(Negate, ...), got {:?}", expr.node);
+    };
+    assert_negate_of(inner.as_ref(), 1);
+}
+
 #[test]
 fn nested_symbolic_subscript_forms_produce_same_ident() {
     let source = "\

crates/core/src/parser/tests/consts.rs

@@ -98,6 +98,32 @@ fn preprocesses_const_group_with_resolvable_identifier_seed() {
     assert_add_one_from(&consts[2].initializer, "B");
 }
 
+#[test]
+fn preprocesses_const_group_with_negative_seed() {
+    let source = "const A = -1, B, C\n";
+    let file = parse(SourceId(0), source).expect("parse");
+    let Item::Const(consts) = &file.items[0].node else {
+        panic!("expected const group");
+    };
+    assert_eq!(consts.len(), 3);
+    assert_negate_of(&consts[0].initializer, 1);
+    assert_add_one_from(&consts[1].initializer, "A");
+    assert_add_one_from(&consts[2].initializer, "B");
+}
+
+#[test]
+fn preprocesses_const_group_with_negative_seed_and_explicit_reset() {
+    let source = "const X = -3, Y = 2, Z\n";
+    let file = parse(SourceId(0), source).expect("parse");
+    let Item::Const(consts) = &file.items[0].node else {
+        panic!("expected const group");
+    };
+    assert_eq!(consts.len(), 3);
+    assert_negate_of(&consts[0].initializer, 3);
+    assert!(matches!(consts[1].initializer, Expr::Number(2, _)));
+    assert_add_one_from(&consts[2].initializer, "Y");
+}
+
 #[test]
 fn parses_top_level_evaluator_block_item() {
     let source = "[ A = 1 ]\n";

crates/core/src/sema/consts.rs

@@ -341,6 +341,10 @@ fn eval_const_expr(
                     Ok(Number::Int(value))
                 }
                 ExprUnaryOp::EvalBracketed => Ok(Number::Int(value)),
+                ExprUnaryOp::Negate => value
+                    .checked_neg()
+                    .map(Number::Int)
+                    .ok_or(ConstExprError::Overflow),
             }
         }
         Expr::TypedView { expr, .. } | Expr::AddressHint { expr, .. } => {

crates/core/src/sema/tests.rs

@@ -59,6 +59,20 @@ fn const_sequence_implicit_initializers_are_resolved() {
     assert_eq!(sema.vars.get("ptr").expect("ptr").address, 2);
 }
 
+#[test]
+fn const_sequence_with_negative_seed_increments_into_zero_and_above() {
+    let source = "const A = -1, B, C\nconst X = -3, Y = 2, Z\n";
+    let file = parse(SourceId(0), source).expect("parse");
+    let sema = analyze(&file).expect("analyze");
+
+    assert_eq!(sema.consts.get("A").expect("A").value, Number::Int(-1));
+    assert_eq!(sema.consts.get("B").expect("B").value, Number::Int(0));
+    assert_eq!(sema.consts.get("C").expect("C").value, Number::Int(1));
+    assert_eq!(sema.consts.get("X").expect("X").value, Number::Int(-3));
+    assert_eq!(sema.consts.get("Y").expect("Y").value, Number::Int(2));
+    assert_eq!(sema.consts.get("Z").expect("Z").value, Number::Int(3));
+}
+
 #[test]
 fn const_sequence_explicit_initializer_resets_increment_chain() {
     let source = "const A = 0, B, C = 10, D\nvar ptr = D\n";

tests/golden/fixtures/syntax-const-negative/expected.bin

@@ -0,0 +1,17 @@
+[default]
+000000: A9 FF A9 00 A9 01 A9 FD A9 02 A9 03 C2 20 A9 FF
+000010: FF A9 FD FF A9 FB FF 60
+
+
+[disasm obj#0 default::main]
+000000: A9 FF       lda #$FF
+000002: A9 00       lda #$00
+000004: A9 01       lda #$01
+000006: A9 FD       lda #$FD
+000008: A9 02       lda #$02
+00000A: A9 03       lda #$03
+00000C: C2 20       rep #$20
+00000E: A9 FF FF    lda #$FFFF
+000011: A9 FD FF    lda #$FFFD
+000014: A9 FB FF    lda #$FFFB
+000017: 60          rts