@tsonic/frontend 0.0.14 → 0.0.16

package/dist/ir/{type-converter → type-system/internal/type-converter}/utility-types.test.js

@@ -10,6 +10,7 @@ import { describe, it } from "mocha";
 import { expect } from "chai";
 import * as ts from "typescript";
 import { expandUtilityType, expandConditionalUtilityType, expandRecordType, } from "./utility-types.js";
+import { createBinding } from "../../../binding/index.js";
 /**
  * Assert value is not null/undefined and return it typed as non-null.
  * Throws if value is null or undefined.
@@ -45,7 +46,8 @@ const createTestProgram = (source, fileName = "test.ts") => {
     const program = ts.createProgram([fileName], compilerOptions, host);
     const sourceFile = assertDefined(program.getSourceFile(fileName), `Source file ${fileName} not found`);
     const checker = program.getTypeChecker();
-    return { program, checker, sourceFile };
+    const binding = createBinding(checker);
+    return { program, checker, sourceFile, binding };
 };
 /**
  * Helper to find a type alias by name and get its type reference node
@@ -66,7 +68,7 @@ const findTypeAliasReference = (sourceFile, aliasName) => {
 /**
  * Stub convertType for testing - just returns the type name
  */
-const stubConvertType = (node, checker) => {
+const stubConvertType = (node, _binding) => {
     if (ts.isTypeReferenceNode(node)) {
         const name = ts.isIdentifier(node.typeName)
             ? node.typeName.text
@@ -79,13 +81,19 @@ const stubConvertType = (node, checker) => {
     if (node.kind === ts.SyntaxKind.NumberKeyword) {
         return { kind: "primitiveType", name: "number" };
     }
+    if (node.kind === ts.SyntaxKind.BooleanKeyword) {
+        return { kind: "primitiveType", name: "boolean" };
+    }
     if (node.kind === ts.SyntaxKind.UndefinedKeyword) {
         return { kind: "primitiveType", name: "undefined" };
     }
+    if (node.kind === ts.SyntaxKind.NullKeyword) {
+        return { kind: "primitiveType", name: "null" };
+    }
     if (node.kind === ts.SyntaxKind.NeverKeyword) {
         return { kind: "neverType" };
     }
-    // Handle literal type nodes (e.g., "a", 1)
+    // Handle literal type nodes (e.g., "a", 1, null, undefined)
     if (ts.isLiteralTypeNode(node)) {
         const literal = node.literal;
         if (ts.isStringLiteral(literal)) {
@@ -94,11 +102,15 @@ const stubConvertType = (node, checker) => {
         if (ts.isNumericLiteral(literal)) {
             return { kind: "literalType", value: Number(literal.text) };
         }
+        // null can appear as LiteralTypeNode in type positions
+        if (literal.kind === ts.SyntaxKind.NullKeyword) {
+            return { kind: "primitiveType", name: "null" };
+        }
     }
     if (ts.isUnionTypeNode(node)) {
         return {
             kind: "unionType",
-            types: node.types.map((t) => stubConvertType(t, checker)),
+            types: node.types.map((t) => stubConvertType(t, _binding)),
         };
     }
     return { kind: "anyType" };
@@ -113,9 +125,9 @@ describe("Utility Type Expansion Safety", () => {
         }
         type PartialWithIndex = Partial<WithStringIndex>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "PartialWithIndex");
-            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Partial", checker, stubConvertType);
+            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Partial", binding, stubConvertType);
             // Should return null because expansion would lose the index signature
             expect(result).to.equal(null);
         });
@@ -127,9 +139,9 @@ describe("Utility Type Expansion Safety", () => {
         }
         type ReadonlyWithIndex = Readonly<WithNumberIndex>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "ReadonlyWithIndex");
-            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Readonly", checker, stubConvertType);
+            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Readonly", binding, stubConvertType);
             // Should return null because expansion would lose the index signature
             expect(result).to.equal(null);
         });
@@ -141,9 +153,9 @@ describe("Utility Type Expansion Safety", () => {
         }
         type PartialPerson = Partial<Person>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "PartialPerson");
-            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Partial", checker, stubConvertType);
+            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Partial", binding, stubConvertType);
             // Should expand successfully
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("objectType");
@@ -162,11 +174,11 @@ describe("Utility Type Expansion Safety", () => {
         }
         type PartialWithSymbol = Partial<WithSymbol>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "PartialWithSymbol");
             // This may or may not find the type ref depending on how TS handles it
             if (typeRef) {
-                const result = expandUtilityType(typeRef, "Partial", checker, stubConvertType);
+                const result = expandUtilityType(typeRef, "Partial", binding, stubConvertType);
                 // If expansion proceeds, it should return null due to symbol key
                 // (symbol keys start with __@ internally)
                 // Note: The actual behavior depends on whether TS resolves the symbol key
@@ -184,9 +196,9 @@ describe("Utility Type Expansion Safety", () => {
         }
         type PartialWithUndefined = Partial<WithExplicitUndefined>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "PartialWithUndefined");
-            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Partial", checker, stubConvertType);
+            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Partial", binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("objectType");
             // The property should preserve the union with undefined
@@ -207,9 +219,9 @@ describe("Utility Type Expansion Safety", () => {
         }
         type PartialWithSynthetic = Partial<WithSyntheticUndefined>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "PartialWithSynthetic");
-            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Partial", checker, stubConvertType);
+            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Partial", binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("objectType");
             // The property type should be string (not string | undefined)
@@ -231,9 +243,9 @@ describe("Utility Type Expansion Safety", () => {
         }
         type PartialRequired = Partial<WithRequiredUndefined>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "PartialRequired");
-            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Partial", checker, stubConvertType);
+            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Partial", binding, stubConvertType);
             expect(result).not.to.equal(null);
             const xProp = result?.members.find((m) => m.kind === "propertySignature" && m.name === "x");
             expect(xProp).not.to.equal(undefined);
@@ -252,9 +264,9 @@ describe("Utility Type Expansion Safety", () => {
         }
         type PartialReadonly = Partial<Readonly<Person>>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "PartialReadonly");
-            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Partial", checker, stubConvertType);
+            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Partial", binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("objectType");
             // All properties should be readonly (from inner Readonly<T>)
@@ -273,9 +285,9 @@ describe("Utility Type Expansion Safety", () => {
         }
         type ReadonlyPartial = Readonly<Partial<Person>>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "ReadonlyPartial");
-            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Readonly", checker, stubConvertType);
+            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Readonly", binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("objectType");
             // All properties should be both readonly (from Readonly<T>) and optional (from Partial<T>)
@@ -296,9 +308,9 @@ describe("Utility Type Expansion Safety", () => {
         }
         type PartialWithMethod = Partial<WithMethod>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "PartialWithMethod");
-            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Partial", checker, stubConvertType);
+            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Partial", binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("objectType");
             // Should have both property and method
@@ -323,9 +335,9 @@ describe("Utility Type Expansion Safety", () => {
         }
         type ContactInfo = Pick<Person, "name" | "email" | "phone">;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "ContactInfo");
-            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Pick", checker, stubConvertType);
+            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Pick", binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("objectType");
             // Should only have name, email, phone (not age)
@@ -348,9 +360,9 @@ describe("Utility Type Expansion Safety", () => {
         }
         type MinimalPerson = Omit<Person, "email" | "phone">;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "MinimalPerson");
-            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Omit", checker, stubConvertType);
+            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Omit", binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("objectType");
             // Should only have name, age (not email, phone)
@@ -369,7 +381,7 @@ describe("Utility Type Expansion Safety", () => {
             const source = `
         function process<T>(data: Partial<T>): void {}
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             // Find the Partial<T> type reference in the function parameter
             let typeRef = null;
             const visitor = (node) => {
@@ -381,11 +393,255 @@ describe("Utility Type Expansion Safety", () => {
                 ts.forEachChild(node, visitor);
             };
             ts.forEachChild(sourceFile, visitor);
-            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Partial", checker, stubConvertType);
+            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Partial", binding, stubConvertType);
             // Should return null because T is a type parameter - can't expand at compile time
             expect(result).to.equal(null);
         });
     });
+    describe("Comprehensive utility type tests (nested, recursive, generic)", () => {
+        it("should expand Partial on recursive type (tree node)", () => {
+            const source = `
+        interface TreeNode {
+          value: number;
+          children: TreeNode[];
+        }
+        type PartialTreeNode = Partial<TreeNode>;
+      `;
+            const { binding, sourceFile } = createTestProgram(source);
+            const typeRef = findTypeAliasReference(sourceFile, "PartialTreeNode");
+            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Partial", binding, stubConvertType);
+            expect(result).not.to.equal(null);
+            expect(result?.kind).to.equal("objectType");
+            expect(result?.members).to.have.length(2);
+            const valueProp = result?.members.find((m) => m.kind === "propertySignature" && m.name === "value");
+            const childrenProp = result?.members.find((m) => m.kind === "propertySignature" && m.name === "children");
+            expect(valueProp).not.to.equal(undefined);
+            expect(childrenProp).not.to.equal(undefined);
+            if (valueProp && valueProp.kind === "propertySignature") {
+                expect(valueProp.isOptional).to.equal(true);
+            }
+            if (childrenProp && childrenProp.kind === "propertySignature") {
+                expect(childrenProp.isOptional).to.equal(true);
+            }
+        });
+        it("should expand Partial on linked list type (self-referential)", () => {
+            const source = `
+        interface ListNode<T> {
+          value: T;
+          next: ListNode<T> | null;
+        }
+        type PartialListNode = Partial<ListNode<string>>;
+      `;
+            const { binding, sourceFile } = createTestProgram(source);
+            const typeRef = findTypeAliasReference(sourceFile, "PartialListNode");
+            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Partial", binding, stubConvertType);
+            expect(result).not.to.equal(null);
+            expect(result?.kind).to.equal("objectType");
+            const valueProp = result?.members.find((m) => m.kind === "propertySignature" && m.name === "value");
+            const nextProp = result?.members.find((m) => m.kind === "propertySignature" && m.name === "next");
+            expect(valueProp).not.to.equal(undefined);
+            expect(nextProp).not.to.equal(undefined);
+        });
+        it("should expand triple-nested utility types", () => {
+            const source = `
+        interface Data {
+          id: number;
+          name: string;
+        }
+        type TripleNested = Partial<Readonly<Required<Data>>>;
+      `;
+            const { binding, sourceFile } = createTestProgram(source);
+            const typeRef = findTypeAliasReference(sourceFile, "TripleNested");
+            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Partial", binding, stubConvertType);
+            expect(result).not.to.equal(null);
+            expect(result?.kind).to.equal("objectType");
+            const idProp = result?.members.find((m) => m.kind === "propertySignature" && m.name === "id");
+            expect(idProp).not.to.equal(undefined);
+            if (idProp && idProp.kind === "propertySignature") {
+                expect(idProp.isReadonly).to.equal(true);
+                expect(idProp.isOptional).to.equal(true);
+            }
+        });
+        it("should expand Pick on nested utility type", () => {
+            const source = `
+        interface User {
+          id: number;
+          name: string;
+          email: string;
+          password: string;
+        }
+        type SafeUser = Pick<Readonly<User>, "id" | "name" | "email">;
+      `;
+            const { binding, sourceFile } = createTestProgram(source);
+            const typeRef = findTypeAliasReference(sourceFile, "SafeUser");
+            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Pick", binding, stubConvertType);
+            expect(result).not.to.equal(null);
+            expect(result?.kind).to.equal("objectType");
+            expect(result?.members).to.have.length(3);
+            const propNames = result?.members
+                .filter((m) => m.kind === "propertySignature")
+                .map((m) => m.name);
+            expect(propNames).to.include("id");
+            expect(propNames).to.include("name");
+            expect(propNames).to.include("email");
+            expect(propNames).not.to.include("password");
+        });
+        it("should expand Omit on Partial type", () => {
+            const source = `
+        interface Config {
+          host: string;
+          port: number;
+          timeout: number;
+          debug: boolean;
+        }
+        type PartialConfig = Omit<Partial<Config>, "debug">;
+      `;
+            const { binding, sourceFile } = createTestProgram(source);
+            const typeRef = findTypeAliasReference(sourceFile, "PartialConfig");
+            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Omit", binding, stubConvertType);
+            expect(result).not.to.equal(null);
+            expect(result?.kind).to.equal("objectType");
+            expect(result?.members).to.have.length(3);
+            const propNames = result?.members
+                .filter((m) => m.kind === "propertySignature")
+                .map((m) => m.name);
+            expect(propNames).not.to.include("debug");
+            expect(propNames).to.include("host");
+        });
+        it("should expand Required on Partial type (roundtrip)", () => {
+            const source = `
+        interface Base {
+          x: number;
+          y: number;
+        }
+        type RoundTrip = Required<Partial<Base>>;
+      `;
+            const { binding, sourceFile } = createTestProgram(source);
+            const typeRef = findTypeAliasReference(sourceFile, "RoundTrip");
+            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Required", binding, stubConvertType);
+            expect(result).not.to.equal(null);
+            expect(result?.kind).to.equal("objectType");
+            const xProp = result?.members.find((m) => m.kind === "propertySignature" && m.name === "x");
+            expect(xProp).not.to.equal(undefined);
+            if (xProp && xProp.kind === "propertySignature") {
+                // Required removes optional, so isOptional should be false
+                expect(xProp.isOptional).to.equal(false);
+            }
+        });
+        it("should expand utility type on generic interface with concrete type arg", () => {
+            const source = `
+        interface Container<T> {
+          value: T;
+          metadata: string;
+        }
+        type PartialNumberContainer = Partial<Container<number>>;
+      `;
+            const { binding, sourceFile } = createTestProgram(source);
+            const typeRef = findTypeAliasReference(sourceFile, "PartialNumberContainer");
+            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Partial", binding, stubConvertType);
+            expect(result).not.to.equal(null);
+            expect(result?.kind).to.equal("objectType");
+            const valueProp = result?.members.find((m) => m.kind === "propertySignature" && m.name === "value");
+            const metadataProp = result?.members.find((m) => m.kind === "propertySignature" && m.name === "metadata");
+            expect(valueProp).not.to.equal(undefined);
+            expect(metadataProp).not.to.equal(undefined);
+            if (valueProp && valueProp.kind === "propertySignature") {
+                expect(valueProp.isOptional).to.equal(true);
+            }
+        });
+        it("should expand utility type on generic interface with multiple type params", () => {
+            const source = `
+        interface Pair<K, V> {
+          key: K;
+          value: V;
+        }
+        type PartialPair = Partial<Pair<string, number>>;
+      `;
+            const { binding, sourceFile } = createTestProgram(source);
+            const typeRef = findTypeAliasReference(sourceFile, "PartialPair");
+            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Partial", binding, stubConvertType);
+            expect(result).not.to.equal(null);
+            expect(result?.kind).to.equal("objectType");
+            expect(result?.members).to.have.length(2);
+            // Verify both properties exist and are optional
+            const keyProp = result?.members.find((m) => m.kind === "propertySignature" && m.name === "key");
+            const valueProp = result?.members.find((m) => m.kind === "propertySignature" && m.name === "value");
+            expect(keyProp).not.to.equal(undefined);
+            expect(valueProp).not.to.equal(undefined);
+            if (keyProp && keyProp.kind === "propertySignature") {
+                expect(keyProp.isOptional).to.equal(true);
+            }
+            if (valueProp && valueProp.kind === "propertySignature") {
+                expect(valueProp.isOptional).to.equal(true);
+            }
+        });
+        it("should expand Readonly on interface with method returning self type", () => {
+            const source = `
+        interface Builder {
+          value: number;
+          build(): Builder;
+        }
+        type ReadonlyBuilder = Readonly<Builder>;
+      `;
+            const { binding, sourceFile } = createTestProgram(source);
+            const typeRef = findTypeAliasReference(sourceFile, "ReadonlyBuilder");
+            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Readonly", binding, stubConvertType);
+            expect(result).not.to.equal(null);
+            expect(result?.kind).to.equal("objectType");
+            const valueProp = result?.members.find((m) => m.kind === "propertySignature" && m.name === "value");
+            const buildMethod = result?.members.find((m) => m.kind === "methodSignature" && m.name === "build");
+            expect(valueProp).not.to.equal(undefined);
+            expect(buildMethod).not.to.equal(undefined);
+            if (valueProp && valueProp.kind === "propertySignature") {
+                expect(valueProp.isReadonly).to.equal(true);
+            }
+        });
+        it("should expand utility type on deeply nested object type", () => {
+            const source = `
+        interface DeepNested {
+          level1: {
+            level2: {
+              level3: {
+                value: string;
+              };
+            };
+          };
+        }
+        type PartialDeep = Partial<DeepNested>;
+      `;
+            const { binding, sourceFile } = createTestProgram(source);
+            const typeRef = findTypeAliasReference(sourceFile, "PartialDeep");
+            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Partial", binding, stubConvertType);
+            expect(result).not.to.equal(null);
+            expect(result?.kind).to.equal("objectType");
+            const level1Prop = result?.members.find((m) => m.kind === "propertySignature" && m.name === "level1");
+            expect(level1Prop).not.to.equal(undefined);
+            if (level1Prop && level1Prop.kind === "propertySignature") {
+                expect(level1Prop.isOptional).to.equal(true);
+            }
+        });
+        it("should handle Pick with single key on large interface", () => {
+            const source = `
+        interface LargeInterface {
+          a: string;
+          b: number;
+          c: boolean;
+          d: string[];
+          e: number[];
+          f: { nested: string };
+        }
+        type SinglePick = Pick<LargeInterface, "c">;
+      `;
+            const { binding, sourceFile } = createTestProgram(source);
+            const typeRef = findTypeAliasReference(sourceFile, "SinglePick");
+            const result = expandUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Pick", binding, stubConvertType);
+            expect(result).not.to.equal(null);
+            expect(result?.kind).to.equal("objectType");
+            expect(result?.members).to.have.length(1);
+            const cProp = result?.members.find((m) => m.kind === "propertySignature" && m.name === "c");
+            expect(cProp).not.to.equal(undefined);
+        });
+    });
 });
 describe("Conditional Utility Type Expansion", () => {
     describe("NonNullable<T>", () => {
@@ -393,9 +649,9 @@ describe("Conditional Utility Type Expansion", () => {
             const source = `
         type Result = NonNullable<string | null>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "NonNullable", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "NonNullable", binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("primitiveType");
             if (result?.kind === "primitiveType") {
@@ -406,9 +662,9 @@ describe("Conditional Utility Type Expansion", () => {
             const source = `
         type Result = NonNullable<string | null | undefined>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "NonNullable", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "NonNullable", binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("primitiveType");
             if (result?.kind === "primitiveType") {
@@ -419,9 +675,9 @@ describe("Conditional Utility Type Expansion", () => {
             const source = `
         type Result = NonNullable<null | undefined>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "NonNullable", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "NonNullable", binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("neverType");
         });
@@ -429,9 +685,9 @@ describe("Conditional Utility Type Expansion", () => {
             const source = `
         type Result = NonNullable<any>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "NonNullable", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "NonNullable", binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("anyType");
         });
@@ -439,9 +695,9 @@ describe("Conditional Utility Type Expansion", () => {
             const source = `
         type Result = NonNullable<unknown>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "NonNullable", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "NonNullable", binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("unknownType");
         });
@@ -449,7 +705,7 @@ describe("Conditional Utility Type Expansion", () => {
             const source = `
         function process<T>(data: NonNullable<T>): void {}
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             let typeRef = null;
             const visitor = (node) => {
                 if (ts.isTypeReferenceNode(node) &&
@@ -460,7 +716,7 @@ describe("Conditional Utility Type Expansion", () => {
                 ts.forEachChild(node, visitor);
             };
             ts.forEachChild(sourceFile, visitor);
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "NonNullable", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "NonNullable", binding, stubConvertType);
             expect(result).to.equal(null);
         });
     });
@@ -469,9 +725,9 @@ describe("Conditional Utility Type Expansion", () => {
             const source = `
         type Result = Exclude<"a" | "b" | "c", "a">;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Exclude", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Exclude", binding, stubConvertType);
             // Should expand successfully (result is "b" | "c")
             // Note: The exact IR kind depends on how TypeScript represents the resolved type
             // which may vary. The key is that expansion succeeds and doesn't return null.
@@ -481,9 +737,9 @@ describe("Conditional Utility Type Expansion", () => {
             const source = `
         type Result = Exclude<string | number, number>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Exclude", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Exclude", binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("primitiveType");
             if (result?.kind === "primitiveType") {
@@ -494,9 +750,9 @@ describe("Conditional Utility Type Expansion", () => {
             const source = `
         type Result = Exclude<string, string>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Exclude", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Exclude", binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("neverType");
         });
@@ -504,7 +760,7 @@ describe("Conditional Utility Type Expansion", () => {
             const source = `
         function process<T>(data: Exclude<T, null>): void {}
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             let typeRef = null;
             const visitor = (node) => {
                 if (ts.isTypeReferenceNode(node) &&
@@ -515,7 +771,7 @@ describe("Conditional Utility Type Expansion", () => {
                 ts.forEachChild(node, visitor);
             };
             ts.forEachChild(sourceFile, visitor);
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Exclude", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Exclude", binding, stubConvertType);
             expect(result).to.equal(null);
         });
     });
@@ -524,9 +780,9 @@ describe("Conditional Utility Type Expansion", () => {
             const source = `
         type Result = Extract<"a" | "b" | "c", "a" | "f">;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Extract", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Extract", binding, stubConvertType);
             expect(result).not.to.equal(null);
             // Result should be "a" (the only common literal)
         });
@@ -534,9 +790,9 @@ describe("Conditional Utility Type Expansion", () => {
             const source = `
         type Result = Extract<string | number, string>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Extract", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Extract", binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("primitiveType");
             if (result?.kind === "primitiveType") {
@@ -547,9 +803,9 @@ describe("Conditional Utility Type Expansion", () => {
             const source = `
         type Result = Extract<string, number>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Extract", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Extract", binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("neverType");
         });
@@ -559,9 +815,9 @@ describe("Conditional Utility Type Expansion", () => {
             const source = `
         type Result = Exclude<never, string>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Exclude", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Exclude", binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("neverType");
         });
@@ -569,9 +825,9 @@ describe("Conditional Utility Type Expansion", () => {
             const source = `
         type Result = Extract<never, string>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Extract", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Extract", binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("neverType");
         });
@@ -579,9 +835,9 @@ describe("Conditional Utility Type Expansion", () => {
             const source = `
         type Result = Exclude<"a" | "b" | "c" | "d", "a" | "c">;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Exclude", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Exclude", binding, stubConvertType);
             expect(result).not.to.equal(null);
             // Should be a union of "b" | "d" (TypeScript checker resolves this)
         });
@@ -589,9 +845,9 @@ describe("Conditional Utility Type Expansion", () => {
             const source = `
         type Result = Extract<"a" | "b" | "c" | "d", "a" | "c" | "e">;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Extract", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Extract", binding, stubConvertType);
             expect(result).not.to.equal(null);
             // Should be a union of "a" | "c" (TypeScript checker resolves this)
         });
@@ -599,9 +855,9 @@ describe("Conditional Utility Type Expansion", () => {
             const source = `
         type Result = Exclude<string | number | (() => void), Function>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Exclude", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Exclude", binding, stubConvertType);
             expect(result).not.to.equal(null);
             // Should expand to string | number (function removed)
         });
@@ -611,13 +867,20 @@ describe("Conditional Utility Type Expansion", () => {
         type Mixed = ("a" | "b") | (1 | 2);
         type OnlyNumbers = Exclude<Mixed, string>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "OnlyNumbers");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Exclude", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Exclude", binding, stubConvertType);
             expect(result).not.to.equal(null);
             // Should be 1 | 2 (string literals removed)
             // TypeScript distributes over the union and removes string-assignable types
             expect(result?.kind).to.equal("unionType");
+            if (result?.kind === "unionType") {
+                expect(result.types).to.have.length(2);
+                const values = result.types
+                    .filter((t) => t.kind === "literalType")
+                    .map((t) => (t.kind === "literalType" ? t.value : null));
+                expect(values).to.deep.equal([1, 2]);
+            }
         });
         it("should distribute Extract over mixed string and number literals", () => {
             // Alice's review case: mixed literals with Extract filtering by type
@@ -625,21 +888,28 @@ describe("Conditional Utility Type Expansion", () => {
         type Mixed = ("a" | "b") | (1 | 2);
         type OnlyStrings = Extract<Mixed, string>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "OnlyStrings");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Extract", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Extract", binding, stubConvertType);
             expect(result).not.to.equal(null);
             // Should be "a" | "b" (number literals removed)
             // TypeScript distributes over the union and keeps only string-assignable types
             expect(result?.kind).to.equal("unionType");
+            if (result?.kind === "unionType") {
+                expect(result.types).to.have.length(2);
+                const values = result.types
+                    .filter((t) => t.kind === "literalType")
+                    .map((t) => (t.kind === "literalType" ? t.value : null));
+                expect(values).to.deep.equal(["a", "b"]);
+            }
         });
         it("should handle nested conditional types", () => {
             const source = `
         type Result = Exclude<Exclude<string | null | undefined, null>, undefined>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Exclude", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Exclude", binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("primitiveType");
             if (result?.kind === "primitiveType") {
@@ -652,9 +922,9 @@ describe("Conditional Utility Type Expansion", () => {
             const source = `
         type Result = ReturnType<() => string>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "ReturnType", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "ReturnType", binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("primitiveType");
             if (result?.kind === "primitiveType") {
@@ -665,9 +935,9 @@ describe("Conditional Utility Type Expansion", () => {
             const source = `
         type Result = ReturnType<(x: number) => boolean>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "ReturnType", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "ReturnType", binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("primitiveType");
             if (result?.kind === "primitiveType") {
@@ -678,9 +948,9 @@ describe("Conditional Utility Type Expansion", () => {
             const source = `
         type Result = ReturnType<() => void>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "ReturnType", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "ReturnType", binding, stubConvertType);
             expect(result).not.to.equal(null);
             // void is handled by fallback
         });
@@ -690,12 +960,19 @@ describe("Conditional Utility Type Expansion", () => {
         type Fn2 = () => number;
         type Result = ReturnType<Fn1 | Fn2>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "ReturnType", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "ReturnType", binding, stubConvertType);
             expect(result).not.to.equal(null);
             // Should be string | number
             expect(result?.kind).to.equal("unionType");
+            if (result?.kind === "unionType") {
+                expect(result.types).to.have.length(2);
+                const names = result.types
+                    .filter((t) => t.kind === "primitiveType")
+                    .map((t) => (t.kind === "primitiveType" ? t.name : null));
+                expect(names).to.deep.equal(["string", "number"]);
+            }
         });
         it("should return null for ReturnType<T> where T is a type parameter", () => {
             const source = `
@@ -703,7 +980,7 @@ describe("Conditional Utility Type Expansion", () => {
           return fn();
         }
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             let typeRef = null;
             const visitor = (node) => {
                 if (ts.isTypeReferenceNode(node) &&
@@ -714,7 +991,7 @@ describe("Conditional Utility Type Expansion", () => {
                 ts.forEachChild(node, visitor);
             };
             ts.forEachChild(sourceFile, visitor);
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "ReturnType", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "ReturnType", binding, stubConvertType);
             expect(result).to.equal(null);
         });
         it("should expand ReturnType with typeof function", () => {
@@ -724,9 +1001,9 @@ describe("Conditional Utility Type Expansion", () => {
         }
         type Result = ReturnType<typeof add>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "ReturnType", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "ReturnType", binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("primitiveType");
             if (result?.kind === "primitiveType") {
@@ -739,9 +1016,9 @@ describe("Conditional Utility Type Expansion", () => {
             const source = `
         type Result = Parameters<(x: string, y: number) => void>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Parameters", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Parameters", binding, stubConvertType);
             expect(result).not.to.equal(null);
             // Parameters returns a tuple type - the exact representation depends on TypeScript
         });
@@ -749,20 +1026,20 @@ describe("Conditional Utility Type Expansion", () => {
             const source = `
         type Result = Parameters<() => void>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
             // Empty tuple may return null (falls through to referenceType)
             // or may return an expanded type - both are acceptable behaviors
             // The key is that it doesn't throw an error
-            expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Parameters", checker, stubConvertType);
+            expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Parameters", binding, stubConvertType);
         });
         it("should expand Parameters with single parameter", () => {
             const source = `
         type Result = Parameters<(x: boolean) => void>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Parameters", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Parameters", binding, stubConvertType);
             expect(result).not.to.equal(null);
         });
         it("should return null for Parameters<T> where T is a type parameter", () => {
@@ -774,7 +1051,7 @@ describe("Conditional Utility Type Expansion", () => {
           fn(...args);
         }
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             let typeRef = null;
             const visitor = (node) => {
                 if (ts.isTypeReferenceNode(node) &&
@@ -785,7 +1062,7 @@ describe("Conditional Utility Type Expansion", () => {
                 ts.forEachChild(node, visitor);
             };
             ts.forEachChild(sourceFile, visitor);
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Parameters", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Parameters", binding, stubConvertType);
             expect(result).to.equal(null);
         });
         it("should expand Parameters with typeof function", () => {
@@ -793,9 +1070,9 @@ describe("Conditional Utility Type Expansion", () => {
         function greet(name: string, age: number): void {}
         type Result = Parameters<typeof greet>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Parameters", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Parameters", binding, stubConvertType);
             expect(result).not.to.equal(null);
         });
     });
@@ -804,9 +1081,9 @@ describe("Conditional Utility Type Expansion", () => {
             const source = `
         type Result = Awaited<Promise<string>>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Awaited", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Awaited", binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("primitiveType");
             if (result?.kind === "primitiveType") {
@@ -817,9 +1094,9 @@ describe("Conditional Utility Type Expansion", () => {
             const source = `
         type Result = Awaited<Promise<Promise<number>>>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Awaited", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Awaited", binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("primitiveType");
             if (result?.kind === "primitiveType") {
@@ -830,9 +1107,9 @@ describe("Conditional Utility Type Expansion", () => {
             const source = `
         type Result = Awaited<string>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Awaited", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Awaited", binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("primitiveType");
             if (result?.kind === "primitiveType") {
@@ -843,9 +1120,9 @@ describe("Conditional Utility Type Expansion", () => {
             const source = `
         type Result = Awaited<Promise<string> | Promise<number>>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Awaited", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Awaited", binding, stubConvertType);
             expect(result).not.to.equal(null);
             // Should be string | number
             expect(result?.kind).to.equal("unionType");
@@ -856,7 +1133,7 @@ describe("Conditional Utility Type Expansion", () => {
           return await promise;
         }
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             let typeRef = null;
             const visitor = (node) => {
                 if (ts.isTypeReferenceNode(node) &&
@@ -867,16 +1144,16 @@ describe("Conditional Utility Type Expansion", () => {
                 ts.forEachChild(node, visitor);
             };
             ts.forEachChild(sourceFile, visitor);
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Awaited", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Awaited", binding, stubConvertType);
             expect(result).to.equal(null);
         });
         it("should expand Awaited<null> to null", () => {
             const source = `
         type Result = Awaited<null>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Result");
-            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Awaited", checker, stubConvertType);
+            const result = expandConditionalUtilityType(assertDefined(typeRef, "typeRef should be defined"), "Awaited", binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("primitiveType");
             if (result?.kind === "primitiveType") {
@@ -891,9 +1168,9 @@ describe("Record Type Expansion", () => {
             const source = `
         type Config = Record<"a" | "b", number>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Config");
-            const result = expandRecordType(assertDefined(typeRef, "typeRef should be defined"), checker, stubConvertType);
+            const result = expandRecordType(assertDefined(typeRef, "typeRef should be defined"), binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("objectType");
             expect(result?.members).to.have.length(2);
@@ -907,9 +1184,9 @@ describe("Record Type Expansion", () => {
             const source = `
         type IndexedConfig = Record<1 | 2, string>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "IndexedConfig");
-            const result = expandRecordType(assertDefined(typeRef, "typeRef should be defined"), checker, stubConvertType);
+            const result = expandRecordType(assertDefined(typeRef, "typeRef should be defined"), binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("objectType");
             expect(result?.members).to.have.length(2);
@@ -924,9 +1201,9 @@ describe("Record Type Expansion", () => {
             const source = `
         type MixedConfig = Record<"name" | "age" | "email", boolean>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "MixedConfig");
-            const result = expandRecordType(assertDefined(typeRef, "typeRef should be defined"), checker, stubConvertType);
+            const result = expandRecordType(assertDefined(typeRef, "typeRef should be defined"), binding, stubConvertType);
             expect(result).not.to.equal(null);
             expect(result?.kind).to.equal("objectType");
             expect(result?.members).to.have.length(3);
@@ -937,9 +1214,9 @@ describe("Record Type Expansion", () => {
             const source = `
         type Dictionary = Record<string, number>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "Dictionary");
-            const result = expandRecordType(assertDefined(typeRef, "typeRef should be defined"), checker, stubConvertType);
+            const result = expandRecordType(assertDefined(typeRef, "typeRef should be defined"), binding, stubConvertType);
             // Should return null - use IrDictionaryType instead
             expect(result).to.equal(null);
         });
@@ -947,9 +1224,9 @@ describe("Record Type Expansion", () => {
             const source = `
         type NumberDictionary = Record<number, string>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "NumberDictionary");
-            const result = expandRecordType(assertDefined(typeRef, "typeRef should be defined"), checker, stubConvertType);
+            const result = expandRecordType(assertDefined(typeRef, "typeRef should be defined"), binding, stubConvertType);
             // Should return null - use IrDictionaryType instead
             expect(result).to.equal(null);
         });
@@ -959,7 +1236,7 @@ describe("Record Type Expansion", () => {
           return {} as Record<K, number>;
         }
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             let typeRef = null;
             const visitor = (node) => {
                 if (ts.isTypeReferenceNode(node) &&
@@ -971,7 +1248,7 @@ describe("Record Type Expansion", () => {
                 ts.forEachChild(node, visitor);
             };
             ts.forEachChild(sourceFile, visitor);
-            const result = expandRecordType(assertDefined(typeRef, "typeRef should be defined"), checker, stubConvertType);
+            const result = expandRecordType(assertDefined(typeRef, "typeRef should be defined"), binding, stubConvertType);
             // Should return null - type parameter can't be expanded
             expect(result).to.equal(null);
         });
@@ -981,9 +1258,9 @@ describe("Record Type Expansion", () => {
             const source = `
         type AnyKeyRecord = Record<PropertyKey, number>;
       `;
-            const { checker, sourceFile } = createTestProgram(source);
+            const { binding, sourceFile } = createTestProgram(source);
             const typeRef = findTypeAliasReference(sourceFile, "AnyKeyRecord");
-            const result = expandRecordType(assertDefined(typeRef, "typeRef should be defined"), checker, stubConvertType);
+            const result = expandRecordType(assertDefined(typeRef, "typeRef should be defined"), binding, stubConvertType);
             // Should return null - PropertyKey is not a finite set of literals
             // and should fall through to referenceType (not dictionaryType)
             expect(result).to.equal(null);
@@ -1018,6 +1295,7 @@ describe("Record Type Expansion", () => {
             const keyTypeNode = foundTypeRef.typeArguments?.[0];
             expect(keyTypeNode).not.to.equal(undefined);
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            // NOTE: This test uses getTypeAtLocation to verify TS internal behavior
             const keyTsType = checker.getTypeAtLocation(keyTypeNode);
             // The key type should be a type parameter, not string
             expect(!!(keyTsType.flags & ts.TypeFlags.TypeParameter)).to.equal(true);