feat!: remove assumeTypes option

Author: RebeccaStevens

docs/rules/immutable-data.md

@@ -59,12 +59,6 @@ This rule accepts an options object of the following type:
 
 ```ts
 type Options = {
-  assumeTypes:
-    | boolean
-    | {
-        forArrays: boolean;
-        forObjects: boolean;
-      };
   ignoreClasses: boolean | "fieldsOnly";
   ignoreImmediateMutation: boolean;
   ignorePattern?: string[] | string;
@@ -76,7 +70,6 @@ type Options = {
 
 ```ts
 type Options = {
-  assumeTypes: true;
   ignoreClasses: false;
   ignoreImmediateMutation: true;
 };
@@ -92,25 +85,6 @@ const liteOptions = {
 };
 ```
 
-### `assumeTypes`
-
-The rule takes advantage of TypeScript's typing engine to check if mutation is taking place.
-If you are not using TypeScript, type checking cannot be performed; hence this option exists.
-
-This option will make the rule assume the type of the nodes it is checking are of type Array/Object.
-However this may result in some false positives being picked up.
-
-Disabling this option can result in false negatives, for example:
-
-```js
-// When this option is DISABLED (and type info is not available).
-const x = [0, 1, 2];
-x.push(3); // This will NOT be flagged.
-// This is due to the fact that without a typing engine, we cannot tell that x is an array.
-```
-
-Note: This option will have no effect if the TypeScript typing engine is available (i.e. you are using TypeScript and have configured ESLint correctly).
-
 ### `ignoreImmediateMutation`
 
 If true, immediate mutation of objects before they are assigned to a variable is allowed.

docs/rules/prefer-tacit.md

@@ -45,35 +45,16 @@ This rule accepts an options object of the following type:
 
 ```ts
 type Options = {
-  assumeTypes: boolean;
   ignorePattern?: string[] | string;
 };
 ```
 
 ### Default Options
 
 ```ts
-const defaults = {
-  assumeTypes: false,
-};
-```
-
-### `assumeTypes`
-
-The rule takes advantage of TypeScript's typing engine to check if callback wrapper is in fact safe to remove.
-
-This option will make the rule assume that the function only accepts the arguments given to it in the wrapper.
-However this may result in some false positives being picked up.
-
-<!-- eslint-disable functional/prefer-tacit -->
-
-```js
-const foo = (x) => f(x); // If `f` only accepts one parameter then this is violation of the rule.
-const bar = foo(1, 2, 3); // But if `f` accepts more than one parameter then it isn't.
+const defaults = {};
 ```
 
-Note: Enabling this option is the only way to get this rule to report violations in an environment without TypeScript's typing engine available (e.g. In Vanilla JS).
-
 ### `ignorePattern`
 
 See the [ignorePattern](./options/ignore-pattern.md) docs.

src/configs/all.ts

@@ -36,7 +36,7 @@ const config: Linter.Config = {
     [`functional/${noTryStatements.name}`]: "error",
     [`functional/${preferImmutableTypes.name}`]: "error",
     [`functional/${preferPropertySignatures.name}`]: "error",
-    [`functional/${preferTacit.name}`]: ["warn", { assumeTypes: true }],
+    [`functional/${preferTacit.name}`]: "warn",
     [`functional/${readonlyType.name}`]: "error",
     [`functional/${typeDeclarationImmutability.name}`]: "error",
   },

src/configs/stylistic.ts

@@ -7,7 +7,7 @@ import * as readonlyType from "~/rules/readonly-type";
 const config: Linter.Config = {
   rules: {
     [`functional/${preferPropertySignatures.name}`]: "error",
-    [`functional/${preferTacit.name}`]: ["warn", { assumeTypes: true }],
+    [`functional/${preferTacit.name}`]: "warn",
     [`functional/${readonlyType.name}`]: "error",
   },
 };

src/rules/immutable-data.ts

@@ -49,12 +49,6 @@ type Options = [
     IgnoreClassesOption &
     IgnorePatternOption & {
       ignoreImmediateMutation: boolean;
-      assumeTypes:
-        | boolean
-        | {
-            forArrays: boolean;
-            forObjects: boolean;
-          };
     },
 ];
 
@@ -72,25 +66,6 @@ const schema: JSONSchema4[] = [
         ignoreImmediateMutation: {
           type: "boolean",
         },
-        assumeTypes: {
-          oneOf: [
-            {
-              type: "boolean",
-            },
-            {
-              type: "object",
-              properties: {
-                forArrays: {
-                  type: "boolean",
-                },
-                forObjects: {
-                  type: "boolean",
-                },
-              },
-              additionalProperties: false,
-            },
-          ],
-        },
       } satisfies JSONSchema4ObjectSchema["properties"],
     ),
     additionalProperties: false,
@@ -104,10 +79,6 @@ const defaultOptions: Options = [
   {
     ignoreClasses: false,
     ignoreImmediateMutation: true,
-    assumeTypes: {
-      forArrays: true,
-      forObjects: true,
-    },
   },
 ];
 
@@ -286,18 +257,13 @@ function checkUpdateExpression(
 function isInChainCallAndFollowsNew(
   node: TSESTree.MemberExpression,
   context: Readonly<RuleContext<keyof typeof errorMessages, Options>>,
-  assumeArrayTypes: boolean,
 ): boolean {
   return (
     // Check for: [0, 1, 2]
     isArrayExpression(node.object) ||
     // Check for: new Array()
     (isNewExpression(node.object) &&
-      isArrayConstructorType(
-        getTypeOfNode(node.object.callee, context),
-        assumeArrayTypes,
-        node.object.callee,
-      )) ||
+      isArrayConstructorType(getTypeOfNode(node.object.callee, context))) ||
     (isCallExpression(node.object) &&
       isMemberExpression(node.object.callee) &&
       isIdentifier(node.object.callee.property) &&
@@ -307,8 +273,6 @@ function isInChainCallAndFollowsNew(
       ) &&
         isArrayConstructorType(
           getTypeOfNode(node.object.callee.object, context),
-          assumeArrayTypes,
-          node.object.callee.object,
         )) ||
         // Check for: array.slice(0)
         arrayNewObjectReturningMethods.some(
@@ -346,37 +310,21 @@ function checkCallExpression(
     };
   }
 
-  const { assumeTypes, ignoreImmediateMutation } = optionsObject;
-
-  const assumeTypesForArrays =
-    assumeTypes === true ||
-    (assumeTypes !== false && assumeTypes.forArrays === true);
+  const { ignoreImmediateMutation } = optionsObject;
 
   // Array mutation?
   if (
     arrayMutatorMethods.has(node.callee.property.name) &&
     (!ignoreImmediateMutation ||
-      !isInChainCallAndFollowsNew(
-        node.callee,
-        context,
-        assumeTypesForArrays,
-      )) &&
-    isArrayType(
-      getTypeOfNode(node.callee.object, context),
-      assumeTypesForArrays,
-      node.callee.object,
-    )
+      !isInChainCallAndFollowsNew(node.callee, context)) &&
+    isArrayType(getTypeOfNode(node.callee.object, context))
   ) {
     return {
       context,
       descriptors: [{ node, messageId: "array" }],
     };
   }
 
-  const assumeTypesForObjects =
-    assumeTypes === true ||
-    (assumeTypes !== false && assumeTypes.forObjects === true);
-
   // Non-array object mutation (ex. Object.assign on identifier)?
   if (
     objectConstructorMutatorFunctions.has(node.callee.property.name) &&
@@ -390,11 +338,7 @@ function checkCallExpression(
       ignorePattern,
       ignoreAccessorPattern,
     ) &&
-    isObjectConstructorType(
-      getTypeOfNode(node.callee.object, context),
-      assumeTypesForObjects,
-      node.callee.object,
-    )
+    isObjectConstructorType(getTypeOfNode(node.callee.object, context))
   ) {
     return {
       context,

src/rules/prefer-tacit.ts

@@ -1,16 +1,12 @@
 import { TSESTree } from "@typescript-eslint/utils";
-import {
-  type JSONSchema4,
-  type JSONSchema4ObjectSchema,
-} from "@typescript-eslint/utils/json-schema";
+import { type JSONSchema4 } from "@typescript-eslint/utils/json-schema";
 import {
   type RuleFix,
   type RuleFixer,
   type RuleContext,
   type ReportDescriptor,
   type ReportSuggestionArray,
 } from "@typescript-eslint/utils/ts-eslint";
-import { deepmerge } from "deepmerge-ts";
 import * as semver from "semver";
 import { type Type } from "typescript";
 
@@ -42,35 +38,23 @@ export const name = "prefer-tacit" as const;
 /**
  * The options this rule can take.
  */
-type Options = [
-  IgnorePatternOption & {
-    assumeTypes: boolean;
-  },
-];
+type Options = [IgnorePatternOption];
 
 /**
  * The schema for the rule options.
  */
 const schema: JSONSchema4[] = [
   {
     type: "object",
-    properties: deepmerge(ignorePatternOptionSchema, {
-      assumeTypes: {
-        type: "boolean",
-      },
-    } satisfies JSONSchema4ObjectSchema["properties"]),
+    properties: ignorePatternOptionSchema,
     additionalProperties: false,
   },
 ];
 
 /**
  * The default options for the rule.
  */
-const defaultOptions: Options = [
-  {
-    assumeTypes: false,
-  },
-];
+const defaultOptions: Options = [{}];
 
 /**
  * The possible error messages.
@@ -213,8 +197,6 @@ function getCallDescriptors(
   options: Options,
   caller: TSESTree.CallExpression,
 ): Array<ReportDescriptor<keyof typeof errorMessages>> {
-  const [{ assumeTypes }] = options;
-
   if (
     node.params.length === caller.arguments.length &&
     node.params.every((param, index) => {
@@ -227,14 +209,8 @@ function getCallDescriptors(
     })
   ) {
     const calleeType = getTypeOfNode(caller.callee, context);
-    const assumingTypes =
-      (calleeType === null || (calleeType.symbol as unknown) === undefined) &&
-      assumeTypes;
 
-    if (
-      assumingTypes ||
-      (calleeType !== null && isCallerViolation(caller, calleeType, context))
-    ) {
+    if (calleeType !== null && isCallerViolation(caller, calleeType, context)) {
       return [
         {
           node,