Remove some unused helpers

ark120202 · ark120202 · commit 220481dd1fe9 · 2019-05-05T21:19:44.000+05:00
diff --git a/src/TSHelper.ts b/src/TSHelper.ts
@@ -29,32 +29,7 @@ const defaultArrayCallMethodNames = new Set<string>([
     "flatMap",
 ]);
 
-const defaultArrayPropertyNames = new Set<string>([
-    "length",
-]);
-
 export class TSHelper {
-    // Reverse lookup of enum key by value
-    public static enumName<T>(needle: T, haystack: any): string {
-        for (const name in haystack) {
-            if (haystack[name] === needle) {
-                return name;
-            }
-        }
-        return "unknown";
-    }
-
-    // Breaks down a mask into all flag names.
-    public static enumNames<T>(mask: number, haystack: any): string[] {
-        const result = [];
-        for (const name in haystack) {
-            if ((mask & haystack[name]) !== 0 && mask >= haystack[name]) {
-                result.push(name);
-            }
-        }
-        return result;
-    }
-
     public static getExtendedTypeNode(node: ts.ClassLikeDeclarationBase, checker: ts.TypeChecker):
     ts.ExpressionWithTypeArguments | undefined {
         if (node && node.heritageClauses) {
@@ -353,21 +328,6 @@ export class TSHelper {
         return [false, undefined];
     }
 
-    public static isExpressionStatement(node: ts.Expression): boolean {
-        return node.parent === undefined || ts.isExpressionStatement(node.parent) || ts.isForStatement(node.parent);
-    }
-
-    public static isInGlobalScope(node: ts.Node): boolean {
-        let parent = node.parent;
-        while (parent !== undefined) {
-            if (ts.isBlock(parent)) {
-                return false;
-            }
-            parent = parent.parent;
-        }
-        return true;
-    }
-
     // Returns true for expressions that may have effects when evaluated
     public static isExpressionWithEvaluationEffect(node: ts.Expression): boolean {
         return !(ts.isLiteralExpression(node) || ts.isIdentifier(node) || node.kind === ts.SyntaxKind.ThisKeyword);
@@ -644,10 +604,6 @@ export class TSHelper {
             signatureDeclarations.map(s => TSHelper.getDeclarationContextType(s, checker)));
     }
 
-    public static isDefaultArrayPropertyName(methodName: string): boolean {
-        return defaultArrayPropertyNames.has(methodName);
-    }
-
     public static escapeString(text: string): string {
         // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String
         const escapeSequences: Array<[RegExp, string]> = [
diff --git a/src/TSTLErrors.ts b/src/TSTLErrors.ts
@@ -115,10 +115,7 @@ export class TSTLErrors {
         new TranspileError(`Unsupported import type.`, node);
 
     public static UnsupportedKind = (description: string, kind: ts.SyntaxKind, node: ts.Node) =>
-        {
-            const kindName = tsHelper.enumName(kind, ts.SyntaxKind);
-            return new TranspileError(`Unsupported ${description} kind: ${kindName}`, node);
-        };
+        new TranspileError(`Unsupported ${description} kind: ${ts.SyntaxKind[kind]}`, node);
 
     public static UnsupportedProperty = (parentName: string, property: string, node: ts.Node) =>
         new TranspileError(`Unsupported property on ${parentName}: ${property}`, node);
diff --git a/test/unit/tshelper.spec.ts b/test/unit/tshelper.spec.ts
@@ -3,36 +3,6 @@ import { DecoratorKind } from "../../src/Decorator";
 import { TSHelper as tsHelper } from "../../src/TSHelper";
 import * as util from "../util";
 
-enum TestEnum {
-    testA = 1,
-    testB = 2,
-    testC = 4,
-}
-
-test.each([
-    { inp: TestEnum.testA, expected: "testA" },
-    { inp: -1, expected: "unknown" },
-    { inp: TestEnum.testA | TestEnum.testB, expected: "unknown" },
-])("EnumName (%p)", ({ inp, expected }) => {
-    const result = tsHelper.enumName(inp, TestEnum);
-
-    expect(result).toEqual(expected);
-});
-
-test.each([
-    { inp: TestEnum.testA, expected: ["testA"] },
-    { inp: -1, expected: [] },
-    { inp: TestEnum.testA | TestEnum.testC, expected: ["testA", "testC"] },
-    {
-        inp: TestEnum.testA | TestEnum.testB | TestEnum.testC,
-        expected: ["testA", "testB", "testC"],
-    },
-])("EnumNames (%p)", ({ inp, expected }) => {
-    const result = tsHelper.enumNames(inp, TestEnum);
-
-    expect(result).toEqual(expected);
-});
-
 test("GetCustomDecorators single", () => {
     const source = `
         /** @compileMembersOnly */
