feat: #187 - Added TypeGuards.hasExpression.

This can be used to tell if a node has a .getExpression function or not.

code-generation/createTypeGuardsUtility.ts

@@ -38,7 +38,7 @@ export function createTypeGuardsUtility(ast: TsSimpleAst, classVMs: ClassViewMod
         docs: [{
             description: "Type guards for checking the type of a node."
         }],
-        methods: getMethodInfos().map(method => ({
+        methods: [...getMethodInfos().map(method => ({
             name: `is${method.name}`,
             isStatic: true,
             docs: [{
@@ -55,7 +55,7 @@ export function createTypeGuardsUtility(ast: TsSimpleAst, classVMs: ClassViewMod
                     writer.writeLine("default:")
                         .indent().write("return false;").newLine();
                 })
-        }))
+        })), getHasExpressionTypeGuard()]
     });
 
     file.save();
@@ -131,6 +131,21 @@ export function createTypeGuardsUtility(ast: TsSimpleAst, classVMs: ClassViewMod
             return nodeToWrapperVM.syntaxKindNames;
         }
     }
+
+    function getHasExpressionTypeGuard(): MethodDeclarationStructure {
+        return {
+            docs: [{ description: "Gets if the node has an expression.\r\n@param node - Node to check." }],
+            isStatic: true,
+            name: "hasExpression",
+            returnType: "node is compiler.Node & { getExpression(): compiler.Expression; }",
+            parameters: [{ name: "node", type: "compiler.Node" }],
+            bodyText: writer => {
+                writer.writeLine("if ((node as any).getExpression == null)");
+                writer.indent().write("return false;");
+                writer.writeLine("return (node as any).getExpression() != null;");
+            }
+        };
+    }
 }
 
 function isAllowedClass(classVM: ClassViewModel) {

src/tests/utils/typeGuardsTests.ts

@@ -0,0 +1,34 @@
+import * as ts from "typescript";
+import {expect} from "chai";
+import {TypeGuards} from "./../../utils";
+import {getInfoFromText} from "./../compiler/testHelpers";
+
+describe(nameof(TypeGuards), () => {
+    // most of the code in TypeGuards is not worth the effort to test... it's auto generated from code so it should be close to correct
+
+    describe(nameof(TypeGuards.hasExpression), () => {
+        it("should have an expression when it's a function call", () => {
+            const {firstChild} = getInfoFromText("funcCall()");
+            expect(TypeGuards.hasExpression(firstChild)).to.be.true;
+            if (TypeGuards.hasExpression(firstChild))
+                expect(firstChild.getExpression().getText()).to.equal("funcCall()");
+        });
+
+        it("should not have an expression when it doesn't", () => {
+            const {firstChild} = getInfoFromText("class Test {}");
+            expect(TypeGuards.hasExpression(firstChild)).to.be.false;
+        });
+
+        it("should have an expression when it's a return statement with a value", () => {
+            const {firstChild} = getInfoFromText("return 5;");
+            expect(TypeGuards.hasExpression(firstChild)).to.be.true;
+            if (TypeGuards.hasExpression(firstChild))
+                expect(firstChild.getExpression().getText()).to.equal("5");
+        });
+
+        it("should not have an expression when it's a return statement without a value", () => {
+            const {firstChild} = getInfoFromText("return;");
+            expect(TypeGuards.hasExpression(firstChild)).to.be.false;
+        });
+    });
+});