+++ /dev/null
-/**
- * @fileoverview Rule to disallow assignments where both sides are exactly the same
- * @author Toru Nagashima
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const SPACES = /\s+/gu;
-
-/**
- * Checks whether the property of 2 given member expression nodes are the same
- * property or not.
- * @param {ASTNode} left A member expression node to check.
- * @param {ASTNode} right Another member expression node to check.
- * @returns {boolean} `true` if the member expressions have the same property.
- */
-function isSameProperty(left, right) {
- if (left.property.type === "Identifier" &&
- left.property.type === right.property.type &&
- left.property.name === right.property.name &&
- left.computed === right.computed
- ) {
- return true;
- }
-
- const lname = astUtils.getStaticPropertyName(left);
- const rname = astUtils.getStaticPropertyName(right);
-
- return lname !== null && lname === rname;
-}
-
-/**
- * Checks whether 2 given member expression nodes are the reference to the same
- * property or not.
- * @param {ASTNode} left A member expression node to check.
- * @param {ASTNode} right Another member expression node to check.
- * @returns {boolean} `true` if the member expressions are the reference to the
- * same property or not.
- */
-function isSameMember(left, right) {
- if (!isSameProperty(left, right)) {
- return false;
- }
-
- const lobj = left.object;
- const robj = right.object;
-
- if (lobj.type !== robj.type) {
- return false;
- }
- if (lobj.type === "MemberExpression") {
- return isSameMember(lobj, robj);
- }
- if (lobj.type === "ThisExpression") {
- return true;
- }
- return lobj.type === "Identifier" && lobj.name === robj.name;
-}
-
-/**
- * Traverses 2 Pattern nodes in parallel, then reports self-assignments.
- * @param {ASTNode|null} left A left node to traverse. This is a Pattern or
- * a Property.
- * @param {ASTNode|null} right A right node to traverse. This is a Pattern or
- * a Property.
- * @param {boolean} props The flag to check member expressions as well.
- * @param {Function} report A callback function to report.
- * @returns {void}
- */
-function eachSelfAssignment(left, right, props, report) {
- if (!left || !right) {
-
- // do nothing
- } else if (
- left.type === "Identifier" &&
- right.type === "Identifier" &&
- left.name === right.name
- ) {
- report(right);
- } else if (
- left.type === "ArrayPattern" &&
- right.type === "ArrayExpression"
- ) {
- const end = Math.min(left.elements.length, right.elements.length);
-
- for (let i = 0; i < end; ++i) {
- const leftElement = left.elements[i];
- const rightElement = right.elements[i];
-
- // Avoid cases such as [...a] = [...a, 1]
- if (
- leftElement &&
- leftElement.type === "RestElement" &&
- i < right.elements.length - 1
- ) {
- break;
- }
-
- eachSelfAssignment(leftElement, rightElement, props, report);
-
- // After a spread element, those indices are unknown.
- if (rightElement && rightElement.type === "SpreadElement") {
- break;
- }
- }
- } else if (
- left.type === "RestElement" &&
- right.type === "SpreadElement"
- ) {
- eachSelfAssignment(left.argument, right.argument, props, report);
- } else if (
- left.type === "ObjectPattern" &&
- right.type === "ObjectExpression" &&
- right.properties.length >= 1
- ) {
-
- /*
- * Gets the index of the last spread property.
- * It's possible to overwrite properties followed by it.
- */
- let startJ = 0;
-
- for (let i = right.properties.length - 1; i >= 0; --i) {
- const propType = right.properties[i].type;
-
- if (propType === "SpreadElement" || propType === "ExperimentalSpreadProperty") {
- startJ = i + 1;
- break;
- }
- }
-
- for (let i = 0; i < left.properties.length; ++i) {
- for (let j = startJ; j < right.properties.length; ++j) {
- eachSelfAssignment(
- left.properties[i],
- right.properties[j],
- props,
- report
- );
- }
- }
- } else if (
- left.type === "Property" &&
- right.type === "Property" &&
- right.kind === "init" &&
- !right.method
- ) {
- const leftName = astUtils.getStaticPropertyName(left);
-
- if (leftName !== null && leftName === astUtils.getStaticPropertyName(right)) {
- eachSelfAssignment(left.value, right.value, props, report);
- }
- } else if (
- props &&
- left.type === "MemberExpression" &&
- right.type === "MemberExpression" &&
- isSameMember(left, right)
- ) {
- report(right);
- }
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = {
- meta: {
- type: "problem",
-
- docs: {
- description: "disallow assignments where both sides are exactly the same",
- category: "Best Practices",
- recommended: true,
- url: "https://eslint.org/docs/rules/no-self-assign"
- },
-
- schema: [
- {
- type: "object",
- properties: {
- props: {
- type: "boolean",
- default: true
- }
- },
- additionalProperties: false
- }
- ]
- },
-
- create(context) {
- const sourceCode = context.getSourceCode();
- const [{ props = true } = {}] = context.options;
-
- /**
- * Reports a given node as self assignments.
- * @param {ASTNode} node A node to report. This is an Identifier node.
- * @returns {void}
- */
- function report(node) {
- context.report({
- node,
- message: "'{{name}}' is assigned to itself.",
- data: {
- name: sourceCode.getText(node).replace(SPACES, "")
- }
- });
- }
-
- return {
- AssignmentExpression(node) {
- if (node.operator === "=") {
- eachSelfAssignment(node.left, node.right, props, report);
- }
- }
- };
- }
-};
projects / dotfiles / .git / blobdiff