fix: trait default-body placeholder overwrites real signature, breaking deriving

The parser emits two TraitItem::Method entries for a method with both
a signature and a default body: the signature (TypeKind::Named) and a
placeholder (TypeKind::Hole). The skip guard in register_trait_methods
tested for TypeKind::Named("_") which never matched TypeKind::Hole,
so the placeholder overwrote the real signature with an unquantified
type variable. The first call site pinned it; the second failed with
'type mismatch'. This also broke deriving for any trait with a default
body at 2+ types.

Fix: match TypeKind::Hole in the skip guard. Two regression tests.

Author: ilyakooo0

crates/knot-compiler/src/infer.rs

@@ -9026,11 +9026,20 @@ impl Infer {
 
         for item in items {
             if let ast::TraitItem::Method { name, ty, .. } = item {
-                // Skip default-body entries with placeholder types
-                if let ast::TypeKind::Named(n) = &ty.ty.node
-                    && n == "_" {
-                        continue;
-                    }
+                // Skip default-body entries with placeholder types.
+                // The parser emits these with `TypeKind::Hole` (not
+                // `Named("_")`), so the old guard never matched and the
+                // placeholder overwrote the real signature — pinning the
+                // method to a single unquantified type variable shared
+                // across all call sites (first use wins, second fails).
+                let is_placeholder = match &ty.ty.node {
+                    ast::TypeKind::Hole => true,
+                    ast::TypeKind::Named(n) => n == "_",
+                    _ => false,
+                };
+                if is_placeholder {
+                    continue;
+                }
                 self.annotation_vars.clear();
                 self.annotation_unit_vars.clear();
                 self.in_type_annotation = true;

crates/knot-compiler/tests/regress_knot_issues.rs

@@ -625,3 +625,60 @@ fn refinements_nested_in_route_body_fields_are_validated() {
     let bad_top = r#"{"events":[],"top":"BAD"}"#;
     assert_eq!(post_json(port, "/gossip", bad_top).0, 400, "a top-level refined field");
 }
+
+// ── 13. Trait default-body placeholder overwrites real signature ────
+
+/// A trait method with both a signature and a default body caused the
+/// placeholder entry (TypeKind::Hole) to overwrite the real signature,
+/// pinning the method to a single unquantified type variable. The first
+/// call site bound it; the second failed with "type mismatch".
+#[test]
+fn trait_default_body_does_not_pin_method_type() {
+    let src = r#"trait Greet a where
+  greet : a -> Text
+  greet x = "hi"
+data Dog = Dog {}
+data Cat = Cat {}
+impl Greet Dog where
+impl Greet Cat where
+main = do
+  println (greet (Dog {}))
+  println (greet (Cat {}))
+  yield {}
+"#;
+    let c = compile("trait_default_monomorphic", src);
+    let out = Command::new(&c.exe)
+        .current_dir(&c.dir)
+        .output()
+        .expect("failed to run compiled program");
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(
+        stdout.contains("\"hi\"") && stdout.matches("\"hi\"").count() == 2,
+        "both impls should use the default body, got: {stdout}",
+    );
+}
+
+/// `deriving` for a trait with a default body must work at multiple types.
+#[test]
+fn deriving_works_at_multiple_types() {
+    let src = r#"trait Describe a where
+  describe : a -> Text
+  describe x = "value: " ++ show x
+data Priority = Low {} | High {} deriving (Describe)
+data Color = Red {} | Blue {} deriving (Describe)
+main = do
+  println (describe (Low {}))
+  println (describe (Red {}))
+  yield {}
+"#;
+    let c = compile("deriving_multi_type", src);
+    let out = Command::new(&c.exe)
+        .current_dir(&c.dir)
+        .output()
+        .expect("failed to run compiled program");
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(
+        stdout.contains("Low") && stdout.contains("Red"),
+        "both derived impls should work, got: {stdout}",
+    );
+}