fix: Fix crashes when dealing with statemented nodes that don't have a body.

Author: dsherret

src/compiler/statement/StatementedNode.ts

@@ -472,6 +472,8 @@ export function StatementedNode<T extends Constructor<StatementedNodeExtensionTy
         insertStatements(index: number, writerFunction: WriterFunction): Statement[];
         insertStatements(index: number, textOrWriterFunction: string | WriterFunction): Statement[];
         insertStatements(index: number, textOrWriterFunction: string | WriterFunction) {
+            addBodyIfNotExists(this);
+
             return getChildSyntaxList.call(this).insertChildText(index, textOrWriterFunction);
 
             function getChildSyntaxList(this: Node) {
@@ -625,7 +627,6 @@ export function StatementedNode<T extends Constructor<StatementedNodeExtensionTy
         }
 
         getFunctions(): FunctionDeclaration[] {
-            // todo: remove type assertion
             return (this.getChildSyntaxListOrThrow().getChildrenOfKind(SyntaxKind.FunctionDeclaration))
                 .filter(f => f.isAmbient() || f.isImplementation());
         }
@@ -877,8 +878,12 @@ export function StatementedNode<T extends Constructor<StatementedNodeExtensionTy
                 // need to get the inner-most body for namespaces
                 return (this.getInnerBody().compilerNode as ts.Block).statements;
             }
-            else if (TypeGuards.isBodyableNode(this))
-                return (this.getBodyOrThrow().compilerNode as any).statements as ts.NodeArray<ts.Statement>;
+            else if (TypeGuards.isBodyableNode(this)) {
+                const body = this.getBody();
+                if (body == null)
+                    return [] as any as ts.NodeArray<ts.Statement>;
+                return (body.compilerNode as any).statements as ts.NodeArray<ts.Statement>;
+            }
             else if (TypeGuards.isBodiedNode(this))
                 return (this.getBody().compilerNode as any).statements as ts.NodeArray<ts.Statement>;
             else if (TypeGuards.isBlock(this))
@@ -888,6 +893,8 @@ export function StatementedNode<T extends Constructor<StatementedNodeExtensionTy
         }
 
         _insertChildren<TNode extends Node, TStructure>(opts: InsertChildrenOptions<TStructure>) {
+            addBodyIfNotExists(this);
+
             return insertIntoBracesOrSourceFileWithGetChildren<TNode, TStructure>({
                 expectedKind: opts.expectedKind,
                 getIndexedChildren: () => this.getStatements(),
@@ -918,3 +925,8 @@ export function StatementedNode<T extends Constructor<StatementedNodeExtensionTy
         }
     };
 }
+
+function addBodyIfNotExists(node: Node) {
+    if (TypeGuards.isBodyableNode(node) && !node.hasBody())
+        node.addBody();
+}

src/tests/compiler/statement/statementedNode/classTests.ts

@@ -1,5 +1,5 @@
 import { expect } from "chai";
-import { ClassDeclaration, StatementedNode } from "../../../../compiler";
+import { FunctionDeclaration, ClassDeclaration, StatementedNode } from "../../../../compiler";
 import { ClassDeclarationStructure } from "../../../../structures";
 import { getInfoFromText } from "../../testHelpers";
 
@@ -87,6 +87,20 @@ describe(nameof(StatementedNode), () => {
 
             expect(sourceFile.getFullText()).to.equal("declare module Namespace {\n    class Identifier {\n        myMethod();\n    }\n}\n");
         });
+
+        function doFunctionTest(startText: string, endText: string) {
+            const { firstChild, sourceFile } = getInfoFromText<FunctionDeclaration>(startText);
+            firstChild.insertClasses(0, [{ name: "C" }]);
+            expect(sourceFile.getFullText()).to.equal(endText);
+        }
+
+        it("should insert into a function with no body", () => {
+            doFunctionTest("function test();", "function test() {\n    class C {\n    }\n}");
+        });
+
+        it("should insert into a function with a body", () => {
+            doFunctionTest("function test() {\n}", "function test() {\n    class C {\n    }\n}");
+        });
     });
 
     describe(nameof<StatementedNode>(n => n.insertClass), () => {

src/tests/compiler/statement/statementedNodeTests.ts

@@ -32,6 +32,10 @@ describe(nameof(StatementedNode), () => {
             doFirstChildTest<FunctionDeclaration>("function i() { var t; var m; }", ["var t;", "var m;"]);
         });
 
+        it("should get the statements of a function with no body", () => {
+            doFirstChildTest<FunctionDeclaration>("function i();", []);
+        });
+
         it("should get the statements of a namespace", () => {
             doFirstChildTest<NamespaceDeclaration>("namespace n { var t; var m; }", ["var t;", "var m;"]);
         });
@@ -158,6 +162,11 @@ describe(nameof(StatementedNode), () => {
             expect(sourceFile.getFullText()).to.equal(expectedCode);
         }
 
+        it("should insert statements into a function with no body", () => {
+            doFirstChildTest<FunctionDeclaration>("function i();\n", 0, "statement;", 1,
+                "function i() {\n    statement;\n}\n");
+        });
+
         it("should insert statements into an empty function", () => {
             doFirstChildTest<FunctionDeclaration>("function i() {\n}\n", 0, "statement;", 1,
                 "function i() {\n    statement;\n}\n");