Fix: Label empty body functions (fixes eslint#92)

There are rules in eslint that expect FunctionExpression
nodes to contain a body. We should not produce an invalid
estree node if we use the estree node types.

Author: soda0289

lib/ast-converter.js

@@ -943,6 +943,10 @@ module.exports = function(ast, extra) {
                     }
                 }
 
+                if (!node.body) {
+                    functionDeclarationType = "TSEmptyBodyFunctionDeclaration";
+                }
+
                 /**
                  * Prefix FunctionDeclarations within TypeScript namespaces with "TS"
                  */
@@ -1142,6 +1146,7 @@ module.exports = function(ast, extra) {
                 var methodLoc = ast.getLineAndCharacterOfPosition(node.name.end + 1),
                     nodeIsMethod = (node.kind === SyntaxKind.MethodDeclaration),
                     isAmbient = ts.isInAmbientContext(node),
+                    isEmptyBody = !(node.body),
                     method = {
                         type: "FunctionExpression",
                         id: null,
@@ -1198,9 +1203,10 @@ module.exports = function(ast, extra) {
                     var methodDefinitionType = hasModifier(SyntaxKind.AbstractKeyword, node)
                         ? "TSAbstractMethodDefinition"
                         : "MethodDefinition";
-                    var methodDefinitionType = "MethodDefinition";
+                    var methodDefinitionType = "MethodDefinition",
+                        isAbstractMethod = false;
                     if (node.modifiers && node.modifiers.length) {
-                        var isAbstractMethod = node.modifiers.some(function(modifier) {
+                        isAbstractMethod = node.modifiers.some(function(modifier) {
                             return modifier.kind === ts.SyntaxKind.AbstractKeyword;
                         });
                         if (isAbstractMethod) {
@@ -1212,6 +1218,13 @@ module.exports = function(ast, extra) {
                         method.type = "TSAmbientFunctionExpression";
                     }
 
+                    if (isEmptyBody) {
+                        if (!isAbstractMethod) {
+                            methodDefinitionType = "TSEmptyBodyMethodDefinition";
+                        }
+                        method.type = "TSEmptyBodyFunctionExpression";
+                    }
+
                     assign(result, {
                         type: methodDefinitionType,
                         key: convertChild(node.name),
@@ -1250,6 +1263,7 @@ module.exports = function(ast, extra) {
                     firstConstructorToken = constructorIsStatic ? ts.findNextToken(node.getFirstToken(), ast) : node.getFirstToken(),
                     constructorLoc = ast.getLineAndCharacterOfPosition(node.parameters.pos - 1),
                     constructorIsAmbient = ts.isInAmbientContext(node),
+                    constructorIsEmptyBody = !(node.body),
                     constructor = {
                         type: "FunctionExpression",
                         id: null,
@@ -1320,6 +1334,9 @@ module.exports = function(ast, extra) {
                 if (constructorIsAmbient) {
                     constructorMethodDefinitionType = "TSAmbientMethodDefinition";
                     constructor.type = "TSAmbientFunctionExpression";
+                } else if (constructorIsEmptyBody) {
+                    constructorMethodDefinitionType = "TSEmptyBodyMethodDefinition";
+                    constructor.type = "TSEmptyBodyFunctionExpression";
                 }
 
                 assign(result, {

tests/fixtures/typescript/basics/abstract-class-with-abstract-method.result.js

@@ -89,7 +89,7 @@ module.exports = {
                                 "name": "createSocket"
                             },
                             "value": {
-                                "type": "FunctionExpression",
+                                "type": "TSEmptyBodyFunctionExpression",
                                 "id": null,
                                 "generator": false,
                                 "expression": false,