refactor: InitializerGetExpressionableNode is now InitializerExpressi…

…onGetableNode for consistency.

BREAKING CHANGE: InitializerGetExpressionableNode was renamed to InitializerExpressionGetableNode.

lib/ts-morph.d.ts

@@ -1138,10 +1138,10 @@ export declare class TypeGuards {
      */
     static isInitializerExpressionableNode(node: Node): node is InitializerExpressionableNode & InitializerExpressionableNodeExtensionType;
     /**
-     * Gets if the node is a InitializerGetExpressionableNode.
+     * Gets if the node is a InitializerExpressionGetableNode.
      * @param node - Node to check.
      */
-    static isInitializerGetExpressionableNode(node: Node): node is InitializerGetExpressionableNode & InitializerGetExpressionableNodeExtensionType;
+    static isInitializertExpressionGetableNode(node: Node): node is InitializerExpressionGetableNode & InitializerExpressionGetableNodeExtensionType;
     /**
      * Gets if the node is a InitializerSetExpressionableNode.
      * @param node - Node to check.
@@ -2385,16 +2385,16 @@ declare type ImplementsClauseableNodeExtensionType = Node & HeritageClauseableNo
 
 export declare function InitializerExpressionableNode<T extends Constructor<InitializerExpressionableNodeExtensionType>>(Base: T): Constructor<InitializerExpressionableNode> & T;
 
-export interface InitializerExpressionableNode extends InitializerGetExpressionableNode, InitializerSetExpressionableNode {
+export interface InitializerExpressionableNode extends InitializerExpressionGetableNode, InitializerSetExpressionableNode {
 }
 
 declare type InitializerExpressionableNodeExtensionType = Node<ts.Node & {
     initializer?: ts.Expression;
 }>;
 
-export declare function InitializerGetExpressionableNode<T extends Constructor<InitializerGetExpressionableNodeExtensionType>>(Base: T): Constructor<InitializerGetExpressionableNode> & T;
+export declare function InitializerExpressionGetableNode<T extends Constructor<InitializerExpressionGetableNodeExtensionType>>(Base: T): Constructor<InitializerExpressionGetableNode> & T;
 
-export interface InitializerGetExpressionableNode {
+export interface InitializerExpressionGetableNode {
     /**
      * Gets if node has an initializer.
      */
@@ -2417,7 +2417,7 @@ export interface InitializerGetExpressionableNode {
     getInitializerOrThrow(): Expression;
 }
 
-declare type InitializerGetExpressionableNodeExtensionType = Node<ts.Node & {
+declare type InitializerExpressionGetableNodeExtensionType = Node<ts.Node & {
     initializer?: ts.Expression;
 }>;
 
@@ -2437,7 +2437,7 @@ export interface InitializerSetExpressionableNode {
 
 declare type InitializerSetExpressionableNodeExtensionType = Node<ts.Node & {
     initializer?: ts.Expression;
-}> & InitializerGetExpressionableNode;
+}> & InitializerExpressionGetableNode;
 
 export declare function JSDocableNode<T extends Constructor<JSDocableNodeExtensionType>>(Base: T): Constructor<JSDocableNode> & T;
 
@@ -2735,7 +2735,8 @@ export interface NamedNodeSpecificBase<TNode extends Node> {
      */
     getNameNode(): TNode;
     /**
-     * Gets the name.
+     * Gets the name as a string.
+     * @throws If the name node is an array binding pattern, object binding pattern, or computed property.
      */
     getName(): string;
 }
@@ -5649,7 +5650,7 @@ export declare class ObjectLiteralExpression extends ObjectLiteralExpressionBase
     insertSetAccessors(index: number, structures: ReadonlyArray<SetAccessorDeclarationStructure>): SetAccessorDeclaration[];
 }
 
-declare const PropertyAssignmentBase: Constructor<InitializerGetExpressionableNode> & Constructor<QuestionTokenableNode> & Constructor<PropertyNamedNode> & typeof Node;
+declare const PropertyAssignmentBase: Constructor<InitializerExpressionGetableNode> & Constructor<QuestionTokenableNode> & Constructor<PropertyNamedNode> & typeof Node;
 
 export declare class PropertyAssignment extends PropertyAssignmentBase<ts.PropertyAssignment> {
     /**
@@ -5678,7 +5679,7 @@ export declare class PropertyAssignment extends PropertyAssignmentBase<ts.Proper
     getStructure(): PropertyAssignmentStructure;
 }
 
-declare const ShorthandPropertyAssignmentBase: Constructor<InitializerGetExpressionableNode> & Constructor<QuestionTokenableNode> & Constructor<NamedNode> & typeof Node;
+declare const ShorthandPropertyAssignmentBase: Constructor<InitializerExpressionGetableNode> & Constructor<QuestionTokenableNode> & Constructor<NamedNode> & typeof Node;
 
 export declare class ShorthandPropertyAssignment extends ShorthandPropertyAssignmentBase<ts.ShorthandPropertyAssignment> {
     /**

src/compiler/ast/base/initializer/InitializerGetExpressionableNode.ts → src/compiler/ast/base/initializer/InitializerExpressionGetableNode.ts

@@ -6,9 +6,9 @@ import { Node } from "../../common";
 import { Expression } from "../../expression";
 import { KindToExpressionMappings } from "../../kindToNodeMappings";
 
-export type InitializerGetExpressionableNodeExtensionType = Node<ts.Node & { initializer?: ts.Expression; }>;
+export type InitializerExpressionGetableNodeExtensionType = Node<ts.Node & { initializer?: ts.Expression; }>;
 
-export interface InitializerGetExpressionableNode {
+export interface InitializerExpressionGetableNode {
     /**
      * Gets if node has an initializer.
      */
@@ -31,8 +31,8 @@ export interface InitializerGetExpressionableNode {
     getInitializerOrThrow(): Expression;
 }
 
-export function InitializerGetExpressionableNode<T extends Constructor<InitializerGetExpressionableNodeExtensionType>>(Base: T): Constructor<InitializerGetExpressionableNode> & T {
-    return class extends Base implements InitializerGetExpressionableNode {
+export function InitializerExpressionGetableNode<T extends Constructor<InitializerExpressionGetableNodeExtensionType>>(Base: T): Constructor<InitializerExpressionGetableNode> & T {
+    return class extends Base implements InitializerExpressionGetableNode {
         hasInitializer() {
             return this.compilerNode.initializer != null;
         }

src/compiler/ast/base/initializer/InitializerExpressionableNode.ts

@@ -1,14 +1,14 @@
 import { Constructor } from "../../../../types";
 import { ts } from "../../../../typescript";
 import { Node } from "../../common";
-import { InitializerGetExpressionableNode } from "./InitializerGetExpressionableNode";
+import { InitializerExpressionGetableNode } from "./InitializerExpressionGetableNode";
 import { InitializerSetExpressionableNode } from "./InitializerSetExpressionableNode";
 
 export type InitializerExpressionableNodeExtensionType = Node<ts.Node & { initializer?: ts.Expression; }>;
 
-export interface InitializerExpressionableNode extends InitializerGetExpressionableNode, InitializerSetExpressionableNode {
+export interface InitializerExpressionableNode extends InitializerExpressionGetableNode, InitializerSetExpressionableNode {
 }
 
 export function InitializerExpressionableNode<T extends Constructor<InitializerExpressionableNodeExtensionType>>(Base: T): Constructor<InitializerExpressionableNode> & T {
-    return InitializerSetExpressionableNode(InitializerGetExpressionableNode(Base));
+    return InitializerSetExpressionableNode(InitializerExpressionGetableNode(Base));
 }

src/compiler/ast/base/initializer/InitializerSetExpressionableNode.ts

@@ -6,10 +6,10 @@ import { SyntaxKind, ts } from "../../../../typescript";
 import { getTextFromStringOrWriter } from "../../../../utils";
 import { callBaseSet } from "../../callBaseSet";
 import { Node } from "../../common";
-import { InitializerGetExpressionableNode } from "./InitializerGetExpressionableNode";
+import { InitializerExpressionGetableNode } from "./InitializerExpressionGetableNode";
 import { callBaseGetStructure } from "../../callBaseGetStructure";
 
-export type InitializerSetExpressionableNodeExtensionType = Node<ts.Node & { initializer?: ts.Expression; }> & InitializerGetExpressionableNode;
+export type InitializerSetExpressionableNodeExtensionType = Node<ts.Node & { initializer?: ts.Expression; }> & InitializerExpressionGetableNode;
 
 export interface InitializerSetExpressionableNode {
     /**

src/compiler/ast/base/initializer/index.ts

@@ -1,3 +1,3 @@
 export * from "./InitializerExpressionableNode";
-export * from "./InitializerGetExpressionableNode";
+export * from "./InitializerExpressionGetableNode";
 export * from "./InitializerSetExpressionableNode";

src/compiler/ast/expression/object/PropertyAssignment.ts

@@ -2,7 +2,7 @@ import { insertIntoParentTextRange, removeCommaSeparatedChild } from "../../../.
 import { WriterFunction } from "../../../../types";
 import { SyntaxKind, ts } from "../../../../typescript";
 import { getTextFromStringOrWriter } from "../../../../utils";
-import { InitializerGetExpressionableNode, PropertyNamedNode, QuestionTokenableNode } from "../../base";
+import { InitializerExpressionGetableNode, PropertyNamedNode, QuestionTokenableNode } from "../../base";
 import { Node } from "../../common";
 import { ShorthandPropertyAssignment } from "./ShorthandPropertyAssignment";
 import { PropertyAssignmentStructure, PropertyAssignmentSpecificStructure } from "../../../../structures";
@@ -12,7 +12,7 @@ import { callBaseGetStructure } from "../../callBaseGetStructure";
 // This node only has a question token in order to tell the user about bad code.
 // (See https://github.com/Microsoft/TypeScript/pull/5121/files)
 
-export const PropertyAssignmentBase = InitializerGetExpressionableNode(QuestionTokenableNode(PropertyNamedNode(Node)));
+export const PropertyAssignmentBase = InitializerExpressionGetableNode(QuestionTokenableNode(PropertyNamedNode(Node)));
 export class PropertyAssignment extends PropertyAssignmentBase<ts.PropertyAssignment> {
     /**
      * Removes the initializer and returns the new shorthand property assignment.

src/compiler/ast/expression/object/ShorthandPropertyAssignment.ts

@@ -1,7 +1,7 @@
 import * as errors from "../../../../errors";
 import { insertIntoParentTextRange, removeChildren, removeCommaSeparatedChild } from "../../../../manipulation";
 import { SyntaxKind, ts } from "../../../../typescript";
-import { InitializerGetExpressionableNode, NamedNode, QuestionTokenableNode } from "../../base";
+import { InitializerExpressionGetableNode, NamedNode, QuestionTokenableNode } from "../../base";
 import { Node } from "../../common/Node";
 import { Expression } from "../Expression";
 import { PropertyAssignment } from "./PropertyAssignment";
@@ -12,7 +12,7 @@ import { callBaseSet } from "../../callBaseSet";
 // This node only has an object assignment initializer, equals token, and question token, in order to tell the user about bad code
 // (See https://github.com/Microsoft/TypeScript/pull/5121/files)
 
-export const ShorthandPropertyAssignmentBase = InitializerGetExpressionableNode(QuestionTokenableNode(NamedNode(Node)));
+export const ShorthandPropertyAssignmentBase = InitializerExpressionGetableNode(QuestionTokenableNode(NamedNode(Node)));
 export class ShorthandPropertyAssignment extends ShorthandPropertyAssignmentBase<ts.ShorthandPropertyAssignment> {
     /**
      * Gets if the shorthand property assignment has an object assignment initializer.

src/next-major-deprecations.md

@@ -1,6 +1,5 @@
 # Deprecations in the next major
 
-* `InitializerGetExpressionableNode` to `InitializerExpressionGetableNode` for consistency with `ExportGetableNode`
 * Deprecate `InitializerSetExpressionableNode`
 * Remove default export from library.
 * Make `isCaseSensitive` required on `FileSystemHost`

src/tests/compiler/ast/base/initializer/initializerGetExpressionableNodeTests.ts → src/tests/compiler/ast/base/initializer/initializerExpressionGetableNodeTests.ts

@@ -1,15 +1,15 @@
 import { expect } from "chai";
-import { EnumDeclaration, Expression, InitializerGetExpressionableNode } from "../../../../../compiler";
+import { EnumDeclaration, Expression, InitializerExpressionGetableNode } from "../../../../../compiler";
 import { SyntaxKind } from "../../../../../typescript";
 import { getInfoFromText } from "../../../testHelpers";
 
-describe(nameof(InitializerGetExpressionableNode), () => {
+describe(nameof(InitializerExpressionGetableNode), () => {
     function getEnumMemberFromText(text: string) {
         const result = getInfoFromText<EnumDeclaration>(text);
         return { member: result.firstChild.getMembers()[0], ...result };
     }
 
-    describe(nameof<InitializerGetExpressionableNode>(n => n.hasInitializer), () => {
+    describe(nameof<InitializerExpressionGetableNode>(n => n.hasInitializer), () => {
         function doTest(code: string, expectedResult: boolean) {
             const { member } = getEnumMemberFromText(code);
             expect(member.hasInitializer()).to.equal(expectedResult);
@@ -24,7 +24,7 @@ describe(nameof(InitializerGetExpressionableNode), () => {
         });
     });
 
-    describe(nameof<InitializerGetExpressionableNode>(n => n.getInitializer), () => {
+    describe(nameof<InitializerExpressionGetableNode>(n => n.getInitializer), () => {
         describe("having initializer", () => {
             const { member } = getEnumMemberFromText("enum MyEnum { myMember = 4 }");
             const initializer = member.getInitializer()!;
@@ -46,7 +46,7 @@ describe(nameof(InitializerGetExpressionableNode), () => {
         });
     });
 
-    describe(nameof<InitializerGetExpressionableNode>(n => n.getInitializerOrThrow), () => {
+    describe(nameof<InitializerExpressionGetableNode>(n => n.getInitializerOrThrow), () => {
         it("should get when the initializer exists", () => {
             const { member } = getEnumMemberFromText("enum MyEnum { myMember = 4 }");
             expect(member.getInitializerOrThrow().getText()).to.equal("4");
@@ -58,7 +58,7 @@ describe(nameof(InitializerGetExpressionableNode), () => {
         });
     });
 
-    describe(nameof<InitializerGetExpressionableNode>(n => n.getInitializerIfKind), () => {
+    describe(nameof<InitializerExpressionGetableNode>(n => n.getInitializerIfKind), () => {
         it("should get when the initializer of kind exists", () => {
             const { member } = getEnumMemberFromText("enum MyEnum { myMember = 4 }");
             expect(member.getInitializerIfKind(SyntaxKind.NumericLiteral)!.getText()).to.equal("4");
@@ -75,7 +75,7 @@ describe(nameof(InitializerGetExpressionableNode), () => {
         });
     });
 
-    describe(nameof<InitializerGetExpressionableNode>(n => n.getInitializerIfKindOrThrow), () => {
+    describe(nameof<InitializerExpressionGetableNode>(n => n.getInitializerIfKindOrThrow), () => {
         it("should get when the initializer of kind exists", () => {
             const { member } = getEnumMemberFromText("enum MyEnum { myMember = 4 }");
             expect(member.getInitializerIfKindOrThrow(SyntaxKind.NumericLiteral).getText()).to.equal("4");

src/utils/TypeGuards.ts

@@ -984,10 +984,10 @@ export class TypeGuards {
     }
 
     /**
-     * Gets if the node is a InitializerGetExpressionableNode.
+     * Gets if the node is a InitializerExpressionGetableNode.
      * @param node - Node to check.
      */
-    static isInitializerGetExpressionableNode(node: compiler.Node): node is compiler.InitializerGetExpressionableNode & compiler.InitializerGetExpressionableNodeExtensionType {
+    static isInitializertExpressionGetableNode(node: compiler.Node): node is compiler.InitializerExpressionGetableNode & compiler.InitializerExpressionGetableNodeExtensionType {
         switch (node.getKind()) {
             case SyntaxKind.BindingElement:
             case SyntaxKind.PropertyDeclaration: