add ignoreAssignmentVariable

Author: gurgunday

Diff for: __tests__/always-return.js

@@ -105,6 +105,14 @@ ruleTester.run('always-return', rule, {
         .finally(() => console.error('end'))`,
       options: [{ ignoreLastCallback: true }],
     },
+    {
+      code: `hey.then(x => { window.a = x })`,
+      options: [{ ignoreAssignmentVariable: ['window'] }],
+    },
+    {
+      code: `hey.then(x => { window.a.x = x })`,
+      options: [{ ignoreAssignmentVariable: ['window.a'] }],
+    },
   ],
 
   invalid: [
@@ -230,5 +238,30 @@ ruleTester.run('always-return', rule, {
       options: [{ ignoreLastCallback: true }],
       errors: [{ message }],
     },
+    {
+      code: `hey.then(x => { console.log(x) })`,
+      options: [{ ignoreAssignmentVariable: ['window'] }],
+      errors: [{ message }],
+    },
+    {
+      code: `hey.then(x => { console.log(x) })`,
+      options: [{ ignoreAssignmentVariable: ['window.s'] }],
+      errors: [{ message }],
+    },
+    {
+      code: `hey.then(x => { ++window.a })`,
+      options: [{ ignoreAssignmentVariable: ['window.a'] }],
+      errors: [{ message }],
+    },
+    {
+      code: `hey.then(x => { window.a.b.c = x })`,
+      options: [{ ignoreAssignmentVariable: ['window.a'] }],
+      errors: [{ message }],
+    },
+    {
+      code: `hey.then(x => { let a = x })`,
+      options: [{ ignoreAssignmentVariable: ['window.a'] }],
+      errors: [{ message }],
+    },
   ],
 })

Diff for: docs/rules/always-return.md

@@ -49,9 +49,9 @@ myPromise.then((b) => {
 
 ##### `ignoreLastCallback`
 
-You can pass an `{ ignoreLastCallback: true }` as an option to this rule to the
-last `then()` callback in a promise chain does not warn if it does not have a
-`return`. Default is `false`.
+You can pass an `{ ignoreLastCallback: true }` as an option to this rule so that
+the last `then()` callback in a promise chain does not warn if it does not have
+a `return`. Default is `false`.
 
 ```js
 // OK
@@ -92,3 +92,29 @@ function foo() {
   })
 }
 ```
+
+##### `ignoreAssignmentVariable`
+
+You can pass an `{ ignoreAssignmentVariable: [] }` as an option to this rule
+with a list of variable names so that the last `then()` callback in a promise
+chain does not warn if it does an assignment to a global variable. Default is
+`[]`.
+
+```js
+/* eslint promise/always-return: ["error", { ignoreAssignmentVariable: ["window"] }] */
+
+// OK
+promise.then((x) => {
+  window.x = x
+})
+
+promise
+  // NG
+  .then((x) => {
+    window.x.y = x
+  })
+  // NG
+  .then((x) => {
+    let b = x
+  })
+```

Diff for: rules/always-return.js

@@ -124,6 +124,34 @@ function peek(arr) {
   return arr[arr.length - 1]
 }
 
+/**
+ * Checks if the node is an assignment to an ignored variable
+ * @param {Node} node
+ * @param {string[]} ignoredVars
+ * @returns {boolean}
+ */
+function isIgnoredAssignment(node, ignoredVars) {
+  if (node.type !== 'ExpressionStatement') return false
+  const expr = node.expression
+  if (expr.type !== 'AssignmentExpression') return false
+  const left = expr.left
+  // istanbul ignore else
+  if (left.type === 'MemberExpression') {
+    if (left.object.type === 'Identifier') {
+      return ignoredVars.includes(left.object.name)
+    }
+    if (
+      left.object.type === 'MemberExpression' &&
+      left.object.object.type === 'Identifier'
+    ) {
+      const fullName = `${left.object.object.name}.${left.object.property.name}`
+      return ignoredVars.includes(fullName)
+    }
+  }
+  // fallback
+  return false
+}
+
 module.exports = {
   meta: {
     type: 'problem',
@@ -139,6 +167,13 @@ module.exports = {
           ignoreLastCallback: {
             type: 'boolean',
           },
+          ignoreAssignmentVariable: {
+            type: 'array',
+            items: {
+              type: 'string',
+            },
+            uniqueItems: true,
+          },
         },
         additionalProperties: false,
       },
@@ -150,6 +185,7 @@ module.exports = {
   create(context) {
     const options = context.options[0] || {}
     const ignoreLastCallback = !!options.ignoreLastCallback
+    const ignoreAssignmentVariable = options.ignoreAssignmentVariable || []
     /**
      * @typedef {object} FuncInfo
      * @property {string[]} branchIDStack This is a stack representing the currently
@@ -244,6 +280,23 @@ module.exports = {
           return
         }
 
+        if (ignoreAssignmentVariable.length && isLastCallback(node)) {
+          let hasIgnoredAssignment = false
+
+          //istanbul ignore else
+          if (node.body?.type === 'BlockStatement') {
+            node.body.body.forEach((statement) => {
+              if (isIgnoredAssignment(statement, ignoreAssignmentVariable)) {
+                hasIgnoredAssignment = true
+              }
+            })
+          }
+
+          if (hasIgnoredAssignment) {
+            return
+          }
+        }
+
         path.finalSegments.forEach((segment) => {
           const id = segment.id
           const branch = funcInfo.branchInfoMap[id]