ac7f1d10e5
The arithmetic-only check from the previous commit shared a hole with the comparison and bitwise/shift ops: lowerBinaryOp derives the result type from the LHS, so `s64 < string` fed mismatched types to `icmp` (LLVM verifier failure) and `s64 & string` reinterpreted the string's bytes. Add isOrderingOperand (numeric / enum / pointer / bool / vector) and isBitwiseOperand (integer / enum / bool / vector), and route `< <= > >=` and `& | ^ << >>` through them alongside the existing arithmetic check, all sharing one diagnostic + placeholder-sentinel path. Flags-enum bitwise (`.read | .write`, `perm & .read`), enum/pointer comparison, and int literals stay legal (50-smoke unaffected). Equality `== / !=` is deliberately left unchecked — its path is heavily special-cased (str_eq, Any unbox, optional == null); folding a check in without regressing those is a separate change, noted in the issue. Regression test renamed arith→binop and broadened to cover `+ * < & <<` against a string operand: examples/214-binop-operand-type-check.sx.
26 lines
1.1 KiB
Plaintext
26 lines
1.1 KiB
Plaintext
// Scalar binary operators check operand-type compatibility. The result
|
|
// type is otherwise taken from the left operand, so mixing a non-numeric
|
|
// type (here `string`) would lower as `<op> : s64` and either reinterpret
|
|
// the string's bytes (arithmetic / bitwise → garbage) or feed mismatched
|
|
// types to `icmp` (ordering → LLVM verifier failure). All such mismatches
|
|
// are now rejected at compile time:
|
|
// - arithmetic `+ - * / %` (numeric / vector / pointer operands)
|
|
// - ordering `< <= > >=` (numeric / enum / pointer operands)
|
|
// - bitwise `& | ^` (integer / enum operands)
|
|
// - shift `<< >>` (integer / enum operands)
|
|
// Legitimate mixes (int+float promotion, flags-enum bitwise, enum/pointer
|
|
// comparison) are unaffected — see `examples/50-smoke.sx`.
|
|
|
|
#import "modules/std.sx";
|
|
|
|
main :: () -> s32 {
|
|
n : s64 = 40;
|
|
s : string = "nope";
|
|
a := n + s; // arithmetic: s64 + string
|
|
b := s * n; // arithmetic: non-numeric LHS (string * s64)
|
|
c := n < s; // ordering: s64 < string
|
|
d := n & s; // bitwise: s64 & string
|
|
e := n << s; // shift: s64 << string
|
|
0;
|
|
}
|