@flint.fyi/ts 0.13.0

package/src/nodes.ts

@@ -0,0 +1,145 @@
+import type * as ts from "typescript";
+
+// TODO: Surely there's a better way to do this...
+// ...but I haven't checked how to do it without slow type operations.
+
+export interface TSNodesByName {
+	ArrayBindingPattern: ts.ArrayBindingPattern;
+	ArrayLiteralExpression: ts.ArrayLiteralExpression;
+	ArrowFunction: ts.ArrowFunction;
+	AsExpression: ts.AsExpression;
+	AwaitExpression: ts.AwaitExpression;
+	BigIntLiteral: ts.BigIntLiteral;
+	BinaryExpression: ts.BinaryExpression;
+	BindingElement: ts.BindingElement;
+	Block: ts.Block;
+	BreakStatement: ts.BreakStatement;
+	Bundle: ts.Bundle;
+	CallExpression: ts.CallExpression;
+	CaseBlock: ts.CaseBlock;
+	CaseClause: ts.CaseClause;
+	CatchClause: ts.CatchClause;
+	ClassDeclaration: ts.ClassDeclaration;
+	ClassExpression: ts.ClassExpression;
+	ClassStaticBlockDeclaration: ts.ClassStaticBlockDeclaration;
+	CommaListExpression: ts.CommaListExpression;
+	ComputedPropertyName: ts.ComputedPropertyName;
+	ConditionalExpression: ts.ConditionalExpression;
+	ConditionalType: ts.ConditionalType;
+	ContinueStatement: ts.ContinueStatement;
+	DebuggerStatement: ts.DebuggerStatement;
+	Decorator: ts.Decorator;
+	DefaultClause: ts.DefaultClause;
+	DeleteExpression: ts.DeleteExpression;
+	DoStatement: ts.DoStatement;
+	ElementAccessExpression: ts.ElementAccessExpression;
+	EmptyStatement: ts.EmptyStatement;
+	EnumDeclaration: ts.EnumDeclaration;
+	EnumMember: ts.EnumMember;
+	ExportAssignment: ts.ExportAssignment;
+	ExportDeclaration: ts.ExportDeclaration;
+	ExportSpecifier: ts.ExportSpecifier;
+	ExpressionStatement: ts.ExpressionStatement;
+	ExpressionWithTypeArguments: ts.ExpressionWithTypeArguments;
+	ExternalModuleReference: ts.ExternalModuleReference;
+	ForInStatement: ts.ForInStatement;
+	ForOfStatement: ts.ForOfStatement;
+	ForStatement: ts.ForStatement;
+	FunctionDeclaration: ts.FunctionDeclaration;
+	FunctionExpression: ts.FunctionExpression;
+	HeritageClause: ts.HeritageClause;
+	Identifier: ts.Identifier;
+	IfStatement: ts.IfStatement;
+	ImportAttribute: ts.ImportAttribute;
+	ImportAttributes: ts.ImportAttributes;
+	ImportClause: ts.ImportClause;
+	ImportDeclaration: ts.ImportDeclaration;
+	ImportEqualsDeclaration: ts.ImportEqualsDeclaration;
+	ImportSpecifier: ts.ImportSpecifier;
+	IndexedAccessType: ts.IndexedAccessType;
+	InterfaceDeclaration: ts.InterfaceDeclaration;
+	IntersectionType: ts.IntersectionType;
+	JsxAttribute: ts.JsxAttribute;
+	JsxAttributes: ts.JsxAttributes;
+	JsxClosingElement: ts.JsxClosingElement;
+	JsxClosingFragment: ts.JsxClosingFragment;
+	JsxElement: ts.JsxElement;
+	JsxExpression: ts.JsxExpression;
+	JsxFragment: ts.JsxFragment;
+	JsxNamespacedName: ts.JsxNamespacedName;
+	JsxOpeningElement: ts.JsxOpeningElement;
+	JsxOpeningFragment: ts.JsxOpeningFragment;
+	JsxSelfClosingElement: ts.JsxSelfClosingElement;
+	JsxSpreadAttribute: ts.JsxSpreadAttribute;
+	JsxText: ts.JsxText;
+	LabeledStatement: ts.LabeledStatement;
+	LiteralType: ts.LiteralType;
+	MappedTypeNode: ts.MappedTypeNode;
+	MetaProperty: ts.MetaProperty;
+	MethodDeclaration: ts.MethodDeclaration;
+	MethodSignature: ts.MethodSignature;
+	MissingDeclaration: ts.MissingDeclaration;
+	ModuleBlock: ts.ModuleBlock;
+	ModuleDeclaration: ts.ModuleDeclaration;
+	NamedExports: ts.NamedExports;
+	NamedImports: ts.NamedImports;
+	NamedTupleMember: ts.NamedTupleMember;
+	NamespaceExport: ts.NamespaceExport;
+	NamespaceExportDeclaration: ts.NamespaceExportDeclaration;
+	NamespaceImport: ts.NamespaceImport;
+	NewExpression: ts.NewExpression;
+	NonNullExpression: ts.NonNullExpression;
+	NoSubstitutionTemplateLiteral: ts.NoSubstitutionTemplateLiteral;
+	NotEmittedStatement: ts.NotEmittedStatement;
+	NotEmittedTypeElement: ts.NotEmittedTypeElement;
+	NumericLiteral: ts.NumericLiteral;
+	ObjectBindingPattern: ts.ObjectBindingPattern;
+	ObjectLiteralExpression: ts.ObjectLiteralExpression;
+	OmittedExpression: ts.OmittedExpression;
+	ParenthesizedExpression: ts.ParenthesizedExpression;
+	PartiallyEmittedExpression: ts.PartiallyEmittedExpression;
+	PostfixUnaryExpression: ts.PostfixUnaryExpression;
+	PrefixUnaryExpression: ts.PrefixUnaryExpression;
+	PrivateIdentifier: ts.PrivateIdentifier;
+	PropertyAccessExpression: ts.PropertyAccessExpression;
+	PropertyAssignment: ts.PropertyAssignment;
+	PropertyDeclaration: ts.PropertyDeclaration;
+	PropertySignature: ts.PropertySignature;
+	QualifiedName: ts.QualifiedName;
+	RegularExpressionLiteral: ts.RegularExpressionLiteral;
+	ReturnStatement: ts.ReturnStatement;
+	SatisfiesExpression: ts.SatisfiesExpression;
+	SemicolonClassElement: ts.SemicolonClassElement;
+	ShorthandPropertyAssignment: ts.ShorthandPropertyAssignment;
+	SourceFile: ts.SourceFile;
+	SpreadAssignment: ts.SpreadAssignment;
+	SpreadElement: ts.SpreadElement;
+	StringLiteral: ts.StringLiteral;
+	SwitchStatement: ts.SwitchStatement;
+	SyntaxList: ts.SyntaxList;
+	SyntheticExpression: ts.SyntheticExpression;
+	TaggedTemplateExpression: ts.TaggedTemplateExpression;
+	TemplateExpression: ts.TemplateExpression;
+	TemplateHead: ts.TemplateHead;
+	TemplateLiteralType: ts.TemplateLiteralType;
+	TemplateLiteralTypeSpan: ts.TemplateLiteralTypeSpan;
+	TemplateMiddle: ts.TemplateMiddle;
+	TemplateSpan: ts.TemplateSpan;
+	TemplateTail: ts.TemplateTail;
+	ThrowStatement: ts.ThrowStatement;
+	TryStatement: ts.TryStatement;
+	TupleType: ts.TupleType;
+	TypeAliasDeclaration: ts.TypeAliasDeclaration;
+	TypeOfExpression: ts.TypeOfExpression;
+	TypeParameter: ts.TypeParameter;
+	TypePredicate: ts.TypePredicate;
+	TypeReference: ts.TypeReference;
+	UnionType: ts.UnionType;
+	VariableDeclaration: ts.VariableDeclaration;
+	VariableDeclarationList: ts.VariableDeclarationList;
+	VariableStatement: ts.VariableStatement;
+	VoidExpression: ts.VoidExpression;
+	WhileStatement: ts.WhileStatement;
+	WithStatement: ts.WithStatement;
+	YieldExpression: ts.YieldExpression;
+}

package/src/normalizeRange.ts

@@ -0,0 +1,30 @@
+import type * as ts from "typescript";
+
+import {
+	CharacterReportRange,
+	NormalizedReportRangeObject,
+} from "@flint.fyi/core";
+
+export function normalizeRange(
+	original: CharacterReportRange,
+	sourceFile: ts.SourceFile,
+): NormalizedReportRangeObject {
+	const onCharacters = isNode(original)
+		? { begin: original.getStart(), end: original.getEnd() }
+		: original;
+
+	return {
+		begin: normalizeRangePosition(onCharacters.begin, sourceFile),
+		end: normalizeRangePosition(onCharacters.end, sourceFile),
+	};
+}
+
+function isNode(value: unknown): value is ts.Node {
+	return typeof value === "object" && value !== null && "kind" in value;
+}
+
+function normalizeRangePosition(raw: number, sourceFile: ts.SourceFile) {
+	const { character, line } = sourceFile.getLineAndCharacterOfPosition(raw);
+
+	return { column: character, line, raw };
+}

package/src/plugin.ts

@@ -0,0 +1,13 @@
+import { createPlugin } from "@flint.fyi/core";
+
+import consecutiveNonNullAssertions from "./rules/consecutiveNonNullAssertions.js";
+import forInArrays from "./rules/forInArrays.js";
+import namespaceDeclarations from "./rules/namespaceDeclarations.js";
+
+export const ts = createPlugin({
+	globs: {
+		all: ["**/*.{cjs,js,jsx,mjs,ts,tsx}"],
+	},
+	name: "ts",
+	rules: [forInArrays, consecutiveNonNullAssertions, namespaceDeclarations],
+});

package/src/rules/consecutiveNonNullAssertions.test.ts

@@ -0,0 +1,33 @@
+import rule from "./consecutiveNonNullAssertions.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+declare const outer: { inner: number } | null;
+outer!!.inner;
+`,
+			output: `
+declare const outer: { inner: number } | null;
+outer!.inner;
+`,
+			snapshot: `
+declare const outer: { inner: number } | null;
+outer!!.inner;
+     ~~
+     Consecutive non-null assertion operators are unnecessary.
+`,
+		},
+	],
+	valid: [
+		`
+declare const outer: { inner: number } | null;
+outer!.inner;
+`,
+		`
+declare const outer: { inner: number } | null;
+outer?.inner!;
+`,
+	],
+});

package/src/rules/consecutiveNonNullAssertions.ts

@@ -0,0 +1,43 @@
+import * as ts from "typescript";
+
+import { typescriptLanguage } from "../language.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		id: "consecutiveNonNullAssertions",
+		preset: "logical",
+	},
+	messages: {
+		consecutiveNonNullAssertion: {
+			primary: "Consecutive non-null assertion operators are unnecessary.",
+			secondary: [
+				"The non-null assertion operator (`!`) is used to assert that a value is not null or undefined.",
+				"Using it multiple times in a row does not do anything, and just takes up space unnecessarily.",
+			],
+			suggestions: ["Remove the redundant non-null assertion operator."],
+		},
+	},
+	setup(context) {
+		return {
+			NonNullExpression(node) {
+				if (node.parent.kind !== ts.SyntaxKind.NonNullExpression) {
+					return;
+				}
+
+				const range = {
+					begin: node.end,
+					end: node.parent.end + 1,
+				};
+
+				context.report({
+					fix: {
+						range,
+						text: "",
+					},
+					message: "consecutiveNonNullAssertion",
+					range,
+				});
+			},
+		};
+	},
+});

package/src/rules/forInArrays.test.ts

@@ -0,0 +1,25 @@
+import rule from "./forInArrays.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+declare const array: string[];
+for (const i in array) {}
+`,
+			snapshot: `
+declare const array: string[];
+for (const i in array) {}
+~~~~~~~~~~~~~~~~~~~~~~
+For-in loops over arrays have surprising behavior that often leads to bugs.
+`,
+		},
+	],
+	valid: [
+		`
+declare const array: string[];
+for (const i of array) {}
+`,
+	],
+});

package/src/rules/forInArrays.ts

@@ -0,0 +1,67 @@
+import * as tsutils from "ts-api-utils";
+import * as ts from "typescript";
+
+import { typescriptLanguage } from "../language.js";
+import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
+import { isTypeRecursive } from "./utils/isTypeRecursive.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		id: "forInArrays",
+		preset: "logical",
+	},
+	messages: {
+		forIn: {
+			primary:
+				"For-in loops over arrays have surprising behavior that often leads to bugs.",
+			secondary: [
+				"A for-in loop (`for (const i in o)`) iterates over all enumerable properties of an object, including those that are not array indices.",
+				"This can lead to unexpected behavior when used with arrays, as it may include properties that are not part of the array's numeric indices.",
+				"It also returns the index key (`i`) as a string, which is not the expected numeric type for array indices.",
+			],
+			suggestions: [
+				"Use a construct more suited for arrays, such as a for-of loop (`for (const i of o)`).",
+			],
+		},
+	},
+	setup(context) {
+		function hasNumberLikeLength(type: ts.Type): boolean {
+			const lengthProperty = type.getProperty("length");
+
+			if (lengthProperty == null) {
+				return false;
+			}
+
+			return tsutils.isTypeFlagSet(
+				context.typeChecker.getTypeOfSymbol(lengthProperty),
+				ts.TypeFlags.NumberLike,
+			);
+		}
+
+		function isArrayLike(type: ts.Type): boolean {
+			return isTypeRecursive(
+				type,
+				(t) => t.getNumberIndexType() != null && hasNumberLikeLength(t),
+			);
+		}
+
+		return {
+			ForInStatement(node) {
+				const type = getConstrainedTypeAtLocation(
+					node.expression,
+					context.typeChecker,
+				);
+
+				if (isArrayLike(type)) {
+					context.report({
+						message: "forIn",
+						range: {
+							begin: node.getStart(),
+							end: node.statement.getStart() - 1,
+						},
+					});
+				}
+			},
+		};
+	},
+});

package/src/rules/namespaceDeclarations.test.ts

@@ -0,0 +1,41 @@
+import rule from "./namespaceDeclarations.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+namespace name {}
+`,
+			snapshot: `
+namespace name {}
+~~~~~~~~~
+Prefer using ECMAScript modules over legacy TypeScript namespaces.
+`,
+		},
+	],
+	valid: [
+		`declare global {}`,
+		`declare module 'name' {}`,
+		{
+			code: `declare module name {}`,
+			options: { allowDeclarations: true },
+		},
+		{
+			code: `declare namespace name {}`,
+			options: { allowDeclarations: true },
+		},
+		{
+			code: `
+declare namespace outer {
+    namespace inner {}
+}`,
+			options: { allowDeclarations: true },
+		},
+		{
+			code: `namespace name {}`,
+			fileName: "file.d.ts",
+			options: { allowDefinitionFiles: true },
+		},
+	],
+});

package/src/rules/namespaceDeclarations.ts

@@ -0,0 +1,58 @@
+import * as tsutils from "ts-api-utils";
+import * as ts from "typescript";
+import { z } from "zod";
+
+import { getNodeRange } from "../getNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		id: "namespaceDeclarations",
+		preset: "logical",
+	},
+	messages: {
+		preferModules: {
+			primary:
+				"Prefer using ECMAScript modules over legacy TypeScript namespaces.",
+			secondary: [
+				"Namespaces are a legacy feature of TypeScript that can lead to confusion and are not compatible with ECMAScript modules.",
+			],
+			suggestions: [
+				"Modern codebases generally use `export` and `import` statements to define and use ECMAScript modules instead.",
+			],
+		},
+	},
+	options: {
+		allowDeclarations: z.boolean().default(false),
+		allowDefinitionFiles: z.boolean().default(false),
+	},
+	setup(context, { allowDeclarations, allowDefinitionFiles }) {
+		if (allowDefinitionFiles && context.sourceFile.isDeclarationFile) {
+			return;
+		}
+
+		return {
+			ModuleDeclaration(node) {
+				if (
+					node.parent.kind !== ts.SyntaxKind.SourceFile ||
+					node.name.kind !== ts.SyntaxKind.Identifier ||
+					node.name.text === "global"
+				) {
+					return;
+				}
+
+				if (
+					allowDeclarations &&
+					tsutils.includesModifier(node.modifiers, ts.SyntaxKind.DeclareKeyword)
+				) {
+					return;
+				}
+
+				context.report({
+					message: "preferModules",
+					range: getNodeRange(node.getChildAt(0), context.sourceFile),
+				});
+			},
+		};
+	},
+});

package/src/rules/ruleTester.ts

@@ -0,0 +1,4 @@
+import { RuleTester } from "@flint.fyi/rule-tester";
+import { describe, it } from "vitest";
+
+export const ruleTester = new RuleTester({ describe, it });

package/src/rules/utils/getConstrainedType.ts

@@ -0,0 +1,9 @@
+import * as ts from "typescript";
+
+export function getConstrainedTypeAtLocation(
+	node: ts.Node,
+	typeChecker: ts.TypeChecker,
+) {
+	const type = typeChecker.getTypeAtLocation(node);
+	return typeChecker.getBaseConstraintOfType(type) ?? type;
+}

package/src/rules/utils/isTypeRecursive.ts

@@ -0,0 +1,10 @@
+import * as ts from "typescript";
+
+export function isTypeRecursive(
+	type: ts.Type,
+	predicate: (t: ts.Type) => boolean,
+): boolean {
+	return type.isUnionOrIntersection()
+		? type.types.some((subType) => isTypeRecursive(subType, predicate))
+		: predicate(type);
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+	"compilerOptions": {
+		"outDir": "lib",
+		"rootDir": "src"
+	},
+	"extends": "../../tsconfig.base.json",
+	"include": ["src"],
+	"references": [{ "path": "../core" }, { "path": "../rule-tester" }]
+}