feat: remove deprecated api (#797)

fixes #767

Author: RebeccaStevens

src/nodes/typeGuards/compound.ts

@@ -5,7 +5,6 @@ import {
 	isDeclarationName,
 	isEntityNameExpression,
 	isJSDocNamespaceBody,
-	isJsxTagNameExpression,
 	isNamespaceBody,
 } from "./union";
 
@@ -134,8 +133,7 @@ export function isJsxTagNamePropertyAccess(
 ): node is ts.JsxTagNamePropertyAccess {
 	return (
 		ts.isPropertyAccessExpression(node) &&
-		// eslint-disable-next-line @typescript-eslint/no-deprecated -- Keep compatibility with ts < 5
-		isJsxTagNameExpression(node.expression)
+		ts.isJsxTagNameExpression(node.expression)
 	);
 }
 

src/nodes/typeGuards/single.test.ts

@@ -2,7 +2,6 @@ import * as ts from "typescript";
 import { describe, expect, it } from "vitest";
 
 import { createNode } from "../../test/utils";
-import { isTsVersionAtLeast } from "../../utils";
 import {
 	isAbstractKeyword,
 	isAccessorKeyword,
@@ -54,16 +53,14 @@ describe("isAbstractKeyword", () => {
 	});
 });
 
-if (isTsVersionAtLeast(4, 9)) {
-	describe("isAccessorKeyword", () => {
-		it.each([
-			[false, ts.factory.createModifier(ts.SyntaxKind.AbstractKeyword)],
-			[true, ts.factory.createModifier(ts.SyntaxKind.AccessorKeyword)],
-		])("returns %j when given %s", (expected, code) => {
-			expect(isAccessorKeyword(createNode(code))).toBe(expected);
-		});
+describe("isAccessorKeyword", () => {
+	it.each([
+		[false, ts.factory.createModifier(ts.SyntaxKind.AbstractKeyword)],
+		[true, ts.factory.createModifier(ts.SyntaxKind.AccessorKeyword)],
+	])("returns %j when given %s", (expected, code) => {
+		expect(isAccessorKeyword(createNode(code))).toBe(expected);
 	});
-}
+});
 
 describe("isAnyKeyword", () => {
 	it.each([
@@ -74,16 +71,14 @@ describe("isAnyKeyword", () => {
 	});
 });
 
-if (isTsVersionAtLeast(4, 5)) {
-	describe("isAssertKeyword", () => {
-		it.each([
-			[false, ts.factory.createToken(ts.SyntaxKind.AbstractKeyword)],
-			[true, ts.factory.createToken(ts.SyntaxKind.AssertKeyword)],
-		])("returns %j when given %s", (expected, code) => {
-			expect(isAssertKeyword(createNode(code))).toBe(expected);
-		});
+describe("isAssertKeyword", () => {
+	it.each([
+		[false, ts.factory.createToken(ts.SyntaxKind.AbstractKeyword)],
+		[true, ts.factory.createToken(ts.SyntaxKind.AssertKeyword)],
+	])("returns %j when given %s", (expected, code) => {
+		expect(isAssertKeyword(createNode(code))).toBe(expected);
 	});
-}
+});
 
 describe("isAsyncKeyword", () => {
 	it.each([
@@ -202,16 +197,14 @@ describe("isInKeyword", () => {
 	});
 });
 
-if (isTsVersionAtLeast(4, 3)) {
-	describe("isJSDocText", () => {
-		it.each([
-			[false, ts.factory.createToken(ts.SyntaxKind.AbstractKeyword)],
-			[true, ts.factory.createJSDocText("")],
-		])("returns %j when given %s", (expected, code) => {
-			expect(isJSDocText(createNode(code))).toBe(expected);
-		});
+describe("isJSDocText", () => {
+	it.each([
+		[false, ts.factory.createToken(ts.SyntaxKind.AbstractKeyword)],
+		[true, ts.factory.createJSDocText("")],
+	])("returns %j when given %s", (expected, code) => {
+		expect(isJSDocText(createNode(code))).toBe(expected);
 	});
-}
+});
 
 describe("isNeverKeyword", () => {
 	it.each([
@@ -258,27 +251,23 @@ describe("isObjectKeyword", () => {
 	});
 });
 
-if (isTsVersionAtLeast(4, 7)) {
-	describe("isOutKeyword", () => {
-		it.each([
-			[false, ts.factory.createToken(ts.SyntaxKind.AbstractKeyword)],
-			[true, ts.factory.createToken(ts.SyntaxKind.OutKeyword)],
-		])("returns %j when given %s", (expected, code) => {
-			expect(isOutKeyword(createNode(code))).toBe(expected);
-		});
+describe("isOutKeyword", () => {
+	it.each([
+		[false, ts.factory.createToken(ts.SyntaxKind.AbstractKeyword)],
+		[true, ts.factory.createToken(ts.SyntaxKind.OutKeyword)],
+	])("returns %j when given %s", (expected, code) => {
+		expect(isOutKeyword(createNode(code))).toBe(expected);
 	});
-}
+});
 
-if (isTsVersionAtLeast(4, 3)) {
-	describe("isOverrideKeyword", () => {
-		it.each([
-			[false, ts.factory.createToken(ts.SyntaxKind.AbstractKeyword)],
-			[true, ts.factory.createToken(ts.SyntaxKind.OverrideKeyword)],
-		])("returns %j when given %s", (expected, code) => {
-			expect(isOverrideKeyword(createNode(code))).toBe(expected);
-		});
+describe("isOverrideKeyword", () => {
+	it.each([
+		[false, ts.factory.createToken(ts.SyntaxKind.AbstractKeyword)],
+		[true, ts.factory.createToken(ts.SyntaxKind.OverrideKeyword)],
+	])("returns %j when given %s", (expected, code) => {
+		expect(isOverrideKeyword(createNode(code))).toBe(expected);
 	});
-}
+});
 
 describe("isPrivateKeyword", () => {
 	it.each([

src/nodes/typeGuards/single.ts

@@ -170,24 +170,6 @@ export function isAssertKeyword(node: ts.Node): node is ts.AssertKeyword {
 	return node.kind === ts.SyntaxKind.AssertKeyword;
 }
 
-/**
- * Test if a node is an `AssertsKeyword`.
- * @deprecated With TypeScript v5, in favor of typescript's `isAssertsKeyword`.
- * @category Nodes - Type Guards
- * @example
- * ```ts
- * declare const node: ts.Node;
- *
- * if (isAssertsKeyword(node)) {
- *   // ...
- * }
- * ```
- * @returns Whether the given node appears to be an `AssertsKeyword`.
- */
-export function isAssertsKeyword(node: ts.Node): node is ts.AssertsKeyword {
-	return node.kind === ts.SyntaxKind.AssertsKeyword;
-}
-
 /**
  * Test if a node is an `AsyncKeyword`.
  * @category Nodes - Type Guards
@@ -205,78 +187,6 @@ export function isAsyncKeyword(node: ts.Node): node is ts.AsyncKeyword {
 	return node.kind === ts.SyntaxKind.AsyncKeyword;
 }
 
-/**
- * Test if a node is an `AwaitKeyword`.
- * @deprecated With TypeScript v5, in favor of typescript's `isAwaitKeyword`.
- * @category Nodes - Type Guards
- * @example
- * ```ts
- * declare const node: ts.Node;
- *
- * if (isAwaitKeyword(node)) {
- *   // ...
- * }
- * ```
- * @returns Whether the given node appears to be an `AwaitKeyword`.
- */
-export function isAwaitKeyword(node: ts.Node): node is ts.AwaitKeyword {
-	return node.kind === ts.SyntaxKind.AwaitKeyword;
-}
-
-/**
- * Test if a node is a {@link BigIntKeyword}.
- * @deprecated With TypeScript v5, in favor of typescript's `isBigIntKeyword`.
- * @category Nodes - Type Guards
- * @example
- * ```ts
- * declare const node: ts.Node;
- *
- * if (isBigIntKeyword(node)) {
- *   // ...
- * }
- * ```
- * @returns Whether the given node appears to be a {@link BigIntKeyword}.
- */
-export function isBigIntKeyword(node: ts.Node): node is BigIntKeyword {
-	return node.kind === ts.SyntaxKind.BigIntKeyword;
-}
-
-/**
- * Test if a node is a {@link BooleanKeyword}.
- * @deprecated With TypeScript v5, in favor of typescript's `isBooleanKeyword`.
- * @category Nodes - Type Guards
- * @example
- * ```ts
- * declare const node: ts.Node;
- *
- * if (isBooleanKeyword(node)) {
- *   // ...
- * }
- * ```
- * @returns Whether the given node appears to be a {@link BooleanKeyword}.
- */
-export function isBooleanKeyword(node: ts.Node): node is BooleanKeyword {
-	return node.kind === ts.SyntaxKind.BooleanKeyword;
-}
-
-/**
- * Test if a node is a `ColonToken`.
- * @deprecated With TypeScript v5, in favor of typescript's `isColonToken`.
- * @category Nodes - Type Guards
- * @example
- * ```ts
- * declare const node: ts.Node;
- *
- * if (isColonToken(node)) {
- *   // ...
- * }
- * ```
- * @returns Whether the given node appears to be a `ColonToken`.
- */
-export function isColonToken(node: ts.Node): node is ts.ColonToken {
-	return node.kind === ts.SyntaxKind.ColonToken;
-}
-
 /**
  * Test if a node is a `ConstKeyword`.
  * @category Nodes - Type Guards
@@ -362,26 +272,6 @@ export function isEndOfFileToken(node: ts.Node): node is ts.EndOfFileToken {
 	return node.kind === ts.SyntaxKind.EndOfFileToken;
 }
 
-/**
- * Test if a node is an `EqualsGreaterThanToken`.
- * @deprecated With TypeScript v5, in favor of typescript's `isEqualsGreaterThanToken`.
- * @category Nodes - Type Guards
- * @example
- * ```ts
- * declare const node: ts.Node;
- *
- * if (isEqualsGreaterThanToken(node)) {
- *   // ...
- * }
- * ```
- * @returns Whether the given node appears to be an `EqualsGreaterThanToken`.
- */
-export function isEqualsGreaterThanToken(
-	node: ts.Node,
-): node is ts.EqualsGreaterThanToken {
-	return node.kind === ts.SyntaxKind.EqualsGreaterThanToken;
-}
-
 /**
  * Test if a node is an `EqualsToken`.
  * @category Nodes - Type Guards
@@ -399,24 +289,6 @@ export function isEqualsToken(node: ts.Node): node is ts.EqualsToken {
 	return node.kind === ts.SyntaxKind.EqualsToken;
 }
 
-/**
- * Test if a node is an `ExclamationToken`.
- * @deprecated With TypeScript v5, in favor of typescript's `isExclamationToken`.
- * @category Nodes - Type Guards
- * @example
- * ```ts
- * declare const node: ts.Node;
- *
- * if (isExclamationToken(node)) {
- *   // ...
- * }
- * ```
- * @returns Whether the given node appears to be an `ExclamationToken`.
- */
-export function isExclamationToken(node: ts.Node): node is ts.ExclamationToken {
-	return node.kind === ts.SyntaxKind.ExclamationToken;
-}
-
 /**
  * Test if a node is an `ExportKeyword`.
  * @category Nodes - Type Guards
@@ -725,42 +597,6 @@ export function isPublicKeyword(node: ts.Node): node is ts.PublicKeyword {
 	return node.kind === ts.SyntaxKind.PublicKeyword;
 }
 
-/**
- * Test if a node is a `QuestionDotToken`.
- * @deprecated With TypeScript v5, in favor of typescript's `isQuestionDotToken`.
- * @category Nodes - Type Guards
- * @example
- * ```ts
- * declare const node: ts.Node;
- *
- * if (isQuestionDotToken(node)) {
- *   // ...
- * }
- * ```
- * @returns Whether the given node appears to be a `QuestionDotToken`.
- */
-export function isQuestionDotToken(node: ts.Node): node is ts.QuestionDotToken {
-	return node.kind === ts.SyntaxKind.QuestionDotToken;
-}
-
-/**
- * Test if a node is a `QuestionToken`.
- * @deprecated With TypeScript v5, in favor of typescript's `isQuestionToken`.
- * @category Nodes - Type Guards
- * @example
- * ```ts
- * declare const node: ts.Node;
- *
- * if (isQuestionToken(node)) {
- *   // ...
- * }
- * ```
- * @returns Whether the given node appears to be a `QuestionToken`.
- */
-export function isQuestionToken(node: ts.Node): node is ts.QuestionToken {
-	return node.kind === ts.SyntaxKind.QuestionToken;
-}
-
 /**
  * Test if a node is a `ReadonlyKeyword`.
  * @category Nodes - Type Guards

src/nodes/typeGuards/union.test.ts

@@ -2,12 +2,9 @@ import * as ts from "typescript";
 import { describe, expect, it } from "vitest";
 
 import { createNode } from "../../test/utils";
-import { isTsVersionAtLeast } from "../../utils";
 import {
 	isAccessExpression,
 	isAccessibilityModifier,
-	isAccessorDeclaration,
-	isArrayBindingElement,
 	isArrayBindingOrAssignmentPattern,
 	isAssignmentPattern,
 	isBooleanLiteral,
@@ -37,36 +34,6 @@ describe("isAccessibilityModifier", () => {
 	});
 });
 
-if (isTsVersionAtLeast(4, 9)) {
-	describe("isAccessorDeclaration", () => {
-		it.each([
-			[false, `abc`],
-			[
-				true,
-				ts.factory.createGetAccessorDeclaration(
-					undefined,
-					"property",
-					[],
-					undefined,
-					undefined,
-				),
-			],
-			[
-				true,
-				ts.factory.createSetAccessorDeclaration(
-					undefined,
-					"property",
-					[],
-					undefined,
-				),
-			],
-		])("returns %j when given %s", (expected, sourceText) => {
-			// eslint-disable-next-line @typescript-eslint/no-deprecated
-			expect(isAccessorDeclaration(createNode(sourceText))).toBe(expected);
-		});
-	});
-}
-
 describe("isArrayBindingOrAssignmentPattern", () => {
 	it.each([
 		[false, `"[a]"`],
@@ -86,8 +53,7 @@ describe("isArrayBindingElement", () => {
 		[true, ts.factory.createBindingElement(undefined, "property", "name")],
 		[true, ts.factory.createOmittedExpression()],
 	])("returns %j when given %s", (expected, sourceText) => {
-		// eslint-disable-next-line @typescript-eslint/no-deprecated
-		expect(isArrayBindingElement(createNode(sourceText))).toBe(expected);
+		expect(ts.isArrayBindingElement(createNode(sourceText))).toBe(expected);
 	});
 });