@gtkx/codegen 1.0.0-rc.4 → 1.1.0

package/src/analysis/param-capability.ts

@@ -0,0 +1,169 @@
+import type { GirCallable, GirParameter } from "../gir/parameter.js";
+import type { CArrayType, TypeId } from "../gir/type-id.js";
+import type { GirType } from "../gir/type.js";
+import type { ModuleContext } from "../writer/context.js";
+import { isCallerAllocatedOut, isInoutParameter } from "../gir/parameter.js";
+import { isCollectibleCallerOut, isHandlePassedInPlace, underlyingType } from "../store/gi/param-marshal.js";
+import { recordInlineSize } from "../store/gi/record-layout.js";
+import { isScalarRef } from "./descriptor-render.js";
+
+const POINTER_DEPTH = 1;
+
+const isPointerType = (context: ModuleContext, type: GirType): boolean => {
+    switch (type.kind) {
+        case "primitive": {
+            return type.category === "string";
+        }
+        case "record": {
+            return recordInlineSize(context, type.value) === undefined;
+        }
+        case "class":
+        case "interface":
+        case "carray":
+        case "list":
+        case "hashtable": {
+            return true;
+        }
+        case "alias":
+        case "callback":
+        case "enum":
+        case "varargs": {
+            return false;
+        }
+    }
+};
+
+const isPointerElement = (context: ModuleContext, element: TypeId): boolean => {
+    if (isScalarRef(context.library, element)) {
+        return false;
+    }
+
+    const type = underlyingType(context, element);
+
+    return type !== undefined && isPointerType(context, type);
+};
+
+const carrayIndirection = (context: ModuleContext, type: CArrayType): number =>
+    POINTER_DEPTH + (isPointerElement(context, type.element) ? POINTER_DEPTH : 0);
+
+const typeIndirection = (context: ModuleContext, type: GirType): number | undefined => {
+    switch (type.kind) {
+        case "primitive": {
+            return type.category === "string" ? POINTER_DEPTH : undefined;
+        }
+        case "callback":
+        case "class":
+        case "hashtable":
+        case "interface":
+        case "list":
+        case "record": {
+            return POINTER_DEPTH;
+        }
+        case "carray": {
+            return carrayIndirection(context, type);
+        }
+        case "alias":
+        case "enum":
+        case "varargs": {
+            return undefined;
+        }
+    }
+};
+
+const baseIndirection = (context: ModuleContext, ref: TypeId | undefined): number | undefined => {
+    if (isScalarRef(context.library, ref)) {
+        return 0;
+    }
+
+    const type = ref === undefined ? undefined : underlyingType(context, ref);
+
+    return type === undefined ? undefined : typeIndirection(context, type);
+};
+
+const declaredIndirection = (parameter: GirParameter): number | undefined => {
+    const cType = parameter.cType;
+
+    if (cType === undefined) {
+        return undefined;
+    }
+
+    return cType.split("*").length - 1;
+};
+
+const marshalledIndirection = (context: ModuleContext, parameter: GirParameter): number | undefined => {
+    const base = baseIndirection(context, parameter.type);
+
+    if (base === undefined) {
+        return undefined;
+    }
+
+    if (isCallerAllocatedOut(parameter) || isHandlePassedInPlace(context, parameter)) {
+        return base;
+    }
+
+    if (isInoutParameter(parameter) && !isScalarRef(context.library, parameter.type)) {
+        return base;
+    }
+
+    return base + POINTER_DEPTH;
+};
+
+const hasCallerSuppliedLength = (context: ModuleContext, parameter: GirParameter): boolean => {
+    const type = parameter.type === undefined ? undefined : underlyingType(context, parameter.type);
+
+    return type?.kind === "carray" && type.lengthParameterIndex !== undefined;
+};
+
+const isUnmarshalableCallerOut = (context: ModuleContext, parameter: GirParameter): boolean => {
+    if (hasCallerSuppliedLength(context, parameter)) {
+        return true;
+    }
+
+    return !isCollectibleCallerOut(context, parameter) && !parameter.optional;
+};
+
+const hasIndirectionMismatch = (context: ModuleContext, parameter: GirParameter): boolean => {
+    const declared = declaredIndirection(parameter);
+    const marshalled = marshalledIndirection(context, parameter);
+
+    if (declared === undefined || marshalled === undefined) {
+        return false;
+    }
+
+    return declared !== marshalled;
+};
+
+const isTypeErasedCallback = (context: ModuleContext, parameter: GirParameter): boolean => {
+    if (parameter.closureIndex === undefined) {
+        return false;
+    }
+
+    const type = parameter.type === undefined ? undefined : underlyingType(context, parameter.type);
+
+    return type?.kind === "callback" && type.value.parameters.length === 0;
+};
+
+const isUnmarshalableCallParam = (context: ModuleContext, parameter: GirParameter): boolean => {
+    if (parameter.isVarargs) {
+        return false;
+    }
+
+    if (isTypeErasedCallback(context, parameter)) {
+        return true;
+    }
+
+    if (parameter.direction === "in") {
+        return false;
+    }
+
+    if (isCallerAllocatedOut(parameter)) {
+        return isUnmarshalableCallerOut(context, parameter);
+    }
+
+    return hasIndirectionMismatch(context, parameter);
+};
+
+const hasUnmarshalableParam = (context: ModuleContext, callable: GirCallable): boolean =>
+    callable.parameters.some((parameter) => isUnmarshalableCallParam(context, parameter));
+
+export { hasUnmarshalableParam };

package/src/analysis/param-structure.ts

@@ -2,8 +2,9 @@ import { toCamelIdentifier } from "@gtkx/utils";
 import type { GirFunction } from "../gir/function.js";
 import type { Library } from "../gir/library.js";
 import type { TypeId } from "../gir/type-id.js";
+import type { JsDocParam } from "../writer/doc-tags.js";
 import { type GirCallable, type GirParameter, isCallerAllocatedOut, isOutParameter } from "../gir/parameter.js";
-import { isCellInout, shouldOmitPrimaryReturn } from "./descriptor-render.js";
+import { isCellInout, isVoidPrimaryReturn } from "./descriptor-render.js";
 
 type InputParameter = {
     parameter: GirParameter;
@@ -16,6 +17,7 @@ type HandlerResultOptions = {
     renderType: (ref: TypeId | undefined, isNullable: boolean) => string;
     shouldIncludeCallerAllocated: boolean;
     isOptOut: boolean;
+    shouldExcludeOut?: (parameter: GirParameter) => boolean;
 };
 
 const isInputParameter = (options: {
@@ -108,7 +110,7 @@ const carrayLengthIndex = (library: Library, ref: TypeId | undefined): number |
     return type.lengthParameterIndex;
 };
 
-const arrayLengthSources = (library: Library, fn: GirFunction): Map<number, number> => {
+const arrayLengthSources = (library: Library, fn: GirCallable): Map<number, number> => {
     const map: Map<number, number> = new Map();
 
     for (const [index, parameter] of fn.parameters.entries()) {
@@ -122,19 +124,7 @@ const arrayLengthSources = (library: Library, fn: GirFunction): Map<number, numb
     return map;
 };
 
-const hasCallerAllocatedArrayLength = (library: Library, fn: GirFunction): boolean => {
-    for (const arrayIndex of arrayLengthSources(library, fn).values()) {
-        const array = fn.parameters[arrayIndex];
-
-        if (array !== undefined && isCallerAllocatedOut(array)) {
-            return true;
-        }
-    }
-
-    return false;
-};
-
-const returnArrayLengthIndices = (library: Library, fn: GirFunction): Set<number> => {
+const returnArrayLengthIndices = (library: Library, fn: GirCallable): Set<number> => {
     const returnType = fn.returnValue.type === undefined ? undefined : library.typeFor(fn.returnValue.type);
 
     if (returnType?.kind !== "carray") {
@@ -150,7 +140,7 @@ const returnArrayLengthIndices = (library: Library, fn: GirFunction): Set<number
     return new Set([lengthIndex]);
 };
 
-const foldedLengthIndices = (library: Library, fn: GirFunction): Set<number> => {
+const foldedLengthIndices = (library: Library, fn: GirCallable): Set<number> => {
     const indices: Set<number> = new Set(arrayLengthSources(library, fn).keys());
 
     for (const index of returnArrayLengthIndices(library, fn)) {
@@ -160,6 +150,20 @@ const foldedLengthIndices = (library: Library, fn: GirFunction): Set<number> =>
     return indices;
 };
 
+const foldedLengthParameters = (library: Library, fn: GirCallable): Set<GirParameter> => {
+    const folded: Set<GirParameter> = new Set();
+
+    for (const index of foldedLengthIndices(library, fn)) {
+        const parameter = fn.parameters[index];
+
+        if (parameter !== undefined) {
+            folded.add(parameter);
+        }
+    }
+
+    return folded;
+};
+
 const parameterIdentifier = (parameter: GirParameter, index: number): string => {
     if (parameter.name.length === 0) {
         return `arg${String(index)}`;
@@ -168,17 +172,62 @@ const parameterIdentifier = (parameter: GirParameter, index: number): string =>
     return toCamelIdentifier(parameter.name);
 };
 
+const handlerParameters = (
+    parameters: GirParameter[],
+    shouldExclude: (parameter: GirParameter) => boolean = () => false,
+): GirParameter[] =>
+    parameters.filter(
+        (parameter) => !parameter.isVarargs && !isOutParameter(parameter) && !shouldExclude(parameter),
+    );
+
+const documentedParameters = (
+    library: Library,
+    fn: GirFunction,
+    shouldSkip: (parameter: GirParameter) => boolean = () => false,
+    renames?: Map<string, string>,
+): JsDocParam[] =>
+    inputParameters(library, fn)
+        .filter(({ parameter }) => !shouldSkip(parameter))
+        .map(({ parameter, index }) => ({
+            name: renames?.get(parameter.name) ?? parameterIdentifier(parameter, index),
+            doc: parameter.doc ?? "",
+        }))
+        .filter((entry) => entry.doc.length > 0);
+
+const documentedHandlerParameters = (parameters: GirParameter[]): JsDocParam[] =>
+    handlerParameters(parameters)
+        .map((parameter, index) => ({ name: parameterIdentifier(parameter, index), doc: parameter.doc ?? "" }))
+        .filter((entry) => entry.doc.length > 0);
+
+const handlerRenames = (parameters: GirParameter[]): Map<string, string> => {
+    const renames: Map<string, string> = new Map();
+
+    for (const [index, parameter] of parameters.entries()) {
+        renames.set(parameter.name, parameterIdentifier(parameter, index));
+    }
+
+    return renames;
+};
+
+const renamesWithInstance = (parameters: GirParameter[], instance: GirParameter | undefined): Map<string, string> => {
+    const renames = handlerRenames(parameters);
+
+    if (instance !== undefined && instance.name.length > 0) {
+        renames.set(instance.name, "this");
+    }
+
+    return renames;
+};
+
 const renderHandlerParameters = (
     parameters: GirParameter[],
     renderType: (ref: TypeId | undefined, isNullable: boolean) => string,
     shouldExclude: (parameter: GirParameter) => boolean = () => false,
 ): string[] =>
-    parameters
-        .filter((parameter) => !parameter.isVarargs && !isOutParameter(parameter) && !shouldExclude(parameter))
-        .map(
-            (parameter, index) =>
-                `${parameterIdentifier(parameter, index)}: ${renderType(parameter.type, parameter.nullable)}`,
-        );
+    handlerParameters(parameters, shouldExclude).map(
+        (parameter, index) =>
+            `${parameterIdentifier(parameter, index)}: ${renderType(parameter.type, parameter.nullable)}`,
+    );
 
 const foldOutParamShape = (primary: string | undefined, outTypes: string[]): string => {
     if (primary !== undefined) {
@@ -226,13 +275,18 @@ const scalarResultType = (primary: string | undefined, isOptOut: boolean): strin
 
 const renderHandlerResultType = (options: HandlerResultOptions): string => {
     const { library, signal, renderType, shouldIncludeCallerAllocated, isOptOut } = options;
+    const shouldExcludeOut = options.shouldExcludeOut ?? (() => false);
 
-    const primary = shouldOmitPrimaryReturn(library, signal.returnValue)
+    const primary = isVoidPrimaryReturn(library, signal.returnValue)
         ? undefined
         : renderType(signal.returnValue.type, signal.returnValue.nullable);
 
     const outTypes = signal.parameters
-        .filter((parameter) => isHandlerOutParameter({ library, parameter, shouldIncludeCallerAllocated }))
+        .filter(
+            (parameter) =>
+                isHandlerOutParameter({ library, parameter, shouldIncludeCallerAllocated }) &&
+                !shouldExcludeOut(parameter),
+        )
         .map((parameter) => renderType(parameter.type, parameter.nullable));
 
     if (outTypes.length === 0) {
@@ -247,10 +301,16 @@ export {
     inputParameters,
     closureAndDestroyIndices,
     arrayLengthSources,
-    hasCallerAllocatedArrayLength,
     foldedLengthIndices,
+    foldedLengthParameters,
     parameterIdentifier,
+    documentedParameters,
+    documentedHandlerParameters,
+    handlerRenames,
+    renamesWithInstance,
+    handlerParameters,
     renderHandlerParameters,
     foldOutParamShape,
     renderHandlerResultType,
+    type InputParameter,
 };

package/src/analysis/ts-type.ts

@@ -1,6 +1,8 @@
+import { sanitizeTypeIdentifier } from "@gtkx/utils";
 import type { Library } from "../gir/library.js";
 import type { EntityType, GirType } from "../gir/type.js";
 import type { ModuleContext } from "../writer/context.js";
+import { isEmittableEntity } from "../gir/emittable.js";
 import { PRIMITIVE_TS_TYPE } from "../gir/primitives.js";
 import {
     type CArrayType,
@@ -24,21 +26,14 @@ type TsTypeTarget = {
     renderGtype: () => string;
 };
 
-const willEmitEntity = (type: EntityType): boolean => {
-    switch (type.kind) {
-        case "callback": {
-            return type.value.introspectable && type.value.name.length > 0;
-        }
-        case "record": {
-            return type.value.introspectable && type.value.name.length > 0;
-        }
-        case "alias":
-        case "class":
-        case "enum":
-        case "interface": {
-            return true;
-        }
-    }
+const willEmitEntity = (type: EntityType): boolean => isEmittableEntity(type.value);
+
+const referenceName = (library: Library, ref: TypeId): ReferenceName | undefined => {
+    const name = library.nameFor(ref);
+
+    return name === undefined
+        ? undefined
+        : { namespaceName: name.namespaceName, typeName: sanitizeTypeIdentifier(name.typeName) };
 };
 
 const renderPrimitiveType = (target: TsTypeTarget, type: Extract<GirType, { kind: "primitive" }>): string =>
@@ -56,12 +51,13 @@ const renderBaseType = (library: Library, target: TsTypeTarget, ref: TypeId | un
     }
 
     const type = library.typeFor(ref);
-    const name = library.nameFor(ref);
 
     if (type === undefined) {
-        return renderNamedType(target, undefined, name);
+        return renderNamedType(target, undefined, undefined);
     }
 
+    const name = referenceName(library, ref);
+
     switch (type.kind) {
         case "primitive": {
             return renderPrimitiveType(target, type);

package/src/analysis/type-key.ts

@@ -0,0 +1,14 @@
+import type { Library } from "../gir/library.js";
+import type { TypeId } from "../gir/type-id.js";
+
+const typeKey = (library: Library, ref: TypeId | undefined): string => {
+    if (ref === undefined) {
+        return "void";
+    }
+
+    const type = library.typeFor(ref);
+
+    return type?.kind === "primitive" && type.category === "void" ? "void" : `${String(ref.nsId)}.${String(ref.id)}`;
+};
+
+export { typeKey };

package/src/analysis/type-shape.ts

@@ -0,0 +1,24 @@
+import type { Library } from "../gir/library.js";
+import type { PrimitiveCategory } from "../gir/primitives.js";
+import type { CArrayType, TypeId } from "../gir/type-id.js";
+import type { GirType } from "../gir/type.js";
+
+const resolvedTypeFor = (library: Library, ref: TypeId | undefined): GirType | undefined =>
+    ref === undefined ? undefined : library.typeFor(ref);
+
+const carrayFor = (library: Library, ref: TypeId | undefined): CArrayType | undefined => {
+    const type = resolvedTypeFor(library, ref);
+
+    return type?.kind === "carray" ? type : undefined;
+};
+
+const primitiveCategoryFor = (library: Library, ref: TypeId | undefined): PrimitiveCategory | undefined => {
+    const type = resolvedTypeFor(library, ref);
+
+    return type?.kind === "primitive" ? type.category : undefined;
+};
+
+const isUnboundedArray = (type: CArrayType): boolean =>
+    type.isZeroTerminated && type.lengthParameterIndex === undefined && type.fixedSize === undefined;
+
+export { carrayFor, isUnboundedArray, primitiveCategoryFor };

package/src/compile.ts

@@ -1,20 +1,37 @@
-import { existsSync, mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { errorMessage, normalizeError } from "@gtkx/utils";
+import { existsSync, mkdirSync, renameSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
 import ts from "typescript";
+import { createStagingDir, sweepStrandedDirs } from "./staging.js";
 
-type SourceModule = {
+type ProjectFile = {
     fileName: string;
+    origin?: string | undefined;
+};
+
+type SourceModule = ProjectFile & {
     source: string;
 };
 
 type CompileProjectParams = {
     projectDir: string;
-    fileNames: string[];
+    files: ProjectFile[];
     compilerOptions: Record<string, unknown>;
     label: string;
 };
 
+type DiagnosedFile = {
+    fileName: string;
+    text: string;
+};
+
+type FailedProjectInput = {
+    projectDir: string;
+    keepAt: string;
+    error: unknown;
+};
+
 const BASE_COMPILER_OPTIONS = {
     module: "esnext",
     moduleResolution: "bundler",
@@ -43,6 +60,10 @@ const CHECK_OPTIONS = {
     noEmit: true,
 };
 
+const CHECK_DIR = ".gtkx-check";
+const FAILED_CHECK_DIR = `${CHECK_DIR}.failed`;
+const LEGACY_CHECK_PREFIX = `${CHECK_DIR}-`;
+
 const FORMAT_HOST: ts.FormatDiagnosticsHost = {
     getCanonicalFileName: (fileName) => fileName,
     getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
@@ -72,54 +93,107 @@ const linkToolingModules = (projectDir: string): (() => void) => {
 const isProjectFile = (rel: string): boolean =>
     !rel.startsWith("..") && !isAbsolute(rel) && !rel.split(/[/\\]/).includes("node_modules");
 
-const projectDiagnosticLine = (diagnostic: ts.Diagnostic, projectDir: string): string | undefined => {
+const projectDiagnosticFile = (diagnostic: ts.Diagnostic, projectDir: string): DiagnosedFile | undefined => {
     const { file, start } = diagnostic;
 
     if (file === undefined || start === undefined) {
         return undefined;
     }
 
-    const filePath = relative(projectDir, file.fileName);
+    const fileName = relative(projectDir, file.fileName);
 
-    if (!isProjectFile(filePath)) {
+    if (!isProjectFile(fileName)) {
         return undefined;
     }
 
     const { line, character } = file.getLineAndCharacterOfPosition(start);
     const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
 
-    return `${filePath}:${String(line + 1)}:${String(character + 1)} - ${message} (TS${String(diagnostic.code)})`;
+    return {
+        fileName,
+        text: `${fileName}:${String(line + 1)}:${String(character + 1)} - ${message} (TS${String(diagnostic.code)})`,
+    };
 };
 
-const projectDiagnosticLines = (diagnostics: ts.Diagnostic[], projectDir: string): string[] => {
-    const lines: string[] = [];
+const projectDiagnosticFiles = (diagnostics: ts.Diagnostic[], projectDir: string): DiagnosedFile[] => {
+    const diagnosed: DiagnosedFile[] = [];
 
     for (const diagnostic of diagnostics) {
-        const line = projectDiagnosticLine(diagnostic, projectDir);
+        const entry = projectDiagnosticFile(diagnostic, projectDir);
+
+        if (entry !== undefined) {
+            diagnosed.push(entry);
+        }
+    }
+
+    return diagnosed;
+};
+
+const collectOrigins = (files: ProjectFile[]): Map<string, string> => {
+    const origins: Map<string, string> = new Map();
+
+    for (const { fileName, origin } of files) {
+        if (origin !== undefined) {
+            origins.set(fileName, origin);
+        }
+    }
 
-        if (line !== undefined) {
-            lines.push(line);
+    return origins;
+};
+
+const groupByOrigin = (diagnosed: DiagnosedFile[], origins: Map<string, string>): Map<string, Set<string>> => {
+    const grouped: Map<string, Set<string>> = new Map();
+
+    for (const { fileName } of diagnosed) {
+        const origin = origins.get(fileName);
+
+        if (origin !== undefined) {
+            grouped.set(origin, (grouped.get(origin) ?? new Set<string>()).add(fileName));
         }
     }
 
-    return lines;
+    return grouped;
 };
 
-const diagnosticError = (label: string, projectDir: string, diagnostics: ts.Diagnostic[]): Error => {
-    const lines = projectDiagnosticLines(diagnostics, projectDir);
+const originLines = (diagnosed: DiagnosedFile[], files: ProjectFile[]): string[] =>
+    [...groupByOrigin(diagnosed, collectOrigins(files))].map(
+        ([origin, generated]) => `Generated from ${origin}: ${[...generated].join(", ")}`,
+    );
+
+const diagnosticError = (params: CompileProjectParams, diagnostics: ts.Diagnostic[]): Error => {
+    const diagnosed = projectDiagnosticFiles(diagnostics, params.projectDir);
+    const { label } = params;
 
-    if (lines.length > 0) {
-        return new Error(`Type checking ${label} found ${String(lines.length)} error(s):\n${lines.join("\n")}`);
+    if (diagnosed.length === 0) {
+        return new Error(`Type checking ${label} failed:\n${ts.formatDiagnostics(diagnostics, FORMAT_HOST).trim()}`);
     }
 
-    return new Error(`Type checking ${label} failed:\n${ts.formatDiagnostics(diagnostics, FORMAT_HOST).trim()}`);
+    const lines = [...diagnosed.map((entry) => entry.text), ...originLines(diagnosed, params.files)];
+
+    return new Error(`Type checking ${label} found ${String(diagnosed.length)} error(s):\n${lines.join("\n")}`);
+};
+
+const keepFailedProject = (input: FailedProjectInput): Error => {
+    const { projectDir, keepAt, error } = input;
+
+    if (!existsSync(projectDir)) {
+        return normalizeError(error);
+    }
+
+    rmSync(keepAt, { recursive: true, force: true });
+    renameSync(projectDir, keepAt);
+    const rebased = errorMessage(error).split(projectDir).join(keepAt);
+
+    return new Error(`${rebased}\nThe generated sources are kept at ${keepAt}, where every path above resolves.`, {
+        cause: error,
+    });
 };
 
 const runProgram = (params: CompileProjectParams): ts.Diagnostic[] => {
     const parsed = ts.parseJsonConfigFileContent(
         {
             compilerOptions: { ...BASE_COMPILER_OPTIONS, ...params.compilerOptions },
-            files: params.fileNames.map((name) => `./${name}`),
+            files: params.files.map((file) => `./${file.fileName}`),
         },
         ts.sys,
         params.projectDir,
@@ -147,17 +221,24 @@ const compileProject = (params: CompileProjectParams): void => {
         const diagnostics = runProgram(params);
 
         if (diagnostics.length > 0) {
-            throw diagnosticError(params.label, params.projectDir, diagnostics);
+            throw diagnosticError(params, diagnostics);
         }
     } finally {
         unlinkToolingModules();
     }
 };
 
+const stageCheckProject = (checkRoot: string): string => {
+    const projectDir = createStagingDir(join(checkRoot, CHECK_DIR));
+    sweepStrandedDirs(checkRoot, LEGACY_CHECK_PREFIX);
+
+    return projectDir;
+};
+
 const checkModules = (params: { modules: SourceModule[]; resolveFrom: string; label: string }): void => {
     const checkRoot = join(params.resolveFrom, "node_modules");
-    mkdirSync(checkRoot, { recursive: true });
-    const projectDir = mkdtempSync(join(checkRoot, ".gtkx-check-"));
+    const projectDir = stageCheckProject(checkRoot);
+    const keepAt = join(checkRoot, FAILED_CHECK_DIR);
 
     try {
         for (const module of params.modules) {
@@ -168,13 +249,16 @@ const checkModules = (params: { modules: SourceModule[]; resolveFrom: string; la
 
         compileProject({
             projectDir,
-            fileNames: params.modules.map((module) => module.fileName),
+            files: params.modules,
             compilerOptions: CHECK_OPTIONS,
             label: params.label,
         });
-    } finally {
-        rmSync(projectDir, { recursive: true, force: true });
+    } catch (error) {
+        throw keepFailedProject({ projectDir, keepAt, error });
     }
+
+    rmSync(projectDir, { recursive: true, force: true });
+    rmSync(keepAt, { recursive: true, force: true });
 };
 
-export { compileProject, checkModules, type SourceModule, type CompileProjectParams };
+export { compileProject, checkModules, keepFailedProject, type ProjectFile, type SourceModule };