From a4e21d78582a4aa47835f660a683bfbf49351de3 Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <nathansa@microsoft.com>
Date: Tue, 8 Dec 2015 12:52:19 -0800
Subject: [PATCH] Address comments

---
 src/compiler/checker.ts | 62 ++++++++++++++++++++++-------------------
 src/compiler/parser.ts  |  6 ++--
 2 files changed, 37 insertions(+), 31 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 66ba4fcee90..fed9c026717 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -11004,37 +11004,19 @@ namespace ts {
             }
             else if (node.parameterName) {
                 let hasReportedError = false;
-                for (var param of parent.parameters) {
-                    if (hasReportedError) {
-                        break;
-                    }
-                    if (param.name.kind === SyntaxKind.ObjectBindingPattern ||
-                        param.name.kind === SyntaxKind.ArrayBindingPattern) {
-
-                        (function checkBindingPattern(pattern: BindingPattern) {
-                            for (const element of pattern.elements) {
-                                if (element.name.kind === SyntaxKind.Identifier &&
-                                    (<Identifier>element.name).text === typePredicate.parameterName) {
-
-                                    error(node.parameterName,
-                                        Diagnostics.A_type_predicate_cannot_reference_element_0_in_a_binding_pattern,
-                                        typePredicate.parameterName);
-                                    hasReportedError = true;
-                                    break;
-                                }
-                                else if (element.name.kind === SyntaxKind.ArrayBindingPattern ||
-                                    element.name.kind === SyntaxKind.ObjectBindingPattern) {
-
-                                    checkBindingPattern(<BindingPattern>element.name);
-                                }
-                            }
-                        })(<BindingPattern>param.name);
+                for (const param of parent.parameters) {
+                    if ((param.name.kind === SyntaxKind.ObjectBindingPattern ||
+                        param.name.kind === SyntaxKind.ArrayBindingPattern) &&
+                        checkBindingPatternForTypePredicateVariable(
+                            <BindingPattern>param.name,
+                            node.parameterName,
+                            typePredicate.parameterName)) {
+                            hasReportedError = true;
+                            break;
                     }
                 }
                 if (!hasReportedError) {
-                    error(node.parameterName,
-                        Diagnostics.Cannot_find_parameter_0,
-                        typePredicate.parameterName);
+                    error(node.parameterName, Diagnostics.Cannot_find_parameter_0, typePredicate.parameterName);
                 }
             }
         }
@@ -11055,6 +11037,30 @@ namespace ts {
             }
         }
 
+        function checkBindingPatternForTypePredicateVariable(
+            pattern: BindingPattern,
+            predicateVariableNode: Node,
+            predicateVariableName: string) {
+            for (const element of pattern.elements) {
+                if (element.name.kind === SyntaxKind.Identifier &&
+                    (<Identifier>element.name).text === predicateVariableName) {
+                    error(predicateVariableNode,
+                        Diagnostics.A_type_predicate_cannot_reference_element_0_in_a_binding_pattern,
+                        predicateVariableName);
+                    return true;
+                }
+                else if (element.name.kind === SyntaxKind.ArrayBindingPattern ||
+                    element.name.kind === SyntaxKind.ObjectBindingPattern) {
+                    if (checkBindingPatternForTypePredicateVariable(
+                        <BindingPattern>element.name,
+                        predicateVariableNode,
+                         predicateVariableName)) {
+                        return true;
+                    }
+                }
+            }
+        }
+
         function checkSignatureDeclaration(node: SignatureDeclaration) {
             // Grammar checking
             if (node.kind === SyntaxKind.IndexSignature) {
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 1c41003a7a1..e146e809122 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -2545,15 +2545,15 @@ namespace ts {
                     return id;
                 }
             });
-            const t = parseType();
+            const type = parseType();
             if (typePredicateVariable) {
                 const node = <TypePredicateNode>createNode(SyntaxKind.TypePredicate, typePredicateVariable.pos);
                 node.parameterName = typePredicateVariable;
-                node.type = t;
+                node.type = type;
                 return finishNode(node);
             }
             else {
-                return t;
+                return type;
             }
         }