@flint.fyi/ts 0.14.6 → 0.18.0

package/src/rules/generatorFunctionYields.test.ts

@@ -1,152 +0,0 @@
-import rule from "./generatorFunctionYields.js";
-import { ruleTester } from "./ruleTester.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-function* emptyGenerator() {
-    console.log("No yield here");
-}
-`,
-			snapshot: `
-function* emptyGenerator() {
-        ~
-        Generator functions must contain at least one yield expression to produce values.
-    console.log("No yield here");
-}
-`,
-		},
-		{
-			code: `
-const generator = function* () {
-    return 42;
-};
-`,
-			snapshot: `
-const generator = function* () {
-                          ~
-                          Generator functions must contain at least one yield expression to produce values.
-    return 42;
-};
-`,
-		},
-		{
-			code: `
-class MyClass {
-    *generatorMethod() {
-        this.doSomething();
-    }
-}
-`,
-			snapshot: `
-class MyClass {
-    *generatorMethod() {
-    ~
-    Generator functions must contain at least one yield expression to produce values.
-        this.doSomething();
-    }
-}
-`,
-		},
-		{
-			code: `
-function* generatorWithNestedFunction() {
-    function inner() {
-        yield 42;
-    }
-}
-`,
-			snapshot: `
-function* generatorWithNestedFunction() {
-        ~
-        Generator functions must contain at least one yield expression to produce values.
-    function inner() {
-        yield 42;
-    }
-}
-`,
-		},
-		{
-			code: `
-function* generatorWithNestedGeneratorFunction() {
-    function* inner() {
-        yield 42;
-    }
-}
-`,
-			snapshot: `
-function* generatorWithNestedGeneratorFunction() {
-        ~
-        Generator functions must contain at least one yield expression to produce values.
-    function* inner() {
-        yield 42;
-    }
-}
-`,
-		},
-	],
-	valid: [
-		`
-function* validGenerator() {
-    yield 1;
-}
-`,
-		`
-function* validGeneratorMultiple() {
-    yield 1;
-    yield 2;
-    yield 3;
-}
-`,
-		`
-const generator = function* () {
-    yield 42;
-};
-`,
-		`
-class MyClass {
-    *generatorMethod() {
-        yield this.value;
-    }
-}
-`,
-		`
-function* conditionalYield(condition: boolean) {
-    if (condition) {
-        yield 1;
-    }
-}
-`,
-		`
-function* yieldInLoop() {
-    for (let i = 0; i < 10; i++) {
-        yield i;
-    }
-}
-`,
-		`
-function* yieldDelegate() {
-    yield* [1, 2, 3];
-}
-`,
-		`
-function regularFunction() {
-    return 42;
-}
-`,
-		`
-const arrow = () => {
-    return 42;
-};
-`,
-		`
-function* generatorWithNestedGenerator() {
-    yield 1;
-    function* inner() {
-        yield 2;
-    }
-}
-`,
-	],
-});

package/src/rules/generatorFunctionYields.ts

@@ -1,71 +0,0 @@
-import * as tsutils from "ts-api-utils";
-import * as ts from "typescript";
-
-import { typescriptLanguage } from "../language.js";
-
-export default typescriptLanguage.createRule({
-	about: {
-		description: "Reports generator functions that do not yield values.",
-		id: "generatorFunctionYields",
-		preset: "logical",
-	},
-	messages: {
-		missingYield: {
-			primary:
-				"Generator functions must contain at least one yield expression to produce values.",
-			secondary: [
-				"Generator functions use the `function*` syntax to create iterators that can produce multiple values over time.",
-				"Without a yield expression, the generator will not produce any values and behaves like an empty iterator.",
-				"This is likely unintentional and indicates incomplete implementation or a misunderstanding of generator functions.",
-			],
-			suggestions: [
-				"Add a `yield` expression to produce values from the generator.",
-				"If the function should not be a generator, remove the asterisk (`*`) from the function declaration.",
-			],
-		},
-	},
-	setup(context) {
-		return {
-			visitors: {
-				FunctionDeclaration: checkFunction,
-				FunctionExpression: checkFunction,
-				MethodDeclaration: checkFunction,
-			},
-		};
-
-		function checkFunction(
-			node:
-				| ts.FunctionDeclaration
-				| ts.FunctionExpression
-				| ts.MethodDeclaration,
-		): void {
-			if (!node.asteriskToken || !node.body || blockContainsYield(node.body)) {
-				return;
-			}
-
-			context.report({
-				message: "missingYield",
-				range: {
-					begin: node.asteriskToken.getStart(context.sourceFile),
-					end: node.asteriskToken.getEnd(),
-				},
-			});
-		}
-	},
-});
-
-function blockContainsYield(block: ts.Block) {
-	function checkForYield(node: ts.Node): boolean | undefined {
-		if (ts.isYieldExpression(node)) {
-			return true;
-		}
-
-		if (tsutils.isFunctionScopeBoundary(node)) {
-			return false;
-		}
-
-		return ts.forEachChild(node, checkForYield);
-	}
-
-	return ts.forEachChild(block, checkForYield);
-}

package/src/rules/globalAssignments.test.ts

@@ -1,216 +0,0 @@
-import rule from "./globalAssignments.js";
-import { ruleTester } from "./ruleTester.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-undefined = 1;
-`,
-			snapshot: `
-undefined = 1;
-~~~~~~~~~
-Read-only global variables should not be reassigned or modified.
-`,
-		},
-		{
-			code: `
-NaN = 42;
-`,
-			snapshot: `
-NaN = 42;
-~~~
-Read-only global variables should not be reassigned or modified.
-`,
-		},
-		{
-			code: `
-Infinity = 100;
-`,
-			snapshot: `
-Infinity = 100;
-~~~~~~~~
-Read-only global variables should not be reassigned or modified.
-`,
-		},
-		{
-			code: `
-Object = null;
-`,
-			snapshot: `
-Object = null;
-~~~~~~
-Read-only global variables should not be reassigned or modified.
-`,
-		},
-		{
-			code: `
-Array = function() {};
-`,
-			snapshot: `
-Array = function() {};
-~~~~~
-Read-only global variables should not be reassigned or modified.
-`,
-		},
-		{
-			code: `
-String = "test";
-`,
-			snapshot: `
-String = "test";
-~~~~~~
-Read-only global variables should not be reassigned or modified.
-`,
-		},
-		{
-			code: `
-Number = 123;
-`,
-			snapshot: `
-Number = 123;
-~~~~~~
-Read-only global variables should not be reassigned or modified.
-`,
-		},
-		{
-			code: `
-Boolean = true;
-`,
-			snapshot: `
-Boolean = true;
-~~~~~~~
-Read-only global variables should not be reassigned or modified.
-`,
-		},
-		{
-			code: `
-Math = {};
-`,
-			snapshot: `
-Math = {};
-~~~~
-Read-only global variables should not be reassigned or modified.
-`,
-		},
-		{
-			code: `
-JSON = null;
-`,
-			snapshot: `
-JSON = null;
-~~~~
-Read-only global variables should not be reassigned or modified.
-`,
-		},
-		{
-			code: `
-window = {};
-`,
-			snapshot: `
-window = {};
-~~~~~~
-Read-only global variables should not be reassigned or modified.
-`,
-		},
-		{
-			code: `
-undefined += 1;
-`,
-			snapshot: `
-undefined += 1;
-~~~~~~~~~
-Read-only global variables should not be reassigned or modified.
-`,
-		},
-		{
-			code: `
-NaN *= 2;
-`,
-			snapshot: `
-NaN *= 2;
-~~~
-Read-only global variables should not be reassigned or modified.
-`,
-		},
-		{
-			code: `
-++undefined;
-`,
-			snapshot: `
-++undefined;
-  ~~~~~~~~~
-  Read-only global variables should not be reassigned or modified.
-`,
-		},
-		{
-			code: `
-NaN++;
-`,
-			snapshot: `
-NaN++;
-~~~
-Read-only global variables should not be reassigned or modified.
-`,
-		},
-		{
-			code: `
---Infinity;
-`,
-			snapshot: `
---Infinity;
-  ~~~~~~~~
-  Read-only global variables should not be reassigned or modified.
-`,
-		},
-		{
-			code: `
-Object--;
-`,
-			snapshot: `
-Object--;
-~~~~~~
-Read-only global variables should not be reassigned or modified.
-`,
-		},
-	],
-	valid: [
-		`let undefined = 1;`,
-		`const NaN = 42;`,
-		`var Infinity = 100;`,
-		`function Object() {}`,
-		`let value = undefined;`,
-		`const result = NaN;`,
-		`if (value === undefined) {}`,
-		`const obj = { undefined: 1 };`,
-		`obj.undefined = 2;`,
-		`const custom = { NaN: 42 }; custom.NaN = 100;`,
-		`let myVar = 5; myVar = 10;`,
-		`const data = { value: 1 }; data.value = 2;`,
-		`let counter = 0; counter++;`,
-		`let index = 10; --index;`,
-		`
-function test() {
-    let undefined = 5;
-    undefined = 10;
-}
-`,
-		`
-const obj = {
-    undefined: 1,
-    NaN: 2,
-};
-obj.undefined = 5;
-`,
-		`
-const fn = (undefined: number) => {
-    undefined = 10;
-};
-`,
-		`
-function test(NaN: string) {
-    NaN = "updated";
-}
-`,
-	],
-});

package/src/rules/globalAssignments.ts

@@ -1,67 +0,0 @@
-import * as tsutils from "ts-api-utils";
-import * as ts from "typescript";
-
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-import { isGlobalVariable } from "../utils/isGlobalVariable.js";
-
-export default typescriptLanguage.createRule({
-	about: {
-		description:
-			"Reports attempting to assign to read-only global variables such as undefined, NaN, Infinity, Object, etc.",
-		id: "globalAssignments",
-		preset: "untyped",
-	},
-	messages: {
-		noGlobalAssign: {
-			primary:
-				"Read-only global variables should not be reassigned or modified.",
-			secondary: [
-				"Global variables like undefined, NaN, Infinity, and built-in objects like Object and Array are read-only and should not be modified.",
-				"Attempting to reassign these globals can lead to confusing behavior and potential bugs in your code.",
-				"In strict mode, reassigning these globals will throw a TypeError at runtime.",
-			],
-			suggestions: [
-				"Use a different variable name instead of shadowing or reassigning globals.",
-				"If you need a similar name, consider using a more specific name that doesn't conflict with global variables.",
-			],
-		},
-	},
-	setup(context) {
-		return {
-			visitors: {
-				BinaryExpression: (node) => {
-					if (
-						tsutils.isAssignmentKind(node.operatorToken.kind) &&
-						isGlobalVariable(node.left, context.typeChecker)
-					) {
-						context.report({
-							message: "noGlobalAssign",
-							range: getTSNodeRange(node.left, context.sourceFile),
-						});
-					}
-				},
-				PostfixUnaryExpression: (node) => {
-					if (isGlobalVariable(node.operand, context.typeChecker)) {
-						context.report({
-							message: "noGlobalAssign",
-							range: getTSNodeRange(node.operand, context.sourceFile),
-						});
-					}
-				},
-				PrefixUnaryExpression: (node) => {
-					if (
-						(node.operator === ts.SyntaxKind.PlusPlusToken ||
-							node.operator === ts.SyntaxKind.MinusMinusToken) &&
-						isGlobalVariable(node.operand, context.typeChecker)
-					) {
-						context.report({
-							message: "noGlobalAssign",
-							range: getTSNodeRange(node.operand, context.sourceFile),
-						});
-					}
-				},
-			},
-		};
-	},
-});

package/src/rules/globalObjectCalls.test.ts

@@ -1,94 +0,0 @@
-import rule from "./globalObjectCalls.js";
-import { ruleTester } from "./ruleTester.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-const result = Math();
-`,
-			snapshot: `
-const result = Math();
-               ~~~~
-               Math is not a function and cannot be called directly.
-`,
-		},
-		{
-			code: `
-const data = JSON();
-`,
-			snapshot: `
-const data = JSON();
-             ~~~~
-             JSON is not a function and cannot be called directly.
-`,
-		},
-		{
-			code: `
-const reflected = Reflect();
-`,
-			snapshot: `
-const reflected = Reflect();
-                  ~~~~~~~
-                  Reflect is not a function and cannot be called directly.
-`,
-		},
-		{
-			code: `
-const atomic = Atomics();
-`,
-			snapshot: `
-const atomic = Atomics();
-               ~~~~~~~
-               Atomics is not a function and cannot be called directly.
-`,
-		},
-		{
-			code: `
-const instance = new Math();
-`,
-			snapshot: `
-const instance = new Math();
-                     ~~~~
-                     Math is not a function and cannot be called directly.
-`,
-		},
-		{
-			code: `
-const instance = new JSON();
-`,
-			snapshot: `
-const instance = new JSON();
-                     ~~~~
-                     JSON is not a function and cannot be called directly.
-`,
-		},
-		{
-			code: `
-const instance = new Reflect();
-`,
-			snapshot: `
-const instance = new Reflect();
-                     ~~~~~~~
-                     Reflect is not a function and cannot be called directly.
-`,
-		},
-		{
-			code: `
-const instance = new Atomics();
-`,
-			snapshot: `
-const instance = new Atomics();
-                     ~~~~~~~
-                     Atomics is not a function and cannot be called directly.
-`,
-		},
-	],
-	valid: [
-		`const value = Math.abs(-5);`,
-		`const parsed = JSON.parse("{}");`,
-		`const stringified = JSON.stringify({});`,
-		`const keys = Reflect.ownKeys({});`,
-		`const result = Atomics.add(buffer, 0, 1);`,
-	],
-});

package/src/rules/globalObjectCalls.ts

@@ -1,52 +0,0 @@
-import * as ts from "typescript";
-
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-
-const globalObjects = new Set(["Atomics", "JSON", "Math", "Reflect"]);
-
-export default typescriptLanguage.createRule({
-	about: {
-		description:
-			"Reports calling global objects like Math, JSON, or Reflect as functions.",
-		id: "globalObjectCalls",
-		preset: "untyped",
-	},
-	messages: {
-		noGlobalObjectCall: {
-			primary: "{{ name }} is not a function and cannot be called directly.",
-			secondary: [
-				"{{ name }} is a built-in global object that provides utility methods and properties.",
-				"It is not a constructor or function and cannot be called or instantiated.",
-			],
-			suggestions: [
-				"Use the static methods available on {{ name }} instead (e.g., {{ name }}.methodName()).",
-			],
-		},
-	},
-	setup(context) {
-		function reportGlobalObjectCall(
-			expression: ts.Expression,
-			name: string,
-		): void {
-			context.report({
-				data: { name },
-				message: "noGlobalObjectCall",
-				range: getTSNodeRange(expression, context.sourceFile),
-			});
-		}
-
-		function checkNode({ expression }: ts.CallExpression | ts.NewExpression) {
-			if (ts.isIdentifier(expression) && globalObjects.has(expression.text)) {
-				reportGlobalObjectCall(expression, expression.text);
-			}
-		}
-
-		return {
-			visitors: {
-				CallExpression: checkNode,
-				NewExpression: checkNode,
-			},
-		};
-	},
-});

package/src/rules/namespaceDeclarations.test.ts

@@ -1,41 +0,0 @@
-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 },
-		},
-	],
-});