Do not use merger if arguments are the same.

docs/Architecture/Linters.md

@@ -52,6 +52,8 @@ These are located in `src/rules/mergers/`, and keyed under their names by the ma
 
 For example, `@typescript-eslint/ban-types` spreads both arguments' `types` members into one large `types` object.
 
+**A merger does not need to be created if the rule does not accept any configuration.**
+
 ## Package Summaries
 
 ESLint configurations are summarized based on extended ESLint and TSLint presets.

src/converters/lintConfigs/rules/convertRules.test.ts

@@ -107,41 +107,118 @@ describe("convertRules", () => {
         expect(ruleEquivalents).toEqual(new Map([["tslint-rule-a", ["eslint-rule-a"]]]));
     });
 
-    it("reports a failure when two outputs exist for a converted rule without a merger", () => {
-        // Arrange
-        const conversionResult = {
-            rules: [
-                {
-                    ruleName: "eslint-rule-a",
-                },
-                {
-                    ruleName: "eslint-rule-a",
-                },
-            ],
-        };
-        const { tslintRule, converters, mergers } = setupConversionEnvironment({
-            conversionResult,
+    describe("runs without an argument merger when both rules have the same arguments", () => {
+        [
+            { ruleArguments: undefined, testCase: "no arguments" },
+            { ruleArguments: [5], testCase: "number argument" },
+            { ruleArguments: ["allow-something"], testCase: "string argument" },
+            { ruleArguments: [{ max: 50 }], testCase: "object argument" },
+            { ruleArguments: [5, "allow-something", { max: 50 }], testCase: "multiple arguments" },
+        ].forEach(({ ruleArguments, testCase }) => {
+            it(testCase, () => {
+                // Arrange
+                const conversionResult = {
+                    rules: [
+                        {
+                            ruleArguments,
+                            ruleName: "eslint-rule-a",
+                        },
+                        {
+                            ruleArguments,
+                            ruleName: "eslint-rule-a",
+                        },
+                    ],
+                };
+                const { tslintRule, converters, mergers } = setupConversionEnvironment({
+                    conversionResult,
+                });
+
+                // Act
+                const { converted, failed } = convertRules(
+                    { ruleConverters: converters, ruleMergers: mergers },
+                    { [tslintRule.ruleName]: tslintRule },
+                    new Map<string, string[]>(),
+                );
+
+                // Assert
+                expect(converted).toEqual(
+                    new Map([
+                        [
+                            "eslint-rule-a",
+                            {
+                                ruleArguments,
+                                ruleName: "eslint-rule-a",
+                                ruleSeverity: "error",
+                                notices: [],
+                            },
+                        ],
+                    ]),
+                );
+                expect(failed).toEqual([]);
+            });
         });
+    });
 
-        // Act
-        const { failed } = convertRules(
-            { ruleConverters: converters, ruleMergers: mergers },
-            { [tslintRule.ruleName]: tslintRule },
-            new Map<string, string[]>(),
-        );
-
-        // Assert
-        expect(failed).toEqual([ConversionError.forMerger("eslint-rule-a")]);
+    describe("reports a failure when two outputs with different arguments exist for a converted rule without a merger", () => {
+        [
+            { existingArguments: [0], newArguments: [1], testCase: "number arguments" },
+            {
+                existingArguments: [""],
+                newArguments: ["allow-something"],
+                testCase: "string arguments",
+            },
+            {
+                existingArguments: [{ max: 0 }],
+                newArguments: [{ max: 50 }],
+                testCase: "object arguments",
+            },
+            {
+                existingArguments: [0, "", { max: 0 }],
+                newArguments: [5, "allow-something", { max: 50 }],
+                testCase: "multiple arguments",
+            },
+        ].forEach(({ existingArguments, newArguments, testCase }) => {
+            it(testCase, () => {
+                // Arrange
+                const conversionResult = {
+                    rules: [
+                        {
+                            ruleArguments: existingArguments,
+                            ruleName: "eslint-rule-a",
+                        },
+                        {
+                            ruleArguments: newArguments,
+                            ruleName: "eslint-rule-a",
+                        },
+                    ],
+                };
+                const { tslintRule, converters, mergers } = setupConversionEnvironment({
+                    conversionResult,
+                });
+
+                // Act
+                const { failed } = convertRules(
+                    { ruleConverters: converters, ruleMergers: mergers },
+                    { [tslintRule.ruleName]: tslintRule },
+                    new Map<string, string[]>(),
+                );
+
+                // Assert
+                expect(failed).toEqual([ConversionError.forMerger("eslint-rule-a")]);
+            });
+        });
     });
 
-    it("merges rule arguments when two outputs exist for a converted rule with a merger", () => {
+    it("merges rule arguments when two outputs with different arguments exist for a converted rule with a merger", () => {
         // Arrange
         const conversionResult = {
             rules: [
                 {
+                    ruleArguments: [0],
                     ruleName: "eslint-rule-a",
                 },
                 {
+                    ruleArguments: [1],
                     ruleName: "eslint-rule-a",
                 },
             ],
@@ -201,7 +278,8 @@ describe("convertRules", () => {
         );
 
         // Assert
-        expect(converted).toEqual(
+        expect([
+            // don't care if arguments merger ran or not
             new Map([
                 [
                     "eslint-rule-a",
@@ -213,7 +291,17 @@ describe("convertRules", () => {
                     },
                 ],
             ]),
-        );
+            new Map([
+                [
+                    "eslint-rule-a",
+                    {
+                        ruleName: "eslint-rule-a",
+                        ruleSeverity: "error",
+                        notices: ["notice-1", "notice-2"],
+                    },
+                ],
+            ]),
+        ]).toContainEqual(converted);
     });
 
     it("merges undefined notices", () => {
@@ -243,7 +331,8 @@ describe("convertRules", () => {
         );
 
         // Assert
-        expect(converted).toEqual(
+        expect([
+            // don't care if arguments merger ran or not
             new Map([
                 [
                     "eslint-rule-a",
@@ -255,7 +344,17 @@ describe("convertRules", () => {
                     },
                 ],
             ]),
-        );
+            new Map([
+                [
+                    "eslint-rule-a",
+                    {
+                        ruleName: "eslint-rule-a",
+                        ruleSeverity: "error",
+                        notices: [],
+                    },
+                ],
+            ]),
+        ]).toContainEqual(converted);
     });
 
     it("marks a new plugin when a conversion has a new plugin", () => {

src/converters/lintConfigs/rules/convertRules.ts

@@ -1,3 +1,5 @@
+import { isEqual } from "lodash";
+
 import { ConversionError } from "../../../errors/conversionError";
 import { ErrorSummary } from "../../../errors/errorSummary";
 import { TSLintConfigurationRules } from "../../../input/findTSLintConfiguration";
@@ -78,21 +80,26 @@ export const convertRules = (
                     continue;
                 }
 
-                // 4d. If not, a rule merger is run to combine it with its existing output settings.
+                // 4d. First it merges the notices, since that is always needed.
+                existingConversion.notices = mergeNotices(existingConversion, newConversion);
+                converted.set(changes.ruleName, existingConversion);
+
+                // 4e. If the existing output has the same arguments as the new output don't bother with a merger.
+                if (isEqual(existingConversion.ruleArguments, newConversion.ruleArguments)) {
+                    continue;
+                }
+
+                // 4f. If not, a rule merger is run to combine it with its existing output settings.
                 const merger = dependencies.ruleMergers.get(changes.ruleName);
                 if (merger === undefined) {
                     failed.push(ConversionError.forMerger(changes.ruleName));
                 } else {
-                    const existingNotices = existingConversion.notices ?? [];
-                    const newNotices = newConversion.notices ?? [];
-
                     converted.set(changes.ruleName, {
                         ...existingConversion,
                         ruleArguments: merger(
                             existingConversion.ruleArguments,
                             newConversion.ruleArguments,
                         ),
-                        notices: Array.from(new Set([...existingNotices, ...newNotices])),
                     });
                 }
             }
@@ -109,3 +116,10 @@ export const convertRules = (
 
     return { converted, failed, missing, plugins, ruleEquivalents };
 };
+
+function mergeNotices(existingConversion: ESLintRuleOptions, newConversion: ESLintRuleOptions) {
+    const existingNotices = existingConversion.notices ?? [];
+    const newNotices = newConversion.notices ?? [];
+
+    return Array.from(new Set([...existingNotices, ...newNotices]));
+}

src/converters/lintConfigs/rules/ruleMergers.ts

@@ -2,7 +2,6 @@ import { mergeBanTypes } from "./ruleMergers/ban-types";
 import { mergeConsistentTypeAssertions } from "./ruleMergers/consistent-type-assertions";
 import { mergeIndent } from "./ruleMergers/indent";
 import { mergeNamingConvention } from "./ruleMergers/naming-convention";
-import { mergeNoCaller } from "./ruleMergers/no-caller";
 import { mergeNoEval } from "./ruleMergers/no-eval";
 import { mergeNoMemberDelimiterStyle } from "./ruleMergers/member-delimiter-style";
 import { mergeNoUnnecessaryTypeAssertion } from "./ruleMergers/no-unnecessary-type-assertion";
@@ -16,6 +15,5 @@ export const ruleMergers = new Map([
     ["@typescript-eslint/naming-convention", mergeNamingConvention],
     ["@typescript-eslint/no-unnecessary-type-assertion", mergeNoUnnecessaryTypeAssertion],
     ["@typescript-eslint/triple-slash-reference", mergeTripleSlashReference],
-    ["no-caller", mergeNoCaller],
     ["no-eval", mergeNoEval],
 ]);