fix(vm): lower string ordered comparisons with lexicographic parity

Compiler-allowed string <, >, <=, >= currently reach the VM as Clt/Cgt
opcodes, but both the std interpreter and the no-std runtime route them
through numeric comparison and fail with TypeMismatch("number") on
string operands, while Ceq already had a string-string fast path.

Add a STRING_STRING operand-type-hint arm to the std Clt/Cgt handlers
backed by a new string_compare_op that applies Rust str lexicographic
ordering, and mirror it in pd-vm-nostd by replacing the numeric-only
numeric_compare with a compare helper that dispatches string-string to
str ordering and keeps int/float numeric semantics otherwise. Mixed
string/number ordering stays a typed TypeMismatch error in both runtimes.

Trace JIT and AOT cannot specialize string Clt/Cgt, so they defer to the
interpreter (trace abandonment / whole-program AOT refusal); the new JIT
tests pin that this produces the exact same result as a pure interpreter
run, i.e. no semantic divergence on the JIT path.

Tests: std compiler string ordering runtime cases (equality, empty,
ASCII prefix, non-ASCII UTF-8, <= >=), mixed-type rejection in both VMs,
no-std lexicographic parity via VMBC decode, trace-JIT fallback parity
and AOT defer-to-interpreter parity.

Author: ffonion

pd-vm-nostd/src/vm.rs

@@ -475,8 +475,16 @@ impl<C> Vm<C> {
                     let lhs = self.pop()?;
                     self.stack.push(Value::Bool(lhs == rhs));
                 }
-                OpCode::Clt => self.numeric_compare(|lhs, rhs| lhs < rhs, |lhs, rhs| lhs < rhs)?,
-                OpCode::Cgt => self.numeric_compare(|lhs, rhs| lhs > rhs, |lhs, rhs| lhs > rhs)?,
+                OpCode::Clt => self.compare(
+                    |lhs, rhs| lhs < rhs,
+                    |lhs, rhs| lhs < rhs,
+                    |lhs, rhs| lhs < rhs,
+                )?,
+                OpCode::Cgt => self.compare(
+                    |lhs, rhs| lhs > rhs,
+                    |lhs, rhs| lhs > rhs,
+                    |lhs, rhs| lhs > rhs,
+                )?,
                 OpCode::Br => {
                     let target = self.read_u32()?;
                     self.jump(target)?;
@@ -968,19 +976,31 @@ impl<C> Vm<C> {
         Ok(())
     }
 
-    fn numeric_compare(
+    fn compare(
         &mut self,
         int_op: impl FnOnce(i64, i64) -> bool,
         float_op: impl FnOnce(f64, f64) -> bool,
+        string_op: impl FnOnce(&str, &str) -> bool,
     ) -> VmResult<()> {
-        let rhs = self.pop_numeric()?;
-        let lhs = self.pop_numeric()?;
-        let result = match (lhs, rhs) {
-            (NumericValue::Int(lhs), NumericValue::Int(rhs)) => int_op(lhs, rhs),
-            (lhs, rhs) => float_op(as_float(lhs), as_float(rhs)),
-        };
-        self.stack.push(Value::Bool(result));
-        Ok(())
+        let rhs = self.pop()?;
+        let lhs = self.pop()?;
+        match (lhs, rhs) {
+            (Value::String(lhs), Value::String(rhs)) => {
+                self.stack
+                    .push(Value::Bool(string_op(lhs.as_str(), rhs.as_str())));
+                Ok(())
+            }
+            (lhs, rhs) => {
+                let rhs = numeric_value(rhs)?;
+                let lhs = numeric_value(lhs)?;
+                let result = match (lhs, rhs) {
+                    (NumericValue::Int(lhs), NumericValue::Int(rhs)) => int_op(lhs, rhs),
+                    (lhs, rhs) => float_op(as_float(lhs), as_float(rhs)),
+                };
+                self.stack.push(Value::Bool(result));
+                Ok(())
+            }
+        }
     }
 
     fn pop(&mut self) -> VmResult<Value> {
@@ -1080,6 +1100,14 @@ impl<C> Vm<C> {
     }
 }
 
+fn numeric_value(value: Value) -> VmResult<NumericValue> {
+    match value {
+        Value::Int(value) => Ok(NumericValue::Int(value)),
+        Value::Float(value) => Ok(NumericValue::Float(value)),
+        _ => Err(VmError::TypeMismatch("number")),
+    }
+}
+
 fn as_float(value: NumericValue) -> f64 {
     match value {
         NumericValue::Int(value) => value as f64,

pd-vm-nostd/tests/call_script_tests.rs

@@ -363,3 +363,63 @@ fn call_script_binding_outside_frame_fails_typed() {
         "expected InvalidFrameState for the out-of-frame binding, got {err:?}"
     );
 }
+
+#[test]
+fn string_ordered_comparison_matches_rust_lexicographic_semantics() {
+    // Compiler-allowed string `<`/`>`/`<=`/`>=` must lower in the no-std VM
+    // with the same Rust `str` lexicographic ordering as the std VM, and
+    // mixed string/number ordering must remain a typed error.
+    let compiled = compile_source(
+        r#"
+            let lt = "abc" < "abd";
+            let gt = "abd" > "abc";
+            let eq_le = "abc" <= "abc";
+            let eq_ge = "abc" >= "abc";
+            let empty_lt = "" < "a";
+            let prefix = "ab" < "abc";
+            let utf8 = ("é" > "e") && ("日本" < "英語");
+            if lt && gt && eq_le && eq_ge && empty_lt && prefix && utf8 {
+                1;
+            } else {
+                0;
+            }
+        "#,
+    )
+    .expect("string ordering source should compile");
+    let bytes = encode_program(&compiled.program.with_local_count(compiled.locals))
+        .expect("string ordering program should encode as VMBC v14");
+    let program = decode_program(&bytes).expect("no-std should decode VMBC v14");
+
+    let mut vm = EmbeddedVm::new(program);
+    assert_eq!(
+        vm.run().expect("string ordering should halt"),
+        EmbeddedVmStatus::Halted
+    );
+    assert_eq!(vm.stack(), &[EmbeddedValue::Int(1)]);
+}
+
+#[test]
+fn string_numeric_mixed_ordered_comparison_remains_typed_error() {
+    // `"abc" < 1` must stay a typed error in the no-std VM: the operand type
+    // hint is (String, Int), which is not the string-string fast path and
+    // must not be coerced into a numeric or string comparison.
+    let compiled = compile_source(
+        r#"
+            let mixed = "abc" < 1;
+            mixed;
+        "#,
+    )
+    .expect("mixed ordering source should compile");
+    let bytes = encode_program(&compiled.program.with_local_count(compiled.locals))
+        .expect("mixed ordering program should encode");
+    let program = decode_program(&bytes).expect("no-std should decode mixed ordering program");
+
+    let mut vm = EmbeddedVm::new(program);
+    let err = vm
+        .run()
+        .expect_err("mixed string/number ordering must remain a typed error");
+    assert!(
+        matches!(err, VmError::TypeMismatch(_)),
+        "expected TypeMismatch, got {err:?}"
+    );
+}

src/vm/mod.rs

@@ -2780,6 +2780,24 @@ impl Vm {
         Ok(())
     }
 
+    pub(super) fn string_compare_op(
+        &mut self,
+        op: impl FnOnce(&str, &str) -> bool,
+    ) -> VmResult<()> {
+        let rhs = match self.pop_value()? {
+            Value::String(value) => value,
+            _ => return Err(VmError::TypeMismatch("string")),
+        };
+        let lhs = match self.pop_value()? {
+            Value::String(value) => value,
+            _ => return Err(VmError::TypeMismatch("string")),
+        };
+        self.instance
+            .stack
+            .push(Value::Bool(op(lhs.as_str(), rhs.as_str())));
+        Ok(())
+    }
+
     pub(super) fn null_eq_op(&mut self) -> VmResult<()> {
         let rhs = self.pop_value()?;
         let lhs = self.pop_value()?;
@@ -3669,6 +3687,10 @@ impl Vm {
                         self.record_operand_hint_hit();
                         self.float_compare_op(|lhs, rhs| lhs < rhs)?
                     }
+                    STRING_STRING_OPERAND_TYPE_HINT => {
+                        self.record_operand_hint_hit();
+                        self.string_compare_op(|lhs, rhs| lhs < rhs)?
+                    }
                     _ => {
                         self.record_operand_hint_miss();
                         self.compare_numeric_op(|lhs, rhs| lhs < rhs, |lhs, rhs| lhs < rhs)?
@@ -3686,6 +3708,10 @@ impl Vm {
                         self.record_operand_hint_hit();
                         self.float_compare_op(|lhs, rhs| lhs > rhs)?
                     }
+                    STRING_STRING_OPERAND_TYPE_HINT => {
+                        self.record_operand_hint_hit();
+                        self.string_compare_op(|lhs, rhs| lhs > rhs)?
+                    }
                     _ => {
                         self.record_operand_hint_miss();
                         self.compare_numeric_op(|lhs, rhs| lhs > rhs, |lhs, rhs| lhs > rhs)?

tests/compiler/compiler_rustscript_tests.rs

@@ -3512,6 +3512,104 @@ fn rustscript_language_runtime_cases_work() {
     run_runtime_cases(&cases);
 }
 
+#[test]
+fn rustscript_string_ordered_comparison_runtime_cases_work() {
+    let cases = vec![
+        RuntimeCase {
+            name: "string less-than is lexicographic",
+            source: r#"
+                ("abc" < "abd") && ("abd" > "abc");
+            "#,
+            flavor: SourceFlavor::RustScript,
+            expected_stack: vec![Value::Bool(true)],
+            expected_locals: None,
+        },
+        RuntimeCase {
+            name: "equal strings are neither less-than nor greater-than",
+            source: r#"
+                let equal = ("abc" < "abc") == false && ("abc" > "abc") == false;
+                equal;
+            "#,
+            flavor: SourceFlavor::RustScript,
+            expected_stack: vec![Value::Bool(true)],
+            expected_locals: None,
+        },
+        RuntimeCase {
+            name: "less-than-or-equal / greater-than-or-equal include equality",
+            source: r#"
+                ("abc" <= "abc") && ("abc" >= "abc") && ("abc" <= "abd") && ("abd" >= "abc");
+            "#,
+            flavor: SourceFlavor::RustScript,
+            expected_stack: vec![Value::Bool(true)],
+            expected_locals: None,
+        },
+        RuntimeCase {
+            name: "empty string compares before and after non-empty strings",
+            source: r#"
+                ("" < "a") && (!("a" < "")) && ("" <= "") && ("" == "");
+            "#,
+            flavor: SourceFlavor::RustScript,
+            expected_stack: vec![Value::Bool(true)],
+            expected_locals: None,
+        },
+        RuntimeCase {
+            name: "ascii prefix ordering matches byte lexicographic order",
+            source: r#"
+                ("ab" < "abc") && (!("abc" < "ab")) && ("abc" > "ab");
+            "#,
+            flavor: SourceFlavor::RustScript,
+            expected_stack: vec![Value::Bool(true)],
+            expected_locals: None,
+        },
+        RuntimeCase {
+            name: "non-ascii utf-8 compares by code-point lexicographic order",
+            source: r#"
+                ("é" > "e") && ("日本" < "英語") && ("中" < "乙") && ("🌍" > "A");
+            "#,
+            flavor: SourceFlavor::RustScript,
+            expected_stack: vec![Value::Bool(true)],
+            expected_locals: None,
+        },
+    ];
+    run_runtime_cases(&cases);
+}
+
+#[test]
+fn rustscript_string_ordered_comparison_rejects_mixed_types() {
+    // A compiler-allowed comparison between a string and a number must not
+    // silently coerce: both the std VM and the no-std VM keep it a typed
+    // runtime error (TypeMismatch), never a lexicographic or numeric answer.
+    let source = r#"
+        let mixed = "abc" < 1;
+        mixed;
+    "#;
+    let compiled = compile_source_with_flavor(source, SourceFlavor::RustScript)
+        .expect("compile should succeed");
+    let mut vm = Vm::try_new(compiled.program).expect("test VM construction must not fail");
+    let err = vm
+        .run()
+        .expect_err("mixed string/number ordering must remain a typed error");
+    assert!(
+        matches!(err, vm::VmError::TypeMismatch(_)),
+        "expected TypeMismatch, got {err:?}"
+    );
+
+    let source_gt = r#"
+        let mixed = 1 >= "abc";
+        mixed;
+    "#;
+    let compiled_gt = compile_source_with_flavor(source_gt, SourceFlavor::RustScript)
+        .expect("compile should succeed");
+    let mut vm_gt = Vm::try_new(compiled_gt.program).expect("test VM construction must not fail");
+    let err_gt = vm_gt
+        .run()
+        .expect_err("mixed number/string ordering must remain a typed error");
+    assert!(
+        matches!(err_gt, vm::VmError::TypeMismatch(_)),
+        "expected TypeMismatch, got {err_gt:?}"
+    );
+}
+
 #[test]
 fn rustscript_language_parse_rejection_cases_work() {
     let cases = vec![