test: cover Hashable Map/Set keys and a UOp interning example

Add pass fixtures for a multi-field struct Map key (insert/lookup/
overwrite/dedup), a Set of that struct, an enum-with-payload key type, and
the canonical tinygrad-style UOp used as a Map<Uop, Uop> intern key and a
dedup Set<Uop>. Add fail fixtures asserting RS0032 for non-hashable Map
keys and Set elements. Add dedicated checker tests (positive, negative,
builtin-key non-regression, and end-to-end UOp lowering) and a runnable
examples/scripts/core/uop_interning.rss.

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

Author: Haofei

crates/rsscript/tests/checker_frontend.rs

@@ -398,6 +398,135 @@ fn check_label(actual: read String, expected: read String) -> Unit {
     assert!(codes.contains(&"RS0204".to_string()));
 }
 
+#[test]
+fn hashable_struct_is_accepted_as_map_key_and_set_element() {
+    let source = r#"
+struct Coord derives(Clone, Eq, Hash) {
+    x: Int
+    y: Int
+}
+
+fn main() -> Unit {
+    let m = Map.new<Coord, Int>()
+    let c = Coord(x: 1, y: 2)
+    Map.insert(map: mut m, key: read c, value: read 10)
+    let here = Map.contains_key(map: read m, key: read c)
+    let s = Set.new<Coord>()
+    let added = Set.insert(set: mut s, value: read c)
+    return Unit
+}
+"#;
+    assert_eq!(
+        analyze_source_with_core("hashable-key.rss", source),
+        Vec::new()
+    );
+}
+
+#[test]
+fn non_hashable_struct_map_key_is_rejected_in_rsscript() {
+    // A struct without `derives(Hash)` is not `Hashable`, so it must be rejected
+    // with RS0032 in RSScript rather than leaking a rustc trait-bound error.
+    let source = r#"
+struct Coord derives(Clone) {
+    x: Int
+    y: Int
+}
+
+fn main() -> Unit {
+    let m = Map.new<Coord, Int>()
+    let c = Coord(x: 1, y: 2)
+    Map.insert(map: mut m, key: read c, value: read 10)
+    return Unit
+}
+"#;
+    let codes = analyze_source_with_core("non-hashable-key.rss", source)
+        .into_iter()
+        .map(|diagnostic| diagnostic.code)
+        .collect::<Vec<_>>();
+    assert!(
+        codes.contains(&"RS0032".to_string()),
+        "expected RS0032, got {codes:?}"
+    );
+}
+
+#[test]
+fn non_hashable_set_element_is_rejected_in_rsscript() {
+    let source = r#"
+struct Coord derives(Clone) {
+    x: Int
+    y: Int
+}
+
+fn main() -> Unit {
+    let s = Set.new<Coord>()
+    let c = Coord(x: 1, y: 2)
+    let added = Set.insert(set: mut s, value: read c)
+    return Unit
+}
+"#;
+    let codes = analyze_source_with_core("non-hashable-set.rss", source)
+        .into_iter()
+        .map(|diagnostic| diagnostic.code)
+        .collect::<Vec<_>>();
+    assert!(
+        codes.contains(&"RS0032".to_string()),
+        "expected RS0032, got {codes:?}"
+    );
+}
+
+#[test]
+fn builtin_scalar_map_keys_remain_accepted() {
+    // Widening Map/Set keys to `K: Hashable` must not regress the common
+    // String/Int key cases.
+    let source = r#"
+fn main() -> Unit {
+    let by_name = Map.new<String, Int>()
+    Map.insert(map: mut by_name, key: read "a", value: read 1)
+    let by_id = Map.new<Int, String>()
+    Map.insert(map: mut by_id, key: read 7, value: read "seven")
+    let ids = Set.new<Int>()
+    let added = Set.insert(set: mut ids, value: read 7)
+    return Unit
+}
+"#;
+    assert_eq!(
+        analyze_source_with_core("builtin-keys.rss", source),
+        Vec::new()
+    );
+}
+
+#[test]
+fn interned_uop_struct_lowers_to_runnable_package() {
+    // Canonical target case: a tinygrad-style UOp struct used as a Map<Uop, Uop>
+    // intern key and a dedup Set<Uop>, end-to-end through Rust lowering.
+    let source = r#"
+struct Uop derives(Clone, Eq, Hash) {
+    op: Int
+    children: List<Int>
+    arg: Option<Int>
+}
+
+fn main() -> Unit {
+    let intern = Map.new<Uop, Uop>()
+    let a = Uop(op: 1, children: List.new<Int>(), arg: Some(7))
+    Map.insert(map: mut intern, key: read a, value: read a)
+    let here = Map.contains_key(map: read intern, key: read a)
+    let seen = Set.new<Uop>()
+    let added = Set.insert(set: mut seen, value: read a)
+    return Unit
+}
+"#;
+    assert_eq!(analyze_source_with_core("uop.rss", source), Vec::new());
+    let package =
+        lower_source_to_rust_package("uop.rss", source, "uop", &common::runtime_path())
+            .unwrap_or_else(|diagnostics| panic!("uop.rss: {diagnostics:?}"));
+    assert!(package.main_rs.is_some());
+    let main_rs = package.main_rs.unwrap();
+    assert!(!main_rs.contains("todo!"));
+    // The derived struct hash/eq lower to Rust derives that make it a HashMap key.
+    assert!(package.lib_rs.contains("Hash"));
+}
+
 #[test]
 fn bundled_interpreter_function_object_new_does_not_retain_closure() {
     let source = r#"

crates/rsscript/tests/fixtures/fail/map-key-not-hashable.rss

@@ -0,0 +1,15 @@
+// expect: RS0032
+
+// A struct that does not derive Hash cannot be a Map key. The Hashable bound on
+// Map keys is checked in RSScript instead of leaking as a rustc trait-bound error.
+struct Coord derives(Clone) {
+    x: Int
+    y: Int
+}
+
+fn main() -> Unit {
+    let m = Map.new<Coord, Int>()
+    let c = Coord(x: 1, y: 2)
+    Map.insert(map: mut m, key: read c, value: read 10)
+    return Unit
+}

crates/rsscript/tests/fixtures/fail/set-elem-not-hashable.rss

@@ -0,0 +1,14 @@
+// expect: RS0032
+
+// A struct that does not derive Hash cannot be a Set element.
+struct Coord derives(Clone) {
+    x: Int
+    y: Int
+}
+
+fn main() -> Unit {
+    let s = Set.new<Coord>()
+    let c = Coord(x: 1, y: 2)
+    let added = Set.insert(set: mut s, value: read c)
+    return Unit
+}

crates/rsscript/tests/fixtures/pass/hashable-enum-payload-key.rss

@@ -0,0 +1,32 @@
+// A sealed sum (enum) that carries payload variants, deriving Eq+Hash, used as a
+// Map key. The Hashable bound accepts the enum because every variant payload
+// field (`Int`, `String`) is itself hashable; the RS0211 derive check separately
+// validates the payload fields. (v0.6 constructs nullary variant values and
+// `match`es payloads; user payload-variant construction is not yet an executable
+// form, so the key values here are the nullary variants.)
+
+sum Token derives(Clone, Eq, Hash) {
+    End
+    Number(value: Int)
+    Name(text: String)
+}
+
+fn classify(token: read Token) -> Int {
+    match token {
+        End => { return 0 }
+        Number(value) => { return value }
+        Name(text) => { return 1 }
+    }
+}
+
+fn main() -> Unit {
+    let counts = Map.new<Token, Int>()
+    let end = End
+
+    Map.insert(map: mut counts, key: read end, value: read classify(token: read end))
+    let here = Map.contains_key(map: read counts, key: read end)
+    if here {
+        Log.write(message: read "token seen")
+    }
+    return Unit
+}

crates/rsscript/tests/fixtures/pass/hashable-struct-map-key.rss

@@ -0,0 +1,29 @@
+// A user struct with several fields, deriving Eq+Hash, used as a Map key:
+// insert, lookup, overwrite (same key), and dedup.
+
+struct Coord derives(Clone, Eq, Hash) {
+    x: Int
+    y: Int
+    label: String
+}
+
+fn main() -> Unit {
+    let m = Map.new<Coord, Int>()
+    let a = Coord(x: 1, y: 2, label: "a")
+    let b = Coord(x: 3, y: 4, label: "b")
+    let a_dup = Coord(x: 1, y: 2, label: "a")
+
+    Map.insert(map: mut m, key: read a, value: read 10)
+    Map.insert(map: mut m, key: read b, value: read 20)
+    // Overwrite: structurally equal key replaces the existing entry.
+    Map.insert(map: mut m, key: read a_dup, value: read 99)
+
+    let here = Map.contains_key(map: read m, key: read a)
+    let got = Map.get(map: read m, key: read a_dup)
+    let n = Map.len(map: read m)
+
+    if here {
+        Log.write(message: read "found")
+    }
+    return Unit
+}

crates/rsscript/tests/fixtures/pass/hashable-struct-set.rss

@@ -0,0 +1,24 @@
+// A Set of a user struct: membership and dedup.
+
+struct Coord derives(Clone, Eq, Hash) {
+    x: Int
+    y: Int
+}
+
+fn main() -> Unit {
+    let seen = Set.new<Coord>()
+    let a = Coord(x: 1, y: 2)
+    let a_dup = Coord(x: 1, y: 2)
+
+    let first = Set.insert(set: mut seen, value: read a)
+    // Structural duplicate: insert returns false, set stays size 1.
+    let again = Set.insert(set: mut seen, value: read a_dup)
+
+    let present = Set.contains(set: read seen, value: read a_dup)
+    let count = Set.len(set: read seen)
+
+    if present {
+        Log.write(message: read "member")
+    }
+    return Unit
+}

crates/rsscript/tests/fixtures/pass/hashable-uop-map-and-set.rss

@@ -0,0 +1,30 @@
+// Canonical target case: a small struct standing in for tinygrad's UOp
+// (an int op tag + a list of child ids + an optional arg) used as a
+// Map<Uop, Uop> intern key and in a dedup Set<Uop>.
+
+struct Uop derives(Clone, Eq, Hash) {
+    op: Int
+    children: List<Int>
+    arg: Option<Int>
+}
+
+fn main() -> Unit {
+    let intern = Map.new<Uop, Uop>()
+    let a = Uop(op: 1, children: List.new<Int>(), arg: Some(7))
+    let b = Uop(op: 2, children: List.new<Int>(), arg: None)
+    let a_dup = Uop(op: 1, children: List.new<Int>(), arg: Some(7))
+
+    Map.insert(map: mut intern, key: read a, value: read a)
+    Map.insert(map: mut intern, key: read b, value: read b)
+    Map.insert(map: mut intern, key: read a_dup, value: read a_dup)
+    let interned = Map.contains_key(map: read intern, key: read a_dup)
+
+    let seen = Set.new<Uop>()
+    let added = Set.insert(set: mut seen, value: read a)
+    let added_dup = Set.insert(set: mut seen, value: read a_dup)
+
+    if interned {
+        Log.write(message: read "uop interned")
+    }
+    return Unit
+}

examples/scripts/core/uop_interning.rss

@@ -0,0 +1,52 @@
+// Graph interning / dedup over a user-defined managed type used as a hash key.
+//
+// `Uop` stands in for a tinygrad-style UOp node: an integer `op` tag, a list of
+// child ids, and an optional integer arg. Deriving `Eq, Hash` makes it a
+// `Hashable` value, so it can be a `Map<Uop, Uop>` key (interning each node to
+// its canonical instance) and a `Set<Uop>` element (dedup). No hand-written
+// hash or equality is needed; the compiler derives the structural ones.
+
+struct Uop derives(Clone, Eq, Hash) {
+    op: Int
+    children: List<Int>
+    arg: Option<Int>
+}
+
+fn main() -> Unit {
+    // Intern table: map each Uop to its canonical (first-seen) Uop.
+    let intern = Map.new<Uop, Uop>()
+
+    let a = Uop(op: 1, children: List.new<Int>(), arg: Some(7))
+    let b = Uop(op: 2, children: List.new<Int>(), arg: None)
+    // `a_again` is a structurally identical, separately-constructed value.
+    let a_again = Uop(op: 1, children: List.new<Int>(), arg: Some(7))
+
+    Map.insert(map: mut intern, key: read a, value: read a)
+    Map.insert(map: mut intern, key: read b, value: read b)
+    // Overwrite-with-same-key path: inserting a structural duplicate replaces.
+    Map.insert(map: mut intern, key: read a_again, value: read a_again)
+
+    let size = Map.len(map: read intern)
+    Log.write(message: read String.concat(
+        left: read "intern size: ",
+        right: read Int.to_string(value: read size),
+    ))
+
+    // Lookup the canonical node for a structural duplicate.
+    let found = Map.contains_key(map: read intern, key: read a_again)
+    if found {
+        Log.write(message: read "a_again interns to an existing node")
+    }
+
+    // Dedup with a Set<Uop>.
+    let seen = Set.new<Uop>()
+    let inserted_a = Set.insert(set: mut seen, value: read a)
+    let inserted_dup = Set.insert(set: mut seen, value: read a_again)
+    let unique = Set.len(set: read seen)
+    Log.write(message: read String.concat(
+        left: read "unique nodes: ",
+        right: read Int.to_string(value: read unique),
+    ))
+
+    return Unit
+}