Fixes CR feedback

Author: tinganho

src/compiler/checker.ts

@@ -5642,13 +5642,13 @@ module ts {
                 }
 
                 if (targetType) {
-                    return getOptionalNarrowedType(type, targetType);
+                    return getNarrowedType(type, targetType);
                 }
 
                 return type;
             }
 
-            function getOptionalNarrowedType(originalType: Type, narrowedTypeCandidate: Type) {
+            function getNarrowedType(originalType: Type, narrowedTypeCandidate: Type) {
                 // Narrow to the target type if it's a subtype of the current type
                 if (isTypeSubtypeOf(narrowedTypeCandidate, originalType)) {
                     return narrowedTypeCandidate;
@@ -5675,7 +5675,7 @@ module ts {
                         } 
                         return type;
                     }
-                    return getOptionalNarrowedType(type, signature.typePredicate.type);
+                    return getNarrowedType(type, signature.typePredicate.type);
                 }
                 return type;
             }
@@ -8627,9 +8627,15 @@ module ts {
                     }
                     else {
                         if (typePredicate.parameterIndex >= 0) {
-                            checkTypeAssignableTo(typePredicate.type,
-                                getTypeAtLocation(node.parameters[typePredicate.parameterIndex]),
-                                typePredicateNode.type);
+                            if (node.parameters[typePredicate.parameterIndex].dotDotDotToken) {
+                                error(typePredicateNode.parameterName,
+                                    Diagnostics.Type_predicate_cannot_reference_a_spread_parameter);
+                            }
+                            else {
+                                checkTypeAssignableTo(typePredicate.type,
+                                    getTypeAtLocation(node.parameters[typePredicate.parameterIndex]),
+                                    typePredicateNode.type);
+                            }
                         }
                         else if (typePredicateNode.parameterName) {
                             error(typePredicateNode.parameterName,
@@ -11275,6 +11281,16 @@ module ts {
             }
         }
 
+        function checkTypePredicate(node: TypePredicateNode) {
+            switch (node.parent.kind) {
+                case SyntaxKind.ArrowFunction:
+                case SyntaxKind.FunctionDeclaration:
+                case SyntaxKind.FunctionExpression:
+                    return;
+            }
+            error(node, Diagnostics.Type_predicates_are_only_allowed_in_return_type_position);
+        }
+
         function checkSourceElement(node: Node): void {
             if (!node) return;
             switch (node.kind) {
@@ -11303,12 +11319,7 @@ module ts {
                 case SyntaxKind.TypeReference:
                     return checkTypeReferenceNode(<TypeReferenceNode>node);
                 case SyntaxKind.TypePredicate:
-                    // Issue an error every time we encounter a type predicate. They are only allowed 
-                    // in return type positions in signature declarations. checkSignatureDeclaration(..) 
-                    // already have a specific check for type predicates, so every time we encounter a type
-                    // predicate in checkSourceElement it must be in a non return type position.
-                    error(node, Diagnostics.Type_predicates_are_only_allowed_in_return_type_position);
-                    return;
+                    return checkTypePredicate(<TypePredicateNode>node);
                 case SyntaxKind.TypeQuery:
                     return checkTypeQuery(<TypeQueryNode>node);
                 case SyntaxKind.TypeLiteral:

src/compiler/diagnosticInformationMap.generated.ts

@@ -184,6 +184,7 @@ module ts {
         Type_predicate_0_is_not_assignable_to_1: { code: 1226, category: DiagnosticCategory.Error, key: "Type predicate '{0}' is not assignable to '{1}'." },
         Parameter_0_is_not_in_the_same_position_as_parameter_1: { code: 1227, category: DiagnosticCategory.Error, key: "Parameter '{0}' is not in the same position as parameter '{1}'." },
         Type_predicates_are_only_allowed_in_return_type_position: { code: 1228, category: DiagnosticCategory.Error, key: "Type predicates are only allowed in return type position." },
+        Type_predicate_cannot_reference_a_spread_parameter: { code: 1229, category: DiagnosticCategory.Error, key: "Type predicate cannot reference a spread parameter." },
         Duplicate_identifier_0: { code: 2300, category: DiagnosticCategory.Error, key: "Duplicate identifier '{0}'." },
         Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: DiagnosticCategory.Error, key: "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor." },
         Static_members_cannot_reference_class_type_parameters: { code: 2302, category: DiagnosticCategory.Error, key: "Static members cannot reference class type parameters." },

src/compiler/diagnosticMessages.json

@@ -723,6 +723,10 @@
         "category": "Error",
         "code": 1228
     },
+    "Type predicate cannot reference a spread parameter.": {
+        "category": "Error",
+        "code": 1229
+    },
 
 
     "Duplicate identifier '{0}'.": {

tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts

@@ -96,4 +96,9 @@ var b1: b is A;
 function b2(a: b is A) {};
 function b3(): A | b is A {
     return true;
-};
+};
+
+// Reference to spread parameter
+function b4(...a): a is A {
+    return true;
+}