Add new object/array-destructuring options to typedef rule (palantir#…

…2146)
mxl · Jan 28, 2017 · 26700c0 · 26700c0
1 parent ffad65f
commit 26700c0
Show file tree

Hide file tree

Showing 10 changed files with 107 additions and 9 deletions.
diff --git a/src/rules/typedefRule.ts b/src/rules/typedefRule.ts
@@ -32,8 +32,10 @@ export class Rule extends Lint.Rules.AbstractRule {
             * \`"parameter"\` checks type specifier of function parameters for non-arrow functions.
             * \`"arrow-parameter"\` checks type specifier of function parameters for arrow functions.
             * \`"property-declaration"\` checks return types of interface properties.
-            * \`"variable-declaration"\` checks variable declarations.
-            * \`"member-variable-declaration"\` checks member variable declarations.`,
+            * \`"variable-declaration"\` checks non-binding variable declarations.
+            * \`"member-variable-declaration"\` checks member variable declarations.
+            * \`"object-destructuring"\` checks object destructuring declarations.
+            * \`"array-destructuring"\` checks array destructuring declarations.`,
         options: {
             type: "array",
             items: {
@@ -46,6 +48,8 @@ export class Rule extends Lint.Rules.AbstractRule {
                     "property-declaration",
                     "variable-declaration",
                     "member-variable-declaration",
+                    "object-destructuring",
+                    "array-destructuring",
                 ],
             },
             minLength: 0,
@@ -194,7 +198,21 @@ class TypedefWalker extends Lint.RuleWalker {
                 && (node as ts.Node).parent!.kind !== ts.SyntaxKind.CatchClause
                 && node.parent.parent.kind !== ts.SyntaxKind.ForInStatement
                 && node.parent.parent.kind !== ts.SyntaxKind.ForOfStatement) {
-            this.checkTypeAnnotation("variable-declaration", node.name.getEnd(), node.type, node.name);
+
+            let rule: string;
+            switch (node.name.kind) {
+                case ts.SyntaxKind.ObjectBindingPattern:
+                    rule = "object-destructuring";
+                    break;
+                case ts.SyntaxKind.ArrayBindingPattern:
+                    rule = "array-destructuring";
+                    break;
+                default:
+                    rule = "variable-declaration";
+                    break;
+            }
+
+            this.checkTypeAnnotation(rule, node.name.getEnd(), node.type, node.name);
         }
         super.visitVariableDeclaration(node);
     }
@@ -212,13 +230,33 @@ class TypedefWalker extends Lint.RuleWalker {
                                 typeAnnotation: ts.TypeNode | undefined,
                                 name?: ts.Node) {
         if (this.hasOption(option) && typeAnnotation == null) {
-            let ns = "";
-            if (name != null && name.kind === ts.SyntaxKind.Identifier) {
-                ns = `: '${(name as ts.Identifier).text}'`;
-            }
-            this.addFailureAt(location, 1, "expected " + option + ns + " to have a typedef");
+            this.addFailureAt(location, 1, "expected " + option + getName(name, ": '", "'") + " to have a typedef");
+        }
+    }
+}
+
+function getName(name?: ts.Node, prefix?: string, suffix?: string): string {
+    let ns = "";
+
+    if (name != null) {
+        switch (name.kind) {
+            case ts.SyntaxKind.Identifier:
+                ns = (name as ts.Identifier).text;
+                break;
+            case ts.SyntaxKind.BindingElement:
+                ns = getName((name as ts.BindingElement).name);
+                break;
+            case ts.SyntaxKind.ArrayBindingPattern:
+                ns = `[ ${(name as ts.ArrayBindingPattern).elements.map( (n) => getName(n) ).join(", ")} ]`;
+                break;
+            case ts.SyntaxKind.ObjectBindingPattern:
+                ns = `{ ${(name as ts.ObjectBindingPattern).elements.map( (n) => getName(n) ).join(", ")} }`;
+                break;
+            default:
+                break;
         }
     }
+    return ns ? `${prefix || ""}${ns}${suffix || ""}` : "";
 }
 
 function isPropertyDeclaration(node: ts.Node): node is ts.PropertyDeclaration {

diff --git a/test/rules/typedef/all/test.ts.lint b/test/rules/typedef/all/test.ts.lint
@@ -92,3 +92,15 @@ class A {
               ~ [expected member-variable-declaration: 'foo' to have a typedef]
     private bar: number;
 }
+
+
+const { paramA, paramB } = { paramA: "test", paramB: 15 };
+                        ~    [expected object-destructuring: '{ paramA, paramB }' to have a typedef]
+
+const { paramA, paramB }: { paramA: string, paramB: number } = { paramA: "test", paramB: 15 };
+
+const [ paramA, paramB ] = [15, 'test'];
+                        ~    [expected array-destructuring: '[ paramA, paramB ]' to have a typedef]
+
+const [ paramA3, paramB3 ]: [ number, string ] = [15, 'test'];
+
diff --git a/test/rules/typedef/all/tslint.json b/test/rules/typedef/all/tslint.json
@@ -7,7 +7,9 @@
          "arrow-parameter",
          "variable-declaration",
          "property-declaration",
-         "member-variable-declaration"
+         "member-variable-declaration",
+         "object-destructuring",
+         "array-destructuring"
       ]
    }
 }
diff --git a/test/rules/typedef/array-destructuring/test.ts.lint b/test/rules/typedef/array-destructuring/test.ts.lint
@@ -0,0 +1,4 @@
+const [ paramA, paramB ] = [15, 'test'];
+                        ~    [expected array-destructuring: '[ paramA, paramB ]' to have a typedef]
+
+const [ paramA3, paramB3 ]: { number: string, paramB1: string } = [15, 'test'];
diff --git a/test/rules/typedef/array-destructuring/tslint.json b/test/rules/typedef/array-destructuring/tslint.json
@@ -0,0 +1,7 @@
+{
+  "rules": {
+      "typedef": [true,
+         "array-destructuring"
+      ]
+   }
+}
diff --git a/test/rules/typedef/none/test.ts.lint b/test/rules/typedef/none/test.ts.lint
@@ -77,3 +77,11 @@ try {
 for (let i of [1, 2, 3]) {
 
 }
+
+const [ paramA, paramB ] = [ 'test', 15 ];
+
+const { paramA, paramB } = { paramA: "test", paramB: 15 };
+
+const [ paramA3, paramB3 ]: [ number, string ] = [15, 'test'];
+
+const { paramA, paramB }: { paramA: string, paramB: number } = { paramA: "test", paramB: 15 };
diff --git a/test/rules/typedef/object-destructuring/test.ts.lint b/test/rules/typedef/object-destructuring/test.ts.lint
@@ -0,0 +1,7 @@
+
+
+const { paramA, paramB } = { paramA: "test", paramB: 15 };
+                        ~    [expected object-destructuring: '{ paramA, paramB }' to have a typedef]
+
+
+const { paramA, paramB }: { paramA: string, paramB: number } = { paramA: "test", paramB: 15 };
diff --git a/test/rules/typedef/object-destructuring/tslint.json b/test/rules/typedef/object-destructuring/tslint.json
@@ -0,0 +1,7 @@
+{
+  "rules": {
+      "typedef": [true,
+         "object-destructuring"
+      ]
+   }
+}
diff --git a/test/rules/typedef/variable-declaration/test.ts.lint b/test/rules/typedef/variable-declaration/test.ts.lint
@@ -0,0 +1,6 @@
+var NoTypeObjectLiteralWithPropertyGetter = { }
+                                         ~    [expected variable-declaration: 'NoTypeObjectLiteralWithPropertyGetter' to have a typedef]
+
+
+const { paramA, paramB } = { paramA: "test", paramB: 15 };
+const [ paramA, paramB ] = [15, 'test'];
diff --git a/test/rules/typedef/variable-declaration/tslint.json b/test/rules/typedef/variable-declaration/tslint.json
@@ -0,0 +1,7 @@
+{
+  "rules": {
+      "typedef": [true,
+         "variable-declaration"
+      ]
+   }
+}