Fix #459: function-name rule should ignore computed names (#505)

src/functionNameRule.ts

@@ -113,7 +113,9 @@ class FunctionNameRuleWalker extends ErrorTolerantWalker {
 
     protected visitMethodDeclaration(node: ts.MethodDeclaration): void {
         const name: string = node.name.getText();
-        if (AstUtils.isPrivate(node)) {
+        if (AstUtils.hasComputedName(node)) {
+            // allow computed names
+        } else if (AstUtils.isPrivate(node)) {
             if (
                 !this.privateMethodRegex.test(name)
                 && this.args.validateStatics === VALIDATE_PRIVATE_STATICS_AS_PRIVATE) {

src/tests/FunctionNameRuleTests.ts

@@ -26,6 +26,27 @@ describe('functionNameRule', () : void => {
         TestHelper.assertViolations(ruleName, script, [ ]);
     });
 
+    it('should pass on functions as symbol properties', (): void => {
+        const script : string = `
+            class MyClass {
+                static [Symbol.staticDefault](): any {}
+                public static [Symbol.staticPublic](): any {}
+                protected static [Symbol.staticProtected](): any {}
+                private static [Symbol.staticPrivate](): any {}
+
+                static [Symbol.methodDefault](): any {}
+                public static [Symbol.methodPublic](): any {}
+                protected static [Symbol.methodProtected](): any {}
+                private static [Symbol.methodPrivate](): any {}
+            }
+
+            const objLiteral = {
+                [Symbol.toStringTag](): string => "hello world"
+            }
+        `;
+        TestHelper.assertViolations(ruleName, script, [ ]);
+    });
+
     it('should pass on correctly public static methods', () : void => {
         const script : string = `
             class MyClass {

src/utils/AstUtils.ts

@@ -149,6 +149,14 @@ export module AstUtils {
         /* tslint:enable:no-bitwise */
     }
 
+    export function hasComputedName(node: ts.Node & { name?: ts.PropertyName }): boolean {
+        if (!node.name) {
+            return false;
+        }
+
+        return ts.isComputedPropertyName(node.name);
+    }
+
     function isBindingPattern(node: ts.Node): node is ts.BindingPattern {
         return node != null && (node.kind === ts.SyntaxKind.ArrayBindingPattern ||
             node.kind === ts.SyntaxKind.ObjectBindingPattern);