Fix readonly-array ignore-local not working in class methods

src/readonly-shared.ts

@@ -45,9 +45,10 @@ export function walk(ctx: Lint.WalkContext<Options>, checkNode: CheckNodeFunctio
   function cb(node: ts.Node): void {
     // Skip checking in functions if ignore-local is set
     if (ctx.options.ignoreLocal && (node.kind === ts.SyntaxKind.FunctionDeclaration
-      || node.kind === ts.SyntaxKind.ArrowFunction || node.kind === ts.SyntaxKind.FunctionExpression)) {
+      || node.kind === ts.SyntaxKind.ArrowFunction || node.kind === ts.SyntaxKind.FunctionExpression
+      || node.kind === ts.SyntaxKind.MethodDeclaration)) {
       // We still need to check the parameters and return type
-      const functionNode: ts.FunctionDeclaration | ts.ArrowFunction = node as any; //tslint:disable-line
+      const functionNode: ts.FunctionDeclaration | ts.ArrowFunction | ts.MethodDeclaration = node as any; //tslint:disable-line
       const invalidNodes = checkIgnoreLocalFunctionNode(functionNode, ctx, checkNode);
       // invalidNodes.forEach((n) => reportInvalidNodes(n, ctx, failureString));
       reportInvalidNodes(invalidNodes, ctx, failureString);
@@ -65,7 +66,7 @@ export function reportInvalidNodes(invalidNodes: ReadonlyArray<InvalidNode>, ctx
   invalidNodes.forEach((invalidNode) => ctx.addFailureAtNode(invalidNode.node, failureString, invalidNode.replacement));
 }
 
-export function checkIgnoreLocalFunctionNode(functionNode: ts.FunctionDeclaration | ts.ArrowFunction,
+export function checkIgnoreLocalFunctionNode(functionNode: ts.FunctionDeclaration | ts.ArrowFunction | ts.MethodDeclaration,
   ctx: Lint.WalkContext<Options>, checkNode: CheckNodeFunction): ReadonlyArray<InvalidNode> {
 
   let invalidNodes: Array<InvalidNode> = [];

src/readonlyArrayRule.ts

@@ -42,7 +42,8 @@ function checkArrayTypeOrReference(node: ts.Node, ctx: Lint.WalkContext<Shared.O
 
 function checkVariableOrParameterImplicitType(node: ts.Node, ctx: Lint.WalkContext<Shared.Options>): ReadonlyArray<Shared.InvalidNode> {
 
-  if (node.kind === ts.SyntaxKind.VariableDeclaration || node.kind === ts.SyntaxKind.Parameter) {
+  if (node.kind === ts.SyntaxKind.VariableDeclaration || node.kind === ts.SyntaxKind.Parameter
+    || node.kind === ts.SyntaxKind.PropertyDeclaration) {
     // The initializer is used to set and implicit type
     const varOrParamNode = node as ts.VariableDeclaration | ts.ParameterDeclaration;
     if (Shared.shouldIgnorePrefix(node, ctx.options, ctx.sourceFile)) {

test/rules/readonly-array/ignore-local/variable.ts.lint

@@ -51,4 +51,44 @@ const foo = (bar: Array<string>, zoo: ReadonlyArray<string>, boo = [1, 2, 3]) =>
 
 }
 
+// -- Inside class
+
+class Foo {
+
+  // -- Class-level variable declarations
+
+  // Should not fail on ReadonlyArray in variable declaration (TypeReferenceNode)
+  const foo: ReadonlyArray<string> = [];
+
+  // Should fail on Array type in variable declaration (TypeReferenceNode)
+  const foo: Array<string> = [];
+             ~~~~~~~~~~~~~ [failure]
+
+  // Should fail on implicit Array type in variable declaration (ArrayLiteralExpression)
+  const foo = [1, 2, 3]
+        ~~~ [failure]
+
+  // -- Class level functions: Local variable declarations
+
+  // Should fail on Array type in variable declaration as function parameter (TypeReferenceNode)
+  foo(bar: Array<string>, zoo: ReadonlyArray<string>, boo = [1, 2, 3]) {
+           ~~~~~~~~~~~~~ [failure]
+                                                      ~~~ [failure]
+
+    // Should not fail on ReadonlyArray in variable declaration (TypeReferenceNode)
+    const foo: ReadonlyArray<string> = [];
+
+    // Should not fail on Array type in variable declaration when local (TypeReferenceNode)
+    const foo: Array<string> = [];
+
+    // Should not fail on Array shorthand in variable declaration when local (TypeReferenceNode)
+    const foo: string[] = [];
+
+    // Should not fail on implicit Array type in variable declaration when local (ArrayLiteralExpression)
+    const foo = [1, 2, 3]
+
+  }
+
+}
+
 [failure]: Only ReadonlyArray allowed.

test/rules/readonly-array/work/variable.ts.lint

@@ -1,6 +1,13 @@
-// Should fail on implicit Array type in variable declaration (ArrayLiteralExpression)
-const foo = [1, 2, 3]
-      ~~~ [failure]
 
+class Foo {
+
+  foo(bar: Array<string>, zoo: ReadonlyArray<string>, boo = [1, 2, 3]) {
+           ~~~~~~~~~~~~~ [failure]
+                                                      ~~~ [failure]
+
+    const foo: Array<string> = [];
+  }
+
+}
 
 [failure]: Only ReadonlyArray allowed.