feat: don't require $ReadOnlyArray if variable is initialized with empty array (#337)

* feat: Don't require $ReadOnlyArray if variable is initialized with empty array * docs: phrasing

Author: pnevyk

.README/rules/no-mutable-array.md

@@ -13,4 +13,6 @@ General reasons for using immutable data structures:
 * They always have failure atomicity
 * They are much easier to cache
 
+Note that initialization of a variable with an empty array is considered valid (e.g., `const values: Array<string> = [];`). This behavior resembles the behavior of Flow's [unsealed objects](https://flow.org/en/docs/types/objects/#toc-unsealed-objects), as it is assumed that empty array is intended to be mutated.
+
 <!-- assertions noMutableArray -->

src/rules/noMutableArray.js

@@ -1,20 +1,49 @@
+import _ from 'lodash';
+
 const schema = [];
 
+// const x = [];
+const isEmptyArrayLiteral = (node) => {
+ return _.get(node, 'init.type') === 'ArrayExpression' && _.get(node, 'init.elements.length') === 0;
+};
+
+// const x = new Array(); const y = Array();
+const isEmptyArrayInstance = (node) => {
+ if (_.get(node, 'init.type') === 'NewExpression' || _.get(node, 'init.type') === 'CallExpression') {
+ return _.get(node, 'init.callee.name') === 'Array' && _.get(node, 'init.arguments.length') === 0;
+ } else {
+ return false;
+ }
+};
+
+const isAnnotationOfEmptyArrayInit = (node) => {
+ if (_.has(node, 'parent.parent.parent')) {
+ const parent = _.get(node, 'parent.parent.parent');
+ const isVariableDeclaration = _.get(parent, 'type') === 'VariableDeclarator';
+
+ return isVariableDeclaration && (isEmptyArrayLiteral(parent) || isEmptyArrayInstance(parent));
+ } else {
+ return false;
+ }
+};
+
 const create = (context) => {
  return {
  ArrayTypeAnnotation (node) {
- context.report({
- fix (fixer) {
- const rawElementType = context.getSourceCode().getText(node.elementType);
-
- return fixer.replaceText(node, '$ReadOnlyArray<' + rawElementType + '>');
- },
- message: 'Use "$ReadOnlyArray" instead of array shorthand notation',
- node
- });
+ if (!isAnnotationOfEmptyArrayInit(node)) {
+ context.report({
+ fix (fixer) {
+ const rawElementType = context.getSourceCode().getText(node.elementType);
+
+ return fixer.replaceText(node, '$ReadOnlyArray<' + rawElementType + '>');
+ },
+ message: 'Use "$ReadOnlyArray" instead of array shorthand notation',
+ node
+ });
+ }
  },
  GenericTypeAnnotation (node) {
- if (node.id.name === 'Array') {
+ if (node.id.name === 'Array' && !isAnnotationOfEmptyArrayInit(node)) {
  context.report({
  fix (fixer) {
  return fixer.replaceText(node.id, '$ReadOnlyArray');

tests/rules/assertions/noMutableArray.js

@@ -9,11 +9,36 @@ export default {
  code: 'type X = string[]',
  errors: [{message: 'Use "$ReadOnlyArray" instead of array shorthand notation'}],
  output: 'type X = $ReadOnlyArray<string>'
+ },
+ {
+ code: 'const values: Array<Array<string>> = [];',
+ errors: [{message: 'Use "$ReadOnlyArray" instead of "Array"'}],
+ output: 'const values: Array<$ReadOnlyArray<string>> = [];'
+ },
+ {
+ code: 'let values: Array<Array<string>>;',
+ errors: [
+ {message: 'Use "$ReadOnlyArray" instead of "Array"'},
+ {message: 'Use "$ReadOnlyArray" instead of "Array"'}
+ ],
+ output: 'let values: $ReadOnlyArray<$ReadOnlyArray<string>>;'
  }
  ],
  valid: [
  {
  code: 'type X = $ReadOnlyArray<string>'
+ },
+ {
+ code: 'const values: Array<$ReadOnlyArray<string>> = [];'
+ },
+ {
+ code: 'const values: $ReadOnlyArray<string>[] = [];'
+ },
+ {
+ code: 'const values: Array<$ReadOnlyArray<string>> = new Array();'
+ },
+ {
+ code: 'const values: Array<$ReadOnlyArray<string>> = Array();'
  }
  ]
 };