diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index c293bebd745..8e89eb51343 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -6248,11 +6248,8 @@ module ts {
         }
 
         function checkCallExpression(node: CallExpression): Type {
-            // Grammar checking
-            var hasGrammarErrorFromCheckModifierOrTypeArguments = checkGrammarModifiers(node) ? true : checkGrammarTypeArguments(node, node.typeArguments);
-            if (!hasGrammarErrorFromCheckModifierOrTypeArguments) {
-                checkGrammarArguments(node, node.arguments);
-            }
+            // Grammar checking; stop grammar-checking if checkGrammarTypeArguments return true
+            checkGrammarTypeArguments(node, node.typeArguments) || checkGrammarArguments(node, node.arguments);
 
             var signature = getResolvedSignature(node);
             if (node.expression.kind === SyntaxKind.SuperKeyword) {
@@ -6405,7 +6402,7 @@ module ts {
 
             // Grammar checking
             if (node.kind === SyntaxKind.ArrowFunction) {
-                checkGrammarFunctionLikeDeclaration(<FunctionLikeDeclaration>node);
+                checkGrammarAnySignatureDeclaration(<FunctionLikeDeclaration>node);
             }
 
             // The identityMapper object is used to indicate that function expressions are wildcards
@@ -7058,6 +7055,16 @@ module ts {
         }
 
         function checkSignatureDeclaration(node: SignatureDeclaration) {
+            // Grammar checking
+            if (node.kind === SyntaxKind.IndexSignature) {
+                checkGrammarIndexSignature(<SignatureDeclaration>node);
+            }
+            // TODO (yuisu): Remove this check in else-if when SyntaxKind.Construct is moved and ambient context is handled
+            else  if (node.kind === SyntaxKind.FunctionType || node.kind === SyntaxKind.ConstructorType ||
+                      node.kind === SyntaxKind.CallSignature || node.kind === SyntaxKind.ConstructSignature){
+                checkGrammarAnySignatureDeclaration(<FunctionLikeDeclaration>node);
+            }
+
             checkTypeParameters(node.typeParameters);
             forEach(node.parameters, checkParameter);
             if (node.type) {
@@ -8765,12 +8772,8 @@ module ts {
                 case SyntaxKind.ConstructorType:
                 case SyntaxKind.CallSignature:
                 case SyntaxKind.ConstructSignature:
-                    // Grammar checking
-                    checkGrammarFunctionLikeDeclaration(<FunctionLikeDeclaration>node)
                     return checkSignatureDeclaration(<SignatureDeclaration>node);
                 case SyntaxKind.IndexSignature:
-                    // Grammar checking
-                    checkGrammarIndexSignature(<SignatureDeclaration>node);
                     return checkSignatureDeclaration(<SignatureDeclaration>node);
                 case SyntaxKind.MethodDeclaration:
                 case SyntaxKind.MethodSignature:
@@ -9829,11 +9832,9 @@ module ts {
             }
         }
 
-        function checkGrammarFunctionLikeDeclaration(node: FunctionLikeDeclaration) {
-            var hasGrammarErrorFromCheckModifierOrTypeParameterList = checkGrammarModifiers(node) ? true : checkGrammarTypeParameterList(node, node.typeParameters);
-            if (!hasGrammarErrorFromCheckModifierOrTypeParameterList) {
-                checkGrammarParameterList(node.parameters);
-            }
+        function checkGrammarAnySignatureDeclaration(node: FunctionLikeDeclaration) {
+            // Prevent cascading error by short-circuit
+            checkGrammarModifiers(node) || checkGrammarTypeParameterList(node, node.typeParameters) || checkGrammarParameterList(node.parameters);
         }
 
         function checkGrammarIndexSignatureParameters(node: SignatureDeclaration): boolean {
@@ -9876,10 +9877,8 @@ module ts {
         }
 
         function checkGrammarIndexSignature(node: SignatureDeclaration) {
-            var hasGrammarErrorFromCheckModifiersOrParameters = checkGrammarModifiers(node) ? true: checkGrammarIndexSignatureParameters(node);
-            if (!hasGrammarErrorFromCheckModifiersOrParameters) {
-                checkGrammarForIndexSignatureModifier(node);
-            }
+            // Prevent cascading error by short-circuit
+            checkGrammarModifiers(node) || checkGrammarIndexSignatureParameters(node) || checkGrammarForIndexSignatureModifier(node);
         }
 
         function checkGrammarForAtLeastOneTypeArgument(node: CallExpression, typeArguments: NodeArray<TypeNode>): boolean {