fix(Data): preserve generic A in TaggedEnum $match arms

.changeset/cold-loops-arrive.md

@@ -0,0 +1,5 @@
+---
+"effect": patch
+---
+
+Fix $match generic type parameter inference inside arms (#6249)

packages/effect/dtslint/Data.tst.ts

@@ -189,5 +189,30 @@ describe("Data", () => {
       expect<typeof A>().type.toBe<(<A>(args: { readonly a: A }) => { readonly _tag: "A"; readonly a: A })>()
       expect<typeof B>().type.toBe<(<B>(args: { readonly b?: B }) => { readonly _tag: "B"; readonly b?: B })>()
     })
+
+    it("should preserve the generic type parameter inside $match arms (#6249)", () => {
+      type TE<T> = Data.TaggedEnum<{
+        Leaf: { value: T }
+        Branch: { children: ReadonlyArray<TE<T>> }
+      }>
+
+      interface TEDefinition extends Data.TaggedEnum.WithGenerics<1> {
+        readonly taggedEnum: TE<this["A"]>
+      }
+
+      const TE = Data.taggedEnum<TEDefinition>()
+
+      function collectValues<A>(node: TE<A>): ReadonlyArray<A> {
+        return TE.$match(node, {
+          Leaf: (leaf) => {
+            expect(leaf.value).type.toBe<A>()
+            return [leaf.value]
+          },
+          Branch: (branch) => branch.children.flatMap(collectValues<A>)
+        })
+      }
+
+      expect(collectValues).type.toBe<<A>(node: TE<A>) => ReadonlyArray<A>>()
+    })
   })
 })

packages/effect/src/Data.ts

@@ -389,18 +389,16 @@ export declare namespace TaggedEnum {
     }
     readonly $match: {
       <
-        A,
-        B,
-        C,
-        D,
-        Cases extends {
-          readonly [Tag in Z["taggedEnum"]["_tag"]]: (
-            args: Extract<TaggedEnum.Kind<Z, A, B, C, D>, { readonly _tag: Tag }>
+        const Self extends TaggedEnum.Kind<Z, any, any, any, any>,
+        const Cases extends {
+          readonly [Tag in Self["_tag"]]: (
+            args: Extract<Self, { readonly _tag: Tag }>
           ) => any
         }
       >(
-        cases: Cases & { [K in Exclude<keyof Cases, Z["taggedEnum"]["_tag"]>]: never }
-      ): (self: TaggedEnum.Kind<Z, A, B, C, D>) => Unify<ReturnType<Cases[Z["taggedEnum"]["_tag"]]>>
+        self: Self,
+        cases: Cases & { [K in Exclude<keyof Cases, Self["_tag"]>]: never }
+      ): Unify<ReturnType<Cases[Self["_tag"]]>>
       <
         A,
         B,
@@ -412,9 +410,8 @@ export declare namespace TaggedEnum {
           ) => any
         }
       >(
-        self: TaggedEnum.Kind<Z, A, B, C, D>,
         cases: Cases & { [K in Exclude<keyof Cases, Z["taggedEnum"]["_tag"]>]: never }
-      ): Unify<ReturnType<Cases[Z["taggedEnum"]["_tag"]]>>
+      ): (self: TaggedEnum.Kind<Z, A, B, C, D>) => Unify<ReturnType<Cases[Z["taggedEnum"]["_tag"]]>>
     }
   }
 }