preserve unknown hash key-type errors in fast-path checks

Author: mgomes

vibes/execution_types_validation.go

@@ -200,6 +200,10 @@ func typeAllowsStringHashKey(ty *TypeExpr) (bool, bool) {
 	}
 
 	switch ty.Kind {
+	case TypeUnknown:
+		// Unknown key types must flow through full matching so callers preserve
+		// unknown-type errors instead of silently treating them as mismatches.
+		return false, false
 	case TypeAny, TypeString:
 		return true, true
 	case TypeUnion:

vibes/execution_types_validation_test.go

@@ -0,0 +1,53 @@
+package vibes
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTypeAllowsStringHashKeyDefersUnknownUnions(t *testing.T) {
+	keyType := &TypeExpr{
+		Kind: TypeUnion,
+		Union: []*TypeExpr{
+			{Name: "typo", Kind: TypeUnknown},
+			{Name: "string", Kind: TypeString},
+		},
+	}
+
+	decided, matches := typeAllowsStringHashKey(keyType)
+	if decided {
+		t.Fatalf("expected unknown key union to defer to full matcher")
+	}
+	if matches {
+		t.Fatalf("unexpected string-key fast-path match for unknown key union")
+	}
+}
+
+func TestValueMatchesTypeHashUnknownKeyUnionReturnsError(t *testing.T) {
+	hashType := &TypeExpr{
+		Kind: TypeHash,
+		TypeArgs: []*TypeExpr{
+			{
+				Kind: TypeUnion,
+				Union: []*TypeExpr{
+					{Name: "typo", Kind: TypeUnknown},
+					{Name: "string", Kind: TypeString},
+				},
+			},
+			{Name: "int", Kind: TypeInt},
+		},
+	}
+
+	matches, err := valueMatchesType(NewHash(map[string]Value{
+		"score": NewInt(1),
+	}), hashType)
+	if err == nil {
+		t.Fatalf("expected unknown type error")
+	}
+	if matches {
+		t.Fatalf("unknown key union should not report a match")
+	}
+	if !strings.Contains(err.Error(), "unknown type typo") {
+		t.Fatalf("expected unknown type error, got %v", err)
+	}
+}