Remove FunctionScope and improve type tracking

src/Program.spec.ts

@@ -712,6 +712,34 @@ describe('Program', () => {
     });
 
     describe('getCompletions', () => {
+        it('includes `for each` variable', async () => {
+            await program.addOrReplaceFile('source/main.brs', `
+                sub main()
+                    items = [1, 2, 3]
+                    for each thing in items
+                        t =
+                    end for
+                    end for
+                end sub
+            `);
+            await program.validate();
+            let completions = (await program.getCompletions(`${rootDir}/source/main.brs`, Position.create(4, 28))).map(x => x.label);
+            expect(completions).to.include('thing');
+        });
+
+        it('includes `for` variable', async () => {
+            await program.addOrReplaceFile('source/main.brs', `
+                sub main()
+                    for i = 0 to 10
+                        t =
+                    end for
+                end sub
+            `);
+            await program.validate();
+            let completions = (await program.getCompletions(`${rootDir}/source/main.brs`, Position.create(3, 28))).map(x => x.label);
+            expect(completions).to.include('i');
+        });
+
         it('should include first-level namespace names for brighterscript files', async () => {
             await program.addOrReplaceFile('source/main.bs', `
                 namespace NameA.NameB.NameC

src/Scope.ts

@@ -612,63 +612,61 @@ export class Scope {
     }
 
     /**
-     * Detect local variables (function scope) that have the same name as scope calls
+     * Detect local variables (vars declared within a function expression) that have the same name as scope calls
      * @param file
      * @param callableContainerMap
      */
     private diagnosticDetectShadowedLocalVars(file: BscFile, callableContainerMap: CallableContainerMap) {
         const classMap = this.getClassMap();
-        //loop through every function scope
-        for (let scope of file.functionScopes) {
-            //every var declaration in this function scope
-            for (let varDeclaration of scope.variableDeclarations) {
-                const varName = varDeclaration.name;
-                const lowerVarName = varName.toLowerCase();
 
+        for (let functionExpression of file.parser.references.functionExpressions) {
+            const localVars = file.parser.references.localVars.get(functionExpression);
+            //every var declaration in this function expression
+            for (let localVar of localVars) {
                 //if the var is a function
-                if (isFunctionType(varDeclaration.type)) {
+                if (isFunctionType(localVar.type)) {
                     //local var function with same name as stdlib function
                     if (
                         //has same name as stdlib
-                        globalCallableMap.has(lowerVarName)
+                        globalCallableMap.has(localVar.lowerName)
                     ) {
                         this.diagnostics.push({
                             ...DiagnosticMessages.localVarFunctionShadowsParentFunction('stdlib'),
-                            range: varDeclaration.nameRange,
+                            range: localVar.nameToken.range,
                             file: file
                         });
 
                         //this check needs to come after the stdlib one, because the stdlib functions are included
                         //in the scope function list
                     } else if (
                         //has same name as scope function
-                        callableContainerMap.has(lowerVarName)
+                        callableContainerMap.has(localVar.lowerName)
                     ) {
                         this.diagnostics.push({
                             ...DiagnosticMessages.localVarFunctionShadowsParentFunction('scope'),
-                            range: varDeclaration.nameRange,
+                            range: localVar.nameToken.range,
                             file: file
                         });
                     }
 
                     //var is not a function
                 } else if (
                     //is NOT a callable from stdlib (because non-function local vars can have same name as stdlib names)
-                    !globalCallableMap.has(lowerVarName)
+                    !globalCallableMap.has(localVar.lowerName)
                 ) {
 
                     //is same name as a callable
-                    if (callableContainerMap.has(lowerVarName)) {
+                    if (callableContainerMap.has(localVar.lowerName)) {
                         this.diagnostics.push({
                             ...DiagnosticMessages.localVarShadowedByScopedFunction(),
-                            range: varDeclaration.nameRange,
+                            range: localVar.nameToken.range,
                             file: file
                         });
                         //has the same name as an in-scope class
-                    } else if (classMap.has(lowerVarName)) {
+                    } else if (classMap.has(localVar.lowerName)) {
                         this.diagnostics.push({
-                            ...DiagnosticMessages.localVarSameNameAsClass(classMap.get(lowerVarName).getName(ParseMode.BrighterScript)),
-                            range: varDeclaration.nameRange,
+                            ...DiagnosticMessages.localVarSameNameAsClass(classMap.get(localVar.lowerName).getName(ParseMode.BrighterScript)),
+                            range: localVar.nameToken.range,
                             file: file
                         });
                     }
@@ -683,6 +681,7 @@ export class Scope {
      * @param callablesByLowerName
      */
     private diagnosticDetectCallsToUnknownFunctions(file: BscFile, callablesByLowerName: CallableContainerMap) {
+
         //validate all expression calls
         for (let expCall of file.functionCalls) {
             const lowerName = expCall.name.toLowerCase();
@@ -692,11 +691,11 @@ export class Scope {
                 continue;
             }
 
-            //get the local scope for this expression
-            let scope = file.getFunctionScopeAtPosition(expCall.nameRange.start);
+            //find a local variable with this name
+            const localVar = file.getLocalVarsAtPosition(expCall.nameRange.start).find(x => x.lowerName === lowerName);
 
             //if we don't already have a variable with this name.
-            if (!scope?.getVariableByName(lowerName)) {
+            if (!localVar) {
                 let callablesWithThisName = callablesByLowerName.get(lowerName);
 
                 //use the first item from callablesByLowerName, because if there are more, that's a separate error

src/astUtils/reflection.spec.ts

@@ -28,7 +28,7 @@ describe('reflection', () => {
         const expr = createStringLiteral('', range);
         const token = createToken(TokenKind.StringLiteral, '', range);
         const body = new Body([]);
-        const assignment = new AssignmentStatement(undefined, ident, expr, undefined);
+        const assignment = new AssignmentStatement(ident, token, expr, undefined);
         const block = new Block([], range);
         const expression = new ExpressionStatement(expr);
         const comment = new CommentStatement([token]);
@@ -44,7 +44,7 @@ describe('reflection', () => {
         const ends = new EndStatement({ end: token });
         const stop = new StopStatement({ stop: token });
         const fors = new ForStatement(token, assignment, token, expr, block, token, token, expr);
-        const foreach = new ForEachStatement({ forEach: token, in: token, endFor: token }, token, expr, block);
+        const foreach = new ForEachStatement(token, ident, token, expr, block, token);
         const whiles = new WhileStatement({ while: token, endWhile: token }, expr, block);
         const dottedSet = new DottedSetStatement(expr, ident, expr);
         const indexedSet = new IndexedSetStatement(expr, expr, expr, token, token);