815 lines
41 KiB
Plaintext
815 lines
41 KiB
Plaintext
"use strict";
|
|
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
|
if (k2 === undefined) k2 = k;
|
|
var desc = Object.getOwnPropertyDescriptor(m, k);
|
|
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
|
desc = { enumerable: true, get: function() { return m[k]; } };
|
|
}
|
|
Object.defineProperty(o, k2, desc);
|
|
}) : (function(o, m, k, k2) {
|
|
if (k2 === undefined) k2 = k;
|
|
o[k2] = m[k];
|
|
}));
|
|
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
}) : function(o, v) {
|
|
o["default"] = v;
|
|
});
|
|
var __importStar = (this && this.__importStar) || (function () {
|
|
var ownKeys = function(o) {
|
|
ownKeys = Object.getOwnPropertyNames || function (o) {
|
|
var ar = [];
|
|
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
|
|
return ar;
|
|
};
|
|
return ownKeys(o);
|
|
};
|
|
return function (mod) {
|
|
if (mod && mod.__esModule) return mod;
|
|
var result = {};
|
|
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
|
|
__setModuleDefault(result, mod);
|
|
return result;
|
|
};
|
|
})();
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const utils_1 = require("@typescript-eslint/utils");
|
|
const tsutils = __importStar(require("ts-api-utils"));
|
|
const ts = __importStar(require("typescript"));
|
|
const util_1 = require("../util");
|
|
function isAtExpressionStatementStart(node) {
|
|
let current = node;
|
|
while (true) {
|
|
const { parent } = current;
|
|
if (parent == null) {
|
|
return false;
|
|
}
|
|
if (parent.range[0] !== current.range[0]) {
|
|
return false;
|
|
}
|
|
if (parent.type === utils_1.AST_NODE_TYPES.ExpressionStatement) {
|
|
return true;
|
|
}
|
|
current = parent;
|
|
}
|
|
}
|
|
function isAtArrowFunctionBodyStart(node, sourceCode) {
|
|
let current = node;
|
|
while (true) {
|
|
if ((0, util_1.isParenthesized)(current, sourceCode)) {
|
|
return false;
|
|
}
|
|
const { parent } = current;
|
|
if (parent == null) {
|
|
return false;
|
|
}
|
|
if (parent.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
|
|
parent.body === current) {
|
|
return true;
|
|
}
|
|
if (parent.range[0] !== current.range[0]) {
|
|
return false;
|
|
}
|
|
current = parent;
|
|
}
|
|
}
|
|
exports.default = (0, util_1.createRule)({
|
|
name: 'no-unnecessary-type-assertion',
|
|
meta: {
|
|
type: 'suggestion',
|
|
docs: {
|
|
description: 'Disallow type assertions that do not change the type of an expression',
|
|
recommended: 'recommended',
|
|
requiresTypeChecking: true,
|
|
},
|
|
fixable: 'code',
|
|
messages: {
|
|
contextuallyUnnecessary: 'This assertion is unnecessary since the receiver accepts the original type of the expression.',
|
|
unnecessaryAssertion: 'This assertion is unnecessary since it does not change the type of the expression.',
|
|
},
|
|
schema: [
|
|
{
|
|
type: 'object',
|
|
additionalProperties: false,
|
|
properties: {
|
|
checkLiteralConstAssertions: {
|
|
type: 'boolean',
|
|
description: 'Whether to check literal const assertions.',
|
|
},
|
|
typesToIgnore: {
|
|
type: 'array',
|
|
description: 'A list of type names to ignore.',
|
|
items: {
|
|
type: 'string',
|
|
},
|
|
},
|
|
},
|
|
},
|
|
],
|
|
},
|
|
defaultOptions: [{}],
|
|
create(context, [options]) {
|
|
const services = (0, util_1.getParserServices)(context);
|
|
const checker = services.program.getTypeChecker();
|
|
const compilerOptions = services.program.getCompilerOptions();
|
|
/**
|
|
* Returns true if there's a chance the variable has been used before a value has been assigned to it
|
|
*/
|
|
function isPossiblyUsedBeforeAssigned(node) {
|
|
const declaration = (0, util_1.getDeclaration)(services, node);
|
|
if (!declaration) {
|
|
// don't know what the declaration is for some reason, so just assume the worst
|
|
return true;
|
|
}
|
|
if (
|
|
// non-strict mode doesn't care about used before assigned errors
|
|
tsutils.isStrictCompilerOptionEnabled(compilerOptions, 'strictNullChecks') &&
|
|
// ignore class properties as they are compile time guarded
|
|
// also ignore function arguments as they can't be used before defined
|
|
ts.isVariableDeclaration(declaration)) {
|
|
// For var declarations, we need to check whether the node
|
|
// is actually in a descendant of its declaration or not. If not,
|
|
// it may be used before defined.
|
|
// eg
|
|
// if (Math.random() < 0.5) {
|
|
// var x: number = 2;
|
|
// } else {
|
|
// x!.toFixed();
|
|
// }
|
|
if (ts.isVariableDeclarationList(declaration.parent) &&
|
|
// var
|
|
declaration.parent.flags === ts.NodeFlags.None &&
|
|
// If they are not in the same file it will not exist.
|
|
// This situation must not occur using before defined.
|
|
services.tsNodeToESTreeNodeMap.has(declaration)) {
|
|
const declaratorNode = services.tsNodeToESTreeNodeMap.get(declaration);
|
|
const scope = context.sourceCode.getScope(node);
|
|
const declaratorScope = context.sourceCode.getScope(declaratorNode);
|
|
let parentScope = declaratorScope;
|
|
while ((parentScope = parentScope.upper)) {
|
|
if (parentScope === scope) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
if (
|
|
// is it `const x!: number`
|
|
declaration.initializer == null &&
|
|
declaration.exclamationToken == null &&
|
|
declaration.type != null) {
|
|
// check if the defined variable type has changed since assignment
|
|
const declarationType = checker.getTypeFromTypeNode(declaration.type);
|
|
const type = (0, util_1.getConstrainedTypeAtLocation)(services, node);
|
|
if (declarationType === type &&
|
|
// `declare`s are never narrowed, so never skip them
|
|
!(ts.isVariableDeclarationList(declaration.parent) &&
|
|
ts.isVariableStatement(declaration.parent.parent) &&
|
|
tsutils.includesModifier((0, util_1.getModifiers)(declaration.parent.parent), ts.SyntaxKind.DeclareKeyword))) {
|
|
// possibly used before assigned, so just skip it
|
|
// better to false negative and skip it, than false positive and fix to compile erroring code
|
|
//
|
|
// no better way to figure this out right now
|
|
// https://github.com/Microsoft/TypeScript/issues/31124
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isConstAssertion(node) {
|
|
return (node.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
|
|
node.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
|
|
node.typeName.name === 'const');
|
|
}
|
|
function isTemplateLiteralWithExpressions(expression) {
|
|
return (expression.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
|
|
expression.expressions.length !== 0);
|
|
}
|
|
function isImplicitlyNarrowedLiteralDeclaration({ expression, parent, }) {
|
|
/**
|
|
* Even on `const` variable declarations, template literals with expressions can sometimes be widened without a type assertion.
|
|
* @see https://github.com/typescript-eslint/typescript-eslint/issues/8737
|
|
*/
|
|
if (isTemplateLiteralWithExpressions(expression)) {
|
|
return false;
|
|
}
|
|
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
|
|
const maybeDeclarationNode = parent.parent;
|
|
return ((maybeDeclarationNode.type === utils_1.AST_NODE_TYPES.VariableDeclaration &&
|
|
maybeDeclarationNode.kind === 'const') ||
|
|
(parent.type === utils_1.AST_NODE_TYPES.PropertyDefinition && parent.readonly));
|
|
}
|
|
function isTypeUnchanged(node, expression, uncast, cast) {
|
|
if (uncast === cast) {
|
|
return true;
|
|
}
|
|
if (node.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSIntersectionType &&
|
|
containsTypeVariable(cast)) {
|
|
return false;
|
|
}
|
|
if ((0, util_1.isTypeFlagSet)(uncast, ts.TypeFlags.Undefined) &&
|
|
(0, util_1.isTypeFlagSet)(cast, ts.TypeFlags.Undefined) &&
|
|
tsutils.isCompilerOptionEnabled(compilerOptions, 'exactOptionalPropertyTypes')) {
|
|
return areUnionPartsEquivalentIgnoringUndefined(uncast, cast);
|
|
}
|
|
if (((0, util_1.isTypeFlagSet)(uncast, ts.TypeFlags.NonPrimitive) &&
|
|
!(0, util_1.isTypeFlagSet)(cast, ts.TypeFlags.NonPrimitive)) ||
|
|
(hasIndexSignature(uncast) && !hasIndexSignature(cast)) ||
|
|
containsAny(uncast) ||
|
|
containsAny(cast) ||
|
|
(containsTypeVariable(cast) && !containsTypeVariable(uncast))) {
|
|
return false;
|
|
}
|
|
if (isConceptuallyLiteral(expression) &&
|
|
(expression.type !== utils_1.AST_NODE_TYPES.ObjectExpression ||
|
|
expression.properties.length === 0 ||
|
|
cast
|
|
.getProperties()
|
|
.some(p => isTypeLiteral(checker.getTypeOfSymbol(p))))) {
|
|
return false;
|
|
}
|
|
if (cast.isIntersection() && !uncast.isIntersection()) {
|
|
const castParts = cast.types;
|
|
const otherPart = castParts.find(part => part !== uncast);
|
|
if (tsutils.isTypeParameter(uncast) &&
|
|
castParts.length === 2 &&
|
|
castParts.some(part => part === uncast) &&
|
|
otherPart != null &&
|
|
isEmptyObjectType(otherPart) &&
|
|
!containsTypeVariable(otherPart)) {
|
|
const constraint = checker.getBaseConstraintOfType(uncast);
|
|
if (constraint && !(0, util_1.isNullableType)(constraint)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
if (!hasSameProperties(uncast, cast) ||
|
|
!haveSameTypeArguments(uncast, cast)) {
|
|
return false;
|
|
}
|
|
return areMutuallyAssignable(uncast, cast);
|
|
}
|
|
function isTypeLiteral(type) {
|
|
return type.isLiteral() || tsutils.isBooleanLiteralType(type);
|
|
}
|
|
function hasIndexSignature(type) {
|
|
return tsutils
|
|
.unionConstituents(type)
|
|
.some(part => checker.getIndexInfosOfType(part).length > 0);
|
|
}
|
|
function getTypeArguments(type) {
|
|
return (type.aliasTypeArguments ??
|
|
(tsutils.isTypeReference(type) ? checker.getTypeArguments(type) : []));
|
|
}
|
|
function typeContains(type, predicate, seen = new Set()) {
|
|
if (seen.has(type)) {
|
|
return false;
|
|
}
|
|
seen.add(type);
|
|
if (predicate(type)) {
|
|
return true;
|
|
}
|
|
if (type.isUnionOrIntersection()) {
|
|
return type.types.some(t => typeContains(t, predicate, seen));
|
|
}
|
|
const nestedTypes = [
|
|
...getTypeArguments(type),
|
|
...type
|
|
.getCallSignatures()
|
|
.flatMap(sig => [
|
|
sig.getReturnType(),
|
|
...sig.getParameters().map(p => checker.getTypeOfSymbol(p)),
|
|
]),
|
|
];
|
|
return nestedTypes.some(t => typeContains(t, predicate, seen));
|
|
}
|
|
function containsAny(type) {
|
|
return typeContains(type, t => (0, util_1.isTypeFlagSet)(t, ts.TypeFlags.Any));
|
|
}
|
|
function containsTypeVariable(type) {
|
|
return typeContains(type, t => (0, util_1.isTypeFlagSet)(t, ts.TypeFlags.TypeVariable | ts.TypeFlags.Index));
|
|
}
|
|
function hasPhantomTypeArguments(type) {
|
|
return isEmptyObjectType(type) && getTypeArguments(type).length > 0;
|
|
}
|
|
function hasTypeParams(sig) {
|
|
return (sig.getTypeParameters()?.length ?? 0) > 0;
|
|
}
|
|
function genericsMismatch(uncast, contextual) {
|
|
return contextual.getProperties().some(prop => {
|
|
const contextualSigs = checker.getSignaturesOfType(checker.getTypeOfSymbol(prop), ts.SignatureKind.Call);
|
|
if (!contextualSigs.some(hasTypeParams)) {
|
|
return false;
|
|
}
|
|
const uncastProp = uncast.getProperty(prop.getEscapedName());
|
|
if (!uncastProp) {
|
|
return true;
|
|
}
|
|
return !checker
|
|
.getSignaturesOfType(checker.getTypeOfSymbol(uncastProp), ts.SignatureKind.Call)
|
|
.some(hasTypeParams);
|
|
});
|
|
}
|
|
function hasSameProperties(uncast, cast) {
|
|
const uncastProps = uncast.getProperties();
|
|
const castProps = cast.getProperties();
|
|
if (uncastProps.length !== castProps.length) {
|
|
return false;
|
|
}
|
|
const castPropNames = new Set(castProps.map(p => p.getEscapedName()));
|
|
return uncastProps.every(prop => {
|
|
const name = prop.getEscapedName();
|
|
return (castPropNames.has(name) &&
|
|
tsutils.isPropertyReadonlyInType(uncast, name, checker) ===
|
|
tsutils.isPropertyReadonlyInType(cast, name, checker));
|
|
});
|
|
}
|
|
function haveSameTypeArguments(uncast, cast) {
|
|
const uncastArgs = getTypeArguments(uncast);
|
|
const castArgs = getTypeArguments(cast);
|
|
return (uncastArgs.length === castArgs.length &&
|
|
uncastArgs.every((arg, i) => arg === castArgs[i]));
|
|
}
|
|
function areMutuallyAssignable(a, b) {
|
|
return (checker.isTypeAssignableTo(a, b) && checker.isTypeAssignableTo(b, a));
|
|
}
|
|
function areUnionPartsEquivalentIgnoringUndefined(uncast, cast) {
|
|
const filterUndefined = (part) => !(0, util_1.isTypeFlagSet)(part, ts.TypeFlags.Undefined);
|
|
const uncastParts = tsutils
|
|
.unionConstituents(uncast)
|
|
.filter(filterUndefined);
|
|
const castParts = tsutils.unionConstituents(cast).filter(filterUndefined);
|
|
if (uncastParts.length !== castParts.length) {
|
|
return false;
|
|
}
|
|
const uncastPartsSet = new Set(uncastParts);
|
|
return castParts.every(part => uncastPartsSet.has(part));
|
|
}
|
|
function getOriginalExpression(node) {
|
|
let current = node.expression;
|
|
while (current.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
|
|
current.type === utils_1.AST_NODE_TYPES.TSTypeAssertion) {
|
|
current = current.expression;
|
|
}
|
|
return current;
|
|
}
|
|
function isDoubleAssertionUnnecessary(node, contextualType) {
|
|
const innerExpression = node.expression;
|
|
if (innerExpression.type !== utils_1.AST_NODE_TYPES.TSAsExpression &&
|
|
innerExpression.type !== utils_1.AST_NODE_TYPES.TSTypeAssertion) {
|
|
return false;
|
|
}
|
|
const originalExpr = getOriginalExpression(node);
|
|
const originalType = services.getTypeAtLocation(originalExpr);
|
|
const castType = services.getTypeAtLocation(node);
|
|
if (isTypeUnchanged(node, innerExpression, originalType, castType) &&
|
|
!(0, util_1.isTypeFlagSet)(castType, ts.TypeFlags.Any)) {
|
|
return 'unnecessaryAssertion';
|
|
}
|
|
if (contextualType) {
|
|
const intermediateType = services.getTypeAtLocation(innerExpression);
|
|
if (((0, util_1.isTypeFlagSet)(intermediateType, ts.TypeFlags.Any) ||
|
|
(0, util_1.isTypeFlagSet)(intermediateType, ts.TypeFlags.Unknown)) &&
|
|
checker.isTypeAssignableTo(originalType, contextualType)) {
|
|
return 'contextuallyUnnecessary';
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
const CONCEPTUALLY_LITERAL_TYPES = new Set([
|
|
utils_1.AST_NODE_TYPES.Literal,
|
|
utils_1.AST_NODE_TYPES.ArrayExpression,
|
|
utils_1.AST_NODE_TYPES.ObjectExpression,
|
|
utils_1.AST_NODE_TYPES.TemplateLiteral,
|
|
utils_1.AST_NODE_TYPES.ClassExpression,
|
|
utils_1.AST_NODE_TYPES.FunctionExpression,
|
|
utils_1.AST_NODE_TYPES.ArrowFunctionExpression,
|
|
utils_1.AST_NODE_TYPES.JSXElement,
|
|
utils_1.AST_NODE_TYPES.JSXFragment,
|
|
]);
|
|
function isConceptuallyLiteral(node) {
|
|
return CONCEPTUALLY_LITERAL_TYPES.has(node.type);
|
|
}
|
|
function isIIFE(expression) {
|
|
return (expression.type === utils_1.AST_NODE_TYPES.CallExpression &&
|
|
(expression.callee.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
|
|
expression.callee.type === utils_1.AST_NODE_TYPES.FunctionExpression));
|
|
}
|
|
function isEmptyObjectType(type) {
|
|
return ((0, util_1.isTypeFlagSet)(type, ts.TypeFlags.NonPrimitive) ||
|
|
(type.getProperties().length === 0 &&
|
|
!type.getCallSignatures().length &&
|
|
!type.getConstructSignatures().length &&
|
|
!type.getStringIndexType() &&
|
|
!type.getNumberIndexType()));
|
|
}
|
|
function hasGenericCallSignature(type) {
|
|
return type.getCallSignatures().some(hasTypeParams);
|
|
}
|
|
function isArgumentToOverloadedFunction(node) {
|
|
const { parent } = node;
|
|
if ((parent.type !== utils_1.AST_NODE_TYPES.CallExpression &&
|
|
parent.type !== utils_1.AST_NODE_TYPES.NewExpression) ||
|
|
!parent.arguments.includes(node)) {
|
|
return false;
|
|
}
|
|
// An optional-chained callee (`foo?.bar(...)`) types as `<method> | undefined`,
|
|
// and a union exposes no call signatures — strip the nullability first.
|
|
const calleeType = services
|
|
.getTypeAtLocation(parent.callee)
|
|
.getNonNullableType();
|
|
const signatures = calleeType.getCallSignatures();
|
|
if (signatures.length <= 1) {
|
|
return false;
|
|
}
|
|
const argIndex = parent.arguments.indexOf(node);
|
|
const paramTypes = signatures.map(sig => {
|
|
const params = sig.getParameters();
|
|
if (argIndex >= params.length) {
|
|
return undefined;
|
|
}
|
|
const param = params[argIndex];
|
|
let paramType = checker.getTypeOfSymbol(param);
|
|
if (param.valueDeclaration &&
|
|
ts.isParameter(param.valueDeclaration) &&
|
|
param.valueDeclaration.dotDotDotToken) {
|
|
const typeArgs = getTypeArguments(paramType);
|
|
if (typeArgs.length > 0) {
|
|
paramType = typeArgs[0];
|
|
}
|
|
}
|
|
return paramType;
|
|
});
|
|
if (paramTypes.some(type => type == null)) {
|
|
return true;
|
|
}
|
|
const definedParamTypes = paramTypes;
|
|
const firstParamType = definedParamTypes[0];
|
|
if (definedParamTypes.every(type => type === firstParamType)) {
|
|
return false;
|
|
}
|
|
const uncastType = services.getTypeAtLocation(node.expression);
|
|
return !definedParamTypes.every(type => checker.isTypeAssignableTo(uncastType, type));
|
|
}
|
|
function isInDestructuringDeclaration(node) {
|
|
const { parent } = node;
|
|
return (parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
|
|
parent.init === node &&
|
|
(parent.id.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
|
|
parent.id.type === utils_1.AST_NODE_TYPES.ArrayPattern));
|
|
}
|
|
function isPropertyInProblematicContext(node) {
|
|
const { parent } = node;
|
|
if (parent.type !== utils_1.AST_NODE_TYPES.Property || parent.value !== node) {
|
|
return false;
|
|
}
|
|
const objectExpr = parent.parent;
|
|
if (objectExpr.type !== utils_1.AST_NODE_TYPES.ObjectExpression) {
|
|
return false;
|
|
}
|
|
const objectTsNode = services.esTreeNodeToTSNodeMap.get(objectExpr);
|
|
if (checker.getContextualType(objectTsNode)?.isUnion()) {
|
|
const nodeTsNode = services.esTreeNodeToTSNodeMap.get(node);
|
|
const propContextualType = checker.getContextualType(nodeTsNode);
|
|
if (propContextualType == null) {
|
|
return true;
|
|
}
|
|
const nonNullableContextualType = checker.getNonNullableType(propContextualType);
|
|
if (nonNullableContextualType.isUnion()) {
|
|
return true;
|
|
}
|
|
const uncastType = services.getTypeAtLocation(node.expression);
|
|
return !checker.isTypeAssignableTo(uncastType, nonNullableContextualType);
|
|
}
|
|
const objectParent = objectExpr.parent;
|
|
return (objectParent.type === utils_1.AST_NODE_TYPES.TSSatisfiesExpression ||
|
|
(objectParent.type === utils_1.AST_NODE_TYPES.CallExpression &&
|
|
objectParent.parent.type === utils_1.AST_NODE_TYPES.TSSatisfiesExpression));
|
|
}
|
|
function isAssignmentInNonStatementContext(node) {
|
|
const { parent } = node;
|
|
if (parent.type !== utils_1.AST_NODE_TYPES.AssignmentExpression ||
|
|
parent.right !== node) {
|
|
return false;
|
|
}
|
|
const assignmentParent = parent.parent;
|
|
return assignmentParent.type !== utils_1.AST_NODE_TYPES.ExpressionStatement;
|
|
}
|
|
function isRightHandSideOfLogicalAssignment(node) {
|
|
const { parent } = node;
|
|
return (parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression &&
|
|
parent.right === node &&
|
|
(parent.operator === '&&=' ||
|
|
parent.operator === '||=' ||
|
|
parent.operator === '??='));
|
|
}
|
|
function isInGenericContext(node) {
|
|
let seenFunction = false;
|
|
for (let current = node.parent; current; current = current.parent) {
|
|
if (current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
|
|
return false;
|
|
}
|
|
if (current.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
|
|
current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
|
|
if (current.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
|
|
return false;
|
|
}
|
|
if (seenFunction) {
|
|
return false;
|
|
}
|
|
seenFunction = true;
|
|
}
|
|
if (current.type === utils_1.AST_NODE_TYPES.CallExpression ||
|
|
current.type === utils_1.AST_NODE_TYPES.NewExpression) {
|
|
if (current.typeArguments != null) {
|
|
continue;
|
|
}
|
|
if (current.type === utils_1.AST_NODE_TYPES.CallExpression &&
|
|
current.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
|
|
current.arguments.includes(node)) {
|
|
continue;
|
|
}
|
|
const calleeType = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(current.callee));
|
|
if (hasGenericCallSignature(calleeType)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function hasPhantomTypeArgumentMismatch(node, uncastType, contextualType) {
|
|
return (isInGenericContext(node) &&
|
|
(hasPhantomTypeArguments(uncastType) ||
|
|
hasPhantomTypeArguments(contextualType)) &&
|
|
!haveSameTypeArguments(uncastType, contextualType));
|
|
}
|
|
const SKIP_PARENT_TYPES = new Set([
|
|
utils_1.AST_NODE_TYPES.TSAsExpression,
|
|
utils_1.AST_NODE_TYPES.TSTypeAssertion,
|
|
utils_1.AST_NODE_TYPES.SpreadElement,
|
|
utils_1.AST_NODE_TYPES.TSSatisfiesExpression,
|
|
]);
|
|
function shouldSkipContextualTypeFallback(node, castIsAny) {
|
|
if (castIsAny) {
|
|
return (node.parent.type === utils_1.AST_NODE_TYPES.LogicalExpression ||
|
|
isInGenericContext(node));
|
|
}
|
|
/**
|
|
* Interpolated template literals can be widened to `string` while contextual
|
|
* typing still accepts them, so the assertion may be required.
|
|
* @see https://github.com/typescript-eslint/typescript-eslint/issues/12276
|
|
*/
|
|
if (isTemplateLiteralWithExpressions(node.expression)) {
|
|
return true;
|
|
}
|
|
if (SKIP_PARENT_TYPES.has(node.parent.type) ||
|
|
node.expression.type === utils_1.AST_NODE_TYPES.ArrayExpression ||
|
|
isInDestructuringDeclaration(node) ||
|
|
isPropertyInProblematicContext(node) ||
|
|
isAssignmentInNonStatementContext(node) ||
|
|
isRightHandSideOfLogicalAssignment(node) ||
|
|
isArgumentToOverloadedFunction(node)) {
|
|
return true;
|
|
}
|
|
if (isInGenericContext(node)) {
|
|
const originalExpr = getOriginalExpression(node);
|
|
return (!isConceptuallyLiteral(originalExpr) &&
|
|
node.parent.type !== utils_1.AST_NODE_TYPES.Property);
|
|
}
|
|
return false;
|
|
}
|
|
function getUncastType(node) {
|
|
// Special handling for IIFE: extract the function's return type
|
|
if (isIIFE(node.expression)) {
|
|
const callee = node.expression.callee;
|
|
const functionType = services.getTypeAtLocation(callee);
|
|
const signatures = functionType.getCallSignatures();
|
|
if (signatures.length > 0) {
|
|
const returnType = checker.getReturnTypeOfSignature(signatures[0]);
|
|
// If the function has no explicit return type annotation and returns undefined,
|
|
// treat it as void (TypeScript infers () => {} as () => undefined, but it should be void)
|
|
if (callee.returnType == null &&
|
|
(0, util_1.isTypeFlagSet)(returnType, ts.TypeFlags.Undefined)) {
|
|
return checker.getVoidType();
|
|
}
|
|
return returnType;
|
|
}
|
|
}
|
|
return services.getTypeAtLocation(node.expression);
|
|
}
|
|
function createAssertionFixer(node) {
|
|
return fixer => {
|
|
if (node.type === utils_1.AST_NODE_TYPES.TSTypeAssertion) {
|
|
const openingAngleBracket = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(node.typeAnnotation, token => token.type === utils_1.AST_TOKEN_TYPES.Punctuator &&
|
|
token.value === '<'), util_1.NullThrowsReasons.MissingToken('<', 'type annotation'));
|
|
const closingAngleBracket = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(node.typeAnnotation, token => token.type === utils_1.AST_TOKEN_TYPES.Punctuator &&
|
|
token.value === '>'), util_1.NullThrowsReasons.MissingToken('>', 'type annotation'));
|
|
// Removing the angle brackets leaves the asserted operand at the
|
|
// assertion's position, so its first token leads whatever the
|
|
// assertion led. A leading `{`/`function`/`class` at the start of an
|
|
// expression statement is parsed as a block / function or class
|
|
// declaration, and a leading `{` at the start of a concise arrow body
|
|
// is parsed as a block body. In those positions the operand must be
|
|
// wrapped in parentheses to stay an expression.
|
|
const firstOperandToken = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(closingAngleBracket), util_1.NullThrowsReasons.MissingToken('operand', 'type assertion'));
|
|
const breaksExpressionStatement = ['{', 'function', 'class'].includes(firstOperandToken.value) &&
|
|
isAtExpressionStatementStart(node);
|
|
const breaksArrowFunctionBody = firstOperandToken.value === '{' &&
|
|
isAtArrowFunctionBodyStart(node, context.sourceCode);
|
|
const needsParens = breaksExpressionStatement || breaksArrowFunctionBody;
|
|
const fixes = [];
|
|
if (needsParens) {
|
|
fixes.push(fixer.insertTextBefore(node, '('));
|
|
}
|
|
fixes.push(fixer.removeRange([
|
|
openingAngleBracket.range[0],
|
|
closingAngleBracket.range[1],
|
|
]));
|
|
if (needsParens) {
|
|
fixes.push(fixer.insertTextAfter(node, ')'));
|
|
}
|
|
return fixes;
|
|
}
|
|
const asToken = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(node.expression, token => token.type === utils_1.AST_TOKEN_TYPES.Identifier && token.value === 'as'), util_1.NullThrowsReasons.MissingToken('>', 'type annotation'));
|
|
const tokenBeforeAs = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(asToken, {
|
|
includeComments: true,
|
|
}), util_1.NullThrowsReasons.MissingToken('comment', 'as'));
|
|
return fixer.removeRange([tokenBeforeAs.range[1], node.range[1]]);
|
|
};
|
|
}
|
|
function reportDoubleAssertionIfUnnecessary(node, contextualType) {
|
|
const doubleAssertionResult = isDoubleAssertionUnnecessary(node, contextualType);
|
|
if (doubleAssertionResult) {
|
|
context.report({
|
|
node,
|
|
messageId: doubleAssertionResult,
|
|
fix(fixer) {
|
|
const originalExpr = getOriginalExpression(node);
|
|
let text = context.sourceCode.getText(originalExpr);
|
|
if (originalExpr.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
|
|
node.parent.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
|
|
node.parent.body === node) {
|
|
text = `(${text})`;
|
|
}
|
|
return fixer.replaceText(node, text);
|
|
},
|
|
});
|
|
}
|
|
}
|
|
return {
|
|
'TSAsExpression, TSTypeAssertion'(node) {
|
|
if (options.typesToIgnore?.includes(context.sourceCode.getText(node.typeAnnotation))) {
|
|
return;
|
|
}
|
|
const castType = services.getTypeAtLocation(node);
|
|
const castTypeIsLiteral = isTypeLiteral(castType);
|
|
const typeAnnotationIsConstAssertion = isConstAssertion(node.typeAnnotation);
|
|
if (!options.checkLiteralConstAssertions &&
|
|
castTypeIsLiteral &&
|
|
typeAnnotationIsConstAssertion) {
|
|
return;
|
|
}
|
|
const uncastType = getUncastType(node);
|
|
const typeIsUnchanged = isTypeUnchanged(node, node.expression, uncastType, castType);
|
|
const wouldSameTypeBeInferred = castTypeIsLiteral
|
|
? isImplicitlyNarrowedLiteralDeclaration(node)
|
|
: !typeAnnotationIsConstAssertion;
|
|
if (typeIsUnchanged && wouldSameTypeBeInferred) {
|
|
context.report({
|
|
node,
|
|
messageId: 'unnecessaryAssertion',
|
|
fix: createAssertionFixer(node),
|
|
});
|
|
return;
|
|
}
|
|
const originalNode = services.esTreeNodeToTSNodeMap.get(node);
|
|
const castIsAny = (0, util_1.isTypeFlagSet)(castType, ts.TypeFlags.Any) &&
|
|
!SKIP_PARENT_TYPES.has(node.parent.type);
|
|
const contextualType = shouldSkipContextualTypeFallback(node, castIsAny)
|
|
? undefined
|
|
: checker.getContextualType(originalNode);
|
|
if (contextualType) {
|
|
const contextualTypeIsAny = (0, util_1.isTypeFlagSet)(contextualType, ts.TypeFlags.Any);
|
|
const isCallArgument = (node.parent.type === utils_1.AST_NODE_TYPES.CallExpression ||
|
|
node.parent.type === utils_1.AST_NODE_TYPES.NewExpression) &&
|
|
node.parent.arguments.includes(node);
|
|
const anyInvolvedInContextualCheck = contextualTypeIsAny
|
|
? isCallArgument && !containsAny(castType)
|
|
: !containsAny(contextualType);
|
|
const isNullishLiteralToUnion = castType.isUnion() &&
|
|
((node.expression.type === utils_1.AST_NODE_TYPES.Literal &&
|
|
node.expression.value == null) ||
|
|
(node.expression.type === utils_1.AST_NODE_TYPES.Identifier &&
|
|
node.expression.name === 'undefined'));
|
|
const isContextuallyUnnecessary = !typeAnnotationIsConstAssertion &&
|
|
!containsAny(uncastType) &&
|
|
anyInvolvedInContextualCheck &&
|
|
!hasPhantomTypeArgumentMismatch(node, uncastType, contextualType) &&
|
|
(castIsAny || !genericsMismatch(uncastType, contextualType)) &&
|
|
(contextualTypeIsAny ||
|
|
checker.isTypeAssignableTo(uncastType, contextualType)) &&
|
|
!isNullishLiteralToUnion;
|
|
if (isContextuallyUnnecessary) {
|
|
context.report({
|
|
node,
|
|
messageId: 'contextuallyUnnecessary',
|
|
fix: createAssertionFixer(node),
|
|
});
|
|
return;
|
|
}
|
|
}
|
|
reportDoubleAssertionIfUnnecessary(node, contextualType);
|
|
},
|
|
TSNonNullExpression(node) {
|
|
const removeExclamationFix = fixer => {
|
|
const exclamationToken = (0, util_1.nullThrows)(context.sourceCode.getLastToken(node, token => token.value === '!'), util_1.NullThrowsReasons.MissingToken('exclamation mark', 'non-null assertion'));
|
|
return fixer.removeRange(exclamationToken.range);
|
|
};
|
|
if (node.parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression &&
|
|
node.parent.operator === '=') {
|
|
if (node.parent.left === node) {
|
|
context.report({
|
|
node,
|
|
messageId: 'contextuallyUnnecessary',
|
|
fix: removeExclamationFix,
|
|
});
|
|
}
|
|
// for all other = assignments we ignore non-null checks
|
|
// this is because non-null assertions can change the type-flow of the code
|
|
// so whilst they might be unnecessary for the assignment - they are necessary
|
|
// for following code
|
|
return;
|
|
}
|
|
const originalNode = services.esTreeNodeToTSNodeMap.get(node);
|
|
const constrainedType = (0, util_1.getConstrainedTypeAtLocation)(services, node.expression);
|
|
const actualType = services.getTypeAtLocation(node.expression);
|
|
// Check both the constrained type and the actual type.
|
|
// If either is nullable, we should not report the assertion as unnecessary.
|
|
// This handles cases like generic constraints with `any` where the
|
|
// constrained type is `any` (nullable) but the actual type might be
|
|
// a type parameter that TypeScript treats nominally.
|
|
// See: https://github.com/typescript-eslint/typescript-eslint/issues/11559
|
|
const constrainedTypeIsNullable = (0, util_1.isNullableType)(constrainedType);
|
|
const actualTypeIsNullable = (0, util_1.isNullableType)(actualType);
|
|
if (!constrainedTypeIsNullable && !actualTypeIsNullable) {
|
|
if (node.expression.type === utils_1.AST_NODE_TYPES.Identifier &&
|
|
isPossiblyUsedBeforeAssigned(node.expression)) {
|
|
return;
|
|
}
|
|
context.report({
|
|
node,
|
|
messageId: 'unnecessaryAssertion',
|
|
fix: removeExclamationFix,
|
|
});
|
|
}
|
|
else {
|
|
// we know it's a nullable type
|
|
// so figure out if the variable is used in a place that accepts nullable types
|
|
// If the constrained type differs from the actual type (e.g., when dealing
|
|
// with unresolved generic type parameters), we should not report the assertion
|
|
// as contextually unnecessary. TypeScript may still require the assertion
|
|
// even if the constraint is nullable (like `any`).
|
|
// See: https://github.com/typescript-eslint/typescript-eslint/issues/11559
|
|
if (constrainedType !== actualType) {
|
|
return;
|
|
}
|
|
const contextualType = (0, util_1.getContextualType)(checker, originalNode);
|
|
if (contextualType) {
|
|
if ((0, util_1.isTypeFlagSet)(constrainedType, ts.TypeFlags.Unknown) &&
|
|
!(0, util_1.isTypeFlagSet)(contextualType, ts.TypeFlags.Unknown)) {
|
|
return;
|
|
}
|
|
// in strict mode you can't assign null to undefined, so we have to make sure that
|
|
// the two types share a nullable type
|
|
const typeIncludesUndefined = (0, util_1.isTypeFlagSet)(constrainedType, ts.TypeFlags.Undefined);
|
|
const typeIncludesNull = (0, util_1.isTypeFlagSet)(constrainedType, ts.TypeFlags.Null);
|
|
const typeIncludesVoid = (0, util_1.isTypeFlagSet)(constrainedType, ts.TypeFlags.Void);
|
|
const contextualTypeIncludesUndefined = (0, util_1.isTypeFlagSet)(contextualType, ts.TypeFlags.Undefined);
|
|
const contextualTypeIncludesNull = (0, util_1.isTypeFlagSet)(contextualType, ts.TypeFlags.Null);
|
|
const contextualTypeIncludesVoid = (0, util_1.isTypeFlagSet)(contextualType, ts.TypeFlags.Void);
|
|
// make sure that the parent accepts the same types
|
|
// i.e. assigning `string | null | undefined` to `string | undefined` is invalid
|
|
const isValidUndefined = typeIncludesUndefined
|
|
? contextualTypeIncludesUndefined
|
|
: true;
|
|
const isValidNull = typeIncludesNull
|
|
? contextualTypeIncludesNull
|
|
: true;
|
|
const isValidVoid = typeIncludesVoid
|
|
? contextualTypeIncludesVoid
|
|
: true;
|
|
if (isValidUndefined && isValidNull && isValidVoid) {
|
|
context.report({
|
|
node,
|
|
messageId: 'contextuallyUnnecessary',
|
|
fix: removeExclamationFix,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
},
|
|
};
|
|
},
|
|
});
|