@flint.fyi/ts 0.14.5 → 0.15.0

package/lib/plugin.d.ts

@@ -2,203 +2,232 @@ export declare const ts: import("@flint.fyi/core").Plugin<import("@flint.fyi/cor
     readonly description: "Reports returning a value with type `any` from a function.";
     readonly id: "anyReturns";
     readonly preset: "logical";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "unsafeReturn" | "unsafeReturnAssignment" | "unsafeReturnThis", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "unsafeReturn" | "unsafeReturnAssignment" | "unsafeReturnThis", undefined>, 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("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "asyncPromiseExecutor", undefined>, 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("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "unexpectedLexicalDeclaration", undefined>, 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("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "duplicateCase", undefined>, 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("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "noChainedAssignment", undefined>, 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("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "noClassAssign", undefined>, 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("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "consecutiveNonNullAssertion", undefined>, 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("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "noConstAssign", undefined>, 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("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "noConstructorReturn", undefined>, 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("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "noDebugger", undefined>, 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("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "defaultCaseShouldBeLast", undefined>, 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("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "duplicateParam", undefined>, 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("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "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<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "emptyBlock", undefined>, 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("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "emptyPattern", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports empty static initialization blocks within class declarations.";
     readonly id: "emptyStaticBlocks";
     readonly preset: "stylistic";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "emptyStaticBlock", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "emptyStaticBlock", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports reassigning exception parameters in catch clauses.";
     readonly id: "exceptionAssignments";
     readonly preset: "logical";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noExAssign", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "noExAssign", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports control flow statements in `finally` blocks that can override control flow in `try`/`catch` blocks.";
+    readonly id: "finallyStatementSafety";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "unsafeFinally", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports for loops with counter variables that move in the wrong direction.";
     readonly id: "forDirections";
     readonly preset: "stylistic";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "wrongDirection", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "wrongDirection", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports iterating over an array with a for-in loop.";
     readonly id: "forInArrays";
     readonly preset: "logical";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "forIn", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "forIn", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports reassigning variables declared with function declarations.";
     readonly id: "functionAssignments";
     readonly preset: "untyped";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noFunctionAssignment", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "noFunctionAssignment", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using `.apply()` or `.call()` or  when the context (`this` value) provides no benefit.";
+    readonly id: "functionCurryingRedundancy";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "unnecessaryCall", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports using the Function constructor to create functions from strings.";
     readonly id: "functionNewCalls";
     readonly preset: "logical";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noFunctionConstructor", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "noFunctionConstructor", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports generator functions that do not yield values.";
     readonly id: "generatorFunctionYields";
     readonly preset: "logical";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "missingYield", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "missingYield", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports attempting to assign to read-only global variables such as undefined, NaN, Infinity, Object, etc.";
     readonly id: "globalAssignments";
     readonly preset: "untyped";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noGlobalAssign", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "noGlobalAssign", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports calling global objects like Math, JSON, or Reflect as functions.";
     readonly id: "globalObjectCalls";
     readonly preset: "untyped";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noGlobalObjectCall", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "noGlobalObjectCall", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports using legacy `namespace` declarations.";
     readonly id: "namespaceDeclarations";
     readonly preset: "logical";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "preferModules", {
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "preferModules", {
     readonly allowDeclarations: import("zod").ZodDefault<import("zod").ZodBoolean>;
     readonly allowDefinitionFiles: import("zod").ZodDefault<import("zod").ZodBoolean>;
 }>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports comparisons with -0 that may not behave as expected.";
     readonly id: "negativeZeroComparisons";
     readonly preset: "logical";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "unexpectedNegativeZeroComparison", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "unexpectedNegativeZeroComparison", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports standalone new expressions that don't use the constructed object.";
     readonly id: "newExpressions";
     readonly preset: "logical";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noStandaloneNew", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "noStandaloneNew", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Disallows using `new` with global non-constructor functions like Symbol and BigInt.";
     readonly id: "newNativeNonConstructors";
     readonly preset: "untyped";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noNewNonConstructor", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "noNewNonConstructor", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports non-octal decimal escape sequences (\\8 and \\9) in string literals.";
     readonly id: "nonOctalDecimalEscapes";
     readonly preset: "logical";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "unexpectedEscape", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "unexpectedEscape", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports parseInt calls with binary, hexadecimal, or octal strings that can be replaced with numeric literals.";
     readonly id: "numericLiteralParsing";
     readonly preset: "stylistic";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "preferLiteral", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "preferLiteral", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Prefer `{}` object literal notation or `Object.create` instead of calling or constructing `Object`.";
+    readonly id: "objectCalls";
+    readonly preset: "stylistic";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "preferObjectLiteral", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Prefer Object.hasOwn() over Object.prototype.hasOwnProperty.call() for checking own properties.";
+    readonly id: "objectHasOwns";
+    readonly preset: "stylistic";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "preferHasOwn", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports unnecessary duplicate keys that override previous values.";
+    readonly id: "objectKeyDuplicates";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "duplicateKey", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports using the deprecated __proto__ property to access or modify an object's prototype.";
     readonly id: "objectProto";
     readonly preset: "untyped";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noProto", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "noProto", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports direct calls to Object.prototype methods on object instances.";
+    readonly id: "objectPrototypeBuiltIns";
+    readonly preset: "logical";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "prototypeBuiltIn", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports using octal escape sequences in string literals.";
     readonly id: "octalEscapes";
     readonly preset: "logical";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noOctalEscape", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "noOctalEscape", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports using legacy octal numeric literals.";
     readonly id: "octalNumbers";
     readonly preset: "untyped";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noOctalNumber", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "noOctalNumber", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports using assignment expressions in return statements.";
     readonly id: "returnAssignments";
     readonly preset: "stylistic";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noReturnAssign", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "noReturnAssign", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports self-assignments which have no effect and are likely errors.";
     readonly id: "selfAssignments";
     readonly preset: "logical";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "selfAssignment", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "selfAssignment", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports comparing a value to itself.";
     readonly id: "selfComparisons";
     readonly preset: "logical";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noSelfComparison", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "noSelfComparison", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports using the comma operator in expressions.";
     readonly id: "sequences";
     readonly preset: "untyped";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noSequences", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "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<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "shadowedRestrictedName", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports array literals with holes (sparse arrays).";
     readonly id: "sparseArrays";
     readonly preset: "logical";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noSparseArray", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "noSparseArray", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports Symbol() calls without description arguments.";
     readonly id: "symbolDescriptions";
     readonly preset: "stylistic";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "missingDescription", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "missingDescription", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports typeof expressions that compare impossible string literals.";
     readonly id: "typeofComparisons";
     readonly preset: "untyped";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "invalidValue", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "invalidValue", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports variables that are declared but never assigned a value.";
     readonly id: "unassignedVariables";
     readonly preset: "untyped";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noUnassigned", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "noUnassigned", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports using variables that are not defined.";
     readonly id: "undefinedVariables";
     readonly preset: "untyped";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "undefinedVariable", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "undefinedVariable", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports files with Unicode Byte Order Marks (BOMs).";
     readonly id: "unicodeBOMs";
     readonly preset: "stylistic";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noBOM", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "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<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "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<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "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<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "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";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "preferNegatingRelation", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "preferNegatingRelation", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports attempting to delete variables with the delete operator.";
     readonly id: "variableDeletions";
     readonly preset: "untyped";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noDeleteVar", undefined>, import("@flint.fyi/core").Rule<{
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "noDeleteVar", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports using the void operator.";
     readonly id: "voidOperator";
     readonly preset: "stylistic";
-}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noVoid", undefined>]>;
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "noVoid", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using with statements";
+    readonly id: "withStatements";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptFileServices, "withStatement", undefined>]>;
+//# sourceMappingURL=plugin.d.ts.map

package/lib/plugin.js

@@ -16,9 +16,11 @@ import emptyBlocks from "./rules/emptyBlocks.js";
 import emptyDestructures from "./rules/emptyDestructures.js";
 import emptyStaticBlocks from "./rules/emptyStaticBlocks.js";
 import exceptionAssignments from "./rules/exceptionAssignments.js";
+import finallyStatementSafety from "./rules/finallyStatementSafety.js";
 import forDirections from "./rules/forDirections.js";
 import forInArrays from "./rules/forInArrays.js";
 import functionAssignments from "./rules/functionAssignments.js";
+import functionCurryingRedundancy from "./rules/functionCurryingRedundancy.js";
 import functionNewCalls from "./rules/functionNewCalls.js";
 import generatorFunctionYields from "./rules/generatorFunctionYields.js";
 import globalAssignments from "./rules/globalAssignments.js";
@@ -29,7 +31,11 @@ import newExpressions from "./rules/newExpressions.js";
 import newNativeNonConstructors from "./rules/newNativeNonConstructors.js";
 import nonOctalDecimalEscapes from "./rules/nonOctalDecimalEscapes.js";
 import numericLiteralParsing from "./rules/numericLiteralParsing.js";
+import objectCalls from "./rules/objectCalls.js";
+import objectHasOwns from "./rules/objectHasOwns.js";
+import objectKeyDuplicates from "./rules/objectKeyDuplicates.js";
 import objectProto from "./rules/objectProto.js";
+import objectPrototypeBuiltIns from "./rules/objectPrototypeBuiltIns.js";
 import octalEscapes from "./rules/octalEscapes.js";
 import octalNumbers from "./rules/octalNumbers.js";
 import returnAssignments from "./rules/returnAssignments.js";
@@ -49,11 +55,12 @@ import unnecessaryConcatenation from "./rules/unnecessaryConcatenation.js";
 import unsafeNegations from "./rules/unsafeNegations.js";
 import variableDeletions from "./rules/variableDeletions.js";
 import voidOperator from "./rules/voidOperator.js";
+import withStatements from "./rules/withStatements.js";
 export const ts = createPlugin({
     files: {
         all: ["**/*.{cjs,js,jsx,mjs,ts,tsx}"],
     },
-    name: "ts",
+    name: "TypeScript",
     rules: [
         anyReturns,
         asyncPromiseExecutors,
@@ -72,9 +79,11 @@ export const ts = createPlugin({
         emptyDestructures,
         emptyStaticBlocks,
         exceptionAssignments,
+        finallyStatementSafety,
         forDirections,
         forInArrays,
         functionAssignments,
+        functionCurryingRedundancy,
         functionNewCalls,
         generatorFunctionYields,
         globalAssignments,
@@ -85,7 +94,11 @@ export const ts = createPlugin({
         newNativeNonConstructors,
         nonOctalDecimalEscapes,
         numericLiteralParsing,
+        objectCalls,
+        objectHasOwns,
+        objectKeyDuplicates,
         objectProto,
+        objectPrototypeBuiltIns,
         octalEscapes,
         octalNumbers,
         returnAssignments,
@@ -105,5 +118,7 @@ export const ts = createPlugin({
         unsafeNegations,
         variableDeletions,
         voidOperator,
+        withStatements,
     ],
 });
+//# sourceMappingURL=plugin.js.map

package/lib/prepareTypeScriptBasedLanguage.d.ts

@@ -0,0 +1,11 @@
+import * as ts from "typescript";
+export interface TypeScriptBasedLanguageFile extends Partial<Disposable> {
+    program: ts.Program;
+    sourceFile: ts.SourceFile;
+}
+export interface TypeScriptBasedLanguageFileFactoryDefinition {
+    createFromDisk(filePathAbsolute: string): TypeScriptBasedLanguageFile;
+    createFromVirtual(filePathAbsolute: string, sourceText: string): TypeScriptBasedLanguageFile;
+}
+export declare function prepareTypeScriptBasedLanguage(): TypeScriptBasedLanguageFileFactoryDefinition;
+//# sourceMappingURL=prepareTypeScriptBasedLanguage.d.ts.map

package/lib/prepareTypeScriptBasedLanguage.js

@@ -0,0 +1,59 @@
+import { createProjectService } from "@typescript-eslint/project-service";
+import { createFSBackedSystem, createVirtualTypeScriptEnvironment, } from "@typescript/vfs";
+import { CachedFactory } from "cached-factory";
+import { debugForFile } from "debug-for-file";
+import path from "node:path";
+import * as ts from "typescript";
+import { createTypeScriptFileFromProjectService } from "./createTypeScriptFileFromProjectService.js";
+const projectRoot = path.join(import.meta.dirname, "../..");
+const log = debugForFile(import.meta.filename);
+export function prepareTypeScriptBasedLanguage() {
+    const { service } = createProjectService();
+    const seenPrograms = new Set();
+    const environments = new CachedFactory((filePathAbsolute) => {
+        const system = createFSBackedSystem(new Map([[filePathAbsolute, "// ..."]]), projectRoot, ts);
+        return createVirtualTypeScriptEnvironment(system, [filePathAbsolute], ts, {
+            skipLibCheck: true,
+            target: ts.ScriptTarget.ESNext,
+        });
+    });
+    const servicePrograms = new CachedFactory((filePathAbsolute) => {
+        log("Opening client file:", filePathAbsolute);
+        service.openClientFile(filePathAbsolute);
+        log("Retrieving client services:", filePathAbsolute);
+        const scriptInfo = service.getScriptInfo(filePathAbsolute);
+        if (!scriptInfo) {
+            throw new Error(`Could not find script info for file: ${filePathAbsolute}`);
+        }
+        const defaultProject = service.getDefaultProjectForFile(scriptInfo.fileName, true);
+        if (!defaultProject) {
+            throw new Error(`Could not find default project for file: ${filePathAbsolute}`);
+        }
+        const program = defaultProject.getLanguageService(true).getProgram();
+        if (!program) {
+            throw new Error(`Could not retrieve program for file: ${filePathAbsolute}`);
+        }
+        return program;
+    });
+    return {
+        createFromDisk: (filePathAbsolute) => {
+            const program = servicePrograms.get(filePathAbsolute);
+            seenPrograms.add(program);
+            return createTypeScriptFileFromProjectService(filePathAbsolute, program, service);
+        },
+        createFromVirtual: (filePathAbsolute, sourceText) => {
+            const environment = environments.get(filePathAbsolute);
+            environment.updateFile(filePathAbsolute, sourceText);
+            /* eslint-disable @typescript-eslint/no-non-null-assertion */
+            const sourceFile = environment.getSourceFile(filePathAbsolute);
+            const program = environment.languageService.getProgram();
+            /* eslint-enable @typescript-eslint/no-non-null-assertion */
+            seenPrograms.add(program);
+            return {
+                program,
+                sourceFile,
+            };
+        },
+    };
+}
+//# sourceMappingURL=prepareTypeScriptBasedLanguage.js.map

package/lib/prepareTypeScriptFile.d.ts

@@ -1,7 +1,12 @@
-import { LanguageFileDefinition } from "@flint.fyi/core";
-import ts from "typescript";
-export declare function prepareTypeScriptFile(languageFile: LanguageFileDefinition, sourceFile: ts.SourceFile): {
-    file: LanguageFileDefinition;
+import { TypeScriptBasedLanguageFile } from "./prepareTypeScriptBasedLanguage.js";
+export declare function prepareTypeScriptFile(file: TypeScriptBasedLanguageFile): {
+    file: {
+        cache?: import("@flint.fyi/core").LanguageFileCacheImpacts;
+        getDiagnostics?(): import("@flint.fyi/core").LanguageDiagnostics;
+        runRule<OptionsSchema extends import("@flint.fyi/core").AnyOptionalSchema | undefined = import("@flint.fyi/core").AnyOptionalSchema | undefined>(rule: import("@flint.fyi/core").AnyRuleDefinition<OptionsSchema>, options: import("@flint.fyi/core").InferredObject<OptionsSchema>): import("@flint.fyi/utils").PromiseOrSync<import("@flint.fyi/core").NormalizedReport[]>;
+        [Symbol.dispose]?: (() => void) | undefined;
+    };
     directives: import("@flint.fyi/core").CommentDirective[];
     reports: import("@flint.fyi/core").FileReport[];
 };
+//# sourceMappingURL=prepareTypeScriptFile.d.ts.map

package/lib/prepareTypeScriptFile.js

@@ -1,7 +1,13 @@
+import { createTypeScriptFileFromProgram } from "./createTypeScriptFileFromProgram.js";
 import { parseDirectivesFromTypeScriptFile } from "./directives/parseDirectivesFromTypeScriptFile.js";
-export function prepareTypeScriptFile(languageFile, sourceFile) {
+export function prepareTypeScriptFile(file) {
+    const { program, sourceFile, [Symbol.dispose]: onDispose } = file;
     return {
         ...parseDirectivesFromTypeScriptFile(sourceFile),
-        file: languageFile,
+        file: {
+            ...(onDispose != null && { [Symbol.dispose]: onDispose }),
+            ...createTypeScriptFileFromProgram(program, sourceFile),
+        },
     };
 }
+//# sourceMappingURL=prepareTypeScriptFile.js.map

package/lib/rules/anyReturns.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports returning a value with type `any` from a function.";
     readonly id: "anyReturns";
     readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "unsafeReturn" | "unsafeReturnAssignment" | "unsafeReturnThis", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "unsafeReturn" | "unsafeReturnAssignment" | "unsafeReturnThis", undefined>;
 export default _default;
+//# sourceMappingURL=anyReturns.d.ts.map

package/lib/rules/anyReturns.js

@@ -46,10 +46,9 @@ export default typescriptLanguage.createRule({
         },
     },
     setup(context) {
-        const isNoImplicitThis = tsutils.isStrictCompilerOptionEnabled(context.program.getCompilerOptions(), "noImplicitThis");
-        function checkReturn(returnNode, reportingNode) {
-            const type = context.typeChecker.getTypeAtLocation(returnNode);
-            const anyType = discriminateAnyType(type, context.typeChecker, context.program, returnNode);
+        function checkReturn(returnNode, reportingNode, program, typeChecker) {
+            const type = typeChecker.getTypeAtLocation(returnNode);
+            const anyType = discriminateAnyType(type, typeChecker, program, returnNode);
             const functionNode = ts.findAncestor(returnNode, 
             // TODO: I believe isFunctionLikeDeclaration was incorrectly marked
             // as deprecated in https://github.com/JoshuaKGoldberg/ts-api-utils/pull/124
@@ -62,16 +61,16 @@ export default typescriptLanguage.createRule({
                 return;
             }
             // function has an explicit return type, so ensure it's a safe return
-            const returnNodeType = getConstrainedTypeAtLocation(returnNode, context.typeChecker);
+            const returnNodeType = getConstrainedTypeAtLocation(returnNode, typeChecker);
             // function expressions will not have their return type modified based on receiver typing
             // so we have to use the contextual typing in these cases, i.e.
             // const foo1: () => Set<string> = () => new Set<any>();
             // the return type of the arrow function is Set<any> even though the variable is typed as Set<string>
             let functionType = ts.isFunctionExpression(functionNode) ||
                 ts.isArrowFunction(functionNode)
-                ? context.typeChecker.getContextualType(functionNode)
-                : context.typeChecker.getTypeAtLocation(functionNode);
-            functionType ??= context.typeChecker.getTypeAtLocation(functionNode);
+                ? typeChecker.getContextualType(functionNode)
+                : typeChecker.getTypeAtLocation(functionNode);
+            functionType ??= typeChecker.getTypeAtLocation(functionNode);
             const callSignatures = tsutils.getCallSignaturesOfType(functionType);
             // If there is an explicit type annotation *and* that type matches the actual
             // function return type, we shouldn't complain (it's intentional, even if unsafe)
@@ -83,8 +82,8 @@ export default typescriptLanguage.createRule({
                         return;
                     }
                     if (tsutils.includesModifier(functionNode.modifiers, ts.SyntaxKind.AsyncKeyword)) {
-                        const awaitedSignatureReturnType = context.typeChecker.getAwaitedType(signatureReturnType);
-                        const awaitedReturnNodeType = context.typeChecker.getAwaitedType(returnNodeType);
+                        const awaitedSignatureReturnType = typeChecker.getAwaitedType(signatureReturnType);
+                        const awaitedReturnNodeType = typeChecker.getAwaitedType(returnNodeType);
                         if (awaitedReturnNodeType === awaitedSignatureReturnType ||
                             (awaitedSignatureReturnType &&
                                 tsutils.isTypeFlagSet(awaitedSignatureReturnType, ts.TypeFlags.Any | ts.TypeFlags.Unknown))) {
@@ -103,11 +102,11 @@ export default typescriptLanguage.createRule({
                         return;
                     }
                     if (anyType === AnyType.AnyArray &&
-                        context.typeChecker.isArrayType(functionReturnType) &&
-                        tsutils.isTypeFlagSet(context.typeChecker.getTypeArguments(functionReturnType)[0], ts.TypeFlags.Unknown)) {
+                        typeChecker.isArrayType(functionReturnType) &&
+                        tsutils.isTypeFlagSet(typeChecker.getTypeArguments(functionReturnType)[0], ts.TypeFlags.Unknown)) {
                         return;
                     }
-                    const awaitedType = context.typeChecker.getAwaitedType(functionReturnType);
+                    const awaitedType = typeChecker.getAwaitedType(functionReturnType);
                     if (awaitedType &&
                         anyType === AnyType.PromiseAny &&
                         tsutils.isTypeFlagSet(awaitedType, ts.TypeFlags.Unknown)) {
@@ -120,11 +119,11 @@ export default typescriptLanguage.createRule({
                 }
                 let message = "unsafeReturn";
                 const isErrorType = tsutils.isIntrinsicErrorType(returnNodeType);
-                if (!isNoImplicitThis) {
+                if (!tsutils.isStrictCompilerOptionEnabled(program.getCompilerOptions(), "noImplicitThis")) {
                     // `return this`
                     const thisExpression = getThisExpression(returnNode);
                     if (thisExpression &&
-                        tsutils.isTypeFlagSet(getConstrainedTypeAtLocation(thisExpression, context.typeChecker), ts.TypeFlags.Any)) {
+                        tsutils.isTypeFlagSet(getConstrainedTypeAtLocation(thisExpression, typeChecker), ts.TypeFlags.Any)) {
                         message = "unsafeReturnThis";
                     }
                 }
@@ -150,15 +149,15 @@ export default typescriptLanguage.createRule({
             const signature = functionType.getCallSignatures().at(0);
             if (signature) {
                 const functionReturnType = signature.getReturnType();
-                const result = isUnsafeAssignment(returnNodeType, functionReturnType, context.typeChecker, returnNode);
+                const result = isUnsafeAssignment(returnNodeType, functionReturnType, typeChecker, returnNode);
                 if (!result) {
                     return;
                 }
                 const { receiver, sender } = result;
                 context.report({
                     data: {
-                        receiver: context.typeChecker.typeToString(receiver),
-                        sender: context.typeChecker.typeToString(sender),
+                        receiver: typeChecker.typeToString(receiver),
+                        sender: typeChecker.typeToString(sender),
                     },
                     message: "unsafeReturnAssignment",
                     range: {
@@ -171,17 +170,18 @@ export default typescriptLanguage.createRule({
         }
         return {
             visitors: {
-                ArrowFunction: (node) => {
+                ArrowFunction: (node, { program, typeChecker }) => {
                     if (!ts.isBlock(node.body)) {
-                        checkReturn(node.body, node.body);
+                        checkReturn(node.body, node.body, program, typeChecker);
                     }
                 },
-                ReturnStatement: (node) => {
+                ReturnStatement: (node, { program, typeChecker }) => {
                     if (node.expression != null) {
-                        checkReturn(node.expression, node);
+                        checkReturn(node.expression, node, program, typeChecker);
                     }
                 },
             },
         };
     },
 });
+//# sourceMappingURL=anyReturns.js.map

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

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

package/lib/rules/anyReturns.test.js

@@ -645,3 +645,4 @@ function foo(): Set<number> {
     `,
     ],
 });
+//# sourceMappingURL=anyReturns.test.js.map