Fix: Label Functions and Methods declartions as Ambient (fixes eslint#162)

Ambient functions do not have a body and will cuase rules to throw
an excpetion. We use the types TSAmbientFunctionExpression and
TSAmbientMethoDeclaration.

Author: soda0289

Diff for: lib/ast-converter.js

@@ -939,7 +939,7 @@ module.exports = function(ast, extra) {
                 if (node.modifiers && node.modifiers.length) {
                     var isDeclareFunction = hasModifier(ts.SyntaxKind.DeclareKeyword, node);
                     if (isDeclareFunction) {
-                        functionDeclarationType = "DeclareFunction";
+                        functionDeclarationType = "TSAmbientFunctionDeclaration";
                     }
                 }
 
@@ -1141,6 +1141,7 @@ module.exports = function(ast, extra) {
                 // TODO: double-check that these positions are correct
                 var methodLoc = ast.getLineAndCharacterOfPosition(node.name.end + 1),
                     nodeIsMethod = (node.kind === SyntaxKind.MethodDeclaration),
+                    isAmbient = ts.isInAmbientContext(node),
                     method = {
                         type: "FunctionExpression",
                         id: null,
@@ -1197,6 +1198,19 @@ module.exports = function(ast, extra) {
                     var methodDefinitionType = hasModifier(SyntaxKind.AbstractKeyword, node)
                         ? "TSAbstractMethodDefinition"
                         : "MethodDefinition";
+                    var methodDefinitionType = "MethodDefinition";
+                    if (node.modifiers && node.modifiers.length) {
+                        var isAbstractMethod = node.modifiers.some(function(modifier) {
+                            return modifier.kind === ts.SyntaxKind.AbstractKeyword;
+                        });
+                        if (isAbstractMethod) {
+                            methodDefinitionType = "TSAbstractMethodDefinition";
+                        }
+                    }
+                    if (isAmbient) {
+                        methodDefinitionType = "TSAmbientMethodDefinition";
+                        method.type = "TSAmbientFunctionExpression";
+                    }
 
                     assign(result, {
                         type: methodDefinitionType,
@@ -1235,6 +1249,7 @@ module.exports = function(ast, extra) {
                     constructorIsAbstract = hasModifier(SyntaxKind.AbstractKeyword, node),
                     firstConstructorToken = constructorIsStatic ? ts.findNextToken(node.getFirstToken(), ast) : node.getFirstToken(),
                     constructorLoc = ast.getLineAndCharacterOfPosition(node.parameters.pos - 1),
+                    constructorIsAmbient = ts.isInAmbientContext(node),
                     constructor = {
                         type: "FunctionExpression",
                         id: null,
@@ -1301,6 +1316,12 @@ module.exports = function(ast, extra) {
                     };
                 }
 
+                var constructorMethodDefinitionType = "MethodDefinition";
+                if (constructorIsAmbient) {
+                    constructorMethodDefinitionType = "TSAmbientMethodDefinition";
+                    constructor.type = "TSAmbientFunctionExpression";
+                }
+
                 assign(result, {
                     type: constructorIsAbstract ? "TSAbstractMethodDefinition" : "MethodDefinition",
                     key: constructorKey,