Add SonarTS converters.

src/converters/lintConfigs/rules/ruleConverters.ts

@@ -55,7 +55,7 @@ import { convertNoDuplicateImports } from "./ruleConverters/no-duplicate-imports
 import { convertNoDuplicateSuper } from "./ruleConverters/no-duplicate-super";
 import { convertNoDuplicateSwitchCase } from "./ruleConverters/no-duplicate-switch-case";
 import { convertNoDuplicateVariable } from "./ruleConverters/no-duplicate-variable";
-import { convertNoDynamicDelete } from './ruleConverters/no-dynamic-delete';
+import { convertNoDynamicDelete } from "./ruleConverters/no-dynamic-delete";
 import { convertNoEmpty } from "./ruleConverters/no-empty";
 import { convertNoEmptyInterface } from "./ruleConverters/no-empty-interface";
 import { convertNoEmptyLineAfterOpeningBrace } from "./ruleConverters/no-empty-line-after-opening-brace";
@@ -232,6 +232,45 @@ import { convertNoUnboundMethods } from "./ruleConverters/eslint-plugin-rxjs/no-
 import { convertNoUnsafeSubjectNext } from "./ruleConverters/eslint-plugin-rxjs/no-unsafe-subject-next";
 import { convertNoUnsafeTakeUntil } from "./ruleConverters/eslint-plugin-rxjs/no-unsafe-takeuntil";
 
+// eslint-plugin-sonarjs converters
+import { convertCognitiveComplexity } from "./ruleConverters/eslint-plugin-sonarjs/cognitive-complexity";
+import { convertConsecutiveOverloads } from "./ruleConverters/eslint-plugin-sonarjs/consecutive-overloads";
+import { convertMaxSwitchCases } from "./ruleConverters/eslint-plugin-sonarjs/max-switch-cases";
+import { convertNoAllDuplicatedBranches } from "./ruleConverters/eslint-plugin-sonarjs/no-all-duplicated-branches";
+import { convertNoAlphabeticalSort } from "./ruleConverters/eslint-plugin-sonarjs/no-alphabetical-sort";
+import { convertNoBigFunction } from "./ruleConverters/eslint-plugin-sonarjs/no-big-function";
+import { convertNoCollapsibleIf } from "./ruleConverters/eslint-plugin-sonarjs/no-collapsible-if";
+import { convertNoCollectionSizeMischeck } from "./ruleConverters/eslint-plugin-sonarjs/no-collection-size-mischeck";
+import { convertNoDuplicateString } from "./ruleConverters/eslint-plugin-sonarjs/no-duplicate-string";
+import { convertNoDuplicatedBranches } from "./ruleConverters/eslint-plugin-sonarjs/no-duplicated-branches";
+import { convertNoElementOverwrite } from "./ruleConverters/eslint-plugin-sonarjs/no-element-overwrite";
+import { convertNoEmptyDestructuring } from "./ruleConverters/eslint-plugin-sonarjs/no-empty-destructuring";
+import { convertNoEmptyNestedBlocks } from "./ruleConverters/eslint-plugin-sonarjs/no-empty-nested-blocks";
+import { convertNoExtraSemicolon } from "./ruleConverters/eslint-plugin-sonarjs/no-extra-semicolon";
+import { convertNoIdenticalConditions } from "./ruleConverters/eslint-plugin-sonarjs/no-identical-conditions";
+import { convertNoIdenticalExpressions } from "./ruleConverters/eslint-plugin-sonarjs/no-identical-expressions";
+import { convertNoIdenticalFunctions } from "./ruleConverters/eslint-plugin-sonarjs/no-identical-functions";
+import { convertNoInMisuse } from "./ruleConverters/eslint-plugin-sonarjs/no-in-misuse";
+import { convertNoInvalidAwait } from "./ruleConverters/eslint-plugin-sonarjs/no-invalid-await";
+import { convertNoInvertedBooleanCheck } from "./ruleConverters/eslint-plugin-sonarjs/no-inverted-boolean-check";
+import { convertNoMultilineStringLiterals } from "./ruleConverters/eslint-plugin-sonarjs/no-multiline-string-literals";
+import { convertNoRedundantBoolean } from "./ruleConverters/eslint-plugin-sonarjs/no-redundant-boolean";
+import { convertNoRedundantJump } from "./ruleConverters/eslint-plugin-sonarjs/no-redundant-jump";
+import { convertNoRedundantParentheses } from "./ruleConverters/eslint-plugin-sonarjs/no-redundant-parentheses";
+import { convertNoSameLineConditional } from "./ruleConverters/eslint-plugin-sonarjs/no-same-line-conditional";
+import { convertNoSelfAssignment } from "./ruleConverters/eslint-plugin-sonarjs/no-self-assignment";
+import { convertNoSmallSwitch } from "./ruleConverters/eslint-plugin-sonarjs/no-small-switch";
+import { convertNoUnconditionalJump } from "./ruleConverters/eslint-plugin-sonarjs/no-unconditional-jump";
+import { convertNoUnusedArray } from "./ruleConverters/eslint-plugin-sonarjs/no-unused-array";
+import { convertNoUseOfEmptyReturnValue } from "./ruleConverters/eslint-plugin-sonarjs/no-use-of-empty-return-value";
+import { convertNoUselessCast } from "./ruleConverters/eslint-plugin-sonarjs/no-useless-cast";
+import { convertNoUselessCatch } from "./ruleConverters/eslint-plugin-sonarjs/no-useless-catch";
+import { convertNoVariableUsageBeforeDeclaration } from "./ruleConverters/eslint-plugin-sonarjs/no-variable-usage-before-declaration";
+import { convertParametersMaxNumber } from "./ruleConverters/eslint-plugin-sonarjs/parameters-max-number";
+import { convertPreferDefaultLast } from "./ruleConverters/eslint-plugin-sonarjs/prefer-default-last";
+import { convertPreferImmediateReturn } from "./ruleConverters/eslint-plugin-sonarjs/prefer-immediate-return";
+import { convertUsePrimitiveType } from "./ruleConverters/eslint-plugin-sonarjs/use-primitive-type";
+
 /**
  * Keys TSLint rule names to their ESLint rule converters.
  */
@@ -248,10 +287,12 @@ export const ruleConverters = new Map([
     ["binary-expression-operand-order", convertBinaryExpressionOperandOrder],
     ["callable-types", convertCallableTypes],
     ["class-name", convertClassName],
+    ["cognitive-complexity", convertCognitiveComplexity],
     ["comment-format", convertCommentFormat],
     ["component-class-suffix", convertComponentClassSuffix],
     ["component-max-inline-declarations", convertComponentMaxInlineDeclarations],
     ["component-selector", convertComponentSelector],
+    ["consecutive-overloads", convertConsecutiveOverloads],
     ["contextual-lifecycle", convertContextualLifecycle],
     ["contextual-decorator", convertContextualDecorator],
     ["curly", convertCurly],
@@ -285,20 +326,26 @@ export const ruleConverters = new Map([
     ["max-func-body-length", convertMaxFuncBodyLength],
     ["max-file-line-count", convertMaxFileLineCount],
     ["max-line-length", convertMaxLineLength],
+    ["max-switch-cases", convertMaxSwitchCases],
     ["member-access", convertMemberAccess],
     ["member-ordering", convertMemberOrdering],
     ["mocha-avoid-only", convertMochaAvoidOnly],
     ["new-parens", convertNewParens],
     ["newline-before-return", convertNewlineBeforeReturn],
     ["newline-per-chained-call", convertNewlinePerChainedCall],
+    ["no-all-duplicated-branches", convertNoAllDuplicatedBranches],
+    ["no-alphabetical-sort", convertNoAlphabeticalSort],
     ["no-angle-bracket-type-assertion", convertNoAngleBracketTypeAssertion],
     ["no-any", convertNoExplicitAny],
     ["no-arg", convertNoArg],
     ["no-async-without-await", convertNoAsyncWithoutAwait],
     ["no-attribute-decorator", convertNoAttributeDecorator],
     ["no-banned-terms", convertNoBannedTerms],
+    ["no-big-function", convertNoBigFunction],
     ["no-bitwise", convertNoBitwise],
     ["no-boolean-literal-compare", convertNoBooleanLiteralCompare],
+    ["no-collapsible-if", convertNoCollapsibleIf],
+    ["no-collection-size-mischeck", convertNoCollectionSizeMischeck],
     ["no-conditional-assignment", convertNoConditionalAssignment],
     ["no-conflicting-lifecycle", convertNoConflictingLifecycle],
     ["no-consecutive-blank-lines", convertNoConsecutiveBlankLines],
@@ -310,34 +357,47 @@ export const ruleConverters = new Map([
     ["no-default-export", convertNoDefaultExport],
     ["no-delete-expression", convertNoDeleteExpression],
     ["no-duplicate-imports", convertNoDuplicateImports],
+    ["no-duplicate-string", convertNoDuplicateString],
     ["no-duplicate-super", convertNoDuplicateSuper],
     ["no-duplicate-switch-case", convertNoDuplicateSwitchCase],
     ["no-duplicate-variable", convertNoDuplicateVariable],
+    ["no-duplicated-branches", convertNoDuplicatedBranches],
     ["no-dynamic-delete", convertNoDynamicDelete],
+    ["no-element-overwrite", convertNoElementOverwrite],
+    ["no-empty-destructuring", convertNoEmptyDestructuring],
     ["no-empty-interface", convertNoEmptyInterface],
     ["no-empty-line-after-opening-brace", convertNoEmptyLineAfterOpeningBrace], // padded-blocks
+    ["no-empty-nested-blocks", convertNoEmptyNestedBlocks],
     ["no-empty", convertNoEmpty],
     ["no-eval", convertNoEval],
+    ["no-extra-semicolon", convertNoExtraSemicolon],
     ["no-floating-promises", convertNoFloatingPromises],
     ["no-for-in-array", convertNoForInArray],
     ["no-for-in", convertNoForIn],
     ["no-forward-ref", convertNoForwardRef],
     ["no-host-metadata-property", convertNoHostMetadataProperty],
+    ["no-identical-conditions", convertNoIdenticalConditions],
+    ["no-identical-expressions", convertNoIdenticalExpressions],
+    ["no-identical-functions", convertNoIdenticalFunctions],
     ["no-implicit-dependencies", convertNoImplicitDependencies],
     ["no-import-side-effect", convertNoImportSideEffect],
+    ["no-in-misuse", convertNoInMisuse],
     ["no-inferrable-types", convertNoInferrableTypes],
     ["no-input-prefix", convertNoInputPrefix],
     ["no-input-rename", convertNoInputRename],
     ["no-inputs-metadata-property", convertNoInputsMetadataProperty],
     ["no-internal-module", convertNoInternalModule],
+    ["no-invalid-await", convertNoInvalidAwait],
     ["no-invalid-regexp", convertNoInvalidRegexp],
     ["no-invalid-template-strings", convertNoInvalidTemplateStrings],
     ["no-invalid-this", convertNoInvalidThis],
+    ["no-inverted-boolean-check", convertNoInvertedBooleanCheck],
     ["no-irregular-whitespace", convertNoIrregularWhitespace],
     ["no-lifecycle-call", convertNoLifecycleCall],
     ["no-magic-numbers", convertNoMagicNumbers],
     ["no-misused-new", convertNoMisusedNew],
     ["no-multiline-string", convertNoMultilineString],
+    ["no-multiline-string-literals", convertNoMultilineStringLiterals],
     ["no-namespace", convertNoNamespace],
     ["no-non-null-assertion", convertNoNonNullAssertion],
     ["no-null-keyword", convertNoNullKeyword],
@@ -352,13 +412,19 @@ export const ruleConverters = new Map([
     ["no-parameter-reassignment", convertNoParameterReassignment],
     ["no-pipe-impure", convertNoPipeImpure],
     ["no-queries-metadata-property", convertNoQueriesMetadataProperty],
+    ["no-redundant-boolean", convertNoRedundantBoolean],
+    ["no-redundant-jump", convertNoRedundantJump],
     ["no-redundant-jsdoc", convertNoRedundantJsdoc],
+    ["no-redundant-parentheses", convertNoRedundantParentheses],
     ["no-reference-import", convertNoReferenceImport],
     ["no-reference", convertNoReference],
     ["no-regex-spaces", convertNoRegexSpaces],
     ["no-require-imports", convertNoRequireImports],
     ["no-return-await", convertNoReturnAwait],
+    ["no-same-line-conditional", convertNoSameLineConditional],
+    ["no-self-assignment", convertNoSelfAssignment],
     ["no-shadowed-variable", convertNoShadowedVariable],
+    ["no-small-switch", convertNoSmallSwitch],
     ["no-sparse-arrays", convertNoSparseArrays],
     ["no-string-literal", convertNoStringLiteral],
     ["no-string-throw", convertNoStringThrow],
@@ -368,17 +434,23 @@ export const ruleConverters = new Map([
     ["no-this-assignment", convertNoThisAssignment],
     ["no-trailing-whitespace", convertNoTrailingWhitespace],
     ["no-unbound-method", convertNoUnboundMethod],
+    ["no-unconditional-jump", convertNoUnconditionalJump],
     ["no-unnecessary-class", convertNoUnnecessaryClass],
     ["no-unnecessary-initializer", convertNoUnnecessaryInitializer],
     ["no-unnecessary-qualifier", convertNoUnnecessaryQualifier],
     ["no-unnecessary-semicolons", convertNoUnnecessarySemicolons],
     ["no-unnecessary-type-assertion", convertNoUnnecessaryTypeAssertion],
+    ["no-unused-array", convertNoUnusedArray],
     ["no-unsafe-finally", convertNoUnsafeFinally],
     ["no-unused-expression", convertNoUnusedExpression],
     ["no-unused-variable", convertNoUnusedVariable],
     ["no-use-before-declare", convertNoUseBeforeDeclare],
+    ["no-use-of-empty-return-value", convertNoUseOfEmptyReturnValue],
+    ["no-useless-cast", convertNoUselessCast],
+    ["no-useless-catch", convertNoUselessCatch],
     ["no-var-keyword", convertNoVarKeyword],
     ["no-var-requires", convertNoVarRequires],
+    ["no-variable-usage-before-declaration", convertNoVariableUsageBeforeDeclaration],
     ["no-void-expression", convertNoVoidExpression],
     ["no-with-statement", convertNoWithStatement],
     ["object-literal-key-quotes", convertObjectLiteralKeyQuotes],
@@ -387,12 +459,15 @@ export const ruleConverters = new Map([
     ["one-variable-per-declaration", convertOneVariablePerDeclaration],
     ["only-arrow-functions", convertOnlyArrowFunctions],
     ["ordered-imports", convertOrderedImports],
+    ["parameters-max-number", convertParametersMaxNumber],
     ["pipe-prefix", convertPipePrefix],
     ["prefer-array-literal", convertPreferArrayLiteral],
     ["prefer-conditional-expression", convertPreferConditionalExpression],
     ["prefer-const", convertPreferConst],
+    ["prefer-default-last", convertPreferDefaultLast],
     ["prefer-for-of", convertPreferForOf],
     ["prefer-function-over-method", convertPreferFunctionOverMethod],
+    ["prefer-immediate-return", convertPreferImmediateReturn],
     ["prefer-object-spread", convertPreferObjectSpread],
     ["prefer-on-push-component-change-detection", convertPreferOnPushComponentChangeDetection],
     ["prefer-output-readonly", convertPreferOutputReadonly],
@@ -444,6 +519,7 @@ export const ruleConverters = new Map([
     ["use-lifecycle-interface", convertUseLifecycleInterface],
     ["use-pipe-decorator", convertUsePipeDecorator],
     ["use-pipe-transform-interface", convertUsePipeTransformInterface],
+    ["use-primitive-type", convertUsePrimitiveType],
     ["variable-name", convertVariableName],
     ["rxjs-no-async-subscribe", convertNoAsyncSubscribe],
     ["rxjs-no-implicit-any-catch", convertNoImplicitAnyCatch],

src/converters/lintConfigs/rules/ruleConverters/eslint-plugin-sonarjs/cognitive-complexity.ts

@@ -0,0 +1,15 @@
+import { RuleConverter } from "../../ruleConverter";
+
+export const convertCognitiveComplexity: RuleConverter = (tslintRule) => {
+    return {
+        rules: [
+            {
+                ...(tslintRule.ruleArguments.length !== 0 && {
+                    ruleArguments: tslintRule.ruleArguments,
+                }),
+                ruleName: "sonarjs/cognitive-complexity",
+            },
+        ],
+        plugins: ["sonarjs"],
+    };
+};

src/converters/lintConfigs/rules/ruleConverters/eslint-plugin-sonarjs/consecutive-overloads.ts

@@ -0,0 +1,11 @@
+import { RuleConverter } from "../../ruleConverter";
+
+export const convertConsecutiveOverloads: RuleConverter = () => {
+    return {
+        rules: [
+            {
+                ruleName: "@typescript-eslint/adjacent-overload-signatures",
+            },
+        ],
+    };
+};

src/converters/lintConfigs/rules/ruleConverters/eslint-plugin-sonarjs/max-switch-cases.ts

@@ -0,0 +1,15 @@
+import { RuleConverter } from "../../ruleConverter";
+
+export const convertMaxSwitchCases: RuleConverter = (tslintRule) => {
+    return {
+        rules: [
+            {
+                ...(tslintRule.ruleArguments.length !== 0 && {
+                    ruleArguments: tslintRule.ruleArguments,
+                }),
+                ruleName: "sonarjs/max-switch-cases",
+            },
+        ],
+        plugins: ["sonarjs"],
+    };
+};

src/converters/lintConfigs/rules/ruleConverters/eslint-plugin-sonarjs/no-all-duplicated-branches.ts

@@ -0,0 +1,12 @@
+import { RuleConverter } from "../../ruleConverter";
+
+export const convertNoAllDuplicatedBranches: RuleConverter = () => {
+    return {
+        rules: [
+            {
+                ruleName: "sonarjs/no-all-duplicated-branches",
+            },
+        ],
+        plugins: ["sonarjs"],
+    };
+};

src/converters/lintConfigs/rules/ruleConverters/eslint-plugin-sonarjs/no-alphabetical-sort.ts

@@ -0,0 +1,12 @@
+import { RuleConverter } from "../../ruleConverter";
+
+export const convertNoAlphabeticalSort: RuleConverter = () => {
+    return {
+        rules: [
+            {
+                ruleArguments: [{ ignoreStringArrays: true }],
+                ruleName: "@typescript-eslint/require-array-sort-compare",
+            },
+        ],
+    };
+};

src/converters/lintConfigs/rules/ruleConverters/eslint-plugin-sonarjs/no-big-function.ts

@@ -0,0 +1,12 @@
+import { RuleConverter } from "../../ruleConverter";
+
+export const convertNoBigFunction: RuleConverter = (tslintRule) => {
+    return {
+        rules: [
+            {
+                ruleArguments: [{ max: tslintRule.ruleArguments[0] ?? 200 }],
+                ruleName: "max-lines-per-function",
+            },
+        ],
+    };
+};

src/converters/lintConfigs/rules/ruleConverters/eslint-plugin-sonarjs/no-collapsible-if.ts

@@ -0,0 +1,12 @@
+import { RuleConverter } from "../../ruleConverter";
+
+export const convertNoCollapsibleIf: RuleConverter = () => {
+    return {
+        rules: [
+            {
+                ruleName: "sonarjs/no-collapsible-if",
+            },
+        ],
+        plugins: ["sonarjs"],
+    };
+};

src/converters/lintConfigs/rules/ruleConverters/eslint-plugin-sonarjs/no-collection-size-mischeck.ts

@@ -0,0 +1,12 @@
+import { RuleConverter } from "../../ruleConverter";
+
+export const convertNoCollectionSizeMischeck: RuleConverter = () => {
+    return {
+        rules: [
+            {
+                ruleName: "sonarjs/no-collection-size-mischeck",
+            },
+        ],
+        plugins: ["sonarjs"],
+    };
+};

src/converters/lintConfigs/rules/ruleConverters/eslint-plugin-sonarjs/no-duplicate-string.ts

@@ -0,0 +1,15 @@
+import { RuleConverter } from "../../ruleConverter";
+
+export const convertNoDuplicateString: RuleConverter = (tslintRule) => {
+    return {
+        rules: [
+            {
+                ...(tslintRule.ruleArguments.length !== 0 && {
+                    ruleArguments: tslintRule.ruleArguments,
+                }),
+                ruleName: "sonarjs/no-duplicate-string",
+            },
+        ],
+        plugins: ["sonarjs"],
+    };
+};

src/converters/lintConfigs/rules/ruleConverters/eslint-plugin-sonarjs/no-duplicated-branches.ts

@@ -0,0 +1,12 @@
+import { RuleConverter } from "../../ruleConverter";
+
+export const convertNoDuplicatedBranches: RuleConverter = () => {
+    return {
+        rules: [
+            {
+                ruleName: "sonarjs/no-duplicated-branches",
+            },
+        ],
+        plugins: ["sonarjs"],
+    };
+};

src/converters/lintConfigs/rules/ruleConverters/eslint-plugin-sonarjs/no-element-overwrite.ts

@@ -0,0 +1,12 @@
+import { RuleConverter } from "../../ruleConverter";
+
+export const convertNoElementOverwrite: RuleConverter = () => {
+    return {
+        rules: [
+            {
+                ruleName: "sonarjs/no-element-overwrite",
+            },
+        ],
+        plugins: ["sonarjs"],
+    };
+};

src/converters/lintConfigs/rules/ruleConverters/eslint-plugin-sonarjs/no-empty-destructuring.ts

@@ -0,0 +1,11 @@
+import { RuleConverter } from "../../ruleConverter";
+
+export const convertNoEmptyDestructuring: RuleConverter = () => {
+    return {
+        rules: [
+            {
+                ruleName: "no-empty-pattern",
+            },
+        ],
+    };
+};

src/converters/lintConfigs/rules/ruleConverters/eslint-plugin-sonarjs/no-empty-nested-blocks.ts

@@ -0,0 +1,12 @@
+import { RuleConverter } from "../../ruleConverter";
+
+export const convertNoEmptyNestedBlocks: RuleConverter = () => {
+    return {
+        rules: [
+            {
+                ruleArguments: [{ allowEmptyCatch: true }],
+                ruleName: "no-empty",
+            },
+        ],
+    };
+};