1.2.0

Author: [Interfaced] Кирилл Дронкин

CHANGELOG.md

@@ -1,5 +1,10 @@
 # Change log
 
+## 1.2.0 (release date: 30.08.2018)
+
+* New redefinitions:
+    - `no-param-reassign` to ignore report for self assignment with typecast
+
 ## 1.1.2 (release date: 2.08.2018)
 
 * `lines-around-class`: handle nested classes

README.md

@@ -64,6 +64,7 @@ Some useful rules which are provided by ESLint are slightly inappropriate for Cl
 so we redefine them with some adjusting for our requirements.
 
 * [interfaced/camelcase](docs/redefined/camelcase.md)
+* [interfaced/no-param-reassign](docs/redefined/no-param-reassign.md)
 * [interfaced/no-unused-expressions](docs/redefined/no-unused-expressions.md)
 * [interfaced/require-jsdoc](docs/redefined/require-jsdoc.md)
 * [interfaced/valid-jsdoc](docs/redefined/valid-jsdoc.md)

docs/redefined/camelcase.md

@@ -16,4 +16,4 @@ but doesn't when `interfaced/camelcase` is used.
 
 * [Original](https://eslint.org/docs/rules/camelcase)
 * [Source](../../lib/rules/redefined/camelcase.js)
-* [Tests](../../test/eslint/rules/camelcase.js)
+* [Tests](../../test/eslint/rules/redefined/camelcase.js)

docs/redefined/no-param-reassign.md

@@ -0,0 +1,29 @@
+# interfaced/no-param-reassign
+
+Ignore report for self assignment with typecast.
+
+## Examples
+
+The following code causes the reports for `arg` from original `no-param-reassign`:
+
+```js
+function func(arg) {
+	arg = /** @type {string} */ (arg);
+}
+```
+
+and when `props` option is set to `true`:
+
+```js
+function func(arg) {
+	arg.a = /** @type {string} */ (arg.a);
+}
+```
+
+but doesn't when `interfaced/no-param-reassign` is used.
+
+## Resources
+
+* [Original](https://eslint.org/docs/rules/no-param-reassign)
+* [Source](../../lib/rules/redefined/no-param-reassign.js)
+* [Tests](../../test/eslint/rules/redefined/no-param-reassign.js)

docs/redefined/no-unused-expressions.md

@@ -30,4 +30,4 @@ but doesn't when `interfaced/no-unused-expressions` is used.
 
 * [Original](https://eslint.org/docs/rules/no-unused-expressions)
 * [Source](../../lib/rules/redefined/no-unused-expressions.js)
-* [Tests](../../test/eslint/rules/no-unused-expressions.js)
+* [Tests](../../test/eslint/rules/redefined/no-unused-expressions.js)

docs/redefined/require-jsdoc.md

@@ -17,4 +17,4 @@ but does when `interfaced/require-jsdoc` is used.
 
 * [Original](https://eslint.org/docs/rules/require-jsdoc)
 * [Source](../../lib/rules/redefined/require-jsdoc.js)
-* [Tests](../../test/eslint/rules/require-jsdoc.js)
+* [Tests](../../test/eslint/rules/redefined/require-jsdoc.js)

docs/redefined/valid-jsdoc.md

@@ -24,4 +24,4 @@ but doesn't when `interfaced/valid-jsdoc` is used.
 
 * [Original](https://eslint.org/docs/rules/valid-jsdoc)
 * [Source](../../lib/rules/redefined/valid-jsdoc.js)
-* [Tests](../../test/eslint/rules/valid-jsdoc.js)
+* [Tests](../../test/eslint/rules/redefined/valid-jsdoc.js)

index.js

@@ -1,5 +1,6 @@
 module.exports.rules = {
 	'camelcase': require('./lib/rules/redefined/camelcase'),
+	'no-param-reassign': require('./lib/rules/redefined/no-param-reassign'),
 	'no-unused-expressions': require('./lib/rules/redefined/no-unused-expressions'),
 	'require-jsdoc': require('./lib/rules/redefined/require-jsdoc'),
 	'valid-jsdoc': require('./lib/rules/redefined/valid-jsdoc'),

lib/ast-utils.js

@@ -63,6 +63,32 @@ function isClass(node) {
 	);
 }
 
+/**
+ * @param {ASTNode} node
+ * @param {SourceCode} sourceCode
+ * @return {boolean}
+ */
+function isTypecast(node, sourceCode) {
+	const tokenBefore = sourceCode.getTokenBefore(node, {
+		includeComments: true
+	});
+
+	const tokenAfter = sourceCode.getTokenAfter(node, {
+		includeComments: true
+	});
+
+	return (
+		tokenBefore &&
+		tokenBefore.type === 'Punctuator' &&
+		tokenBefore.value === '(' &&
+		hasJSDocTags(tokenBefore, ['type'], sourceCode) &&
+
+		tokenAfter &&
+		tokenAfter.type === 'Punctuator' &&
+		tokenAfter.value === ')'
+	);
+}
+
 /**
  * @param {ASTNode} propExpression
  * @return {string}
@@ -524,6 +550,7 @@ module.exports = {
 	isTypedefExpression,
 	isConstantExpression,
 	isClass,
+	isTypecast,
 	resolvePropName,
 	resolveClassName,
 	resolveParamNames,

lib/rules/redefined/no-param-reassign.js

@@ -0,0 +1,92 @@
+const originalRule = require('eslint/lib/rules/no-param-reassign');
+
+const {isTypecast} = require('../../ast-utils');
+const {deepShallowCopy} = require('../../utils');
+
+module.exports = {
+	meta: originalRule.meta,
+	create: (context) => {
+		const sourceCode = context.getSourceCode();
+		const contextCopy = deepShallowCopy(context);
+
+		/**
+		 * @param {ASTNode} nodeA
+		 * @param {ASTNode} nodeB
+		 * @param {string} type
+		 * @return {boolean}
+		 */
+		function bothHaveType(nodeA, nodeB, type) {
+			return nodeA.type === type && nodeB.type === type;
+		}
+
+		/**
+		 * @param {ASTNode} nodeA
+		 * @param {ASTNode} nodeB
+		 * @return {boolean}
+		 */
+		function bothHaveSameName(nodeA, nodeB) {
+			return nodeA.name === nodeB.name;
+		}
+
+		contextCopy.report = (error) => {
+			const {node} = error;
+
+			let assignment;
+			if (node.parent.type === 'AssignmentExpression') {
+				assignment = node.parent;
+			} else if (node.parent.type === 'MemberExpression') {
+				let ancestor = node.parent;
+				while (ancestor.type === 'MemberExpression') {
+					ancestor = ancestor.parent;
+				}
+
+				if (ancestor.type === 'AssignmentExpression') {
+					assignment = ancestor;
+				}
+			}
+
+			if (assignment && assignment.operator === '=') {
+				const lhs = assignment.left;
+				const rhs = assignment.right;
+
+				if (isTypecast(rhs, sourceCode)) {
+					if (bothHaveType(lhs, rhs, 'Identifier') && bothHaveSameName(lhs, rhs)) {
+						return;
+					}
+
+					if (bothHaveType(lhs, rhs, 'MemberExpression')) {
+						let lhsObject = lhs;
+						let rhsObject = rhs;
+
+						let areIdentical = true;
+						while (areIdentical) {
+							if (bothHaveType(lhsObject, rhsObject, 'Identifier')) {
+								areIdentical = bothHaveSameName(lhsObject, rhsObject);
+							} else {
+								areIdentical = (
+									bothHaveType(lhsObject.property, rhsObject.property, 'Identifier') &&
+									bothHaveSameName(lhsObject.property, rhsObject.property)
+								);
+							}
+
+							lhsObject = lhsObject.object;
+							rhsObject = rhsObject.object;
+
+							if (!lhsObject || !rhsObject) {
+								break;
+							}
+						}
+
+						if (areIdentical) {
+							return;
+						}
+					}
+				}
+			}
+
+			context.report(error);
+		};
+
+		return originalRule.create(contextCopy);
+	}
+};