Added no-unused-expression converter

src/rules/converters.ts

@@ -86,6 +86,7 @@ import { convertNoUnnecessaryQualifier } from "./converters/no-unnecessary-quali
 import { convertNoUnnecessarySemicolons } from "./converters/no-unnecessary-semicolons";
 import { convertNoUnnecessaryTypeAssertion } from "./converters/no-unnecessary-type-assertion";
 import { convertNoUnsafeFinally } from "./converters/no-unsafe-finally";
+import { convertNoUnusedExpression } from "./converters/no-unused-expression";
 import { convertNoUseBeforeDeclare } from "./converters/no-use-before-declare";
 import { convertNoVarKeyword } from "./converters/no-var-keyword";
 import { convertNoVarRequires } from "./converters/no-var-requires";
@@ -210,6 +211,7 @@ export const converters = new Map([
     ["no-unnecessary-semicolons", convertNoUnnecessarySemicolons],
     ["no-unnecessary-type-assertion", convertNoUnnecessaryTypeAssertion],
     ["no-unsafe-finally", convertNoUnsafeFinally],
+    ["no-unused-expression", convertNoUnusedExpression],
     ["no-use-before-declare", convertNoUseBeforeDeclare],
     ["no-var-keyword", convertNoVarKeyword],
     ["no-var-requires", convertNoVarRequires],
@@ -251,7 +253,6 @@ export const converters = new Map([
     // ["ban", convertBan], // no-restricted-properties
     // ["import-blacklist", convertImportBlacklist], // no-restricted-imports
     // ["no-duplicate-variable", convertNoDuplicateVariable], // no-redeclare
-    // ["no-unused-expression", convertNoUnusedExpression], // no-unused-expressions
     // ["space-within-parens", convertSpaceWithinParens], // space-in-parens
     // ["variable-name", convertVariableName], // a bunch of rules...
 

src/rules/converters/no-unused-expression.ts

@@ -0,0 +1,32 @@
+import { RuleConverter } from "../converter";
+
+export const convertNoUnusedExpression: RuleConverter = tslintRule => {
+    return {
+        rules: [
+            {
+                ruleName: "no-unused-expressions",
+                ...collectNoticesAndArguments(tslintRule.ruleArguments),
+            },
+        ],
+    };
+};
+
+const collectNoticesAndArguments = (tsLintRuleArguments: any[]) => {
+    if (tsLintRuleArguments.length === 0) {
+        return undefined;
+    }
+
+    const notices = [];
+    const ruleArguments: any[] = [];
+
+    if (tsLintRuleArguments.includes("allow-tagged-template")) {
+        ruleArguments.push({ allowTaggedTemplates: true });
+    } else {
+        notices.push(`ESLint does not support optional config ${tsLintRuleArguments[0]}.`);
+    }
+
+    return {
+        ...(notices.length > 0 && { notices }),
+        ...(ruleArguments.length > 0 && { ruleArguments }),
+    };
+};

src/rules/converters/tests/no-unused-expression.test.ts

@@ -0,0 +1,47 @@
+import { convertNoUnusedExpression } from "../no-unused-expression";
+
+describe(convertNoUnusedExpression, () => {
+    test("conversion without arguments", () => {
+        const result = convertNoUnusedExpression({
+            ruleArguments: [],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "no-unused-expressions",
+                },
+            ],
+        });
+    });
+
+    test("conversion with allow-tagged-template argument", () => {
+        const result = convertNoUnusedExpression({
+            ruleArguments: ["allow-tagged-template"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleArguments: [{ allowTaggedTemplates: true }],
+                    ruleName: "no-unused-expressions",
+                },
+            ],
+        });
+    });
+
+    test("conversion with argument not equals allow-tagged-template", () => {
+        const result = convertNoUnusedExpression({
+            ruleArguments: ["allow-fast-null-checks"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "no-unused-expressions",
+                    notices: ["ESLint does not support optional config allow-fast-null-checks."],
+                },
+            ],
+        });
+    });
+});