@flint.fyi/ts 0.14.5 → 0.15.0

package/src/rules/typeofComparisons.test.ts

@@ -1,86 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./typeofComparisons.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-if (typeof value === "") {
-    process();
-}
-`,
-			snapshot: `
-if (typeof value === "") {
-                     ~~
-                     This string literal is not one that the typeof operator will ever produce.
-    process();
-}
-`,
-		},
-		{
-			code: `
-if (typeof data != "invalid") {
-    reject();
-}
-`,
-			snapshot: `
-if (typeof data != "invalid") {
-                   ~~~~~~~~~
-                   This string literal is not one that the typeof operator will ever produce.
-    reject();
-}
-`,
-		},
-		{
-			code: `
-if ("invalid" === typeof flag) {
-    toggle();
-}
-`,
-			snapshot: `
-if ("invalid" === typeof flag) {
-    ~~~~~~~~~
-    This string literal is not one that the typeof operator will ever produce.
-    toggle();
-}
-`,
-		},
-		{
-			code: `
-if (typeof value === "String") {
-    process();
-}
-`,
-			snapshot: `
-if (typeof value === "String") {
-                     ~~~~~~~~
-                     This string literal is not one that the typeof operator will ever produce.
-    process();
-}
-`,
-		},
-		{
-			code: `
-const isValid = typeof input !== "array";
-`,
-			snapshot: `
-const isValid = typeof input !== "array";
-                                 ~~~~~~~
-                                 This string literal is not one that the typeof operator will ever produce.
-`,
-		},
-	],
-	valid: [
-		`if (typeof value === "string") { process(); }`,
-		`if (typeof variable == "undefined") { handle(); }`,
-		`if (typeof data != "number") { reject(); }`,
-		`if (typeof callback !== "function") { throw new Error("Invalid callback"); }`,
-		`if (typeof flag === "boolean") { toggle(); }`,
-		`if (typeof value === "object") { parse(); }`,
-		`if (typeof value === "symbol") { handle(); }`,
-		`if (typeof value === "bigint") { compute(); }`,
-		`if (typeof value === other) { process(); }`,
-		`if (typeof value === typeof other) { compare(); }`,
-		`const type = typeof value;`,
-	],
-});

package/src/rules/typeofComparisons.ts

@@ -1,88 +0,0 @@
-import * as ts from "typescript";
-
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-
-const validTypeofValues = new Set([
-	"bigint",
-	"boolean",
-	"function",
-	"number",
-	"object",
-	"string",
-	"symbol",
-	"undefined",
-]);
-
-// TODO: Reuse a shared getStaticValue-style utility?
-function getStringValue(node: ts.Expression) {
-	return ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)
-		? node.text
-		: undefined;
-}
-
-function getTypeofOperand(node: ts.Expression) {
-	return ts.isTypeOfExpression(node) && node.expression;
-}
-
-export default typescriptLanguage.createRule({
-	about: {
-		description:
-			"Reports typeof expressions that compare impossible string literals.",
-		id: "typeofComparisons",
-		preset: "untyped",
-	},
-	messages: {
-		invalidValue: {
-			primary:
-				"This string literal is not one that the typeof operator will ever produce.",
-			secondary: [
-				"The typeof operator returns one of a specific set of string values.",
-				"Comparing typeof to an invalid string is usually a typo and will never match.",
-				'The only valid values are: "bigint", "boolean", "function", "number", "object", "string", "symbol", and "undefined".',
-			],
-			suggestions: [
-				"Check for typos and use one of the valid typeof return values.",
-			],
-		},
-	},
-	setup(context) {
-		function checkComparison(node: ts.BinaryExpression) {
-			const leftTypeofOperand = getTypeofOperand(node.left);
-			const rightTypeofOperand = getTypeofOperand(node.right);
-
-			let comparisonValue: ts.Expression | undefined;
-			if (leftTypeofOperand) {
-				comparisonValue = node.right;
-			} else if (rightTypeofOperand) {
-				comparisonValue = node.left;
-			} else {
-				return;
-			}
-
-			const stringValue = getStringValue(comparisonValue);
-			if (stringValue != null && !validTypeofValues.has(stringValue)) {
-				context.report({
-					message: "invalidValue",
-					range: getTSNodeRange(comparisonValue, context.sourceFile),
-				});
-			}
-		}
-
-		return {
-			visitors: {
-				BinaryExpression: (node) => {
-					if (
-						node.operatorToken.kind === ts.SyntaxKind.EqualsEqualsToken ||
-						node.operatorToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken ||
-						node.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsToken ||
-						node.operatorToken.kind ===
-							ts.SyntaxKind.ExclamationEqualsEqualsToken
-					) {
-						checkComparison(node);
-					}
-				},
-			},
-		};
-	},
-});

package/src/rules/unassignedVariables.test.ts

@@ -1,73 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./unassignedVariables.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-let value;
-`,
-			snapshot: `
-let value;
-    ~~~~~
-    Variable 'value' is declared but never assigned a value.
-`,
-		},
-		{
-			code: `
-var variable;
-console.log(variable);
-`,
-			snapshot: `
-var variable;
-    ~~~~~~~~
-    Variable 'variable' is declared but never assigned a value.
-console.log(variable);
-`,
-		},
-		{
-			code: `
-let unassigned: number;
-console.log(unassigned);
-`,
-			snapshot: `
-let unassigned: number;
-    ~~~~~~~~~~
-    Variable 'unassigned' is declared but never assigned a value.
-console.log(unassigned);
-`,
-		},
-		{
-			code: `
-function example() {
-    let local;
-    return local;
-}
-`,
-			snapshot: `
-function example() {
-    let local;
-        ~~~~~
-        Variable 'local' is declared but never assigned a value.
-    return local;
-}
-`,
-		},
-	],
-	valid: [
-		`let assigned = 5;`,
-		`const constant = 10;`,
-		`var variable = "hello";`,
-		`let value: number = 42;`,
-		`let x; x = 5;`,
-		`let y; y = 10; console.log(y);`,
-		`var z; z += 1;`,
-		`let counter; counter++;`,
-		`let value; value--;`,
-		`for (let index = 0; index < 10; index++) {}`,
-		`for (let item; item < 10; item++) {}`,
-		`let result; result ||= "default";`,
-		`let data; data &&= "value";`,
-		`let nullish; nullish ??= "fallback";`,
-	],
-});

package/src/rules/unassignedVariables.ts

@@ -1,69 +0,0 @@
-import * as ts from "typescript";
-
-import { typescriptLanguage } from "../language.js";
-import { getModifyingReferences } from "../utils/getModifyingReferences.js";
-
-export default typescriptLanguage.createRule({
-	about: {
-		description:
-			"Reports variables that are declared but never assigned a value.",
-		id: "unassignedVariables",
-		preset: "untyped",
-	},
-	messages: {
-		noUnassigned: {
-			primary: "Variable '{{ name }}' is declared but never assigned a value.",
-			secondary: [
-				"Declaring a variable without ever assigning it a value means it will always be `undefined`.",
-				"This is often a mistake, such as forgetting to initialize the variable or assign to it later.",
-			],
-			suggestions: [
-				"Assign a value to the variable, either at declaration or before it is used.",
-				"If the variable is meant to be `undefined`, consider making that explicit for clarity.",
-			],
-		},
-	},
-	setup(context) {
-		function hasAssignments(
-			identifier: ts.Identifier,
-			sourceFile: ts.SourceFile,
-			typeChecker: ts.TypeChecker,
-		): boolean {
-			// TODO (#400): Switch to scope analysis
-			return !!getModifyingReferences(identifier, sourceFile, typeChecker)
-				.length;
-		}
-
-		return {
-			visitors: {
-				VariableDeclaration: (node) => {
-					if (node.initializer || !ts.isIdentifier(node.name)) {
-						return;
-					}
-
-					if (
-						ts.isVariableDeclarationList(node.parent) &&
-						!!(node.parent.flags & ts.NodeFlags.Const)
-					) {
-						return;
-					}
-
-					if (
-						!hasAssignments(node.name, context.sourceFile, context.typeChecker)
-					) {
-						context.report({
-							data: {
-								name: node.name.text,
-							},
-							message: "noUnassigned",
-							range: {
-								begin: node.name.getStart(context.sourceFile),
-								end: node.name.getEnd(),
-							},
-						});
-					}
-				},
-			},
-		};
-	},
-});

package/src/rules/undefinedVariables.test.ts

@@ -1,81 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./undefinedVariables.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-console.log(undefinedVar);
-`,
-			snapshot: `
-console.log(undefinedVar);
-            ~~~~~~~~~~~~
-            Variable 'undefinedVar' is used but was never defined.
-`,
-		},
-		{
-			code: `
-function test() {
-    return notDefined;
-}
-`,
-			snapshot: `
-function test() {
-    return notDefined;
-           ~~~~~~~~~~
-           Variable 'notDefined' is used but was never defined.
-}
-`,
-		},
-		{
-			code: `
-const value = unknownVariable;
-`,
-			snapshot: `
-const value = unknownVariable;
-              ~~~~~~~~~~~~~~~
-              Variable 'unknownVariable' is used but was never defined.
-`,
-		},
-		{
-			code: `
-if (condition) {
-    doSomething();
-}
-`,
-			snapshot: `
-if (condition) {
-    ~~~~~~~~~
-    Variable 'condition' is used but was never defined.
-    doSomething();
-    ~~~~~~~~~~~
-    Variable 'doSomething' is used but was never defined.
-}
-`,
-		},
-		{
-			code: `
-const result = first + second;
-`,
-			snapshot: `
-const result = first + second;
-               ~~~~~
-               Variable 'first' is used but was never defined.
-                       ~~~~~~
-                       Variable 'second' is used but was never defined.
-`,
-		},
-	],
-	valid: [
-		`const value = 5; console.log(value);`,
-		`function test(parameter: number) { return parameter; }`,
-		`let count = 0; count++;`,
-		`const obj = { prop: 1 }; console.log(obj.prop);`,
-		`typeof undefinedVar === "undefined"`,
-		`const obj = {}; const { prop } = obj;`,
-		`function fn() { return 1; } fn();`,
-		`class MyClass {} const instance = new MyClass();`,
-		`import { value } from "module"; console.log(value);`,
-		`const array = [1, 2, 3]; array.forEach(item => console.log(item));`,
-	],
-});

package/src/rules/undefinedVariables.ts

@@ -1,97 +0,0 @@
-import * as ts from "typescript";
-
-import { typescriptLanguage } from "../language.js";
-
-export default typescriptLanguage.createRule({
-	about: {
-		description: "Reports using variables that are not defined.",
-		id: "undefinedVariables",
-		preset: "untyped",
-	},
-	messages: {
-		undefinedVariable: {
-			primary: "Variable '{{ name }}' is used but was never defined.",
-			secondary: [
-				"Variables must be declared before they can be used.",
-				"Using undefined variables will cause a ReferenceError at runtime.",
-			],
-			suggestions: [
-				"Declare the variable before using it, or check if the variable name is spelled correctly.",
-			],
-		},
-	},
-	setup(context) {
-		return {
-			visitors: {
-				Identifier: (node) => {
-					if (
-						ts.isVariableDeclaration(node.parent) &&
-						node.parent.name === node
-					) {
-						return;
-					}
-
-					if (ts.isParameter(node.parent) && node.parent.name === node) {
-						return;
-					}
-
-					if (
-						(ts.isFunctionDeclaration(node.parent) ||
-							ts.isClassDeclaration(node.parent) ||
-							ts.isInterfaceDeclaration(node.parent) ||
-							ts.isTypeAliasDeclaration(node.parent) ||
-							ts.isEnumDeclaration(node.parent) ||
-							ts.isModuleDeclaration(node.parent)) &&
-						node.parent.name === node
-					) {
-						return;
-					}
-
-					if (
-						ts.isImportSpecifier(node.parent) ||
-						ts.isImportClause(node.parent) ||
-						ts.isNamespaceImport(node.parent)
-					) {
-						return;
-					}
-
-					if (
-						ts.isPropertyAccessExpression(node.parent) &&
-						node.parent.name === node
-					) {
-						return;
-					}
-
-					if (
-						ts.isPropertyAssignment(node.parent) &&
-						node.parent.name === node
-					) {
-						return;
-					}
-
-					if (
-						ts.isTypeOfExpression(node.parent) &&
-						node.parent.expression === node
-					) {
-						return;
-					}
-
-					// TODO: This rule is untyped, so it should use scope analysis
-					// https://github.com/JoshuaKGoldberg/flint/issues/400
-					if (!context.typeChecker.getSymbolAtLocation(node)) {
-						context.report({
-							data: {
-								name: node.text,
-							},
-							message: "undefinedVariable",
-							range: {
-								begin: node.getStart(context.sourceFile),
-								end: node.getEnd(),
-							},
-						});
-					}
-				},
-			},
-		};
-	},
-});

package/src/rules/unicodeBOMs.test.ts

@@ -1,67 +0,0 @@
-// flint-disable-file invalidCodeLines -- This rule checks the first character of code files.
-import { ruleTester } from "./ruleTester.js";
-import rule from "./unicodeBOMs.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `\uFEFFconst value = 1;
-`,
-			snapshot: `\uFEFFconst value = 1;
-~
-This Unicode Byte Order Mark (BOM) is unnecessary and can cause issues with some tools.
-`,
-			suggestions: [
-				{
-					id: "removeBOM",
-					updated: `const value = 1;
-`,
-				},
-			],
-		},
-		{
-			code: `\uFEFF// Comment
-const value = 1;
-`,
-			snapshot: `\uFEFF// Comment
-~
-This Unicode Byte Order Mark (BOM) is unnecessary and can cause issues with some tools.
-const value = 1;
-`,
-			suggestions: [
-				{
-					id: "removeBOM",
-					updated: `// Comment
-const value = 1;
-`,
-				},
-			],
-		},
-		{
-			code: `\uFEFF
-const value = 1;
-`,
-			snapshot: `\uFEFF
-~
-This Unicode Byte Order Mark (BOM) is unnecessary and can cause issues with some tools.
-const value = 1;
-`,
-			suggestions: [
-				{
-					id: "removeBOM",
-					updated: `
-const value = 1;
-`,
-				},
-			],
-		},
-	],
-	valid: [
-		`const value = 1;`,
-		`// Comment at the start
-const value = 1;`,
-		`
-const value = 1;`,
-		`function test() { return 42; }`,
-	],
-});

package/src/rules/unicodeBOMs.ts

@@ -1,44 +0,0 @@
-import { typescriptLanguage } from "../language.js";
-
-export default typescriptLanguage.createRule({
-	about: {
-		description: "Reports files with Unicode Byte Order Marks (BOMs).",
-		id: "unicodeBOMs",
-		preset: "stylistic",
-	},
-	messages: {
-		noBOM: {
-			primary:
-				"This Unicode Byte Order Mark (BOM) is unnecessary and can cause issues with some tools.",
-			secondary: [
-				"The Unicode BOM is a special character (U+FEFF) that can appear at the start of a file to indicate its byte order and encoding.",
-				"While it can be useful in some contexts, it does not improve tooling portability and is not generally helpful for editors.",
-			],
-			suggestions: ["Remove the BOM from the beginning of the file."],
-		},
-	},
-	setup(context) {
-		const text = context.sourceFile.getFullText();
-		if (text.charCodeAt(0) !== 0xfeff) {
-			return {};
-		}
-
-		context.report({
-			message: "noBOM",
-			range: {
-				begin: 0,
-				end: 1,
-			},
-			suggestions: [
-				{
-					id: "removeBOM",
-					range: {
-						begin: 0,
-						end: 1,
-					},
-					text: "",
-				},
-			],
-		});
-	},
-});