0.85.0 - #27 - Setting variable declaration type.

docs/details/variables.md

@@ -46,8 +46,6 @@ const var1 = "5",
     var2 = "6";
 ```
 
-### Get variable declaration list
-
 Get one from the variable statement:
 
 ```typescript
@@ -62,9 +60,9 @@ const firstConstDeclaration = sourceFile.getVariableDeclarationList(l =>
     l.getDeclarationType() === VariableDeclarationType.Const);
 ```
 
-### Get declaration type
+### Declaration type
 
-Use:
+Get:
 
 ```typescript
 const declarationType = variableDeclarationList.getDeclarationType();
@@ -73,11 +71,19 @@ const declarationType = variableDeclarationList.getDeclarationType();
 It will return one of the following values:
 
 ```typescript
+import {VariableDeclarationType} from "ts-simple-ast";
+
 VariableDeclarationType.Let;
 VariableDeclarationType.Const;
 VariableDeclarationType.Var;
 ```
 
+Set:
+
+```typescript
+variableDeclarationList.setDeclarationType(VariableDeclarationType.Const);
+```
+
 ## Variable Declaration
 
 These are the individual declarations within a variable declaration list.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-simple-ast",
-  "version": "0.84.0",
+  "version": "0.85.0",
   "description": "TypeScript compiler wrapper for AST navigation and code generation.",
   "main": "dist/main.js",
   "typings": "dist/main.d.ts",

src/compiler/statement/VariableDeclarationList.ts

@@ -1,4 +1,6 @@
 import * as ts from "typescript";
+import * as errors from "./../../errors";
+import {insertIntoParent} from "./../../manipulation";
 import {Node} from "./../common";
 import {VariableDeclaration} from "./VariableDeclaration";
 import {VariableDeclarationType} from "./VariableDeclarationType";
@@ -24,4 +26,45 @@ export class VariableDeclarationList extends Node<ts.VariableDeclarationList> {
         else
             return VariableDeclarationType.Var;
     }
+
+    /**
+     * Gets the variable declaration type keyword.
+     */
+    getDeclarationTypeKeyword(): Node {
+        const declarationType = this.getDeclarationType();
+        switch (declarationType) {
+            case VariableDeclarationType.Const:
+                return this.getFirstChildByKindOrThrow(ts.SyntaxKind.ConstKeyword);
+            case VariableDeclarationType.Let:
+                return this.getFirstChildByKindOrThrow(ts.SyntaxKind.LetKeyword);
+            case VariableDeclarationType.Var:
+                return this.getFirstChildByKindOrThrow(ts.SyntaxKind.VarKeyword);
+            default:
+                throw errors.getNotImplementedForNeverValueError(declarationType);
+        }
+    }
+
+    /**
+     * Sets the variable declaration type.
+     * @param type - Type to set.
+     */
+    setDeclarationType(type: VariableDeclarationType) {
+        if (this.getDeclarationType() === type)
+            return this;
+        const keyword = this.getDeclarationTypeKeyword();
+
+        insertIntoParent({
+            childIndex: keyword.getChildIndex(),
+            insertItemsCount: 1,
+            insertPos: keyword.getStart(),
+            newText: type,
+            parent: this,
+            replacing: {
+                nodes: [keyword],
+                textLength: keyword.getWidth()
+            }
+        });
+
+        return this;
+    }
 }

src/compiler/statement/VariableStatement.ts

@@ -18,7 +18,7 @@ export class VariableStatement extends VariableStatementBase<ts.VariableStatemen
         callBaseFill(VariableStatementBase.prototype, this, structure);
 
         if (structure.declarationType != null)
-            throw new errors.NotImplementedError("Filling variable declaration type not implemented. Please comment on issue #27 if you need this and I will increase the priority.");
+            this.getDeclarationList().setDeclarationType(structure.declarationType);
         if (structure.declarations != null)
             throw new errors.NotImplementedError("Filling variable declarations not implemented. Please open an issue if you need this and I will increase the prioirty.");
 

src/errors/helpers.ts

@@ -95,3 +95,11 @@ export function throwIfNullOrUndefined<T>(value: T | undefined, errorMessage: st
         throw new InvalidOperationError(typeof errorMessage === "string" ? errorMessage : errorMessage());
     return value;
 }
+
+/**
+ * Throw if the value should have been the never type.
+ * @param value - Value to check.
+ */
+export function getNotImplementedForNeverValueError(value: never) {
+    return new NotImplementedError(`Not implemented value: ${value}`);
+}

src/tests/compiler/statement/variableDeclarationListTests.ts

@@ -5,19 +5,64 @@ import {getInfoFromText} from "./../testHelpers";
 // todo: need to add tests here for getMembers
 describe(nameof(VariableDeclarationList), () => {
     describe(nameof<VariableDeclarationList>(d => d.getDeclarationType), () => {
+        function doTest(code: string, expectedType: VariableDeclarationType) {
+            const {firstChild} = getInfoFromText<VariableStatement>(code);
+            expect(firstChild.getDeclarationList().getDeclarationType()).to.equal(expectedType);
+        }
+
+        it("should get var for a var variable", () => {
+            doTest("var myVar;", VariableDeclarationType.Var);
+        });
+
+        it("should get let for a let variable", () => {
+            doTest("let myVar;", VariableDeclarationType.Let);
+        });
+
+        it("should get const for a const variable", () => {
+            doTest("const myVar = 3;", VariableDeclarationType.Const);
+        });
+    });
+
+    describe(nameof<VariableDeclarationList>(d => d.getDeclarationTypeKeyword), () => {
+        function doTest(code: string, expectedType: VariableDeclarationType) {
+            const {firstChild} = getInfoFromText<VariableStatement>(code);
+            expect(firstChild.getDeclarationList().getDeclarationTypeKeyword().getText()).to.equal(expectedType);
+        }
+
         it("should get var for a var variable", () => {
-            const {firstChild} = getInfoFromText<VariableStatement>("var myVar;");
-            expect(firstChild.getDeclarationList().getDeclarationType()).to.equal(VariableDeclarationType.Var);
+            doTest("var myVar;", VariableDeclarationType.Var);
         });
 
         it("should get let for a let variable", () => {
-            const {firstChild} = getInfoFromText<VariableStatement>("let myVar;");
-            expect(firstChild.getDeclarationList().getDeclarationType()).to.equal(VariableDeclarationType.Let);
+            doTest("let myVar;", VariableDeclarationType.Let);
         });
 
         it("should get const for a const variable", () => {
-            const {firstChild} = getInfoFromText<VariableStatement>("const myVar = 3;");
-            expect(firstChild.getDeclarationList().getDeclarationType()).to.equal(VariableDeclarationType.Const);
+            doTest("const myVar = 3;", VariableDeclarationType.Const);
+        });
+    });
+
+    describe(nameof<VariableDeclarationList>(d => d.setDeclarationType), () => {
+        function doTest(code: string, newType: VariableDeclarationType, expectedCode: string) {
+            const {firstChild, sourceFile} = getInfoFromText<VariableStatement>(code);
+            firstChild.getDeclarationList().setDeclarationType(newType);
+            expect(sourceFile.getFullText()).to.equal(expectedCode);
+        }
+
+        it("should not change the type when it is the same", () => {
+            doTest("var myVar;", VariableDeclarationType.Var, "var myVar;");
+        });
+
+        it("should change to let", () => {
+            doTest("var myVar;", VariableDeclarationType.Let, "let myVar;");
+        });
+
+        it("should change to const", () => {
+            doTest("var myVar;", VariableDeclarationType.Const, "const myVar;");
+        });
+
+        it("should change to var", () => {
+            doTest("let myVar;", VariableDeclarationType.Var, "var myVar;");
         });
     });
 });

src/tests/compiler/statement/variableStatementTests.ts

@@ -1,5 +1,6 @@
 import {expect} from "chai";
-import {VariableStatement} from "./../../../compiler";
+import {VariableStatement, VariableDeclarationType} from "./../../../compiler";
+import {VariableStatementStructure} from "./../../../structures";
 import {getInfoFromText} from "./../testHelpers";
 
 describe(nameof(VariableStatement), () => {
@@ -14,4 +15,16 @@ describe(nameof(VariableStatement), () => {
             doTest("const t = '';\nconst v = '';\nconst u = '';", 1, "const t = '';\nconst u = '';");
         });
     });
+
+    describe(nameof<VariableStatement>(d => d.fill), () => {
+        function doTest(text: string, fillStructure: Partial<VariableStatementStructure>, expectedText: string) {
+            const {sourceFile} = getInfoFromText(text);
+            sourceFile.getVariableStatements()[0].fill(fillStructure);
+            expect(sourceFile.getFullText()).to.equal(expectedText);
+        }
+
+        it("should set the variable declaration type", () => {
+            doTest("const t = '';", { declarationType: VariableDeclarationType.Let }, "let t = '';");
+        });
+    });
 });