eslint-plugin-unicorn 70.0.0 → 71.0.0

package/rules/isolated-functions.js

@@ -98,13 +98,51 @@ const create = context => {
 
 	options.comments = options.comments.map(comment => comment.toLowerCase());
 
-	const allowedGlobals = {
+	const configuredGlobals = {
 		...(globals[`es${context.languageOptions.ecmaVersion}`] ?? globals.builtins),
 		...context.languageOptions.globals,
-		...options.overrideGlobals,
 	};
 	const checked = new WeakSet();
 
+	const getAllowedGlobalValue = reference => {
+		const {identifier, resolved} = reference;
+		const {name} = identifier;
+
+		if (Object.hasOwn(options.overrideGlobals, name)) {
+			const overrideGlobalValue = options.overrideGlobals[name];
+
+			if (overrideGlobalValue === 'off') {
+				return 'off';
+			}
+
+			if (resolved && !sourceCode.isGlobalReference(identifier)) {
+				return;
+			}
+
+			return overrideGlobalValue;
+		}
+
+		if (
+			Object.hasOwn(configuredGlobals, name)
+			&& configuredGlobals[name] === 'off'
+		) {
+			return 'off';
+		}
+
+		if (!sourceCode.isGlobalReference(identifier)) {
+			return;
+		}
+
+		if (
+			!Object.hasOwn(configuredGlobals, name)
+			&& !resolved?.eslintExplicitGlobal
+		) {
+			return;
+		}
+
+		return resolved?.writeable ? 'writable' : 'readonly';
+	};
+
 	function * getFunctionContextProblems(node, reason, root = node) {
 		const messageId = functionContextReferenceMessageIds.get(node.type);
 		if (messageId) {
@@ -173,18 +211,20 @@ const create = context => {
 				continue;
 			}
 
-			if (Object.hasOwn(allowedGlobals, identifier.name) && allowedGlobals[identifier.name] !== 'off') {
+			const allowedGlobalValue = getAllowedGlobalValue(reference);
+			let problemReason = reason;
+
+			if (allowedGlobalValue !== undefined && allowedGlobalValue !== 'off') {
 				if (reference.isReadOnly()) {
 					continue;
 				}
 
-				const globalsValue = allowedGlobals[identifier.name];
-				const isGlobalWritable = [true, 'writable', 'writeable'].includes(globalsValue);
+				const isGlobalWritable = [true, 'writable', 'writeable'].includes(allowedGlobalValue);
 				if (isGlobalWritable) {
 					continue;
 				}
 
-				reason += ' (global variable is not writable)';
+				problemReason += ' (global variable is not writable)';
 			}
 
 			// Could consider checking for typeof operator here, like in no-undef?
@@ -192,7 +232,7 @@ const create = context => {
 			context.report({
 				node: identifier,
 				messageId: MESSAGE_ID_EXTERNALLY_SCOPED_VARIABLE,
-				data: {name: identifier.name, reason},
+				data: {name: identifier.name, reason: problemReason},
 			});
 		}
 

package/rules/name-replacements.js

@@ -1,6 +1,5 @@
 import path from 'node:path';
 import {isRegExp} from 'node:util/types';
-import helperValidatorIdentifier from '@babel/helper-validator-identifier';
 import {
 	getAvailableVariableName,
 	cartesianProductSamples,
@@ -9,6 +8,7 @@ import {
 	upperFirst,
 	lowerFirst,
 	isVirtualFilename,
+	isIdentifierName,
 } from './utils/index.js';
 import {defaultReplacements, defaultAllowList, defaultIgnore} from './shared/name-replacements.js';
 import {
@@ -24,7 +24,6 @@ import {functionTypes} from './ast/index.js';
 const MESSAGE_ID_REPLACE = 'replace';
 const MESSAGE_ID_SUGGESTION = 'suggestion';
 const MESSAGE_ID_RENAME = 'rename';
-const {isIdentifierName} = helperValidatorIdentifier;
 const anotherNameMessage = 'A more descriptive name will do too.';
 const messages = {
 	[MESSAGE_ID_REPLACE]: `The {{nameTypeText}} \`{{discouragedName}}\` should be named \`{{replacement}}\`. ${anotherNameMessage}`,

package/rules/no-anonymous-default-export.js

@@ -1,6 +1,5 @@
 import path from 'node:path';
 import {getFunctionHeadLocation, getFunctionNameWithKind, isOpeningParenToken} from '@eslint-community/eslint-utils';
-import helperValidatorIdentifier from '@babel/helper-validator-identifier';
 import {camelCase} from 'change-case';
 import {
 	getClassHeadLocation,
@@ -9,11 +8,10 @@ import {
 	getAvailableVariableName,
 	upperFirst,
 	isVirtualFilename,
+	isIdentifierName,
 } from './utils/index.js';
 import {isMemberExpression} from './ast/index.js';
 
-const {isIdentifierName} = helperValidatorIdentifier;
-
 const MESSAGE_ID_ERROR = 'no-anonymous-default-export/error';
 const MESSAGE_ID_SUGGESTION = 'no-anonymous-default-export/suggestion';
 const messages = {

package/rules/no-array-callback-reference.js

@@ -1,4 +1,4 @@
-import helperValidatorIdentifier from '@babel/helper-validator-identifier';
+import isIdentifier from 'is-identifier';
 import {findVariable} from '@eslint-community/eslint-utils';
 import typedArray from './shared/typed-array.js';
 import {isMethodCall, isUndefined} from './ast/index.js';
@@ -22,11 +22,6 @@ const ERROR_WITH_NAME_MESSAGE_ID = 'error-with-name';
 const ERROR_WITHOUT_NAME_MESSAGE_ID = 'error-without-name';
 const REPLACE_WITH_NAME_MESSAGE_ID = 'replace-with-name';
 const REPLACE_WITHOUT_NAME_MESSAGE_ID = 'replace-without-name';
-const {
-	isIdentifierName,
-	isKeyword,
-	isStrictBindReservedWord,
-} = helperValidatorIdentifier;
 const messages = {
 	[ERROR_WITH_NAME_MESSAGE_ID]: 'Do not pass function `{{name}}` directly to `.{{method}}(…)`.',
 	[ERROR_WITHOUT_NAME_MESSAGE_ID]: 'Do not pass function directly to `.{{method}}(…)`.',
@@ -301,10 +296,7 @@ function isDefinitelyNotFunctionValue(node, context, visitedVariables = new Set(
 		: false;
 }
 
-const isValidParameterName = name =>
-	isIdentifierName(name)
-	&& !isKeyword(name)
-	&& !isStrictBindReservedWord(name, true);
+const isValidParameterName = isIdentifier;
 
 function getSuggestionParameters(callExpression, callback, parameters) {
 	if (callback.type !== 'Identifier') {

package/rules/no-chained-comparison.js

@@ -1,4 +1,5 @@
 import {hasSideEffect} from '@eslint-community/eslint-utils';
+import {isBooleanLiteral} from './ast/index.js';
 import {getParenthesizedText, isParenthesized, isBoolean} from './utils/index.js';
 
 const MESSAGE_ID_ERROR = 'no-chained-comparison/error';
@@ -13,7 +14,6 @@ const equalityOperators = new Set(['===', '!==', '==', '!=']);
 const comparisonOperators = orderingOperators.union(equalityOperators);
 
 const isComparison = node => node.type === 'BinaryExpression' && comparisonOperators.has(node.operator);
-const isBooleanLiteral = node => node.type === 'Literal' && typeof node.value === 'boolean';
 
 // The `&&` rewrite is a `LogicalExpression`, which binds looser than any comparison. It can only
 // replace `node` where a surrounding operator won't recapture it: at the top of an expression or

package/rules/no-computed-property-existence-check.js

@@ -134,10 +134,7 @@ const create = context => {
 	});
 
 	context.on('BinaryExpression', node => {
-		if (!(
-			node.operator === 'in'
-			&& !isStaticPropertyKey(node.left)
-		)) {
+		if (node.operator !== 'in' || isStaticPropertyKey(node.left)) {
 			return;
 		}
 

package/rules/no-declarations-before-early-exit.js

@@ -1,5 +1,10 @@
 import {isCommentToken, hasSideEffect} from '@eslint-community/eslint-utils';
-import {containsSuspensionPoint, getReferences, trackBranchExits} from './utils/index.js';
+import {
+	containsSuspensionPoint,
+	getReferences,
+	isReactHookName,
+	trackBranchExits,
+} from './utils/index.js';
 
 const MESSAGE_ID = 'no-declarations-before-early-exit';
 const messages = {
@@ -23,10 +28,6 @@ function isGuardStatement(node, branchAlwaysExits) {
 	return consequentExits !== alternateExits;
 }
 
-// https://github.com/facebook/react/blob/main/packages/eslint-plugin-react-hooks/src/rules/RulesOfHooks.ts
-const isReactHookName = name =>
-	name === 'use' || /^use[\dA-Z]/.test(name);
-
 // Matches `useFoo(…)` and `Namespace.useFoo(…)` (for example, `React.useMemo(…)`).
 const isReactHookCall = node => {
 	if (node?.type !== 'CallExpression') {

package/rules/no-error-property-assignment.js

@@ -142,7 +142,7 @@ const getLocalUpdateFrame = knownErrorVariableFrames =>
 	?? knownErrorVariableFrames.at(-1);
 
 const updateExistingKnownErrorVariable = (knownErrorVariableFrames, variable, constructorName) => {
-	let crossesFunctionBoundary = false;
+	let isCrossesFunctionBoundary = false;
 
 	for (const frame of knownErrorVariableFrames.toReversed()) {
 		if (frame.knownErrorVariables.has(variable)) {
@@ -151,7 +151,7 @@ const updateExistingKnownErrorVariable = (knownErrorVariableFrames, variable, co
 				return true;
 			}
 
-			if (!crossesFunctionBoundary) {
+			if (!isCrossesFunctionBoundary) {
 				frame.knownErrorVariables.set(variable, undefined);
 			}
 
@@ -160,7 +160,7 @@ const updateExistingKnownErrorVariable = (knownErrorVariableFrames, variable, co
 		}
 
 		if (frame.isFunctionBoundary) {
-			crossesFunctionBoundary = true;
+			isCrossesFunctionBoundary = true;
 		}
 	}
 

package/rules/no-for-loop.js

@@ -876,14 +876,14 @@ const create = context => {
 
 				let declarationElement = element;
 				let declarationType = 'const';
-				let removeDeclaration = true;
+				let isRemoveDeclaration = true;
 
 				if (elementNode) {
 					if (elementNode.id.type === 'ObjectPattern' || elementNode.id.type === 'ArrayPattern') {
-						removeDeclaration = arrayReferences.length === 1;
+						isRemoveDeclaration = arrayReferences.length === 1;
 					}
 
-					if (removeDeclaration) {
+					if (isRemoveDeclaration) {
 						declarationType = elementNode.parent.kind;
 						declarationElement = sourceCode.getText(elementNode.id);
 					}
@@ -911,7 +911,7 @@ const create = context => {
 				}
 
 				if (elementNode) {
-					yield removeDeclaration
+					yield isRemoveDeclaration
 						? fixer.removeRange(getRemovalRange(elementNode, sourceCode))
 						: fixer.replaceText(elementNode.init, element);
 				}

package/rules/no-keyword-prefix.js

@@ -90,12 +90,12 @@ function reportObjectPatternAndShouldSkipPropertyCheck(report, node, options) {
 		return true;
 	}
 
-	const assignmentKeyEqualsValue = parent.key.name === parent.value.name;
+	const isAssignmentKeyEqualsValue = parent.key.name === parent.value.name;
 
 	const valueIsInvalid = parent.value.name && Boolean(keyword);
 
 	// Ignore destructuring if the option is set, unless a new identifier is created
-	if (valueIsInvalid && !assignmentKeyEqualsValue) {
+	if (valueIsInvalid && !isAssignmentKeyEqualsValue) {
 		report(node, keyword);
 	}
 

package/rules/no-mismatched-map-key.js

@@ -1,7 +1,7 @@
 import {findVariable, getStaticValue} from '@eslint-community/eslint-utils';
 import {isMethodCall} from './ast/index.js';
 import {isReference, isSame, unwrapExpression} from './utils/comparison.js';
-import {isKnownNonMap} from './utils/index.js';
+import {isComparableStaticValue, isKnownNonMap} from './utils/index.js';
 
 /**
 @import {TSESTree as ESTree} from '@typescript-eslint/types';
@@ -21,13 +21,6 @@ const skippedNodeTypes = new Set([
 	'FunctionExpression',
 ]);
 
-const isComparableStaticValue = value =>
-	value === null
-	|| (
-		typeof value !== 'object'
-		&& typeof value !== 'function'
-	);
-
 const isSameValueZero = (left, right) =>
 	left === right
 	|| (
@@ -132,7 +125,7 @@ function patternContainsSameBinding(node, mapHasRoot, context) {
 
 function hasCallExpression(node, context) {
 	const {visitorKeys} = context.sourceCode;
-	let result = false;
+	let isResult = false;
 
 	function visit(node) {
 		if (!node) {
@@ -142,14 +135,14 @@ function hasCallExpression(node, context) {
 		node = unwrapExpression(node);
 
 		if (
-			result
+			isResult
 			|| skippedNodeTypes.has(node.type)
 		) {
 			return;
 		}
 
 		if (node.type === 'CallExpression') {
-			result = true;
+			isResult = true;
 			return;
 		}
 
@@ -170,7 +163,7 @@ function hasCallExpression(node, context) {
 
 	visit(node);
 
-	return result;
+	return isResult;
 }
 
 function areDifferentKeys(left, right, context) {
@@ -353,11 +346,11 @@ function isNestedMapHasGuard(node, mapHasCall, context) {
 
 function hasSameMapHasCall(node, mapHasCall, context) {
 	const {visitorKeys} = context.sourceCode;
-	let result = false;
+	let isResult = false;
 
 	function visit(node) {
 		if (
-			result
+			isResult
 			|| !node
 			|| skippedNodeTypes.has(node.type)
 		) {
@@ -370,7 +363,7 @@ function hasSameMapHasCall(node, mapHasCall, context) {
 			nestedMapHasCall
 			&& isSameMapReceiver(unwrapExpression(mapHasCall).callee.object, unwrapExpression(nestedMapHasCall).callee.object, context)
 		) {
-			result = true;
+			isResult = true;
 			return;
 		}
 
@@ -391,16 +384,16 @@ function hasSameMapHasCall(node, mapHasCall, context) {
 
 	visit(node);
 
-	return result;
+	return isResult;
 }
 
 function hasMapReceiverWrite(node, mapHasCall, context) {
 	const {visitorKeys} = context.sourceCode;
-	let result = false;
+	let isResult = false;
 
 	function visit(node) {
 		if (
-			result
+			isResult
 			|| !node
 			|| skippedNodeTypes.has(node.type)
 			|| isNestedMapHasGuard(node, mapHasCall, context)
@@ -409,7 +402,7 @@ function hasMapReceiverWrite(node, mapHasCall, context) {
 		}
 
 		if (isMapReceiverWrite(node, mapHasCall, context)) {
-			result = true;
+			isResult = true;
 			return;
 		}
 
@@ -430,7 +423,7 @@ function hasMapReceiverWrite(node, mapHasCall, context) {
 
 	visit(node);
 
-	return result;
+	return isResult;
 }
 
 function getMapAccessProblems(node, mapHasCall, context, reportedAccessKeys) {

package/rules/no-named-default.js

@@ -97,12 +97,9 @@ const create = context => {
 	});
 
 	context.on('ExportSpecifier', specifier => {
-		if (!(
-			isValueExport(specifier)
+		if (!(isValueExport(specifier)
 			&& specifier.exported.name === 'default'
-			&& isValueExport(specifier.parent)
-			&& !specifier.parent.source
-		)) {
+			&& isValueExport(specifier.parent)) || specifier.parent.source) {
 			return;
 		}
 

package/rules/no-negated-array-predicate.js

@@ -24,13 +24,6 @@ const replacementMethod = new Map([
 ]);
 const methods = replacementMethod.keys().toArray();
 
-const predicateBodyTypesRequiringParentheses = new Set([
-	'TSAsExpression',
-	'TSNonNullExpression',
-	'TSSatisfiesExpression',
-	'TSTypeAssertion',
-]);
-
 const needsParenthesesInConciseArrowBody = (node, text) =>
 	node.parent.type === 'ArrowFunctionExpression'
 	&& node.parent.body === node
@@ -75,7 +68,7 @@ function getReplacementPredicateText(node, context) {
 	}
 
 	const text = context.sourceCode.getText(node);
-	const needsParentheses = predicateBodyTypesRequiringParentheses.has(node.type) || shouldAddParenthesesToUnaryExpressionArgument(node, '!');
+	const needsParentheses = shouldAddParenthesesToUnaryExpressionArgument(node, '!');
 
 	return {
 		node,
@@ -158,7 +151,7 @@ const create = context => {
 				replacement,
 			},
 			* fix(fixer) {
-				const needsReturnOrThrowParentheses = (
+				const isNeedsReturnOrThrowParentheses = (
 					(parent.type === 'ReturnStatement' || parent.type === 'ThrowStatement')
 					&& parent.argument === unaryExpression
 					&& !isOnSameLine(bangToken, tokenAfterBang, context)
@@ -171,12 +164,12 @@ const create = context => {
 
 				if (
 					tokenStore === sourceCode
-					&& !needsReturnOrThrowParentheses
+					&& !isNeedsReturnOrThrowParentheses
 				) {
 					yield fixSpaceAroundKeyword(fixer, unaryExpression, context);
 				}
 
-				if (needsReturnOrThrowParentheses) {
+				if (isNeedsReturnOrThrowParentheses) {
 					yield addParenthesesToReturnOrThrowExpression(fixer, parent, context);
 					return;
 				}

package/rules/no-negated-comparison.js

@@ -98,14 +98,14 @@ function * fix({
 	const tokenAfterBangIncludingComments = sourceCode.getTokenAfter(bangToken, {includeComments: true});
 	const operatorToken = getPunctuatorBinaryExpressionOperatorToken(comparison, context);
 	const {parent} = unaryExpression;
-	const needsReturnOrThrowParentheses = (
+	const isNeedsReturnOrThrowParentheses = (
 		(parent.type === 'ReturnStatement' || parent.type === 'ThrowStatement')
 		&& parent.argument === unaryExpression
 		&& !isOnSameLine(bangToken, tokenAfterBang, context)
 		&& !isParenthesized(unaryExpression, context)
 	);
 
-	if (!needsReturnOrThrowParentheses) {
+	if (!isNeedsReturnOrThrowParentheses) {
 		yield fixSpaceAroundKeyword(fixer, unaryExpression, context);
 	}
 
@@ -117,16 +117,13 @@ function * fix({
 		yield fixer.insertTextAfter(tokenAfterBangIncludingComments, ' ');
 	}
 
-	if (!(
-		parentNeedsGroupedComparison(parent)
-		&& !isParenthesized(unaryExpression, context)
-	)) {
+	if (!parentNeedsGroupedComparison(parent) || isParenthesized(unaryExpression, context)) {
 		yield removeParentheses(comparison, fixer, context);
 	}
 
 	yield fixer.replaceText(operatorToken, replacementOperator);
 
-	if (needsReturnOrThrowParentheses) {
+	if (isNeedsReturnOrThrowParentheses) {
 		yield addParenthesesToReturnOrThrowExpression(fixer, parent, context);
 		return;
 	}
@@ -178,21 +175,21 @@ function * fixLogical({
 	const bangToken = sourceCode.getFirstToken(unaryExpression);
 	const tokenAfterBang = sourceCode.getTokenAfter(bangToken);
 	const {parent} = unaryExpression;
-	const needsReturnOrThrowParentheses = (
+	const isNeedsReturnOrThrowParentheses = (
 		(parent.type === 'ReturnStatement' || parent.type === 'ThrowStatement')
 		&& parent.argument === unaryExpression
 		&& !isOnSameLine(bangToken, tokenAfterBang, context)
 		&& !isParenthesized(unaryExpression, context)
 	);
 
-	if (!needsReturnOrThrowParentheses) {
+	if (!isNeedsReturnOrThrowParentheses) {
 		yield fixSpaceAroundKeyword(fixer, unaryExpression, context);
 	}
 
 	yield fixer.remove(bangToken);
 	yield fixer.replaceText(logicalExpression, getFixedLogicalExpressionText(logicalExpression, context));
 
-	if (needsReturnOrThrowParentheses) {
+	if (isNeedsReturnOrThrowParentheses) {
 		yield addParenthesesToReturnOrThrowExpression(fixer, parent, context);
 		return;
 	}

package/rules/no-negation-in-equality-check.js

@@ -23,11 +23,8 @@ const create = context => {
 	context.on('BinaryExpression', binaryExpression => {
 		const {operator, left} = binaryExpression;
 
-		if (!(
-			isEqualityCheck(binaryExpression)
-			&& isNegatedExpression(left)
-			&& !isNegatedExpression(left.argument)
-		)) {
+		if (!(isEqualityCheck(binaryExpression)
+			&& isNegatedExpression(left)) || isNegatedExpression(left.argument)) {
 			return;
 		}
 

package/rules/no-process-exit.js

@@ -11,9 +11,9 @@ const isWorkerThreads = node =>
 
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
-	const startsWithHashBang = context.sourceCode.lines[0].indexOf('#!') === 0;
+	const isStartsWithHashBang = context.sourceCode.lines[0].indexOf('#!') === 0;
 
-	if (startsWithHashBang) {
+	if (isStartsWithHashBang) {
 		return;
 	}
 
@@ -22,7 +22,7 @@ const create = context => {
 	let processEventHandlerDepth = 0;
 
 	// Only report if it's outside a worker thread context. See #328.
-	let requiredWorkerThreadsModule = false;
+	let isRequiredWorkerThreadsModule = false;
 	const problemNodes = [];
 
 	const isProcessEventHandler = node => isMethodCall(node, {
@@ -39,7 +39,7 @@ const create = context => {
 			isStaticRequire(callExpression)
 			&& isWorkerThreads(callExpression.arguments[0])
 		) {
-			requiredWorkerThreadsModule = true;
+			isRequiredWorkerThreadsModule = true;
 		}
 	});
 
@@ -49,7 +49,7 @@ const create = context => {
 			importDeclaration.source.type === 'Literal'
 			&& isWorkerThreads(importDeclaration.source)
 		) {
-			requiredWorkerThreadsModule = true;
+			isRequiredWorkerThreadsModule = true;
 		}
 	});
 
@@ -81,7 +81,7 @@ const create = context => {
 	});
 
 	context.onExit('Program', function * () {
-		if (requiredWorkerThreadsModule) {
+		if (isRequiredWorkerThreadsModule) {
 			return;
 		}
 

package/rules/no-static-only-class.js

@@ -38,16 +38,10 @@ function isStaticMember(node) {
 	}
 
 	// TypeScript class
-	if (
-		isDeclare
+	return !(isDeclare
 		|| isReadonly
 		|| accessibility !== undefined
-		|| (Array.isArray(decorators) && decorators.length > 0)
-	) {
-		return false;
-	}
-
-	return true;
+		|| (Array.isArray(decorators) && decorators.length > 0));
 }
 
 function * switchClassMemberToObjectProperty(node, context, fixer) {

package/rules/no-thenable.js

@@ -79,16 +79,13 @@ const cases = [
 	{
 		selector: 'CallExpression',
 		* getNodes(node, context) {
-			if (!(
-				isMethodCall(node, {
-					objects: ['Object', 'Reflect'],
-					method: 'defineProperty',
-					minimumArguments: 3,
-					optionalCall: false,
-					optionalMember: false,
-				})
-				&& node.arguments[0].type !== 'SpreadElement'
-			)) {
+			if (!isMethodCall(node, {
+				objects: ['Object', 'Reflect'],
+				method: 'defineProperty',
+				minimumArguments: 3,
+				optionalCall: false,
+				optionalMember: false,
+			}) || node.arguments[0].type === 'SpreadElement') {
 				return;
 			}
 
@@ -117,11 +114,8 @@ const cases = [
 			}
 
 			for (const pairs of node.arguments[0].elements) {
-				if (!(
-					pairs?.type === 'ArrayExpression'
-					&& pairs.elements[0]
-					&& pairs.elements[0].type !== 'SpreadElement'
-				)) {
+				if (!(pairs?.type === 'ArrayExpression'
+					&& pairs.elements[0]) || pairs.elements[0].type === 'SpreadElement') {
 					continue;
 				}
 

package/rules/no-undeclared-class-members.js

@@ -179,11 +179,7 @@ const getDeclaredClassMemberNames = (classBody, sourceCode) => {
 	const names = new Set(['constructor']);
 
 	for (const member of classBody.body) {
-		if (!(
-			classMemberTypes.has(member.type)
-			&& member.static !== true
-			&& member.kind !== 'constructor'
-		)) {
+		if (!classMemberTypes.has(member.type) || member.static === true || member.kind === 'constructor') {
 			continue;
 		}