New: hasSideEffect function

Author: mysticatea

docs/api/ast-utils.md

@@ -350,6 +350,67 @@ function getStringIfConstant(node, initialScope) {
 
 ----
 
+## hasSideEffect
+
+```js
+const ret = utils.hasSideEffect(node, sourceCode, options)
+```
+
+Check whether a given node has any side effect or not.
+
+The side effect means that it *may* modify a certain variable or object member. This function considers the node which contains the following types as the node which has side effects:
+
+- `AssignmentExpression`
+- `AwaitExpression`
+- `CallExpression`
+- `NewExpression`
+- `UnaryExpression` (`[operator = "delete"]`)
+- `UpdateExpression`
+- `YieldExpression`
+- When `options.considerGetters` is `true`:
+    - `MemberExpression`
+- When `options.considerImplicitTypeConversion` is `true`:
+    - `BinaryExpression` (`[operator = "==" | "!=" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "|" | "^" | "&" | "in"]`)
+    - `MemberExpression` (`[computed = true]`)
+    - `MethodDefinition` (`[computed = true]`)
+    - `Property` (`[computed = true]`)
+    - `UnaryExpression` (`[operator = "-" | "+" | "!" | "~"]`)
+
+### Parameters
+
+ Name | Type | Description
+:-----|:-----|:------------
+node | Node | The node to check.
+sourceCode | SourceCode | The source code object to get visitor keys.
+options.considerGetters | boolean | Default is `false`. If `true` then it considers member accesses as the node which has side effects.
+options.considerImplicitTypeConversion | boolean | Default is `false`. If `true` then it considers implicit type conversion as the node which has side effects.
+
+### Return value
+
+`true` if the node has a certain side effect.
+
+### Example
+
+```js{9}
+const { hasSideEffect } = require("eslint-utils")
+
+module.exports = {
+    meta: {},
+    create(context) {
+        const sourceCode = context.getSourceCode()
+        return {
+            ":expression"(node) {
+                if (hasSideEffect(node, sourceCode)) {
+                    // ...
+                }
+            },
+        }
+    },
+}
+```
+
+----
+
 ## isParenthesized
 
 ```js

package.json

@@ -9,7 +9,9 @@
   "files": [
     "index.*"
   ],
-  "dependencies": {},
+  "dependencies": {
+    "eslint-visitor-keys": "^1.0.0"
+  },
   "devDependencies": {
     "@mysticatea/eslint-plugin": "^5.0.1",
     "codecov": "^3.0.2",

src/has-side-effect.js

@@ -0,0 +1,164 @@
+import evk from "eslint-visitor-keys"
+
+const typeConversionBinaryOps = Object.freeze(
+    new Set([
+        "==",
+        "!=",
+        "<",
+        "<=",
+        ">",
+        ">=",
+        "<<",
+        ">>",
+        ">>>",
+        "+",
+        "-",
+        "*",
+        "/",
+        "%",
+        "|",
+        "^",
+        "&",
+        "in",
+    ])
+)
+const typeConversionUnaryOps = Object.freeze(new Set(["-", "+", "!", "~"]))
+const visitor = Object.freeze(
+    Object.assign(Object.create(null), {
+        $visit(node, options, visitorKeys) {
+            const { type } = node
+
+            if (typeof this[type] === "function") {
+                return this[type](node, options, visitorKeys)
+            }
+
+            return this.$visitChildren(node, options, visitorKeys)
+        },
+
+        $visitChildren(node, options, visitorKeys) {
+            const { type } = node
+
+            for (const key of visitorKeys[type] || evk.getKeys(node)) {
+                const value = node[key]
+
+                if (Array.isArray(value)) {
+                    for (const element of value) {
+                        if (
+                            element &&
+                            this.$visit(element, options, visitorKeys)
+                        ) {
+                            return true
+                        }
+                    }
+                } else if (value && this.$visit(value, options, visitorKeys)) {
+                    return true
+                }
+            }
+
+            return false
+        },
+
+        ArrowFunctionExpression() {
+            return false
+        },
+        AssignmentExpression() {
+            return true
+        },
+        AwaitExpression() {
+            return true
+        },
+        BinaryExpression(node, options, visitorKeys) {
+            if (
+                options.considerImplicitTypeConversion &&
+                typeConversionBinaryOps.has(node.operator) &&
+                (node.left.type !== "Literal" || node.right.type !== "Literal")
+            ) {
+                return true
+            }
+            return this.$visitChildren(node, options, visitorKeys)
+        },
+        CallExpression() {
+            return true
+        },
+        FunctionExpression() {
+            return false
+        },
+        MemberExpression(node, options, visitorKeys) {
+            if (options.considerGetters) {
+                return true
+            }
+            if (
+                options.considerImplicitTypeConversion &&
+                node.computed &&
+                node.property.type !== "Literal"
+            ) {
+                return true
+            }
+            return this.$visitChildren(node, options, visitorKeys)
+        },
+        MethodDefinition(node, options, visitorKeys) {
+            if (
+                options.considerImplicitTypeConversion &&
+                node.computed &&
+                node.key.type !== "Literal"
+            ) {
+                return true
+            }
+            return this.$visitChildren(node, options, visitorKeys)
+        },
+        NewExpression() {
+            return true
+        },
+        Property(node, options, visitorKeys) {
+            if (
+                options.considerImplicitTypeConversion &&
+                node.computed &&
+                node.key.type !== "Literal"
+            ) {
+                return true
+            }
+            return this.$visitChildren(node, options, visitorKeys)
+        },
+        UnaryExpression(node, options, visitorKeys) {
+            if (node.operator === "delete") {
+                return true
+            }
+            if (
+                options.considerImplicitTypeConversion &&
+                typeConversionUnaryOps.has(node.operator) &&
+                node.argument.type !== "Literal"
+            ) {
+                return true
+            }
+            return this.$visitChildren(node, options, visitorKeys)
+        },
+        UpdateExpression() {
+            return true
+        },
+        YieldExpression() {
+            return true
+        },
+    })
+)
+
+/**
+ * Check whether a given node has any side effect or not.
+ * @param {Node} node The node to get.
+ * @param {SourceCode} sourceCode The source code object.
+ * @param {object} [options] The option object.
+ * @param {boolean} [options.considerGetters=false] If `true` then it considers member accesses as the node which has side effects.
+ * @param {boolean} [options.considerImplicitTypeConversion=false] If `true` then it considers implicit type conversion as the node which has side effects.
+ * @param {object} [options.visitorKeys=evk.KEYS] The keys to traverse nodes. Use `context.getSourceCode().visitorKeys`.
+ * @returns {boolean} `true` if the node has a certain side effect.
+ */
+export function hasSideEffect(
+    node,
+    sourceCode,
+    { considerGetters = false, considerImplicitTypeConversion = false } = {}
+) {
+    return visitor.$visit(
+        node,
+        { considerGetters, considerImplicitTypeConversion },
+        sourceCode.visitorKeys || evk.KEYS
+    )
+}

src/index.js

@@ -5,6 +5,7 @@ import { getInnermostScope } from "./get-innermost-scope"
 import { getPropertyName } from "./get-property-name"
 import { getStaticValue } from "./get-static-value"
 import { getStringIfConstant } from "./get-string-if-constant"
+import { hasSideEffect } from "./has-side-effect"
 import { isParenthesized } from "./is-parenthesized"
 import { PatternMatcher } from "./pattern-matcher"
 import {
@@ -50,6 +51,7 @@ export default {
     getPropertyName,
     getStaticValue,
     getStringIfConstant,
+    hasSideEffect,
     isArrowToken,
     isClosingBraceToken,
     isClosingBracketToken,
@@ -88,6 +90,7 @@ export {
     getPropertyName,
     getStaticValue,
     getStringIfConstant,
+    hasSideEffect,
     isArrowToken,
     isClosingBraceToken,
     isClosingBracketToken,