Add type-error rule - fixes #27 (#73)

Author: Florian Breisch

docs/rules/prefer-type-error.md

@@ -0,0 +1,67 @@
+# Enforce throwing `TypeError` in type checking conditions
+
+This rule enforces you to throw a `TypeError` after a type checking if-statement, instead of a generic `Error`.
+
+It's aware of the most commonly used type checking operators and identifiers like `typeof`, `instanceof`, `.isString()`, etc, borrowed from [ES2017](https://tc39.github.io/ecma262/), [Underscore](http://underscorejs.org), [Lodash](https://lodash.com), and [jQuery](https://jquery.com). For a complete list of the recognized identifiers, please take a look at the [identifier-definition](https://github.com/sindresorhus/eslint-plugin-unicorn/blob/master/rules/prefer-type-error.js#L3).
+
+The rule investigates every throw-statement which throws a generic `Error`. It will fail if the throw-statement is the only expression in the surrounding block and is preceeded by an if-statement whose condition consists of type-checks exclusively.
+
+In order to fix the violation, you have to replace the `Error` with a `TypeError`. Fortunately, this rule is able to `--fix` it for you.
+
+
+## Fail
+
+```js
+if (Array.isArray(foo) === false) {
+	throw new Error('Array expected');
+}
+```
+
+```js
+if (Number.isNaN(foo) === false && Number.isInteger(foo) === false) {
+	throw new Error('Integer expected');
+}
+```
+
+```js
+if (isNaN(foo) === false) {
+	throw new Error('Number expected');
+}
+```
+
+```js
+if (typeof foo !== 'function' &&
+	foo instanceof CookieMonster === false &&
+	foo instanceof Unicorn === false) {
+	throw new Error('Magic expected');
+}
+```
+
+
+## Pass
+
+```js
+if (Array.isArray(foo) === false) {
+	throw new TypeError('Array expected');
+}
+```
+
+```js
+if (Number.isNaN(foo) === false && Number.isInteger(foo) === false) {
+	throw new TypeError('Integer expected');
+}
+```
+
+```js
+if (isNaN(foo) === false) {
+	throw new TypeError('Number expected');
+}
+```
+
+```js
+if (typeof foo !== 'function' &&
+	foo instanceof CookieMonster === false &&
+	foo instanceof Unicorn === false) {
+	throw new TypeError('Magic expected');
+}
+```

index.js

@@ -25,7 +25,8 @@ module.exports = {
 				'unicorn/no-new-buffer': 'error',
 				'unicorn/no-hex-escape': 'error',
 				'unicorn/custom-error-definition': 'error',
-				'unicorn/prefer-starts-ends-with': 'error'
+				'unicorn/prefer-starts-ends-with': 'error',
+				'unicorn/prefer-type-error': 'error'
 			}
 		}
 	}

readme.md

@@ -45,7 +45,8 @@ Configure it in `package.json`.
 			"unicorn/no-new-buffer": "error",
 			"unicorn/no-hex-escape": "error",
 			"unicorn/custom-error-definition": "error",
-			"unicorn/prefer-starts-ends-with": "error"
+			"unicorn/prefer-starts-ends-with": "error",
+			"unicorn/prefer-type-error": "error"
 		}
 	}
 }
@@ -67,6 +68,7 @@ Configure it in `package.json`.
 - [no-hex-escape](docs/rules/no-hex-escape.md) - Enforce the use of unicode escapes instead of hexadecimal escapes. *(fixable)*
 - [custom-error-definition](docs/rules/custom-error-definition.md) - Enforces the only valid way of `Error` subclassing. *(fixable)*
 - [prefer-starts-ends-with](docs/rules/prefer-starts-ends-with.md) - Prefer `String#startsWidth` & `String#endsWidth` over more complex alternatives.
+- [prefer-type-error](docs/rules/prefer-type-error.md) - Enforce throwing `TypeError` in type checking conditions. *(fixable)*
 
 
 ## Recommended config

rules/prefer-type-error.js

@@ -0,0 +1,126 @@
+'use strict';
+
+const tcIdentifiers = new Set([
+	'isArguments',
+	'isArray',
+	'isArrayBuffer',
+	'isArrayLike',
+	'isArrayLikeObject',
+	'isBoolean',
+	'isBuffer',
+	'isDate',
+	'isElement',
+	'isError',
+	'isFinite',
+	'isFunction',
+	'isInteger',
+	'isLength',
+	'isMap',
+	'isNaN',
+	'isNative',
+	'isNil',
+	'isNull',
+	'isNumber',
+	'isObject',
+	'isObjectLike',
+	'isPlainObject',
+	'isPrototypeOf',
+	'isRegExp',
+	'isSafeInteger',
+	'isSet',
+	'isString',
+	'isSymbol',
+	'isTypedArray',
+	'isUndefined',
+	'isView',
+	'isWeakMap',
+	'isWeakSet',
+	'isWindow',
+	'isXMLDoc'
+]);
+
+const tcGlobalIdentifiers = new Set([
+	'isNaN',
+	'isFinite'
+]);
+
+const isTypecheckingIdentifier = (node, callExpression, isMemberExpression) =>
+	callExpression !== undefined &&
+	callExpression.arguments.length > 0 &&
+	node.type === 'Identifier' &&
+	((isMemberExpression === true &&
+	tcIdentifiers.has(node.name)) ||
+	(isMemberExpression === false &&
+	tcGlobalIdentifiers.has(node.name)));
+
+const throwsErrorObject = node =>
+	node.argument.type === 'NewExpression' &&
+	node.argument.callee.type === 'Identifier' &&
+	node.argument.callee.name === 'Error';
+
+const isLone = node =>
+	node.parent !== null &&
+	node.parent.body !== null &&
+	node.parent.body.length === 1;
+
+const isTypecheckingMemberExpression = (node, callExpression) => {
+	if (isTypecheckingIdentifier(node.property, callExpression, true)) {
+		return true;
+	}
+
+	if (node.object.type === 'MemberExpression') {
+		return isTypecheckingMemberExpression(node.object, callExpression);
+	}
+
+	return false;
+};
+
+const isTypecheckingExpression = (node, callExpression) => {
+	switch (node.type) {
+		case 'Identifier':
+			return isTypecheckingIdentifier(node, callExpression, false);
+		case 'MemberExpression':
+			return isTypecheckingMemberExpression(node, callExpression);
+		case 'CallExpression':
+			return isTypecheckingExpression(node.callee, node);
+		case 'UnaryExpression':
+			return node.operator === 'typeof' ||
+				(node.operator === '!' &&
+				isTypecheckingExpression(node.argument));
+		case 'BinaryExpression':
+			return node.operator === 'instanceof' ||
+				isTypecheckingExpression(node.left, callExpression) ||
+				isTypecheckingExpression(node.right, callExpression);
+		case 'LogicalExpression':
+			return isTypecheckingExpression(node.left, callExpression) &&
+				isTypecheckingExpression(node.right, callExpression);
+		default:
+			return false;
+	}
+};
+
+const isTypechecking = node => node.type === 'IfStatement' && isTypecheckingExpression(node.test);
+
+const create = context => {
+	return {
+		ThrowStatement: node => {
+			if (throwsErrorObject(node) &&
+				isLone(node) &&
+				node.parent.parent !== null &&
+				isTypechecking(node.parent.parent)) {
+				context.report({
+					node,
+					message: '`new Error()` is too unspecific for a type check. Use `new TypeError()` instead.',
+					fix: fixer => fixer.replaceText(node.argument.callee, 'TypeError')
+				});
+			}
+		}
+	};
+};
+
+module.exports = {
+	create,
+	meta: {
+		fixable: 'code'
+	}
+};