@flint.fyi/ts 0.14.4 → 0.14.6

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @flint/ts
 
+## 0.14.6
+
+### Patch Changes
+
+- b789918: fix(ts): [forDirections] allow multi-part conditions
+- Updated dependencies [1bbae2e]
+- Updated dependencies [11abdff]
+  - @flint.fyi/core@0.16.0
+
+## 0.14.5
+
+### Patch Changes
+
+- 7e21021: fix(ts): [chainedAssignments] allow non-assignment right-side operators
+
 ## 0.14.4
 
 ### Patch Changes

package/lib/createTypeScriptFileFromProgram.js

@@ -37,6 +37,9 @@ export function createTypeScriptFileFromProgram(program, sourceFile) {
                 report: (report) => {
                     reports.push({
                         ...report,
+                        fix: report.fix && !Array.isArray(report.fix)
+                            ? [report.fix]
+                            : report.fix,
                         message: rule.messages[report.message],
                         range: normalizeRange(report.range, sourceFile),
                     });
@@ -53,7 +56,7 @@ export function createTypeScriptFileFromProgram(program, sourceFile) {
                 visitors[NodeSyntaxKinds[node.kind]]?.(node);
                 node.forEachChild(visit);
             };
-            sourceFile.forEachChild(visit);
+            visit(sourceFile);
             return reports;
         },
     };

package/lib/formatDiagnostic.js

@@ -92,7 +92,7 @@ function formatCodeSpan(file, start, length, indent, squiggleColor) {
                 gutterSeparator;
         context += squiggleColor;
         if (i === firstLine) {
-            const lastCharForLine = i === lastLine ? lastLineChar : void 0;
+            const lastCharForLine = i === lastLine ? lastLineChar : undefined;
             context += lineContent.slice(0, firstLineChar).replace(/\S/g, " ");
             context += lineContent
                 .slice(firstLineChar, lastCharForLine)

package/lib/index.d.ts

@@ -1,4 +1,7 @@
 export { getTSNodeRange } from "./getTSNodeRange.js";
 export * from "./language.js";
 export { ts } from "./plugin.js";
+export { getDeclarationsIfGlobal } from "./utils/getDeclarationsIfGlobal.js";
 export { isGlobalDeclaration } from "./utils/isGlobalDeclaration.js";
+export { isGlobalDeclarationOfName } from "./utils/isGlobalDeclarationOfName.js";
+export { isGlobalVariable } from "./utils/isGlobalVariable.js";

package/lib/index.js

@@ -1,4 +1,7 @@
 export { getTSNodeRange } from "./getTSNodeRange.js";
 export * from "./language.js";
 export { ts } from "./plugin.js";
+export { getDeclarationsIfGlobal } from "./utils/getDeclarationsIfGlobal.js";
 export { isGlobalDeclaration } from "./utils/isGlobalDeclaration.js";
+export { isGlobalDeclarationOfName } from "./utils/isGlobalDeclarationOfName.js";
+export { isGlobalVariable } from "./utils/isGlobalVariable.js";

package/lib/normalizeRange.js

@@ -1,16 +1,13 @@
+import { getColumnAndLineOfPosition, } from "@flint.fyi/core";
 export function normalizeRange(original, sourceFile) {
     const onCharacters = isNode(original)
         ? { begin: original.getStart(), end: original.getEnd() }
         : original;
     return {
-        begin: normalizeRangePosition(onCharacters.begin, sourceFile),
-        end: normalizeRangePosition(onCharacters.end, sourceFile),
+        begin: getColumnAndLineOfPosition(sourceFile, onCharacters.begin),
+        end: getColumnAndLineOfPosition(sourceFile, onCharacters.end),
     };
 }
 function isNode(value) {
     return typeof value === "object" && value !== null && "kind" in value;
 }
-function normalizeRangePosition(raw, sourceFile) {
-    const { character, line } = sourceFile.getLineAndCharacterOfPosition(raw);
-    return { column: character, line, raw };
-}

package/lib/plugin.d.ts

@@ -1,4 +1,4 @@
-export declare const ts: import("@flint.fyi/core").Plugin<import("@flint.fyi/core").RuleAbout, string | undefined, [import("@flint.fyi/core").Rule<{
+export declare const ts: import("@flint.fyi/core").Plugin<import("@flint.fyi/core").RuleAbout, "all", [import("@flint.fyi/core").Rule<{
     readonly description: "Reports returning a value with type `any` from a function.";
     readonly id: "anyReturns";
     readonly preset: "logical";
@@ -51,6 +51,10 @@ export declare const ts: import("@flint.fyi/core").Plugin<import("@flint.fyi/cor
     readonly id: "elseIfDuplicates";
     readonly preset: "logical";
 }, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "duplicateCondition", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports empty block statements that should contain code.";
+    readonly id: "emptyBlocks";
+    readonly preset: "stylistic";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "emptyBlock", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports using empty destructuring patterns that destructure no values.";
     readonly id: "emptyDestructures";
     readonly preset: "logical";
@@ -146,6 +150,10 @@ export declare const ts: import("@flint.fyi/core").Plugin<import("@flint.fyi/cor
     readonly id: "sequences";
     readonly preset: "untyped";
 }, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noSequences", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports variable declarations that shadow JavaScript's restricted names.";
+    readonly id: "shadowedRestrictedNames";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "shadowedRestrictedName", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports array literals with holes (sparse arrays).";
     readonly id: "sparseArrays";
     readonly preset: "logical";
@@ -170,10 +178,18 @@ export declare const ts: import("@flint.fyi/core").Plugin<import("@flint.fyi/cor
     readonly id: "unicodeBOMs";
     readonly preset: "stylistic";
 }, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noBOM", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports standalone block statements that don't create a meaningful scope.";
+    readonly id: "unnecessaryBlocks";
+    readonly preset: "stylistic";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "unnecessaryBlock", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports catch clauses that only rethrow the caught error without modification.";
     readonly id: "unnecessaryCatches";
     readonly preset: "logical";
 }, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "unnecessaryCatch", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports string concatenation using the + operator when both operands are string literals.";
+    readonly id: "unnecessaryConcatenation";
+    readonly preset: "stylistic";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "unnecessaryConcatenation", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports negating the left operand of `in` or `instanceof` relations.";
     readonly id: "unsafeNegations";
     readonly preset: "untyped";

package/lib/plugin.js

@@ -12,6 +12,7 @@ import debuggerStatements from "./rules/debuggerStatements.js";
 import defaultCaseLast from "./rules/defaultCaseLast.js";
 import duplicateArguments from "./rules/duplicateArguments.js";
 import elseIfDuplicates from "./rules/elseIfDuplicates.js";
+import emptyBlocks from "./rules/emptyBlocks.js";
 import emptyDestructures from "./rules/emptyDestructures.js";
 import emptyStaticBlocks from "./rules/emptyStaticBlocks.js";
 import exceptionAssignments from "./rules/exceptionAssignments.js";
@@ -35,13 +36,16 @@ import returnAssignments from "./rules/returnAssignments.js";
 import selfAssignments from "./rules/selfAssignments.js";
 import selfComparisons from "./rules/selfComparisons.js";
 import sequences from "./rules/sequences.js";
+import shadowedRestrictedNames from "./rules/shadowedRestrictedNames.js";
 import sparseArrays from "./rules/sparseArrays.js";
 import symbolDescriptions from "./rules/symbolDescriptions.js";
 import typeofComparisons from "./rules/typeofComparisons.js";
 import unassignedVariables from "./rules/unassignedVariables.js";
 import undefinedVariables from "./rules/undefinedVariables.js";
 import unicodeBOMs from "./rules/unicodeBOMs.js";
+import unnecessaryBlocks from "./rules/unnecessaryBlocks.js";
 import unnecessaryCatches from "./rules/unnecessaryCatches.js";
+import unnecessaryConcatenation from "./rules/unnecessaryConcatenation.js";
 import unsafeNegations from "./rules/unsafeNegations.js";
 import variableDeletions from "./rules/variableDeletions.js";
 import voidOperator from "./rules/voidOperator.js";
@@ -49,7 +53,7 @@ export const ts = createPlugin({
     files: {
         all: ["**/*.{cjs,js,jsx,mjs,ts,tsx}"],
     },
-    name: "ts",
+    name: "TypeScript",
     rules: [
         anyReturns,
         asyncPromiseExecutors,
@@ -64,6 +68,7 @@ export const ts = createPlugin({
         defaultCaseLast,
         duplicateArguments,
         elseIfDuplicates,
+        emptyBlocks,
         emptyDestructures,
         emptyStaticBlocks,
         exceptionAssignments,
@@ -87,13 +92,16 @@ export const ts = createPlugin({
         selfAssignments,
         selfComparisons,
         sequences,
+        shadowedRestrictedNames,
         sparseArrays,
         symbolDescriptions,
         typeofComparisons,
         unassignedVariables,
         undefinedVariables,
         unicodeBOMs,
+        unnecessaryBlocks,
         unnecessaryCatches,
+        unnecessaryConcatenation,
         unsafeNegations,
         variableDeletions,
         voidOperator,

package/lib/rules/chainedAssignments.js

@@ -30,7 +30,8 @@ export default typescriptLanguage.createRule({
                         return;
                     }
                     const rightSide = unwrapParenthesizedExpression(node.right);
-                    if (!ts.isBinaryExpression(rightSide)) {
+                    if (!ts.isBinaryExpression(rightSide) ||
+                        !tsutils.isAssignmentKind(rightSide.operatorToken.kind)) {
                         return;
                     }
                     const parent = unwrapParenthesizedExpressionsParent(node);

package/lib/rules/chainedAssignments.test.js

@@ -233,6 +233,30 @@ class MyClass {
         second = 0;
     }
 }
+`,
+        `
+let result = "";
+result += "a" + "b";
+`,
+        `
+let result = 0;
+result += 1 + 2;
+`,
+        `
+let result = 0;
+result += 1 * 2;
+`,
+        `
+let result = 0;
+result += 1 - 2;
+`,
+        `
+let result = 0;
+result += 1 / 2;
+`,
+        `
+let result = 0;
+result += 1 ** 2;
 `,
     ],
 });

package/lib/rules/debuggerStatements.test.js

@@ -29,8 +29,8 @@ function test() {
             snapshot: `
 function test() {
 	debugger;
- ~~~~~~~~~
- Debugger statements should not be used in production code.
+	~~~~~~~~~
+	Debugger statements should not be used in production code.
 }
 `,
             suggestions: [
@@ -53,8 +53,8 @@ if (condition) {
             snapshot: `
 if (condition) {
 	debugger;
- ~~~~~~~~~
- Debugger statements should not be used in production code.
+	~~~~~~~~~
+	Debugger statements should not be used in production code.
 }
 `,
             suggestions: [

package/lib/rules/emptyBlocks.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports empty block statements that should contain code.";
+    readonly id: "emptyBlocks";
+    readonly preset: "stylistic";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "emptyBlock", undefined>;
+export default _default;

package/lib/rules/emptyBlocks.js

@@ -0,0 +1,66 @@
+import * as ts from "typescript";
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+const allowedParents = new Set([
+    ts.SyntaxKind.ArrowFunction,
+    ts.SyntaxKind.CatchClause,
+    ts.SyntaxKind.Constructor,
+    ts.SyntaxKind.FunctionDeclaration,
+    ts.SyntaxKind.FunctionExpression,
+    ts.SyntaxKind.GetAccessor,
+    ts.SyntaxKind.MethodDeclaration,
+    ts.SyntaxKind.SetAccessor,
+]);
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports empty block statements that should contain code.",
+        id: "emptyBlocks",
+        preset: "stylistic",
+    },
+    messages: {
+        emptyBlock: {
+            primary: "Empty block statements should be removed or contain code.",
+            secondary: [
+                "Empty blocks can indicate incomplete code or areas where logic was removed but the block structure was left behind.",
+                "They can also reduce code readability by cluttering the codebase with unnecessary braces.",
+            ],
+            suggestions: [
+                "Add a comment explaining why the block is intentionally empty, or remove the empty block entirely.",
+            ],
+        },
+    },
+    setup(context) {
+        function hasComments(block) {
+            const fullText = context.sourceFile.getFullText();
+            const openBrace = block.getStart(context.sourceFile);
+            const closeBrace = block.getEnd();
+            const innerText = fullText.substring(openBrace + 1, closeBrace - 1);
+            // Check if there are any non-whitespace characters (which would be comments)
+            // since we already know there are no statements
+            return /\S+/.test(innerText.trim());
+        }
+        function isEmptyBlock(block) {
+            return block.statements.length === 0 && !hasComments(block);
+        }
+        return {
+            visitors: {
+                Block: (node) => {
+                    if (!allowedParents.has(node.parent.kind) && isEmptyBlock(node)) {
+                        context.report({
+                            message: "emptyBlock",
+                            range: getTSNodeRange(node, context.sourceFile),
+                        });
+                    }
+                },
+                CaseBlock: (node) => {
+                    if (node.clauses.length === 0) {
+                        context.report({
+                            message: "emptyBlock",
+                            range: getTSNodeRange(node, context.sourceFile),
+                        });
+                    }
+                },
+            },
+        };
+    },
+});

package/lib/rules/emptyBlocks.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/rules/emptyBlocks.test.js

@@ -0,0 +1,135 @@
+import rule from "./emptyBlocks.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+if (condition) {}
+`,
+            snapshot: `
+if (condition) {}
+               ~~
+               Empty block statements should be removed or contain code.
+`,
+        },
+        {
+            code: `
+if (condition) {
+} else {}
+`,
+            snapshot: `
+if (condition) {
+               ~
+               Empty block statements should be removed or contain code.
+} else {}
+~
+       ~~
+       Empty block statements should be removed or contain code.
+`,
+        },
+        {
+            code: `
+while (condition) {}
+`,
+            snapshot: `
+while (condition) {}
+                  ~~
+                  Empty block statements should be removed or contain code.
+`,
+        },
+        {
+            code: `
+for (let i = 0; i < 10; i++) {}
+`,
+            snapshot: `
+for (let i = 0; i < 10; i++) {}
+                             ~~
+                             Empty block statements should be removed or contain code.
+`,
+        },
+        {
+            code: `
+switch (value) {}
+`,
+            snapshot: `
+switch (value) {}
+               ~~
+               Empty block statements should be removed or contain code.
+`,
+        },
+        {
+            code: `
+do {} while (condition);
+`,
+            snapshot: `
+do {} while (condition);
+   ~~
+   Empty block statements should be removed or contain code.
+`,
+        },
+        {
+            code: `
+if (x) {
+    doSomething();
+} else if (y) {}
+`,
+            snapshot: `
+if (x) {
+    doSomething();
+} else if (y) {}
+              ~~
+              Empty block statements should be removed or contain code.
+`,
+        },
+        {
+            code: `
+try {
+    doSomething();
+} finally {}
+`,
+            snapshot: `
+try {
+    doSomething();
+} finally {}
+          ~~
+          Empty block statements should be removed or contain code.
+`,
+        },
+    ],
+    valid: [
+        `if (condition) { doSomething(); }`,
+        `while (condition) { doSomething(); }`,
+        `for (let i = 0; i < 10; i++) { doSomething(); }`,
+        `switch (value) { case 1: break; }`,
+        `do { doSomething(); } while (condition);`,
+        `function test() {}`,
+        `const fn = function() {};`,
+        `const arrow = () => {};`,
+        `class MyClass { method() {} }`,
+        `class MyClass { constructor() {} }`,
+        `class MyClass { get value() {} }`,
+        `class MyClass { set value(v) {} }`,
+        `
+if (condition) {
+    // Intentionally empty
+}
+`,
+        `
+while (condition) {
+    /* Do nothing */
+}
+`,
+        `
+try {
+    doSomething();
+} catch (error) {}
+`,
+        `
+try {
+    doSomething();
+} catch (error) {
+    // Ignore errors
+}
+`,
+    ],
+});

package/lib/rules/forDirections.js

@@ -7,6 +7,13 @@ function getConditionDirection(condition, counterName) {
     }
     const leftName = getCounterName(condition.left);
     const rightName = getCounterName(condition.right);
+    if (!leftName && !rightName) {
+        return condition.operatorToken.kind ===
+            ts.SyntaxKind.AmpersandAmpersandToken
+            ? (getConditionDirection(condition.left, counterName) ??
+                getConditionDirection(condition.right, counterName))
+            : undefined;
+    }
     const isCounterLeft = leftName === counterName;
     const isCounterRight = rightName === counterName;
     if (!isCounterLeft && !isCounterRight) {
@@ -38,10 +45,10 @@ function getConditionDirection(condition, counterName) {
 function getCounterName(node) {
     return ts.isIdentifier(node) ? node.text : undefined;
 }
-function getUpdateDirection(update) {
-    if (ts.isPostfixUnaryExpression(update) ||
-        ts.isPrefixUnaryExpression(update)) {
-        switch (update.operator) {
+function getIncrementorDirection(incrementor) {
+    if (ts.isPostfixUnaryExpression(incrementor) ||
+        ts.isPrefixUnaryExpression(incrementor)) {
+        switch (incrementor.operator) {
             case ts.SyntaxKind.MinusMinusToken:
                 return -1;
             case ts.SyntaxKind.PlusPlusToken:
@@ -50,8 +57,8 @@ function getUpdateDirection(update) {
                 return undefined;
         }
     }
-    if (ts.isBinaryExpression(update)) {
-        const { operatorToken, right } = update;
+    if (ts.isBinaryExpression(incrementor)) {
+        const { operatorToken, right } = incrementor;
         if (operatorToken.kind === ts.SyntaxKind.PlusEqualsToken ||
             operatorToken.kind === ts.SyntaxKind.MinusEqualsToken) {
             if (ts.isNumericLiteral(right)) {
@@ -106,12 +113,12 @@ export default typescriptLanguage.createRule({
                     if (!declaration || !ts.isIdentifier(declaration.name)) {
                         return;
                     }
-                    const updateDirection = getUpdateDirection(node.incrementor);
+                    const updateDirection = getIncrementorDirection(node.incrementor);
                     if (!updateDirection) {
                         return;
                     }
                     const conditionDirection = getConditionDirection(node.condition, declaration.name.text);
-                    if (updateDirection !== conditionDirection) {
+                    if (conditionDirection && conditionDirection !== updateDirection) {
                         context.report({
                             message: "wrongDirection",
                             range: getTSNodeRange(node.incrementor, context.sourceFile),

package/lib/rules/forDirections.test.js

@@ -80,6 +80,30 @@ for (let index = 0; index < 10; index += -1) {}
 for (let index = 0; index < 10; index += -1) {}
                                 ~~~~~~~~~~~
                                 The update moves the counter in the wrong direction for this loop condition.
+`,
+        },
+        {
+            code: `
+declare context text: string;
+for (let i = 10; i >= 0 && text[i] !== " "; i++) { }
+`,
+            snapshot: `
+declare context text: string;
+for (let i = 10; i >= 0 && text[i] !== " "; i++) { }
+                                            ~~~
+                                            The update moves the counter in the wrong direction for this loop condition.
+`,
+        },
+        {
+            code: `
+declare context text: string;
+for (let i = 10; text[i] !== " " && i >= 0; i++) { }
+`,
+            snapshot: `
+declare context text: string;
+for (let i = 10; text[i] !== " " && i >= 0; i++) { }
+                                            ~~~
+                                            The update moves the counter in the wrong direction for this loop condition.
 `,
         },
     ],
@@ -95,5 +119,6 @@ for (let index = 0; index < 10; index += -1) {}
         `for (let index = 10; index > 0; index -= 1) { }`,
         `for (let index = 0; index < 10; index += 2) { }`,
         `for (let index = 10; index > 0; index -= 2) { }`,
+        `for (let i = 10; i >= 0 && text[i] === "\\"; i--) { }`,
     ],
 });

package/lib/rules/octalNumbers.test.js

@@ -159,8 +159,8 @@ function calculate() {
             snapshot: `
 function calculate() {
 	return 077;
-        ~~~
-        This legacy octal numeric literal evaluates to 63. Did you mean that value, or to use a modern octal syntax such as 0o77?
+	       ~~~
+	       This legacy octal numeric literal evaluates to 63. Did you mean that value, or to use a modern octal syntax such as 0o77?
 }
 `,
             suggestions: [

package/lib/rules/shadowedRestrictedNames.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports variable declarations that shadow JavaScript's restricted names.";
+    readonly id: "shadowedRestrictedNames";
+    readonly preset: "untyped";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "shadowedRestrictedName", undefined>;
+export default _default;