fix: improve reading tsconfig (#2192)

## PR Checklist

- [x] Addresses an existing open issue: fixes #1532 
- [x] That issue was marked as [`status: accepting
prs`](https://github.com/JoshuaKGoldberg/TypeStat/issues?q=is%3Aopen+is%3Aissue+label%3A%22status%3A+accepting+prs%22)
- [x] Steps in
[CONTRIBUTING.md](https://github.com/JoshuaKGoldberg/TypeStat/blob/main/.github/CONTRIBUTING.md)
were taken

## Overview

I have taken inspiration how to do this from `ts-fix`. They are doing it
with `ts.getParsedCommandLineOfConfigFile` so I think that is what would
be the best way here too.

I also reworked testSetup so it uses more same code as the whole tool.
`cwd` is passed down from `runCli` so we can supply it in the test
easier.

`printers.node` uses now the existing SourceFile so we do not need to
create dummy SourceFile for it. I didn't see behaviour change but I
think it should be better this way. Now it can use the context from
original SourceFile.

Most changes are in the test files.

Author: rubiesonthesky

src/cli/runCli.ts

@@ -63,7 +63,11 @@ export const runCli = async (
 	let result: TypeStatResult;
 
 	try {
-		result = await runtime.mainRunner(rawOptions.config, runtime.output);
+		result = await runtime.mainRunner(
+			rawOptions.config,
+			process.cwd(),
+			runtime.output,
+		);
 	} catch (error) {
 		result = {
 			error: error instanceof Error ? error : new Error(error as string),

src/index.ts

@@ -45,9 +45,10 @@ export type TypeStatResult =
 
 export const typeStat = async (
 	configPath: string | undefined,
+	cwd: string,
 	output: ProcessOutput,
 ): Promise<TypeStatResult> => {
-	const allPendingOptions = await tryLoadingPendingOptions(configPath, output);
+	const allPendingOptions = tryLoadingPendingOptions(configPath, cwd, output);
 	if (
 		allPendingOptions instanceof Error ||
 		typeof allPendingOptions === "string"
@@ -90,10 +91,7 @@ export const typeStat = async (
 
 	for (let i = 0; i < allPendingOptions.length; i += 1) {
 		// Collect all files to be run on this option iteration from the include glob(s)
-		const fileNames = await collectFileNames(
-			process.cwd(),
-			allPendingOptions[i].include,
-		);
+		const fileNames = await collectFileNames(cwd, allPendingOptions[i].include);
 		if (typeof fileNames !== "object") {
 			return {
 				error: new Error(
@@ -144,12 +142,13 @@ export const typeStat = async (
 	};
 };
 
-const tryLoadingPendingOptions = async (
+const tryLoadingPendingOptions = (
 	configPath: string | undefined,
+	cwd: string,
 	output: ProcessOutput,
-): Promise<Error | PendingTypeStatOptions[] | string> => {
+): Error | PendingTypeStatOptions[] | string => {
 	try {
-		return await loadPendingOptions(configPath, output);
+		return loadPendingOptions(configPath, cwd, output);
 	} catch (error) {
 		return error instanceof Error ? error : new Error(error as string);
 	}

src/mutations/creations/creationMutations.ts

@@ -16,7 +16,7 @@ export const createDeclarationForTypeSummaries = (
 		enclosingDeclaration,
 		typeSummaries,
 	);
-	const newLine = printNewLine(request.options.compilerOptions);
+	const newLine = printNewLine(request.options.parsedTsConfig.options);
 
 	return [`type ${name} = {`, newLine, printedSummaries, `};`].join("");
 };

src/mutators/builtIn/fixIncompleteTypes/fixIncompleteImplicitGenerics/additions.ts

@@ -8,7 +8,7 @@ export const addNewTypeNodes = (
 	node: ts.ClassLikeDeclaration,
 	createdTypes: string[],
 ) => {
-	const endline = printNewLine(request.options.compilerOptions);
+	const endline = printNewLine(request.options.parsedTsConfig.options);
 
 	return {
 		insertion: `${endline}${createdTypes.join(endline)}`,

src/mutators/builtIn/fixIncompleteTypes/fixIncompleteReactTypes/fixReactPropsFromPropTypes/index.ts

@@ -89,8 +89,11 @@ const createInterfaceCreationMutation = (
 	node: ReactComponentNode,
 	interfaceNode: ts.InterfaceDeclaration,
 ): TextInsertMutation => {
-	const endline = printNewLine(request.options.compilerOptions);
-	const interfaceNodeText = request.services.printers.node(interfaceNode);
+	const endline = printNewLine(request.options.parsedTsConfig.options);
+	const interfaceNodeText = request.services.printers.node(
+		interfaceNode,
+		request.sourceFile,
+	);
 
 	return {
 		insertion: [endline, endline, interfaceNodeText, endline].join(""),

src/mutators/builtIn/fixIncompleteTypes/fixIncompleteReactTypes/fixReactPropsMissing.ts

@@ -190,7 +190,7 @@ const createPropsTypeCreationMutation = (
 	interfaceName: string,
 	{ attributeTypes, requiredAttributeNames }: AttributeTypesAndRequirements,
 ) => {
-	const endline = printNewLine(request.options.compilerOptions);
+	const endline = printNewLine(request.options.parsedTsConfig.options);
 
 	return {
 		insertion: [

src/mutators/builtIn/fixIncompleteTypes/fixIncompleteReactTypes/reactFiltering/reactUsageFiltering.ts

@@ -1,7 +1,8 @@
+import ts from "typescript";
+
 import { ProcessOutput } from "../output/types.js";
 import { collectOptionals } from "../shared/arrays.js";
 import { ReactPropTypesHint, ReactPropTypesOptionality } from "./enums.js";
-import { ParsedCompilerOptions } from "./parseRawCompilerOptions.js";
 import { collectAddedMutators } from "./parsing/collectAddedMutators.js";
 import { collectFileOptions } from "./parsing/collectFileOptions.js";
 import { collectNoImplicitAny } from "./parsing/collectNoImplicitAny.js";
@@ -11,9 +12,9 @@ import { collectStrictNullChecks } from "./parsing/collectStrictNullChecks.js";
 import { PendingTypeStatOptions, RawTypeStatOptions } from "./types.js";
 
 export interface OptionsFromRawOptionsSettings {
-	compilerOptions: Readonly<ParsedCompilerOptions>;
 	cwd: string;
 	output: ProcessOutput;
+	parsedTsConfig: Readonly<ts.ParsedCommandLine>;
 	projectPath: string;
 	rawOptions: RawTypeStatOptions;
 }
@@ -23,17 +24,23 @@ export interface OptionsFromRawOptionsSettings {
  * @returns Parsed TypeStat options, or a string for an error complaint.
  */
 export const fillOutRawOptions = ({
-	compilerOptions,
 	cwd,
 	output,
+	parsedTsConfig,
 	projectPath,
 	rawOptions,
 }: OptionsFromRawOptionsSettings): PendingTypeStatOptions => {
 	const rawOptionTypes = rawOptions.types ?? {};
-	const noImplicitAny = collectNoImplicitAny(compilerOptions, rawOptions);
-	const noImplicitThis = collectNoImplicitThis(compilerOptions, rawOptions);
+	const noImplicitAny = collectNoImplicitAny(
+		parsedTsConfig.options,
+		rawOptions,
+	);
+	const noImplicitThis = collectNoImplicitThis(
+		parsedTsConfig.options,
+		rawOptions,
+	);
 	const { compilerStrictNullChecks, typeStrictNullChecks } =
-		collectStrictNullChecks(compilerOptions, rawOptionTypes);
+		collectStrictNullChecks(parsedTsConfig.options, rawOptionTypes);
 
 	const packageOptions = collectPackageOptions(cwd, rawOptions);
 
@@ -47,12 +54,6 @@ export const fillOutRawOptions = ({
 			suppressTypeErrors: false,
 			...rawOptions.cleanups,
 		},
-		compilerOptions: {
-			...compilerOptions,
-			noImplicitAny,
-			noImplicitThis,
-			strictNullChecks: compilerStrictNullChecks,
-		},
 		files: collectFileOptions(rawOptions),
 		filters: collectOptionals(rawOptions.filters),
 		fixes: {
@@ -74,14 +75,26 @@ export const fillOutRawOptions = ({
 					ReactPropTypesOptionality.AsWritten,
 			},
 		},
-		include: rawOptions.include ?? compilerOptions.include,
+		include: rawOptions.include?.length
+			? rawOptions.include
+			: parsedTsConfig.fileNames,
 		mutators: collectAddedMutators(
 			rawOptions,
 			packageOptions.directory,
 			output,
 		),
 		output,
 		package: packageOptions,
+		parsedTsConfig: {
+			...parsedTsConfig,
+			options: {
+				...parsedTsConfig.options,
+				noEmit: true,
+				noImplicitAny,
+				noImplicitThis,
+				strictNullChecks: compilerStrictNullChecks,
+			},
+		},
 		postProcess: { shell },
 		projectPath,
 		types: {

src/options/fillOutRawOptions.ts

@@ -12,15 +12,15 @@ import { PendingTypeStatOptions, RawTypeStatOptions } from "./types.js";
  * Reads pre-file-rename TypeStat options using a config path.
  * @returns Promise for filled-out TypeStat options, or a string complaint from failing to make them.
  */
-export const loadPendingOptions = async (
+export const loadPendingOptions = (
 	configPath: string | undefined,
+	cwd: string,
 	output: ProcessOutput,
-): Promise<PendingTypeStatOptions[] | string> => {
+): PendingTypeStatOptions[] | string => {
 	if (configPath === undefined) {
 		return "-c/--config file must be provided.";
 	}
 
-	const cwd = process.cwd();
 	const foundRawOptions = findRawOptions(cwd, configPath);
 	if (typeof foundRawOptions === "string") {
 		return foundRawOptions;
@@ -34,12 +34,12 @@ export const loadPendingOptions = async (
 	for (let i = 0; i < allRawOptions.length; i += 1) {
 		const rawOptions = allRawOptions[i];
 		const projectPath = getProjectPath(cwd, filePath, rawOptions);
-		const compilerOptions = await parseRawCompilerOptions(cwd, projectPath);
+		const parsedTsConfig = parseRawCompilerOptions(cwd, projectPath);
 
 		const filledOutOptions = fillOutRawOptions({
-			compilerOptions,
 			cwd,
 			output,
+			parsedTsConfig,
 			projectPath,
 			rawOptions,
 		});

src/options/loadPendingOptions.ts

@@ -1,33 +1,28 @@
-import * as fsp from "node:fs/promises";
+import path from "node:path";
 import ts from "typescript";
 
 import { createParseConfigHost } from "../services/createParseConfigHost.js";
 import { stringifyDiagnosticMessageText } from "../shared/diagnostics.js";
 
-export interface ParsedCompilerOptions extends ts.CompilerOptions {
-	include?: string[];
-}
-
-export const parseRawCompilerOptions = async (
+export const parseRawCompilerOptions = (
 	cwd: string,
 	projectPath: string,
-): Promise<ts.CompilerOptions> => {
-	const configRaw = (await fsp.readFile(projectPath)).toString();
-	const compilerOptions = ts.parseConfigFileTextToJson(projectPath, configRaw);
-	if (compilerOptions.error !== undefined) {
+): ts.ParsedCommandLine => {
+	const configFile = ts.getParsedCommandLineOfConfigFile(
+		path.resolve(cwd, projectPath),
+		undefined,
+		createParseConfigHost(cwd),
+	);
+
+	if (!configFile) {
+		throw new Error("tsConfig file not found.");
+	}
+
+	if (configFile.errors.length) {
 		throw new Error(
-			`Could not parse compiler options from '${projectPath}': ${stringifyDiagnosticMessageText(compilerOptions.error)}`,
+			`Could not parse compiler options from '${projectPath}': ${stringifyDiagnosticMessageText(configFile.errors[0])}`,
 		);
 	}
 
-	const config = compilerOptions.config as ParsedCompilerOptions;
-
-	// TSConfig includes often come in a glob form like ["src"]
-	config.include &&= ts.parseJsonConfigFileContent(
-		compilerOptions.config,
-		createParseConfigHost(),
-		cwd,
-	).fileNames;
-
-	return config;
+	return configFile;
 };