Use function like to determine if it is in different scope

Author: sheetalkamat

src/compiler/checker.ts

@@ -398,18 +398,14 @@ namespace ts {
             }
 
             let sourceFiles = host.getSourceFiles();
-            return sourceFiles.indexOf(referenceDeclarationFile) <= sourceFiles.indexOf(locationNodeFile) || !isInSameLexicalScope(); 
+            return indexOf(sourceFiles, referenceDeclarationFile) <= indexOf(sourceFiles, locationNodeFile) || !isInSameLexicalScope(); 
 
             function isInSameLexicalScope() {
                 let referenceDeclarationScope = getEnclosingBlockScopeContainer(referenceDeclaration);
                 let locationNodeScope = getEnclosingBlockScopeContainer(locationNode);
 
                 while (locationNodeScope && referenceDeclarationScope !== locationNodeScope) {
-                    switch (locationNodeScope.kind) {
-                        // In function like scope
-                        case SyntaxKind.FunctionExpression:
-                        case SyntaxKind.FunctionDeclaration:
-                        case SyntaxKind.ArrowFunction:
+                    if (isFunctionLike(locationNodeScope)) {
                             return false;
                     }
 

tests/baselines/reference/letUsedInClassMethodOutOfOrder.js

@@ -0,0 +1,19 @@
+//// [letUsedInClassMethodOutOfOrder.ts]
+class c {
+    method1() {
+        a; // shouldnt error
+    }
+}
+
+let a = 10;
+
+//// [letUsedInClassMethodOutOfOrder.js]
+var c = (function () {
+    function c() {
+    }
+    c.prototype.method1 = function () {
+        a; // shouldnt error
+    };
+    return c;
+})();
+var a = 10;

tests/baselines/reference/letUsedInClassMethodOutOfOrder.symbols

@@ -0,0 +1,15 @@
+=== tests/cases/compiler/letUsedInClassMethodOutOfOrder.ts ===
+class c {
+>c : Symbol(c, Decl(letUsedInClassMethodOutOfOrder.ts, 0, 0))
+
+    method1() {
+>method1 : Symbol(method1, Decl(letUsedInClassMethodOutOfOrder.ts, 0, 9))
+
+        a; // shouldnt error
+>a : Symbol(a, Decl(letUsedInClassMethodOutOfOrder.ts, 6, 3))
+    }
+}
+
+let a = 10;
+>a : Symbol(a, Decl(letUsedInClassMethodOutOfOrder.ts, 6, 3))
+

tests/baselines/reference/letUsedInClassMethodOutOfOrder.types

@@ -0,0 +1,16 @@
+=== tests/cases/compiler/letUsedInClassMethodOutOfOrder.ts ===
+class c {
+>c : c
+
+    method1() {
+>method1 : () => void
+
+        a; // shouldnt error
+>a : number
+    }
+}
+
+let a = 10;
+>a : number
+>10 : number
+

tests/cases/compiler/letUsedInClassMethodOutOfOrder.ts

@@ -0,0 +1,7 @@
+class c {
+    method1() {
+        a; // shouldnt error
+    }
+}
+
+let a = 10;