@flint.fyi/ts 0.14.5 → 0.15.0

package/lib/rules/asyncPromiseExecutors.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports using async functions as Promise executor functions.";
     readonly id: "asyncPromiseExecutors";
     readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "asyncPromiseExecutor", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "asyncPromiseExecutor", undefined>;
 export default _default;
+//# sourceMappingURL=asyncPromiseExecutors.d.ts.map

package/lib/rules/asyncPromiseExecutors.js

@@ -24,8 +24,8 @@ export default typescriptLanguage.createRule({
     setup(context) {
         return {
             visitors: {
-                NewExpression: (node) => {
-                    if (!isGlobalDeclaration(node.expression, context.typeChecker) ||
+                NewExpression: (node, { sourceFile, typeChecker }) => {
+                    if (!isGlobalDeclaration(node.expression, typeChecker) ||
                         !node.arguments?.length) {
                         return;
                     }
@@ -40,7 +40,7 @@ export default typescriptLanguage.createRule({
                     context.report({
                         message: "asyncPromiseExecutor",
                         range: {
-                            begin: asyncModifier.getStart(context.sourceFile),
+                            begin: asyncModifier.getStart(sourceFile),
                             end: asyncModifier.getEnd(),
                         },
                     });
@@ -49,3 +49,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=asyncPromiseExecutors.js.map

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=asyncPromiseExecutors.test.d.ts.map

package/lib/rules/asyncPromiseExecutors.test.js

@@ -69,3 +69,4 @@ new SomethingElse(async (resolve) => {
 `,
     ],
 });
+//# sourceMappingURL=asyncPromiseExecutors.test.js.map

package/lib/rules/caseDeclarations.d.ts

@@ -1,6 +1,8 @@
+import { TypeScriptFileServices } from "../language.js";
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports lexical declarations in case clauses without wrapping them in blocks.";
     readonly id: "caseDeclarations";
     readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "unexpectedLexicalDeclaration", undefined>;
+}, import("../nodes.js").TSNodesByName, TypeScriptFileServices, "unexpectedLexicalDeclaration", undefined>;
 export default _default;
+//# sourceMappingURL=caseDeclarations.d.ts.map

package/lib/rules/caseDeclarations.js

@@ -21,25 +21,25 @@ export default typescriptLanguage.createRule({
         },
     },
     setup(context) {
-        function getLexicalDeclaration(statements) {
+        function getLexicalDeclaration(statements, sourceFile) {
             for (const statement of statements) {
                 if (ts.isVariableStatement(statement) &&
                     tsutils.isNodeFlagSet(statement.declarationList, ts.NodeFlags.Let | ts.NodeFlags.Const)) {
-                    return statement.declarationList.getChildAt(0, context.sourceFile);
+                    return statement.declarationList.getChildAt(0, sourceFile);
                 }
                 if (ts.isClassDeclaration(statement) ||
                     ts.isFunctionDeclaration(statement)) {
-                    return statement.getChildAt(0, context.sourceFile);
+                    return statement.getChildAt(0, sourceFile);
                 }
             }
             return undefined;
         }
-        function checkClause(node) {
-            const declarationNode = getLexicalDeclaration(node.statements);
+        function checkClause(node, { sourceFile }) {
+            const declarationNode = getLexicalDeclaration(node.statements, sourceFile);
             if (declarationNode) {
                 context.report({
                     message: "unexpectedLexicalDeclaration",
-                    range: getTSNodeRange(declarationNode, context.sourceFile),
+                    range: getTSNodeRange(declarationNode, sourceFile),
                 });
             }
         }
@@ -51,3 +51,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=caseDeclarations.js.map

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=caseDeclarations.test.d.ts.map

package/lib/rules/caseDeclarations.test.js

@@ -225,3 +225,4 @@ switch (value) {
 `,
     ],
 });
+//# sourceMappingURL=caseDeclarations.test.js.map

package/lib/rules/caseDuplicates.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports switch statements with duplicate case clause test expressions.";
     readonly id: "caseDuplicates";
     readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "duplicateCase", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "duplicateCase", undefined>;
 export default _default;
+//# sourceMappingURL=caseDuplicates.d.ts.map

package/lib/rules/caseDuplicates.js

@@ -22,18 +22,18 @@ export default typescriptLanguage.createRule({
     setup(context) {
         return {
             visitors: {
-                SwitchStatement: (node) => {
+                SwitchStatement: (node, { sourceFile }) => {
                     const seenCases = [];
                     for (const clause of node.caseBlock.clauses) {
                         if (!ts.isCaseClause(clause)) {
                             continue;
                         }
-                        const isDuplicate = seenCases.some((seenCase) => hasSameTokens(seenCase, clause.expression, context.sourceFile));
+                        const isDuplicate = seenCases.some((seenCase) => hasSameTokens(seenCase, clause.expression, sourceFile));
                         if (isDuplicate) {
                             context.report({
                                 message: "duplicateCase",
                                 range: {
-                                    begin: clause.getStart(context.sourceFile),
+                                    begin: clause.getStart(sourceFile),
                                     end: clause.expression.getEnd(),
                                 },
                             });
@@ -47,3 +47,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=caseDuplicates.js.map

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=caseDuplicates.test.d.ts.map

package/lib/rules/caseDuplicates.test.js

@@ -305,3 +305,4 @@ const result = (input: number) => {
 `,
     ],
 });
+//# sourceMappingURL=caseDuplicates.test.js.map

package/lib/rules/chainedAssignments.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports using chained assignment expressions (e.g., a = b = c).";
     readonly id: "chainedAssignments";
     readonly preset: "stylistic";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noChainedAssignment", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "noChainedAssignment", undefined>;
 export default _default;
+//# sourceMappingURL=chainedAssignments.d.ts.map

package/lib/rules/chainedAssignments.js

@@ -25,7 +25,7 @@ export default typescriptLanguage.createRule({
     setup(context) {
         return {
             visitors: {
-                BinaryExpression: (node) => {
+                BinaryExpression: (node, { sourceFile }) => {
                     if (!tsutils.isAssignmentKind(node.operatorToken.kind)) {
                         return;
                     }
@@ -40,10 +40,11 @@ export default typescriptLanguage.createRule({
                     }
                     context.report({
                         message: "noChainedAssignment",
-                        range: getTSNodeRange(node.operatorToken, context.sourceFile),
+                        range: getTSNodeRange(node.operatorToken, sourceFile),
                     });
                 },
             },
         };
     },
 });
+//# sourceMappingURL=chainedAssignments.js.map

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=chainedAssignments.test.d.ts.map

package/lib/rules/chainedAssignments.test.js

@@ -260,3 +260,4 @@ result += 1 ** 2;
 `,
     ],
 });
+//# sourceMappingURL=chainedAssignments.test.js.map

package/lib/rules/classAssignments.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports reassigning class declarations.";
     readonly id: "classAssignments";
     readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noClassAssign", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "noClassAssign", undefined>;
 export default _default;
+//# sourceMappingURL=classAssignments.d.ts.map

package/lib/rules/classAssignments.js

@@ -21,16 +21,16 @@ export default typescriptLanguage.createRule({
     setup(context) {
         return {
             visitors: {
-                ClassDeclaration: (node) => {
+                ClassDeclaration: (node, { sourceFile, typeChecker }) => {
                     if (!node.name) {
                         return;
                     }
-                    const modifyingReferences = getModifyingReferences(node.name, context.sourceFile, context.typeChecker);
+                    const modifyingReferences = getModifyingReferences(node.name, sourceFile, typeChecker);
                     for (const reference of modifyingReferences) {
                         context.report({
                             message: "noClassAssign",
                             range: {
-                                begin: reference.getStart(context.sourceFile),
+                                begin: reference.getStart(sourceFile),
                                 end: reference.getEnd(),
                             },
                         });
@@ -40,3 +40,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=classAssignments.js.map

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=classAssignments.test.d.ts.map

package/lib/rules/classAssignments.test.js

@@ -154,3 +154,4 @@ instance.property = "value";
 `,
     ],
 });
+//# sourceMappingURL=classAssignments.test.js.map

package/lib/rules/consecutiveNonNullAssertions.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports unnecessary extra non-null assertions.";
     readonly id: "consecutiveNonNullAssertions";
     readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "consecutiveNonNullAssertion", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "consecutiveNonNullAssertion", undefined>;
 export default _default;
+//# sourceMappingURL=consecutiveNonNullAssertions.d.ts.map

package/lib/rules/consecutiveNonNullAssertions.js

@@ -40,3 +40,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=consecutiveNonNullAssertions.js.map

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=consecutiveNonNullAssertions.test.d.ts.map

package/lib/rules/consecutiveNonNullAssertions.test.js

@@ -30,3 +30,4 @@ outer?.inner!;
 `,
     ],
 });
+//# sourceMappingURL=consecutiveNonNullAssertions.test.js.map

package/lib/rules/constantAssignments.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports attempting to reassign variables declared with const.";
     readonly id: "constantAssignments";
     readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noConstAssign", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "noConstAssign", undefined>;
 export default _default;
+//# sourceMappingURL=constantAssignments.d.ts.map

package/lib/rules/constantAssignments.js

@@ -34,7 +34,7 @@ export default typescriptLanguage.createRule({
         }
         return {
             visitors: {
-                VariableDeclarationList: (node) => {
+                VariableDeclarationList: (node, { sourceFile, typeChecker }) => {
                     if (!(node.flags & ts.NodeFlags.Const) ||
                         node.declarations.length === 0) {
                         return;
@@ -42,12 +42,12 @@ export default typescriptLanguage.createRule({
                     for (const declaration of node.declarations) {
                         const identifiers = collectBindingElements(declaration.name);
                         for (const identifier of identifiers) {
-                            const modifyingReferences = getModifyingReferences(identifier, context.sourceFile, context.typeChecker);
+                            const modifyingReferences = getModifyingReferences(identifier, sourceFile, typeChecker);
                             for (const reference of modifyingReferences) {
                                 context.report({
                                     message: "noConstAssign",
                                     range: {
-                                        begin: reference.getStart(context.sourceFile),
+                                        begin: reference.getStart(sourceFile),
                                         end: reference.getEnd(),
                                     },
                                 });
@@ -59,3 +59,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=constantAssignments.js.map

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=constantAssignments.test.d.ts.map

package/lib/rules/constantAssignments.test.js

@@ -219,3 +219,4 @@ class MyClass {
 `,
     ],
 });
+//# sourceMappingURL=constantAssignments.test.js.map

package/lib/rules/constructorReturns.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports returning values from constructor functions.";
     readonly id: "constructorReturns";
     readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noConstructorReturn", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "noConstructorReturn", undefined>;
 export default _default;
+//# sourceMappingURL=constructorReturns.d.ts.map

package/lib/rules/constructorReturns.js

@@ -22,7 +22,7 @@ export default typescriptLanguage.createRule({
     setup(context) {
         return {
             visitors: {
-                Constructor: (node) => {
+                Constructor: (node, { sourceFile }) => {
                     if (!node.body) {
                         return;
                     }
@@ -32,7 +32,7 @@ export default typescriptLanguage.createRule({
                                 context.report({
                                     message: "noConstructorReturn",
                                     range: {
-                                        begin: node.getStart(context.sourceFile),
+                                        begin: node.getStart(sourceFile),
                                         end: node.getEnd(),
                                     },
                                 });
@@ -50,3 +50,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=constructorReturns.js.map

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=constructorReturns.test.d.ts.map

package/lib/rules/constructorReturns.test.js

@@ -94,3 +94,4 @@ class Example {
         `class Example { constructor() { function helper() { return 1; } } }`,
     ],
 });
+//# sourceMappingURL=constructorReturns.test.js.map

package/lib/rules/debuggerStatements.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports using debugger statements.";
     readonly id: "debuggerStatements";
     readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noDebugger", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "noDebugger", undefined>;
 export default _default;
+//# sourceMappingURL=debuggerStatements.d.ts.map

package/lib/rules/debuggerStatements.js

@@ -41,3 +41,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=debuggerStatements.js.map

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=debuggerStatements.test.d.ts.map

package/lib/rules/debuggerStatements.test.js

@@ -78,3 +78,4 @@ if (condition) {
         `throw new Error("test");`,
     ],
 });
+//# sourceMappingURL=debuggerStatements.test.js.map

package/lib/rules/defaultCaseLast.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports switch statements where the default clause is not last.";
     readonly id: "defaultCaseLast";
     readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "defaultCaseShouldBeLast", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "defaultCaseShouldBeLast", undefined>;
 export default _default;
+//# sourceMappingURL=defaultCaseLast.d.ts.map

package/lib/rules/defaultCaseLast.js

@@ -21,7 +21,7 @@ export default typescriptLanguage.createRule({
     setup(context) {
         return {
             visitors: {
-                SwitchStatement: (node) => {
+                SwitchStatement: (node, { sourceFile }) => {
                     const clauses = node.caseBlock.clauses;
                     const defaultClauseIndex = clauses.findIndex((clause) => clause.kind === ts.SyntaxKind.DefaultClause);
                     if (defaultClauseIndex === -1 ||
@@ -32,8 +32,8 @@ export default typescriptLanguage.createRule({
                     context.report({
                         message: "defaultCaseShouldBeLast",
                         range: {
-                            begin: defaultClause.getStart(context.sourceFile),
-                            end: defaultClause.getStart(context.sourceFile) + "default".length,
+                            begin: defaultClause.getStart(sourceFile),
+                            end: defaultClause.getStart(sourceFile) + "default".length,
                         },
                     });
                 },
@@ -41,3 +41,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=defaultCaseLast.js.map

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=defaultCaseLast.test.d.ts.map

package/lib/rules/defaultCaseLast.test.js

@@ -193,3 +193,4 @@ switch (value) {
 `,
     ],
 });
+//# sourceMappingURL=defaultCaseLast.test.js.map

package/lib/rules/duplicateArguments.d.ts

@@ -1,6 +1,8 @@
+import { TypeScriptFileServices } from "../language.js";
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports functions with duplicate parameter names in their signatures.";
     readonly id: "duplicateArguments";
     readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "duplicateParam", undefined>;
+}, import("../nodes.js").TSNodesByName, TypeScriptFileServices, "duplicateParam", undefined>;
 export default _default;
+//# sourceMappingURL=duplicateArguments.d.ts.map

package/lib/rules/duplicateArguments.js

@@ -19,7 +19,7 @@ export default typescriptLanguage.createRule({
         },
     },
     setup(context) {
-        function checkNode({ parameters }) {
+        function checkNode({ parameters }, { sourceFile }) {
             const seenNames = new Set();
             for (const parameter of parameters) {
                 if (!ts.isIdentifier(parameter.name)) {
@@ -30,7 +30,7 @@ export default typescriptLanguage.createRule({
                 if (existingParameter) {
                     context.report({
                         message: "duplicateParam",
-                        range: getTSNodeRange(parameter.name, context.sourceFile),
+                        range: getTSNodeRange(parameter.name, sourceFile),
                     });
                 }
                 else {
@@ -49,3 +49,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=duplicateArguments.js.map

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=duplicateArguments.test.d.ts.map

package/lib/rules/duplicateArguments.test.js

@@ -137,3 +137,4 @@ function test(value, value, value) {
         `function test([first, second]) { return first + second; }`,
     ],
 });
+//# sourceMappingURL=duplicateArguments.test.js.map

package/lib/rules/elseIfDuplicates.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports duplicate conditions in if-else-if chains that make code unreachable.";
     readonly id: "elseIfDuplicates";
     readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "duplicateCondition", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "duplicateCondition", undefined>;
 export default _default;
+//# sourceMappingURL=elseIfDuplicates.d.ts.map

package/lib/rules/elseIfDuplicates.js

@@ -21,14 +21,14 @@ export default typescriptLanguage.createRule({
         },
     },
     setup(context) {
-        function checkIfStatement(node) {
+        function checkIfStatement(node, sourceFile) {
             const seen = [];
             let current = node;
             while (true) {
-                if (seen.some((previous) => hasSameTokens(previous, current.expression, context.sourceFile))) {
+                if (seen.some((previous) => hasSameTokens(previous, current.expression, sourceFile))) {
                     context.report({
                         message: "duplicateCondition",
-                        range: getTSNodeRange(current.expression, context.sourceFile),
+                        range: getTSNodeRange(current.expression, sourceFile),
                     });
                 }
                 if (!current.elseStatement ||
@@ -41,13 +41,14 @@ export default typescriptLanguage.createRule({
         }
         return {
             visitors: {
-                IfStatement: (node) => {
+                IfStatement: (node, { sourceFile }) => {
                     if (!ts.isIfStatement(node.parent) ||
                         node.parent.elseStatement !== node) {
-                        checkIfStatement(node);
+                        checkIfStatement(node, sourceFile);
                     }
                 },
             },
         };
     },
 });
+//# sourceMappingURL=elseIfDuplicates.js.map

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=elseIfDuplicates.test.d.ts.map

package/lib/rules/elseIfDuplicates.test.js

@@ -174,3 +174,4 @@ if (value) {
         `if (first) { doFirst(); } else if (second) { doSecond(); } else { doDefault(); }`,
     ],
 });
+//# sourceMappingURL=elseIfDuplicates.test.js.map

package/lib/rules/emptyBlocks.d.ts

@@ -2,5 +2,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>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "emptyBlock", undefined>;
 export default _default;
+//# sourceMappingURL=emptyBlocks.d.ts.map

package/lib/rules/emptyBlocks.js

@@ -30,33 +30,34 @@ export default typescriptLanguage.createRule({
         },
     },
     setup(context) {
-        function hasComments(block) {
-            const fullText = context.sourceFile.getFullText();
-            const openBrace = block.getStart(context.sourceFile);
+        function hasComments(block, sourceFile) {
+            const fullText = sourceFile.getFullText();
+            const openBrace = block.getStart(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);
+        function isEmptyBlock(block, sourceFile) {
+            return block.statements.length === 0 && !hasComments(block, sourceFile);
         }
         return {
             visitors: {
-                Block: (node) => {
-                    if (!allowedParents.has(node.parent.kind) && isEmptyBlock(node)) {
+                Block: (node, { sourceFile }) => {
+                    if (!allowedParents.has(node.parent.kind) &&
+                        isEmptyBlock(node, sourceFile)) {
                         context.report({
                             message: "emptyBlock",
-                            range: getTSNodeRange(node, context.sourceFile),
+                            range: getTSNodeRange(node, sourceFile),
                         });
                     }
                 },
-                CaseBlock: (node) => {
+                CaseBlock: (node, { sourceFile }) => {
                     if (node.clauses.length === 0) {
                         context.report({
                             message: "emptyBlock",
-                            range: getTSNodeRange(node, context.sourceFile),
+                            range: getTSNodeRange(node, sourceFile),
                         });
                     }
                 },
@@ -64,3 +65,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=emptyBlocks.js.map

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=emptyBlocks.test.d.ts.map

package/lib/rules/emptyBlocks.test.js

@@ -133,3 +133,4 @@ try {
 `,
     ],
 });
+//# sourceMappingURL=emptyBlocks.test.js.map

package/lib/rules/emptyDestructures.d.ts

@@ -1,6 +1,8 @@
+import { TypeScriptFileServices } from "../language.js";
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports using empty destructuring patterns that destructure no values.";
     readonly id: "emptyDestructures";
     readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "emptyPattern", undefined>;
+}, import("../nodes.js").TSNodesByName, TypeScriptFileServices, "emptyPattern", undefined>;
 export default _default;
+//# sourceMappingURL=emptyDestructures.d.ts.map