Typecast symbols are not merged to other namespaces

docs/typecasts.md

@@ -38,6 +38,7 @@ Rules:
 - There can be a maximum of one `typecast` statement per block
 - Only runtime symbols can be typecast
 - Currently only `m` is supported
+- When used in a namespace, only the current namespace statement is affected - other namespace statements that contibute to the same namespaces do not have the typecast applied
 
 This is very usefuly for components, so that the actual type of Associative Array `m` can narrowed to provide better validation.
 

src/Scope.spec.ts

@@ -8,7 +8,7 @@ import PluginInterface from './PluginInterface';
 import { expectDiagnostics, expectDiagnosticsIncludes, expectTypeToBe, expectZeroDiagnostics, trim } from './testHelpers.spec';
 import { Logger } from './Logger';
 import type { BrsFile } from './files/BrsFile';
-import type { ForEachStatement, NamespaceStatement } from './parser/Statement';
+import type { AssignmentStatement, ForEachStatement, NamespaceStatement } from './parser/Statement';
 import type { CompilerPlugin, OnScopeValidateEvent } from './interfaces';
 import { DiagnosticOrigin } from './interfaces';
 import { SymbolTypeFlag } from './SymbolTypeFlag';
@@ -29,7 +29,7 @@ import { AssociativeArrayType } from './types/AssociativeArrayType';
 import { InterfaceType } from './types/InterfaceType';
 import { ComponentType } from './types/ComponentType';
 import * as path from 'path';
-import { WalkMode } from './astUtils/visitors';
+import { WalkMode, createVisitor } from './astUtils/visitors';
 import type { FunctionExpression } from './parser/Expression';
 
 describe('Scope', () => {
@@ -3527,6 +3527,53 @@ describe('Scope', () => {
             const mType = forEachStmt.getSymbolTable().getSymbolType('m', { flags: SymbolTypeFlag.runtime });
             expectTypeToBe(mType, AssociativeArrayType);
         });
+
+        it('does not propagate a typecast m across namespace statements', () => {
+            const file1 = program.setFile<BrsFile>('source/one.bs', `
+                interface Thing1
+                    value as integer
+                end interface
+
+                namespace Alpha.Beta
+                    typecast m as Thing1
+
+                    sub method1()
+                        x = m.value
+                        print x
+                    end sub
+                end namespace
+            `);
+            const file2 = program.setFile<BrsFile>('source/two.bs', `
+                namespace Alpha.Beta
+                    sub method2()
+                        x = m.value
+                        print x
+                    end sub
+                end namespace
+            `);
+            program.validate();
+            expectZeroDiagnostics(program);
+            // find places in AST where "x" is assigned
+            const assigns = [] as Array<AssignmentStatement>;
+            const assignmentVisitor = createVisitor({
+                AssignmentStatement: (stmt) => {
+                    if (stmt.tokens.name.text.toLowerCase() === 'x') {
+                        assigns.push(stmt);
+                    }
+                }
+            });
+            file1.ast.walk(assignmentVisitor, { walkMode: WalkMode.visitAllRecursive });
+            file2.ast.walk(assignmentVisitor, { walkMode: WalkMode.visitAllRecursive });
+
+            // method1 - uses Thing1 'm'
+            expectTypeToBe(assigns[0].getSymbolTable().getSymbolType('m', { flags: SymbolTypeFlag.runtime }), InterfaceType);
+            expect(assigns[0].getSymbolTable().getSymbolType('m', { flags: SymbolTypeFlag.runtime }).toString()).to.eq('Thing1');
+            expectTypeToBe(assigns[0].getSymbolTable().getSymbolType('x', { flags: SymbolTypeFlag.runtime }), IntegerType);
+
+            // method1 - uses untypecast 'm'
+            expectTypeToBe(assigns[1].getSymbolTable().getSymbolType('m', { flags: SymbolTypeFlag.runtime }), AssociativeArrayType);
+            expectTypeToBe(assigns[1].getSymbolTable().getSymbolType('x', { flags: SymbolTypeFlag.runtime }), DynamicType);
+        });
     });
 
     describe('unlinkSymbolTable', () => {

src/SymbolTable.ts

@@ -226,6 +226,7 @@ export class SymbolTable implements SymbolTypeGetter {
             options.data.description = data?.description;
             options.data.flags = foundFlags ?? options.flags;
             options.data.memberOfAncestor = data?.memberOfAncestor;
+            options.data.doNotMerge = data?.doNotMerge;
         }
         return resolvedType;
     }
@@ -237,6 +238,9 @@ export class SymbolTable implements SymbolTypeGetter {
     mergeSymbolTable(symbolTable: SymbolTable) {
         for (let [, value] of symbolTable.symbolMap) {
             for (const symbol of value) {
+                if (symbol.data?.doNotMerge) {
+                    continue;
+                }
                 this.addSymbol(
                     symbol.name,
                     symbol.data,
@@ -249,12 +253,12 @@ export class SymbolTable implements SymbolTypeGetter {
 
     mergeNamespaceSymbolTables(symbolTable: SymbolTable) {
         const disposables = [] as Array<() => void>;
-        //console.log(' :: mergeNamespaceSymbolTables:', this.name, '<-', symbolTable.name);
         for (let [_name, value] of symbolTable.symbolMap) {
-            //console.log(name, value.length);
             const symbol = value[0];
             if (symbol) {
-                //console.log(symbol.name, ' ~ ', symbol.type.toString());
+                if (symbol.data?.doNotMerge) {
+                    continue;
+                }
                 const existingRuntimeType = this.getSymbolType(symbol.name, { flags: symbol.flags });
 
                 if (isNamespaceType(existingRuntimeType) && isNamespaceType(symbol.type)) {
@@ -270,13 +274,10 @@ export class SymbolTable implements SymbolTypeGetter {
                 }
             }
         }
-        //console.log(' :: mergeNamespaceSymbolTables: checking siblings');
 
         for (let siblingTable of symbolTable.siblings) {
-            //console.log(' sibling', siblingTable.name);
             disposables.push(...this.mergeNamespaceSymbolTables(siblingTable));
         }
-        //console.log(' :: mergeNamespaceSymbolTables:', this.name, '<-', symbolTable.name, 'done');
         return disposables;
     }
 

src/bscPlugin/validation/BrsFileValidator.ts

@@ -175,7 +175,7 @@ export class BrsFileValidator {
                 this.validateContinueStatement(node);
             },
             TypecastStatement: (node) => {
-                node.parent.getSymbolTable().addSymbol('m', { definingNode: node }, node.getType({ flags: SymbolTypeFlag.typetime }), SymbolTypeFlag.runtime);
+                node.parent.getSymbolTable().addSymbol('m', { definingNode: node, doNotMerge: true }, node.getType({ flags: SymbolTypeFlag.typetime }), SymbolTypeFlag.runtime);
             }
         });
 

src/files/BrsFile.ts

@@ -1305,7 +1305,7 @@ export class BrsFile implements BscFile {
             const typeTimeSymbols = symbolTable.table.getOwnSymbols(SymbolTypeFlag.typetime);
 
             for (const symbol of runTimeSymbols) {
-                if (!isAnyReferenceType(symbol.type)) {
+                if (!isAnyReferenceType(symbol.type) && symbol.name.toLowerCase() !== 'm') {
                     const symbolNameLower = symbolTable.namePrefixLower
                         ? `${symbolTable.namePrefixLower}.${symbol.name.toLowerCase()}`
                         : symbol.name.toLowerCase();

src/interfaces.ts

@@ -821,11 +821,30 @@ export interface FileLink<T> {
 }
 
 export interface ExtraSymbolData {
+    /**
+     * What AST node defined this symbol?
+     */
     definingNode?: AstNode;
+    /**
+     * Description of this symbol
+     */
     description?: string;
-    completionPriority?: number; // the higher the number, the lower the priority
+    /**
+     * the higher the number, the lower the priority
+     */
+    completionPriority?: number;
+    /**
+     * Flags for this symbol
+     */
     flags?: SymbolTypeFlag;
-    memberOfAncestor?: boolean; // this symbol comes from an ancestor symbol table
+    /**
+     * this symbol comes from an ancestor symbol table
+     */
+    memberOfAncestor?: boolean;
+    /**
+     * Do not merge this symbol when merging symbol tables
+     */
+    doNotMerge?: boolean;
 }
 
 export interface GetTypeOptions {