Add support for const type parameters

dsherret · Mar 17, 2023 · 9082b3d · 9082b3d
1 parent 187c4a8
commit 9082b3d
Show file tree

Hide file tree

Showing 8 changed files with 71 additions and 10 deletions.
diff --git a/packages/ts-morph/src/compiler/ast/base/ModifierableNode.ts b/packages/ts-morph/src/compiler/ast/base/ModifierableNode.ts
@@ -220,9 +220,9 @@ function getAddAfterModifierTexts(text: ModifierTexts): ModifierTexts[] {
     case "readonly":
       return ["export", "default", "declare", "public", "private", "protected", "static", "override", "abstract"];
     case "out":
-      return ["in"];
+      return ["const", "in"];
     case "in":
-      return [];
+      return ["const"];
     case "accessor":
       return ["public", "private", "protected", "declare", "override", "static", "abstract", "readonly"];
     /* istanbul ignore next */

diff --git a/packages/ts-morph/src/compiler/ast/type/TypeParameterDeclaration.ts b/packages/ts-morph/src/compiler/ast/type/TypeParameterDeclaration.ts
@@ -23,6 +23,16 @@ export enum TypeParameterVariance {
 const createBase = <T extends typeof Node>(ctor: T) => ModifierableNode(NamedNode(ctor));
 export const TypeParameterDeclarationBase = createBase(Node);
 export class TypeParameterDeclaration extends TypeParameterDeclarationBase<ts.TypeParameterDeclaration> {
+  /** Gets if this is a const type parameter. */
+  isConst() {
+    return this.hasModifier(SyntaxKind.ConstKeyword);
+  }
+
+  /** Sets if this is a const type parameter or not. */
+  setIsConst(value: boolean) {
+    return this.toggleModifier("const", value);
+  }
+
   /**
    * Gets the constraint of the type parameter.
    */
@@ -131,9 +141,9 @@ export class TypeParameterDeclaration extends TypeParameterDeclarationBase<ts.Ty
   /** Gets the variance of the type parameter. */
   getVariance() {
     let variance = TypeParameterVariance.None;
-    if (this.hasModifier("in"))
+    if (this.hasModifier(SyntaxKind.InKeyword))
       variance |= TypeParameterVariance.In;
-    if (this.hasModifier("out"))
+    if (this.hasModifier(SyntaxKind.OutKeyword))
       variance |= TypeParameterVariance.Out;
     return variance;
   }
@@ -168,6 +178,9 @@ export class TypeParameterDeclaration extends TypeParameterDeclarationBase<ts.Ty
   set(structure: Partial<TypeParameterDeclarationStructure>) {
     callBaseSet(TypeParameterDeclarationBase.prototype, this, structure);
 
+    if (structure.isConst != null)
+      this.setIsConst(structure.isConst);
+
     if (structure.constraint != null)
       this.setConstraint(structure.constraint);
     else if (structure.hasOwnProperty(nameof(structure, "constraint")))
@@ -193,6 +206,7 @@ export class TypeParameterDeclaration extends TypeParameterDeclarationBase<ts.Ty
 
     return callBaseGetStructure<TypeParameterDeclarationSpecificStructure>(TypeParameterDeclarationBase.prototype, this, {
       kind: StructureKind.TypeParameter,
+      isConst: this.isConst(),
       constraint: constraintNode != null ? constraintNode.getText({ trimLeadingIndentation: true }) : undefined,
       default: defaultNode ? defaultNode.getText({ trimLeadingIndentation: true }) : undefined,
       variance: this.getVariance(),

diff --git a/packages/ts-morph/src/structurePrinters/types/TypeParameterDeclarationStructurePrinter.ts b/packages/ts-morph/src/structurePrinters/types/TypeParameterDeclarationStructurePrinter.ts
@@ -27,6 +27,8 @@ export class TypeParameterDeclarationStructurePrinter extends NodePrinter<Option
     }
 
     writer.hangingIndent(() => {
+      if (structure.isConst)
+        writer.write("const ");
       if (structure.variance != null) {
         if ((structure.variance & TypeParameterVariance.In) !== 0)
           writer.write("in ");

diff --git a/packages/ts-morph/src/structures/type/TypeParameterDeclarationStructure.ts b/packages/ts-morph/src/structures/type/TypeParameterDeclarationStructure.ts
@@ -8,6 +8,7 @@ export interface TypeParameterDeclarationStructure extends Structure, TypeParame
 }
 
 export interface TypeParameterDeclarationSpecificStructure extends KindedStructure<StructureKind.TypeParameter> {
+  isConst?: boolean;
   constraint?: string | WriterFunction;
   default?: string | WriterFunction;
   variance?: TypeParameterVariance;

diff --git a/packages/ts-morph/src/tests/compiler/ast/base/typeParameteredNodeTests.ts b/packages/ts-morph/src/tests/compiler/ast/base/typeParameteredNodeTests.ts
@@ -149,8 +149,9 @@ describe("TypeParameteredNode", () => {
         constraint: "string",
         default: "number",
         variance: TypeParameterVariance.InOut,
+        isConst: true,
       };
-      doTest("function identifier() {}", 0, structure, "function identifier<in out V extends string = number>() {}");
+      doTest("function identifier() {}", 0, structure, "function identifier<const in out V extends string = number>() {}");
     });
   });
 

diff --git a/packages/ts-morph/src/tests/compiler/ast/class/classDeclarationTests.ts b/packages/ts-morph/src/tests/compiler/ast/class/classDeclarationTests.ts
@@ -280,8 +280,8 @@ abstract class Test<T extends string = number, U> extends Base implements IBase
           name: "Test",
           docs: [{ kind: StructureKind.JSDoc, description: "Test", tags: [] }],
           typeParameters: [
-            { kind: StructureKind.TypeParameter, name: "T", constraint: "string", default: "number", variance: TypeParameterVariance.None },
-            { kind: StructureKind.TypeParameter, name: "U", constraint: undefined, default: undefined, variance: TypeParameterVariance.None },
+            { kind: StructureKind.TypeParameter, name: "T", isConst: false, constraint: "string", default: "number", variance: TypeParameterVariance.None },
+            { kind: StructureKind.TypeParameter, name: "U", isConst: false, constraint: undefined, default: undefined, variance: TypeParameterVariance.None },
           ],
           properties: [{
             kind: StructureKind.PropertySignature,
@@ -359,8 +359,8 @@ abstract class Test<T extends string = number, U> extends Base implements IBase
               scope: undefined,
             }],
             typeParameters: [
-              { kind: StructureKind.TypeParameter, name: "T", constraint: "string", default: "number", variance: TypeParameterVariance.None },
-              { kind: StructureKind.TypeParameter, name: "U", constraint: undefined, default: undefined, variance: TypeParameterVariance.None },
+              { kind: StructureKind.TypeParameter, name: "T", isConst: false, constraint: "string", default: "number", variance: TypeParameterVariance.None },
+              { kind: StructureKind.TypeParameter, name: "U", isConst: false, constraint: undefined, default: undefined, variance: TypeParameterVariance.None },
             ],
           }, {
             kind: StructureKind.MethodSignature,
@@ -657,12 +657,14 @@ class Test<T extends string = number, U> extends Base implements IBase {
             typeParameters: [{
               kind: StructureKind.TypeParameter,
               name: "T",
+              isConst: false,
               constraint: "string",
               default: "number",
               variance: TypeParameterVariance.None,
             }, {
               kind: StructureKind.TypeParameter,
               name: "U",
+              isConst: false,
               constraint: undefined,
               default: undefined,
               variance: TypeParameterVariance.None,

diff --git a/packages/ts-morph/src/tests/compiler/ast/type/typeParameterDeclarationTests.ts b/packages/ts-morph/src/tests/compiler/ast/type/typeParameterDeclarationTests.ts
@@ -18,6 +18,43 @@ describe("TypeParameterDeclaration", () => {
     });
   });
 
+  describe(nameof<TypeParameterDeclaration>("setIsConst"), () => {
+    function doTest(text: string, value: boolean, expected: string) {
+      const typeParameterDeclaration = getTypeParameterFromText(text);
+      typeParameterDeclaration.setIsConst(value);
+      expect(typeParameterDeclaration.getSourceFile().getFullText()).to.equal(expected);
+
+      // now do the opposite and it should equal the original text
+      typeParameterDeclaration.setIsConst(!value);
+      expect(typeParameterDeclaration.getSourceFile().getFullText()).to.equal(text);
+    }
+
+    it("should set and remove when it doesn't exist", () => {
+      doTest("function func<T>() {}", true, "function func<const T>() {}");
+      doTest("function func<in T>() {}", true, "function func<const in T>() {}");
+      doTest("function func<out T>() {}", true, "function func<const out T>() {}");
+      doTest("function func<in out T>() {}", true, "function func<const in out T>() {}");
+    });
+  });
+
+  describe(nameof<TypeParameterDeclaration>("isConst"), () => {
+    function doTest(text: string, expectedValue: boolean) {
+      const typeParameterDeclaration = getTypeParameterFromText(text);
+      expect(typeParameterDeclaration.isConst()).to.equal(expectedValue);
+    }
+
+    it("should get", () => {
+      doTest("function func<T>() {}", false);
+      doTest("function func<in T>() {}", false);
+      doTest("function func<out T>() {}", false);
+      doTest("function func<in out T>() {}", false);
+      doTest("function func<const T>() {}", true);
+      doTest("function func<const out T>() {}", true);
+      doTest("function func<const in T>() {}", true);
+      doTest("function func<const in out T>() {}", true);
+    });
+  });
+
   describe(nameof<TypeParameterDeclaration>("getConstraint"), () => {
     it("should return undefined when there's no constraint", () => {
       const typeParameterDeclaration = getTypeParameterFromText("function func<T>() {}\n");
@@ -286,16 +323,18 @@ describe("TypeParameterDeclaration", () => {
       doTest("class C<T> {}", {
         kind: StructureKind.TypeParameter,
         name: "T",
+        isConst: false,
         constraint: undefined,
         default: undefined,
         variance: TypeParameterVariance.None,
       });
     });
 
     it("should get when it has everything", () => {
-      doTest("class C<in T extends string = number> {}", {
+      doTest("class C<const in T extends string = number> {}", {
         kind: StructureKind.TypeParameter,
         name: "T",
+        isConst: true,
         constraint: "string",
         default: "number",
         variance: TypeParameterVariance.In,
@@ -306,6 +345,7 @@ describe("TypeParameterDeclaration", () => {
       doTest("class C<T extends {\n        prop: string;\n    } = {\n    }> {}", {
         kind: StructureKind.TypeParameter,
         name: "T",
+        isConst: false,
         constraint: "{\n    prop: string;\n}",
         default: "{\n}",
         variance: TypeParameterVariance.None,

diff --git a/packages/ts-morph/src/tests/compiler/testHelpers/fillStructureWithDefaults.ts b/packages/ts-morph/src/tests/compiler/testHelpers/fillStructureWithDefaults.ts
@@ -440,6 +440,7 @@ export namespace fillStructures {
     if (typeof structure === "string")
       structure = { name: structure };
 
+    setIfNull(structure, "isConst", false);
     setIfNull(structure, "constraint", undefined);
     setIfNull(structure, "default", undefined);