Use custom type guard.

DanielRosenwasser · DanielRosenwasser · commit 2aa97bd1b94b · 2015-09-18T12:22:52.000-07:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -6907,7 +6907,7 @@ namespace ts {
             }
         }
 
-        function isFunctionExpressionOrArrowFunction(node: Node): boolean {
+        function isFunctionExpressionOrArrowFunction(node: Node): node is FunctionExpression {
             return node.kind === SyntaxKind.FunctionExpression || node.kind === SyntaxKind.ArrowFunction;
         }
 
@@ -6926,8 +6926,8 @@ namespace ts {
         function getContextualSignature(node: FunctionExpression | MethodDeclaration): Signature {
             Debug.assert(node.kind !== SyntaxKind.MethodDeclaration || isObjectLiteralMethod(node));
             let type = isObjectLiteralMethod(node)
-                ? getContextualTypeForObjectLiteralMethod(<MethodDeclaration>node)
-                : getContextualType(<FunctionExpression>node);
+                ? getContextualTypeForObjectLiteralMethod(node)
+                : getContextualType(node);
             if (!type) {
                 return undefined;
             }
@@ -13656,7 +13656,7 @@ namespace ts {
                     forEach(node.decorators, checkFunctionAndClassExpressionBodies);
                     forEach((<MethodDeclaration>node).parameters, checkFunctionAndClassExpressionBodies);
                     if (isObjectLiteralMethod(node)) {
-                        checkFunctionExpressionOrObjectLiteralMethodBody(<MethodDeclaration>node);
+                        checkFunctionExpressionOrObjectLiteralMethodBody(node);
                     }
                     break;
                 case SyntaxKind.Constructor:
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
@@ -660,7 +660,7 @@ namespace ts {
         return node && node.kind === SyntaxKind.Block && isFunctionLike(node.parent);
     }
 
-    export function isObjectLiteralMethod(node: Node) {
+    export function isObjectLiteralMethod(node: Node): node is MethodDeclaration {
         return node && node.kind === SyntaxKind.MethodDeclaration && node.parent.kind === SyntaxKind.ObjectLiteralExpression;
     }
 

Original file line number	Diff line number	Diff line change
`@@ -6907,7 +6907,7 @@ namespace ts {`
`6907`	`6907`	`}`
`6908`	`6908`	`}`
`6909`	`6909`
`6910`		`- function isFunctionExpressionOrArrowFunction(node: Node): boolean {`
	`6910`	`+ function isFunctionExpressionOrArrowFunction(node: Node): node is FunctionExpression {`
`6911`	`6911`	`return node.kind === SyntaxKind.FunctionExpression \|\| node.kind === SyntaxKind.ArrowFunction;`
`6912`	`6912`	`}`
`6913`	`6913`
`@@ -6926,8 +6926,8 @@ namespace ts {`
`6926`	`6926`	`function getContextualSignature(node: FunctionExpression \| MethodDeclaration): Signature {`
`6927`	`6927`	`Debug.assert(node.kind !== SyntaxKind.MethodDeclaration \|\| isObjectLiteralMethod(node));`
`6928`	`6928`	`let type = isObjectLiteralMethod(node)`
`6929`		`- ? getContextualTypeForObjectLiteralMethod(<MethodDeclaration>node)`
`6930`		`- : getContextualType(<FunctionExpression>node);`
	`6929`	`+ ? getContextualTypeForObjectLiteralMethod(node)`
	`6930`	`+ : getContextualType(node);`
`6931`	`6931`	`if (!type) {`
`6932`	`6932`	`return undefined;`
`6933`	`6933`	`}`
`@@ -13656,7 +13656,7 @@ namespace ts {`
`13656`	`13656`	`forEach(node.decorators, checkFunctionAndClassExpressionBodies);`
`13657`	`13657`	`forEach((<MethodDeclaration>node).parameters, checkFunctionAndClassExpressionBodies);`
`13658`	`13658`	`if (isObjectLiteralMethod(node)) {`
`13659`		`- checkFunctionExpressionOrObjectLiteralMethodBody(<MethodDeclaration>node);`
	`13659`	`+ checkFunctionExpressionOrObjectLiteralMethodBody(node);`
`13660`	`13660`	`}`
`13661`	`13661`	`break;`
`13662`	`13662`	`case SyntaxKind.Constructor:`
Original file line number	Diff line number	Diff line change
`@@ -660,7 +660,7 @@ namespace ts {`
`660`	`660`	`return node && node.kind === SyntaxKind.Block && isFunctionLike(node.parent);`
`661`	`661`	`}`
`662`	`662`
`663`		`- export function isObjectLiteralMethod(node: Node) {`
	`663`	`+ export function isObjectLiteralMethod(node: Node): node is MethodDeclaration {`
`664`	`664`	`return node && node.kind === SyntaxKind.MethodDeclaration && node.parent.kind === SyntaxKind.ObjectLiteralExpression;`
`665`	`665`	`}`
`666`	`666`