fix(lsp): type check fix, no_fold fix.

Author: Meshiest

CHANGELOG.md

@@ -10,6 +10,8 @@
 - **`Opaque` hovers with its own docs** - It showed the Rerouter gate's blurb, which says nothing about the fold-hiding and type-erasing behaviour it exists for.
 - **Fixed `.Value` on a multi-output result** - `a.pop().Value` typed as the whole record, so every use of it mismatched.
 - **Fixed a type alias not resolving through a namespace import** - `import * as T` with `mod f() -> MyType` failed with "unknown type". Aliases now inline as they do for a named import, and `T.MyType` parses as a qualified type.
+- **`GetLeaderboard` returns `int`** - It was typed `any`, so arithmetic on its result had no operator overload.
+- **`bool` arithmetic with two bools** - `bool + bool` (and `- * / %`) now promotes to `int`, matching `bool`/`int` mixes and the bitwise ops; `(a && b) + (c && d)` compiles.
 
 ## 0.17.0
 

crates/lsp/src/main.rs

@@ -300,7 +300,6 @@ impl Backend {
                 source: &src_owned,
                 file: &file_owned,
                 module_name: None,
-                no_fold: false,
             })
         })
         .await;
@@ -846,7 +845,6 @@ impl LanguageServer for Backend {
                     source: &src_owned,
                     file: &file_owned,
                     module_name: None,
-                    no_fold: false,
                 },
                 wirescript::EmitOptions::default(),
                 progress_cb,

crates/wirescript/src/catalog/calls.rs

@@ -1315,7 +1315,7 @@ fn build_calls() -> HashMap<&'static str, CallSpec> {
             vec![CallOutput {
             field: None,
                 port: WirePort::Value,
-                ty: Type::Any,
+                ty: Type::Int,
             }],
         ),
     );
@@ -2648,6 +2648,21 @@ mod tests {
         assert!(find_call("doesNotExist").is_none());
     }
 
+    #[test]
+    fn leaderboard_getters_return_int() {
+        // The inventory dump types both leaderboard `Value` outputs as `int`;
+        // `GetLeaderboard` was declared `Any`, so arithmetic on its result had
+        // no operator overload.
+        for name in ["GetLeaderboard", "GetTeamLeaderboardValue"] {
+            let c = find_call(name).unwrap();
+            assert!(
+                matches!(c.outputs[0].ty, Type::Int),
+                "{name} should return int, got {:?}",
+                c.outputs[0].ty
+            );
+        }
+    }
+
     /// Params that name a settable field the gate does not expose as a wire
     /// input. These only ever work as constants — lowering writes them into the
     /// component's data and drops the wire; a computed value has nowhere to go.

crates/wirescript/src/catalog/operators.rs

@@ -83,6 +83,8 @@ fn math_binary(op: &'static str, class_math: &'static str, vec: bool) -> OpSpec
             ports: BINARY_PORTS,
         },
         // bool → int promotion (engine coerces bool wires to 0/1 on int ports).
+        // Both operands promote, so bool⊕bool is int-valued too — matching the
+        // mixed forms below and the bitwise ops, which already allow it.
         OpRule {
             operands: &[Type::Int, Type::Bool],
             result: Type::Int,
@@ -95,6 +97,12 @@ fn math_binary(op: &'static str, class_math: &'static str, vec: bool) -> OpSpec
             gate_class: class_math,
             ports: BINARY_PORTS,
         },
+        OpRule {
+            operands: &[Type::Bool, Type::Bool],
+            result: Type::Int,
+            gate_class: class_math,
+            ports: BINARY_PORTS,
+        },
     ];
     if vec {
         // Vector math runs on the same gate: MathAdd/Subtract/Multiply/Divide/
@@ -583,6 +591,17 @@ mod tests {
         assert_eq!(r.gate_class, "BrickComponentType_WireGraph_Expr_MathAdd");
     }
 
+    #[test]
+    fn add_bool_bool_promotes_to_int() {
+        // bool coerces to 0/1 on int ports, so bool⊕bool is int-valued -- same
+        // as bool⊕int and the bitwise ops. Covers `(a && b) + (c && d)`.
+        for op in ["+", "-", "*", "/", "%"] {
+            let r = resolve_op(op, &[Type::Bool, Type::Bool])
+                .unwrap_or_else(|| panic!("no rule for bool {op} bool"));
+            assert!(matches!(r.result, Type::Int), "{op} bool/bool should be int");
+        }
+    }
+
     #[test]
     fn add_mixed_promotes_to_float() {
         let r = resolve_op("+", &[Type::Int, Type::Float]).unwrap();

crates/wirescript/src/typecheck.rs

@@ -1916,6 +1916,12 @@ fn infer_expr_inner(
                 (Type::Vector, "x" | "X" | "y" | "Y" | "z" | "Z") => Type::Float,
                 (Type::Color, "r" | "R" | "g" | "G" | "b" | "B" | "a" | "A") => Type::Float,
                 (Type::Rotator, "pitch" | "yaw" | "roll") => Type::Float,
+                // An array read yields the element plus a bounds flag, but it is
+                // typed as the bare element (see IndexAccess), so by the time the
+                // flag is projected - directly or through a `let` - the object is
+                // the element type and this would fall through to Any. Lowering
+                // already maps these names to the gate's bOutOfBounds port.
+                (_, "OutOfBounds" | "bOutOfBounds") => Type::Bool,
                 _ => Type::Any,
             }
         }