@flint.fyi/ts 0.13.2 → 0.14.1

package/src/directives/parseDirectivesFromTypeScriptFile.ts

@@ -0,0 +1,31 @@
+import { DirectivesCollector } from "@flint.fyi/core";
+import * as tsutils from "ts-api-utils";
+import ts from "typescript";
+
+import { normalizeRange } from "../normalizeRange.js";
+
+export function parseDirectivesFromTypeScriptFile(sourceFile: ts.SourceFile) {
+	const collector = new DirectivesCollector(
+		sourceFile.statements.at(0)?.getStart(sourceFile) ?? sourceFile.text.length,
+	);
+
+	tsutils.forEachComment(sourceFile, (fullText, sourceRange) => {
+		const commentText = fullText.slice(sourceRange.pos, sourceRange.end);
+		const match = /^\/\/\s*flint-(\S+)(?:\s+(.+))?/.exec(commentText);
+		if (!match) {
+			return;
+		}
+
+		const commentRange = {
+			begin: sourceRange.pos,
+			end: sourceRange.end,
+		};
+
+		const range = normalizeRange(commentRange, sourceFile);
+		const [type, selection] = match.slice(1);
+
+		collector.add(range, selection, type);
+	});
+
+	return collector.collect();
+}

package/src/getFirstEnumValues.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest";
+
+import { getFirstEnumValues } from "./getFirstEnumValues.js";
+
+describe("getFirstEnumValues", () => {
+	it("returns an empty object when given an empty enum", () => {
+		enum Empty {}
+
+		const result = getFirstEnumValues(Empty);
+
+		expect(result).toEqual({});
+	});
+
+	it("returns all original pairs when when given a non-repeating enum", () => {
+		enum NonRepeating {
+			A = 1,
+			B = 2,
+			C = 3,
+		}
+
+		const result = getFirstEnumValues(NonRepeating);
+
+		expect(result).toEqual({
+			1: "A",
+			2: "B",
+			3: "C",
+			A: 1,
+			B: 2,
+			C: 3,
+		});
+	});
+
+	it("returns the first key when when given a repeating-value enum", () => {
+		enum Repeating {
+			A = 1,
+			B = 2,
+			// eslint-disable-next-line @typescript-eslint/prefer-literal-enum-member
+			C = A,
+		}
+
+		const result = getFirstEnumValues(Repeating);
+
+		expect(result).toEqual({
+			1: "A",
+			2: "B",
+			A: 1,
+			B: 2,
+			C: 1,
+		});
+	});
+});

package/src/getFirstEnumValues.ts

@@ -0,0 +1,59 @@
+/**
+ * Removes TypeScript enum values that alias earlier values.
+ * @param original Any TypeScript enum with numeric values.
+ * @returns A version of the enum with only the first occurrence of each value.
+ * @example
+ * Given the following enum:
+ * ```ts
+ * enum Example {
+ *   A = 1,
+ *   B = 2,
+ *   C = A
+ * }
+ * ```
+ * Its original value looks like:
+ * ```ts
+ * {
+ *   1: 'C', // <-- Points to 'C', the alias of 'A'
+ *   2: 'B',
+ *   A: 1,
+ *   B: 2,
+ *   C: 1,
+ * }
+ * ```
+ * Calling `getFirstEnumValues(Example)` would return:
+ * ```ts
+ * {
+ *   1: 'A', // <-- Corrected to the original 'A'
+ *   2: 'B',
+ *   A: 1,
+ *   B: 2,
+ *   C: 1,
+ * }
+ * ```
+ */
+export function getFirstEnumValues<
+	Keys extends string,
+	Values extends number,
+	Original extends Record<Keys | Values, Keys | Values>,
+>(original: Original) {
+	const result = {} as Original;
+
+	for (const key in original) {
+		if (typeof original[key] !== "number") {
+			continue;
+		}
+
+		if (!(key in result)) {
+			result[key] = original[key];
+		}
+
+		if (!(original[key] in result)) {
+			// 🤷 enums are tricky to type.
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
+			result[original[key]] = key as any;
+		}
+	}
+
+	return result;
+}

package/src/language.ts

@@ -12,6 +12,7 @@ import * as ts from "typescript";
 import { createTypeScriptFileFromProgram } from "./createTypeScriptFileFromProgram.js";
 import { createTypeScriptFileFromProjectService } from "./createTypeScriptFileFromProjectService.js";
 import { TSNodesByName } from "./nodes.js";
+import { prepareTypeScriptFile } from "./prepareTypeScriptFile.js";
 
 const log = debugForFile(import.meta.filename);
 
@@ -84,18 +85,21 @@ export const typescriptLanguage = createLanguage<
 		});
 
 		return {
-			prepareFileOnDisk: (filePathAbsolute) => {
+			prepareFromDisk: (filePathAbsolute) => {
 				const program = servicePrograms.get(filePathAbsolute);
 
 				seenPrograms.add(program);
 
-				return createTypeScriptFileFromProjectService(
-					filePathAbsolute,
-					program,
-					service,
-				);
+				const { languageFile, sourceFile } =
+					createTypeScriptFileFromProjectService(
+						filePathAbsolute,
+						program,
+						service,
+					);
+
+				return prepareTypeScriptFile(languageFile, sourceFile);
 			},
-			prepareFileVirtually: (filePathAbsolute, sourceText) => {
+			prepareFromVirtual: (filePathAbsolute, sourceText) => {
 				const environment = environments.get(filePathAbsolute);
 				environment.updateFile(filePathAbsolute, sourceText);
 				/* eslint-disable @typescript-eslint/no-non-null-assertion */
@@ -105,7 +109,12 @@ export const typescriptLanguage = createLanguage<
 
 				seenPrograms.add(program);
 
-				return createTypeScriptFileFromProgram(program, sourceFile);
+				const languageFile = createTypeScriptFileFromProgram(
+					program,
+					sourceFile,
+				);
+
+				return prepareTypeScriptFile(languageFile, sourceFile);
 			},
 		};
 	},

package/src/prepareTypeScriptFile.ts

@@ -0,0 +1,14 @@
+import { LanguageFileDefinition } from "@flint.fyi/core";
+import ts from "typescript";
+
+import { parseDirectivesFromTypeScriptFile } from "./directives/parseDirectivesFromTypeScriptFile.js";
+
+export function prepareTypeScriptFile(
+	languageFile: LanguageFileDefinition,
+	sourceFile: ts.SourceFile,
+) {
+	return {
+		...parseDirectivesFromTypeScriptFile(sourceFile),
+		file: languageFile,
+	};
+}

package/src/rules/consecutiveNonNullAssertions.ts

@@ -4,6 +4,7 @@ import { typescriptLanguage } from "../language.js";
 
 export default typescriptLanguage.createRule({
 	about: {
+		description: "Reports unnecessary extra non-null assertions.",
 		id: "consecutiveNonNullAssertions",
 		preset: "logical",
 	},
@@ -26,8 +27,8 @@ export default typescriptLanguage.createRule({
 					}
 
 					const range = {
-						begin: node.end,
-						end: node.parent.end + 1,
+						begin: node.end - 1,
+						end: node.parent.end,
 					};
 
 					context.report({

package/src/rules/forInArrays.ts

@@ -7,6 +7,7 @@ import { isTypeRecursive } from "./utils/isTypeRecursive.js";
 
 export default typescriptLanguage.createRule({
 	about: {
+		description: "Reports iterating over an array with a for-in loop.",
 		id: "forInArrays",
 		preset: "logical",
 	},

package/src/rules/namespaceDeclarations.ts

@@ -7,6 +7,7 @@ import { typescriptLanguage } from "../language.js";
 
 export default typescriptLanguage.createRule({
 	about: {
+		description: "Reports using legacy `namespace` declarations.",
 		id: "namespaceDeclarations",
 		preset: "logical",
 	},
@@ -23,8 +24,18 @@ export default typescriptLanguage.createRule({
 		},
 	},
 	options: {
-		allowDeclarations: z.boolean().default(false),
-		allowDefinitionFiles: z.boolean().default(false),
+		allowDeclarations: z
+			.boolean()
+			.default(false)
+			.describe(
+				"Whether to allow namespaces declared with the `declare` keyword.",
+			),
+		allowDefinitionFiles: z
+			.boolean()
+			.default(false)
+			.describe(
+				"Whether to allow namespaces in `.d.ts` and other definition files.",
+			),
 	},
 	setup(context, { allowDeclarations, allowDefinitionFiles }) {
 		if (allowDefinitionFiles && context.sourceFile.isDeclarationFile) {