@flint.fyi/ts 0.14.5 → 0.15.0

package/src/rules/sequences.test.ts

@@ -1,49 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./sequences.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-const a = (1, 2);
-`,
-			snapshot: `
-const a = (1, 2);
-            ~
-            The "sequence" (comma) operator is often confusing and a sign of mistaken logic.
-`,
-		},
-		{
-			code: `
-function f() {
-    return (g(), h());
-}
-`,
-			snapshot: `
-function f() {
-    return (g(), h());
-               ~
-               The "sequence" (comma) operator is often confusing and a sign of mistaken logic.
-}
-`,
-		},
-		{
-			code: `
-for ((a = 1, b = 2); ; ) {
-}
-`,
-			snapshot: `
-for ((a = 1, b = 2); ; ) {
-           ~
-           The "sequence" (comma) operator is often confusing and a sign of mistaken logic.
-}
-`,
-		},
-	],
-	valid: [
-		`const a = [1, 2];`,
-		`const a = (1 + 2);`,
-		`function f() { g(); h(); }`,
-		`for (let i = 0; i < 10; i += 1) {}`,
-	],
-});

package/src/rules/sequences.ts

@@ -1,37 +0,0 @@
-import * as ts from "typescript";
-
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-
-export default typescriptLanguage.createRule({
-	about: {
-		description: "Reports using the comma operator in expressions.",
-		id: "sequences",
-		preset: "untyped",
-	},
-	messages: {
-		noSequences: {
-			primary:
-				'The "sequence" (comma) operator is often confusing and a sign of mistaken logic.',
-			secondary: [
-				"The comma operator can make code harder to read and may hide side effects.",
-				"Prefer separate expressions instead of using a single sequence.",
-			],
-			suggestions: ["Split the expression into separate statements."],
-		},
-	},
-	setup(context) {
-		return {
-			visitors: {
-				BinaryExpression: (node) => {
-					if (node.operatorToken.kind === ts.SyntaxKind.CommaToken) {
-						context.report({
-							message: "noSequences",
-							range: getTSNodeRange(node.operatorToken, context.sourceFile),
-						});
-					}
-				},
-			},
-		};
-	},
-});

package/src/rules/shadowedRestrictedNames.test.ts

@@ -1,148 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./shadowedRestrictedNames.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-let undefined = 5;
-`,
-			snapshot: `
-let undefined = 5;
-    ~~~~~~~~~
-    This variable misleadingly shadows the global \`undefined\`.
-`,
-		},
-		{
-			code: `
-const NaN = 123;
-`,
-			snapshot: `
-const NaN = 123;
-      ~~~
-      This variable misleadingly shadows the global \`NaN\`.
-`,
-		},
-		{
-			code: `
-var Infinity = 100;
-`,
-			snapshot: `
-var Infinity = 100;
-    ~~~~~~~~
-    This variable misleadingly shadows the global \`Infinity\`.
-`,
-		},
-		{
-			code: `
-function test(arguments) {
-    return arguments.length;
-}
-`,
-			snapshot: `
-function test(arguments) {
-              ~~~~~~~~~
-              This variable misleadingly shadows the global \`arguments\`.
-    return arguments.length;
-}
-`,
-		},
-		{
-			code: `
-function eval() {
-    return 42;
-}
-`,
-			snapshot: `
-function eval() {
-         ~~~~
-         This variable misleadingly shadows the global \`eval\`.
-    return 42;
-}
-`,
-		},
-		{
-			code: `
-const arrowFunc = (undefined) => undefined;
-`,
-			snapshot: `
-const arrowFunc = (undefined) => undefined;
-                   ~~~~~~~~~
-                   This variable misleadingly shadows the global \`undefined\`.
-`,
-		},
-		{
-			code: `
-class NaN {
-    constructor() {}
-}
-`,
-			snapshot: `
-class NaN {
-      ~~~
-      This variable misleadingly shadows the global \`NaN\`.
-    constructor() {}
-}
-`,
-		},
-		{
-			code: `
-const obj = {
-    method(eval) {
-        return eval;
-    }
-};
-`,
-			snapshot: `
-const obj = {
-    method(eval) {
-           ~~~~
-           This variable misleadingly shadows the global \`eval\`.
-        return eval;
-    }
-};
-`,
-		},
-		{
-			code: `
-function test() {
-    const { undefined } = obj;
-}
-`,
-			snapshot: `
-function test() {
-    const { undefined } = obj;
-            ~~~~~~~~~
-            This variable misleadingly shadows the global \`undefined\`.
-}
-`,
-		},
-		{
-			code: `
-function test() {
-    const [NaN] = array;
-}
-`,
-			snapshot: `
-function test() {
-    const [NaN] = array;
-           ~~~
-           This variable misleadingly shadows the global \`NaN\`.
-}
-`,
-		},
-	],
-	valid: [
-		`let value = undefined;`,
-		`const result = NaN;`,
-		`const max = Infinity;`,
-		`function test() { return arguments; }`,
-		`const code = eval("1 + 1");`,
-		`let myValue = 5;`,
-		`function myFunction() {}`,
-		`class MyClass {}`,
-		`const obj = { undefined: 5 };`,
-		`const key = "undefined";`,
-		`obj.undefined = 5;`,
-	],
-});

package/src/rules/shadowedRestrictedNames.ts

@@ -1,105 +0,0 @@
-import * as ts from "typescript";
-
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-
-const restrictedNames = new Set([
-	"arguments",
-	"eval",
-	"Infinity",
-	"NaN",
-	"undefined",
-]);
-
-export default typescriptLanguage.createRule({
-	about: {
-		description:
-			"Reports variable declarations that shadow JavaScript's restricted names.",
-		id: "shadowedRestrictedNames",
-		preset: "untyped",
-	},
-	messages: {
-		shadowedRestrictedName: {
-			primary: "This variable misleadingly shadows the global `{{ name }}`.",
-			secondary: [
-				"JavaScript has certain built-in global identifiers that are considered restricted because shadowing them can lead to confusing or erroneous code.",
-				"When you declare a variable with a restricted name, it shadows the global identifier and can cause unexpected behavior.",
-			],
-			suggestions: [
-				"Use a different variable name that doesn't shadow a restricted name.",
-			],
-		},
-	},
-	setup(context) {
-		function checkIdentifier(node: ts.Identifier): void {
-			if (restrictedNames.has(node.text)) {
-				context.report({
-					data: {
-						name: node.text,
-					},
-					message: "shadowedRestrictedName",
-					range: getTSNodeRange(node, context.sourceFile),
-				});
-			}
-		}
-
-		function checkBindingName(name: ts.BindingName): void {
-			if (ts.isIdentifier(name)) {
-				checkIdentifier(name);
-			} else if (
-				ts.isObjectBindingPattern(name) ||
-				ts.isArrayBindingPattern(name)
-			) {
-				for (const element of name.elements) {
-					if (ts.isBindingElement(element)) {
-						checkBindingName(element.name);
-					}
-				}
-			}
-		}
-
-		function checkParameters(
-			parameters: ts.NodeArray<ts.ParameterDeclaration>,
-		): void {
-			for (const parameter of parameters) {
-				checkBindingName(parameter.name);
-			}
-		}
-
-		return {
-			visitors: {
-				ArrowFunction: (node) => {
-					checkParameters(node.parameters);
-				},
-				ClassDeclaration: (node) => {
-					if (node.name) {
-						checkIdentifier(node.name);
-					}
-				},
-				ClassExpression: (node) => {
-					if (node.name) {
-						checkIdentifier(node.name);
-					}
-				},
-				FunctionDeclaration: (node) => {
-					if (node.name) {
-						checkIdentifier(node.name);
-					}
-					checkParameters(node.parameters);
-				},
-				FunctionExpression: (node) => {
-					if (node.name) {
-						checkIdentifier(node.name);
-					}
-					checkParameters(node.parameters);
-				},
-				MethodDeclaration: (node) => {
-					checkParameters(node.parameters);
-				},
-				VariableDeclaration: (node) => {
-					checkBindingName(node.name);
-				},
-			},
-		};
-	},
-});

package/src/rules/sparseArrays.test.ts

@@ -1,111 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./sparseArrays.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-const array = [1, , 3];
-`,
-			snapshot: `
-const array = [1, , 3];
-                  ~
-                  Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
-`,
-		},
-		{
-			code: `
-const array = [, 2, 3];
-`,
-			snapshot: `
-const array = [, 2, 3];
-               ~
-               Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
-`,
-		},
-		{
-			code: `
-const array = [1, , , 4];
-`,
-			snapshot: `
-const array = [1, , , 4];
-                  ~
-                  Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
-                    ~
-                    Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
-`,
-		},
-		{
-			code: `
-const nested = [[1, , 3], [4, 5, 6]];
-`,
-			snapshot: `
-const nested = [[1, , 3], [4, 5, 6]];
-                    ~
-                    Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
-`,
-		},
-		{
-			code: `
-const result = [
-    1,
-    ,
-    3
-];
-`,
-			snapshot: `
-const result = [
-    1,
-    ,
-    ~
-    Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
-    3
-];
-`,
-		},
-		{
-			code: `
-const matrix = [
-    [1, 2, 3],
-    [4, , 6],
-    [7, 8, 9]
-];
-`,
-			snapshot: `
-const matrix = [
-    [1, 2, 3],
-    [4, , 6],
-        ~
-        Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
-    [7, 8, 9]
-];
-`,
-		},
-		{
-			code: `
-function getArray() {
-    return [1, , 3];
-}
-`,
-			snapshot: `
-function getArray() {
-    return [1, , 3];
-               ~
-               Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
-}
-`,
-		},
-	],
-	valid: [
-		`const array = [1, 2, 3];`,
-		`const array = [];`,
-		`const array = [1];`,
-		`const array = [1, undefined, 3];`,
-		`const array = [undefined, 2, 3];`,
-		`const array = [1, 2, undefined];`,
-		`const array = [1, 2, 3,];`,
-		`const nested = [[1, undefined, 3], [4, 5, 6]];`,
-		`const matrix = [[1, 2, 3], [4, undefined, 6], [7, 8, 9]];`,
-		`const values = [null, undefined, 0, false, ""];`,
-	],
-});

package/src/rules/sparseArrays.ts

@@ -1,61 +0,0 @@
-import * as ts from "typescript";
-
-import { typescriptLanguage } from "../language.js";
-
-export default typescriptLanguage.createRule({
-	about: {
-		description: "Reports array literals with holes (sparse arrays).",
-		id: "sparseArrays",
-		preset: "logical",
-	},
-	messages: {
-		noSparseArray: {
-			primary:
-				'Sparse arrays with "holes" (empty slots) are misleading and behave differently from `undefined` values.',
-			secondary: [
-				"Array methods treat holes inconsistently, which can lead to unexpected behavior and bugs.",
-				"Using explicit `undefined` values makes the intent clear and ensures consistent behavior.",
-			],
-			suggestions: [
-				"Replace holes with explicit `undefined` values.",
-				"Remove unintended commas if the holes are accidental.",
-			],
-		},
-	},
-	setup(context) {
-		return {
-			visitors: {
-				OmittedExpression: (node) => {
-					const parent = node.parent;
-					if (!ts.isArrayLiteralExpression(parent)) {
-						return;
-					}
-
-					const syntaxList = parent
-						.getChildren(context.sourceFile)
-						.find((child) => child.kind === ts.SyntaxKind.SyntaxList);
-
-					if (!syntaxList) {
-						return;
-					}
-
-					const children = syntaxList.getChildren(context.sourceFile);
-					const omittedIndex = children.indexOf(node);
-
-					for (let i = omittedIndex + 1; i < children.length; i++) {
-						if (children[i].kind === ts.SyntaxKind.CommaToken) {
-							context.report({
-								message: "noSparseArray",
-								range: {
-									begin: children[i].getStart(context.sourceFile),
-									end: children[i].getEnd(),
-								},
-							});
-							break;
-						}
-					}
-				},
-			},
-		};
-	},
-});

package/src/rules/symbolDescriptions.test.ts

@@ -1,90 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./symbolDescriptions.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-const symbol = Symbol();
-`,
-			snapshot: `
-const symbol = Symbol();
-               ~~~~~~~~
-               Symbols without descriptions are more difficult to debug or reason about.
-`,
-		},
-		{
-			code: `
-const uniqueKey = Symbol();
-`,
-			snapshot: `
-const uniqueKey = Symbol();
-                  ~~~~~~~~
-                  Symbols without descriptions are more difficult to debug or reason about.
-`,
-		},
-		{
-			code: `
-const symbols = [Symbol(), Symbol()];
-`,
-			snapshot: `
-const symbols = [Symbol(), Symbol()];
-                 ~~~~~~~~
-                 Symbols without descriptions are more difficult to debug or reason about.
-                           ~~~~~~~~
-                           Symbols without descriptions are more difficult to debug or reason about.
-`,
-		},
-		{
-			code: `
-function createSymbol() {
-	return Symbol();
-}
-`,
-			snapshot: `
-function createSymbol() {
-	return Symbol();
-	       ~~~~~~~~
-	       Symbols without descriptions are more difficult to debug or reason about.
-}
-`,
-		},
-		{
-			code: `
-const obj = {
-	key: Symbol(),
-};
-`,
-			snapshot: `
-const obj = {
-	key: Symbol(),
-	     ~~~~~~~~
-	     Symbols without descriptions are more difficult to debug or reason about.
-};
-`,
-		},
-		{
-			code: `
-const value = condition ? Symbol() : null;
-`,
-			snapshot: `
-const value = condition ? Symbol() : null;
-                          ~~~~~~~~
-                          Symbols without descriptions are more difficult to debug or reason about.
-`,
-		},
-	],
-	valid: [
-		`const symbol = Symbol("description");`,
-		`const uniqueKey = Symbol("uniqueKey");`,
-		`const mySymbol = Symbol("my symbol");`,
-		`const symbols = [Symbol("first"), Symbol("second")];`,
-		`function createSymbol() { return Symbol("created"); }`,
-		`const obj = { key: Symbol("key") };`,
-		`const value = Symbol.for("global");`,
-		`const iterator = Symbol.iterator;`,
-		`const hasInstance = Symbol.hasInstance;`,
-		`const primitiveValue = Symbol.toPrimitive;`,
-		`Symbol("valid")`,
-	],
-});

package/src/rules/symbolDescriptions.ts

@@ -1,47 +0,0 @@
-import * as ts from "typescript";
-
-import { typescriptLanguage } from "../language.js";
-
-export default typescriptLanguage.createRule({
-	about: {
-		description: "Reports Symbol() calls without description arguments.",
-		id: "symbolDescriptions",
-		preset: "stylistic",
-	},
-	messages: {
-		missingDescription: {
-			primary:
-				"Symbols without descriptions are more difficult to debug or reason about.",
-			secondary: [
-				"Creating a symbol without a description makes debugging difficult, as the symbol's purpose isn't clear when inspecting it.",
-				"While the description doesn't affect the symbol's uniqueness, it appears in the symbol's string representation and can be accessed via `Symbol.prototype.description`.",
-			],
-			suggestions: [
-				"Add a descriptive string argument to the Symbol constructor that explains the symbol's purpose.",
-			],
-		},
-	},
-	setup(context) {
-		return {
-			visitors: {
-				CallExpression: (node) => {
-					if (
-						!ts.isIdentifier(node.expression) ||
-						node.expression.text !== "Symbol" ||
-						node.arguments.length
-					) {
-						return;
-					}
-
-					context.report({
-						message: "missingDescription",
-						range: {
-							begin: node.getStart(context.sourceFile),
-							end: node.getEnd(),
-						},
-					});
-				},
-			},
-		};
-	},
-});