feat: wrap OptionalTypeNode (#1647)

Author: dsherret

packages/ts-morph/lib/ts-morph.d.ts

@@ -4194,6 +4194,8 @@ export declare class Node<NodeType extends ts.Node = ts.Node> {
   static isNodeWithTypeArguments(node: Node | undefined): node is NodeWithTypeArguments;
   /** Gets if the node is a NullLiteral. */
   static isNullLiteral(node: Node | undefined): node is NullLiteral;
+  /** Gets if the node is a OptionalTypeNode. */
+  static isOptionalTypeNode(node: Node | undefined): node is OptionalTypeNode;
   /** Gets if the node is a OverloadableNode. */
   static isOverloadable<T extends Node>(node: T | undefined): node is OverloadableNode & OverloadableNodeExtensionType & T;
   /** Gets if the node is a OverrideableNode. */
@@ -6513,6 +6515,7 @@ export interface ImplementedKindToNodeMappings {
   [SyntaxKind.ObjectBindingPattern]: ObjectBindingPattern;
   [SyntaxKind.ObjectLiteralExpression]: ObjectLiteralExpression;
   [SyntaxKind.OmittedExpression]: OmittedExpression;
+  [SyntaxKind.OptionalType]: OptionalTypeNode;
   [SyntaxKind.Parameter]: ParameterDeclaration;
   [SyntaxKind.ParenthesizedExpression]: ParenthesizedExpression;
   [SyntaxKind.ParenthesizedType]: ParenthesizedTypeNode;
@@ -8752,6 +8755,15 @@ export declare class NamedTupleMember extends NamedTupleMemberBase<ts.NamedTuple
   getParentOrThrow(message?: string | (() => string)): NonNullable<NodeParentType<ts.NamedTupleMember>>;
 }
 
+export declare class OptionalTypeNode extends TypeNode<ts.OptionalTypeNode> {
+  /** Gets the optional type node's inner type. */
+  getTypeNode(): TypeNode<ts.TypeNode>;
+  /** @inheritdoc **/
+  getParent(): NodeParentType<ts.OptionalTypeNode>;
+  /** @inheritdoc **/
+  getParentOrThrow(message?: string | (() => string)): NonNullable<NodeParentType<ts.OptionalTypeNode>>;
+}
+
 export declare class ParenthesizedTypeNode extends TypeNode<ts.ParenthesizedTypeNode> {
   /** Gets the node within the parentheses. */
   getTypeNode(): TypeNode;

packages/ts-morph/src/compiler/ast/common/Node.ts

@@ -3481,6 +3481,11 @@ export class Node<NodeType extends ts.Node = ts.Node> {
   /** Gets if the node is a OmittedExpression. */
   static readonly isOmittedExpression: (node: compiler.Node | undefined) => node is compiler.OmittedExpression = Node.is(SyntaxKind.OmittedExpression);
 
+  /** Gets if the node is a OptionalTypeNode. */
+  static isOptionalTypeNode(node: compiler.Node | undefined): node is compiler.OptionalTypeNode {
+    return node?.getKind() === SyntaxKind.OptionalType;
+  }
+
   /** Gets if the node is a OverloadableNode. */
   static isOverloadable<T extends compiler.Node>(node: T | undefined): node is compiler.OverloadableNode & compiler.OverloadableNodeExtensionType & T {
     switch (node?.getKind()) {
@@ -4085,6 +4090,7 @@ export class Node<NodeType extends ts.Node = ts.Node> {
       case SyntaxKind.LiteralType:
       case SyntaxKind.MappedType:
       case SyntaxKind.NamedTupleMember:
+      case SyntaxKind.OptionalType:
       case SyntaxKind.ParenthesizedType:
       case SyntaxKind.RestType:
       case SyntaxKind.TemplateLiteralType:

packages/ts-morph/src/compiler/ast/kindToNodeMappings.generated.ts

@@ -144,6 +144,7 @@ export interface ImplementedKindToNodeMappings {
   [SyntaxKind.ObjectBindingPattern]: compiler.ObjectBindingPattern;
   [SyntaxKind.ObjectLiteralExpression]: compiler.ObjectLiteralExpression;
   [SyntaxKind.OmittedExpression]: compiler.OmittedExpression;
+  [SyntaxKind.OptionalType]: compiler.OptionalTypeNode;
   [SyntaxKind.Parameter]: compiler.ParameterDeclaration;
   [SyntaxKind.ParenthesizedExpression]: compiler.ParenthesizedExpression;
   [SyntaxKind.ParenthesizedType]: compiler.ParenthesizedTypeNode;

packages/ts-morph/src/compiler/ast/type/OptionalTypeNode.ts

@@ -0,0 +1,9 @@
+import { ts } from "@ts-morph/common";
+import { TypeNode } from "./TypeNode";
+
+export class OptionalTypeNode extends TypeNode<ts.OptionalTypeNode> {
+  /** Gets the optional type node's inner type. */
+  getTypeNode() {
+    return this._getNodeFromCompilerNode(this.compilerNode.type);
+  }
+}

packages/ts-morph/src/compiler/ast/type/index.ts

@@ -11,6 +11,7 @@ export * from "./IntersectionTypeNode";
 export * from "./LiteralTypeNode";
 export * from "./MappedTypeNode";
 export * from "./NamedTupleMember";
+export * from "./OptionalTypeNode";
 export * from "./ParenthesizedTypeNode";
 export * from "./RestTypeNode";
 export * from "./TemplateLiteralTypeNode";

packages/ts-morph/src/factories/kindToWrapperMappings.ts

@@ -145,6 +145,7 @@ export const kindToWrapperMappings: { [key: number]: unknown } = {
   [SyntaxKind.ObjectBindingPattern]: compiler.ObjectBindingPattern,
   [SyntaxKind.ObjectLiteralExpression]: compiler.ObjectLiteralExpression,
   [SyntaxKind.OmittedExpression]: compiler.OmittedExpression,
+  [SyntaxKind.OptionalType]: compiler.OptionalTypeNode,
   [SyntaxKind.Parameter]: compiler.ParameterDeclaration,
   [SyntaxKind.ParenthesizedExpression]: compiler.ParenthesizedExpression,
   [SyntaxKind.ParenthesizedType]: compiler.ParenthesizedTypeNode,

packages/ts-morph/src/tests/compiler/ast/type/optionalTypeNodeTest.ts

@@ -0,0 +1,21 @@
+import { nameof, SyntaxKind } from "@ts-morph/common";
+import { expect } from "chai";
+import { OptionalTypeNode } from "../../../../compiler";
+import { getInfoFromTextWithDescendant } from "../../testHelpers";
+
+describe("OptionalTypeNode", () => {
+  function getNode(text: string) {
+    return getInfoFromTextWithDescendant<OptionalTypeNode>(text, SyntaxKind.OptionalType);
+  }
+
+  describe(nameof<OptionalTypeNode>("getTypeNode"), () => {
+    function doTest(text: string, expected: string) {
+      const { descendant } = getNode(text);
+      expect(descendant.getTypeNode().getText()).to.equal(expected);
+    }
+
+    it("should get the type", () => {
+      doTest("type T = [string, number?]", "number");
+    });
+  });
+});