brighterscript 1.0.0-alpha.27 → 1.0.0-alpha.29

package/dist/bscPlugin/validation/ScopeValidator.d.ts

@@ -1,7 +1,11 @@
+import type { Range } from 'vscode-languageserver';
 import type { BrsFile } from '../../files/BrsFile';
 import type { OnScopeValidateEvent } from '../../interfaces';
+import type { Token } from '../../lexer/Token';
+import type { AstNode } from '../../parser/AstNode';
 import type { VariableExpression, DottedGetExpression } from '../../parser/Expression';
 import { CallExpression } from '../../parser/Expression';
+import type { BscType } from '../../types/BscType';
 /**
  * A validator that handles all scope validations for a program validation cycle.
  * You should create ONE of these to handle all scope events between beforeProgramValidate and afterProgramValidate,
@@ -15,12 +19,15 @@ export declare class ScopeValidator {
     processEvent(event: OnScopeValidateEvent): void;
     reset(): void;
     private walkFiles;
+    private doesFileRequireChangedSymbol;
+    private doesFileProvideChangedSymbol;
+    private doesFileAssignChangedSymbol;
     private currentSegmentBeingValidated;
     private isTypeKnown;
     /**
      * If this is the lhs of an assignment, we don't need to flag it as unresolved
      */
-    private ignoreUnresolvedAssignmentLHS;
+    private hasValidDeclaration;
     /**
      * Flag duplicate enums
      */
@@ -72,6 +79,35 @@ export declare class ScopeValidator {
      * and make sure we can find a class with that name
      */
     private validateNewExpression;
+    /**
+     * Create diagnostics for any duplicate function declarations
+     */
+    private flagDuplicateFunctionDeclarations;
+    /**
+     * Verify that all of the scripts imported by each file in this scope actually exist, and have the correct case
+     */
+    private validateScriptImportPaths;
+    /**
+     * Validate all classes defined in this scope
+     */
+    private validateClasses;
+    /**
+     * Find various function collisions
+     */
+    private diagnosticDetectFunctionCollisions;
+    private detectNameCollisions;
+    validateNameCollision(file: BrsFile, node: AstNode, nameIdentifier: Token): void;
+    detectShadowedLocalVar(file: BrsFile, varDeclaration: {
+        name: string;
+        type: BscType;
+        nameRange: Range;
+    }): void;
+    private detectVariableNamespaceCollisions;
+    private validateXmlInterface;
+    /**
+     * Detect when a child has imported a script that an ancestor also imported
+     */
+    private diagnosticDetectDuplicateAncestorScriptImports;
     /**
      * Adds a diagnostic to the first scope for this key. Prevents duplicate diagnostics
      * for diagnostics where scope isn't important. (i.e. CreateObject validations)

package/dist/bscPlugin/validation/ScopeValidator.js

@@ -14,6 +14,9 @@ const visitors_1 = require("../../astUtils/visitors");
 const AstValidationSegmenter_1 = require("../../AstValidationSegmenter");
 const TokenKind_1 = require("../../lexer/TokenKind");
 const Parser_1 = require("../../parser/Parser");
+const ClassValidator_1 = require("../../validators/ClassValidator");
+const globalCallables_1 = require("../../globalCallables");
+const SGTypes_1 = require("../../parser/SGTypes");
 /**
  * The lower-case names of all platform-included scenegraph nodes
  */
@@ -37,6 +40,15 @@ class ScopeValidator {
         }
         this.walkFiles();
         this.detectDuplicateEnums();
+        this.flagDuplicateFunctionDeclarations();
+        this.validateScriptImportPaths();
+        this.validateClasses();
+        if ((0, reflection_1.isXmlScope)(event.scope)) {
+            //detect when the child imports a script that its ancestor also imports
+            this.diagnosticDetectDuplicateAncestorScriptImports(event.scope);
+            //validate component interface
+            this.validateXmlInterface(event.scope);
+        }
     }
     reset() {
         this.event = undefined;
@@ -44,26 +56,30 @@ class ScopeValidator {
         this.multiScopeCache.clear();
     }
     walkFiles() {
+        const hasChangeInfo = this.event.changedFiles && this.event.changedSymbols;
+        //do many per-file checks for every file in this (and parent) scopes
+        this.event.scope.enumerateBrsFiles((file) => {
+            if (!(0, reflection_1.isBrsFile)(file)) {
+                return;
+            }
+            const thisFileHasChanges = this.event.changedFiles.includes(file);
+            this.detectVariableNamespaceCollisions(file);
+            if (thisFileHasChanges || this.doesFileProvideChangedSymbol(file, this.event.changedSymbols)) {
+                this.diagnosticDetectFunctionCollisions(file);
+                this.detectNameCollisions(file);
+            }
+        });
         this.event.scope.enumerateOwnFiles((file) => {
             if ((0, reflection_1.isBrsFile)(file)) {
-                const hasChangeInfo = this.event.changedFiles && this.event.changedSymbols;
-                let thisFileRequiresChangedSymbol = false;
-                for (let requiredSymbol of file.requiredSymbols) {
-                    // eslint-disable-next-line no-bitwise
-                    for (const flag of [1 /* SymbolTypeFlag.runtime */, 2 /* SymbolTypeFlag.typetime */]) {
-                        // eslint-disable-next-line no-bitwise
-                        if (flag & requiredSymbol.flags) {
-                            const changeSymbolSetForFlag = this.event.changedSymbols.get(flag);
-                            if (util_1.default.setContainsUnresolvedSymbol(changeSymbolSetForFlag, requiredSymbol)) {
-                                thisFileRequiresChangedSymbol = true;
-                            }
-                        }
-                    }
-                }
                 const thisFileHasChanges = this.event.changedFiles.includes(file);
-                if (hasChangeInfo && !thisFileRequiresChangedSymbol && !thisFileHasChanges) {
+                const thisFileRequiresChangedSymbol = this.doesFileRequireChangedSymbol(file);
+                const hasUnvalidatedSegments = file.validationSegmenter.hasUnvalidatedSegments();
+                if (hasChangeInfo && !thisFileRequiresChangedSymbol && !thisFileHasChanges && !hasUnvalidatedSegments) {
                     // this file does not require a symbol that has changed, and this file has not changed
-                    return;
+                    if (!this.doesFileAssignChangedSymbol(file)) {
+                        // this file does not have a variable assignment that needs to be checked
+                        return;
+                    }
                 }
                 if (thisFileHasChanges) {
                     this.event.scope.clearAstSegmentDiagnosticsByFile(file);
@@ -93,15 +109,38 @@ class ScopeValidator {
                     },
                     AssignmentStatement: (assignStmt) => {
                         this.validateAssignmentStatement(file, assignStmt);
+                        // Note: this also includes For statements
+                        this.detectShadowedLocalVar(file, {
+                            name: assignStmt.tokens.name.text,
+                            type: assignStmt.getType({ flags: 1 /* SymbolTypeFlag.runtime */ }),
+                            nameRange: assignStmt.tokens.name.range
+                        });
                     },
                     NewExpression: (newExpr) => {
                         this.validateNewExpression(file, newExpr);
+                    },
+                    ForEachStatement: (forEachStmt) => {
+                        this.detectShadowedLocalVar(file, {
+                            name: forEachStmt.tokens.item.text,
+                            type: forEachStmt.getType({ flags: 1 /* SymbolTypeFlag.runtime */ }),
+                            nameRange: forEachStmt.tokens.item.range
+                        });
+                    },
+                    FunctionParameterExpression: (funcParam) => {
+                        this.detectShadowedLocalVar(file, {
+                            name: funcParam.tokens.name.text,
+                            type: funcParam.getType({ flags: 1 /* SymbolTypeFlag.runtime */ }),
+                            nameRange: funcParam.tokens.name.range
+                        });
                     }
                 });
                 const segmentsToWalkForValidation = (thisFileHasChanges || !hasChangeInfo)
                     ? file.validationSegmenter.segmentsForValidation // validate everything in the file
                     : file.getValidationSegments(this.event.changedSymbols); // validate only what's needed in the file
                 for (const segment of segmentsToWalkForValidation) {
+                    if (!file.validationSegmenter.checkIfSegmentNeedRevalidation(segment)) {
+                        continue;
+                    }
                     this.currentSegmentBeingValidated = segment;
                     this.event.scope.clearAstSegmentDiagnostics(segment);
                     segment.walk(validationVisitor, {
@@ -112,6 +151,49 @@ class ScopeValidator {
             }
         });
     }
+    doesFileRequireChangedSymbol(file) {
+        let thisFileRequiresChangedSymbol = false;
+        for (let requiredSymbol of file.requiredSymbols) {
+            // eslint-disable-next-line no-bitwise
+            for (const flag of [1 /* SymbolTypeFlag.runtime */, 2 /* SymbolTypeFlag.typetime */]) {
+                // eslint-disable-next-line no-bitwise
+                if (flag & requiredSymbol.flags) {
+                    const changeSymbolSetForFlag = this.event.changedSymbols.get(flag);
+                    if (util_1.default.setContainsUnresolvedSymbol(changeSymbolSetForFlag, requiredSymbol)) {
+                        thisFileRequiresChangedSymbol = true;
+                        break;
+                    }
+                }
+            }
+        }
+        return thisFileRequiresChangedSymbol;
+    }
+    doesFileProvideChangedSymbol(file, changedSymbols) {
+        if (!changedSymbols) {
+            return true;
+        }
+        for (const flag of [1 /* SymbolTypeFlag.runtime */, 2 /* SymbolTypeFlag.typetime */]) {
+            const providedSymbolKeysFlag = file.providedSymbols.symbolMap.get(flag).keys();
+            const changedSymbolSetForFlag = changedSymbols.get(flag);
+            for (let providedKey of providedSymbolKeysFlag) {
+                if (changedSymbolSetForFlag.has(providedKey)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    doesFileAssignChangedSymbol(file) {
+        let thisFileAssignsChangedSymbol = false;
+        const runTimeChangedSymbolSet = this.event.changedSymbols.get(1 /* SymbolTypeFlag.runtime */);
+        for (let assignedSymbol of file.assignedSymbols) {
+            if (runTimeChangedSymbolSet.has(assignedSymbol.token.text.toLowerCase())) {
+                thisFileAssignsChangedSymbol = true;
+                break;
+            }
+        }
+        return thisFileAssignsChangedSymbol;
+    }
     isTypeKnown(exprType) {
         let isKnownType = exprType === null || exprType === void 0 ? void 0 : exprType.isResolvable();
         return isKnownType;
@@ -119,7 +201,7 @@ class ScopeValidator {
     /**
      * If this is the lhs of an assignment, we don't need to flag it as unresolved
      */
-    ignoreUnresolvedAssignmentLHS(expression, exprType, definingNode) {
+    hasValidDeclaration(expression, exprType, definingNode) {
         var _a, _b;
         if (!(0, reflection_1.isVariableExpression)(expression)) {
             return false;
@@ -130,6 +212,10 @@ class ScopeValidator {
             assignmentAncestor = definingNode;
             return ((_a = assignmentAncestor === null || assignmentAncestor === void 0 ? void 0 : assignmentAncestor.tokens.name) === null || _a === void 0 ? void 0 : _a.text.toLowerCase()) === ((_b = expression === null || expression === void 0 ? void 0 : expression.tokens.name) === null || _b === void 0 ? void 0 : _b.text.toLowerCase());
         }
+        else if ((0, reflection_1.isFunctionParameterExpression)(definingNode)) {
+            // this symbol was defined in a function param
+            return true;
+        }
         else {
             assignmentAncestor = expression === null || expression === void 0 ? void 0 : expression.findAncestor(reflection_1.isAssignmentStatement);
         }
@@ -355,7 +441,10 @@ class ScopeValidator {
         const expectedLHSType = assignStmt.typeExpression.getType(Object.assign(Object.assign({}, getTypeOpts), { data: {}, typeChain: typeChainExpectedLHS }));
         const actualRHSType = (_a = assignStmt.value) === null || _a === void 0 ? void 0 : _a.getType(getTypeOpts);
         const compatibilityData = {};
-        if (!(expectedLHSType === null || expectedLHSType === void 0 ? void 0 : expectedLHSType.isTypeCompatible(actualRHSType, compatibilityData))) {
+        if (!expectedLHSType || !expectedLHSType.isResolvable()) {
+            this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotFindName(assignStmt.typeExpression.getName(Parser_1.ParseMode.BrighterScript))), { range: assignStmt.typeExpression.range, file: file }));
+        }
+        else if (!(expectedLHSType === null || expectedLHSType === void 0 ? void 0 : expectedLHSType.isTypeCompatible(actualRHSType, compatibilityData))) {
             this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.assignmentTypeMismatch(actualRHSType.toString(), expectedLHSType.toString(), compatibilityData)), { range: assignStmt.range, file: file }));
         }
     }
@@ -468,18 +557,22 @@ class ScopeValidator {
             typeChain: typeChain,
             data: typeData
         });
-        const shouldIgnoreLHS = this.ignoreUnresolvedAssignmentLHS(expression, exprType, typeData === null || typeData === void 0 ? void 0 : typeData.definingNode);
-        if (!this.isTypeKnown(exprType) && !shouldIgnoreLHS) {
-            if ((_a = expression.getType({ flags: oppositeSymbolType })) === null || _a === void 0 ? void 0 : _a.isResolvable()) {
+        const hasValidDeclaration = this.hasValidDeclaration(expression, exprType, typeData === null || typeData === void 0 ? void 0 : typeData.definingNode);
+        if (!this.isTypeKnown(exprType) && !hasValidDeclaration) {
+            if ((_a = expression.getType({ flags: oppositeSymbolType, isExistenceTest: true })) === null || _a === void 0 ? void 0 : _a.isResolvable()) {
                 const oppoSiteTypeChain = [];
-                const invalidlyUsedResolvedType = expression.getType({ flags: oppositeSymbolType, typeChain: oppoSiteTypeChain });
+                const invalidlyUsedResolvedType = expression.getType({ flags: oppositeSymbolType, typeChain: oppoSiteTypeChain, isExistenceTest: true });
                 const typeChainScan = util_1.default.processTypeChain(oppoSiteTypeChain);
                 if (isUsedAsType) {
                     this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.itemCannotBeUsedAsType(typeChainScan.fullChainName)), { range: expression.range, file: file }));
                 }
-                else {
+                else if (invalidlyUsedResolvedType && !(0, reflection_1.isReferenceType)(invalidlyUsedResolvedType)) {
                     this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.itemCannotBeUsedAsVariable(invalidlyUsedResolvedType.toString())), { range: expression.range, file: file }));
                 }
+                else {
+                    const typeChainScan = util_1.default.processTypeChain(typeChain);
+                    this.addMultiScopeDiagnostic(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.cannotFindName(typeChainScan.itemName, typeChainScan.fullNameOfItem)), { range: typeChainScan.range }));
+                }
             }
             else {
                 const typeChainScan = util_1.default.processTypeChain(typeChain);
@@ -604,12 +697,328 @@ class ScopeValidator {
             this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expressionIsNotConstructable(fullName)), { file: file, range: newExpression.className.range }));
         }
     }
+    /**
+     * Create diagnostics for any duplicate function declarations
+     */
+    flagDuplicateFunctionDeclarations() {
+        //for each list of callables with the same name
+        for (let [lowerName, callableContainers] of this.event.scope.getCallableContainerMap()) {
+            let globalCallables = [];
+            let nonGlobalCallables = [];
+            let ownCallables = [];
+            let ancestorNonGlobalCallables = [];
+            for (let container of callableContainers) {
+                if (container.scope === this.event.program.globalScope) {
+                    globalCallables.push(container);
+                }
+                else {
+                    nonGlobalCallables.push(container);
+                    if (container.scope === this.event.scope) {
+                        ownCallables.push(container);
+                    }
+                    else {
+                        ancestorNonGlobalCallables.push(container);
+                    }
+                }
+            }
+            //add info diagnostics about child shadowing parent functions
+            if (ownCallables.length > 0 && ancestorNonGlobalCallables.length > 0) {
+                for (let container of ownCallables) {
+                    //skip the init function (because every component will have one of those){
+                    if (lowerName !== 'init') {
+                        let shadowedCallable = ancestorNonGlobalCallables[ancestorNonGlobalCallables.length - 1];
+                        if (!!shadowedCallable && shadowedCallable.callable.file === container.callable.file) {
+                            //same file: skip redundant imports
+                            continue;
+                        }
+                        this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.overridesAncestorFunction(container.callable.name, container.scope.name, shadowedCallable.callable.file.destPath, 
+                        //grab the last item in the list, which should be the closest ancestor's version
+                        shadowedCallable.scope.name)), { range: container.callable.nameRange, file: container.callable.file, origin: interfaces_1.DiagnosticOrigin.Scope }));
+                    }
+                }
+            }
+            //add error diagnostics about duplicate functions in the same scope
+            if (ownCallables.length > 1) {
+                for (let callableContainer of ownCallables) {
+                    let callable = callableContainer.callable;
+                    this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.duplicateFunctionImplementation(callable.name, callableContainer.scope.name)), { range: callable.nameRange, file: callable.file, origin: interfaces_1.DiagnosticOrigin.Scope }));
+                }
+            }
+        }
+    }
+    /**
+     * Verify that all of the scripts imported by each file in this scope actually exist, and have the correct case
+     */
+    validateScriptImportPaths() {
+        let scriptImports = this.event.scope.getOwnScriptImports();
+        //verify every script import
+        for (let scriptImport of scriptImports) {
+            let referencedFile = this.event.scope.getFileByRelativePath(scriptImport.destPath);
+            //if we can't find the file
+            if (!referencedFile) {
+                //skip the default bslib file, it will exist at transpile time but should not show up in the program during validation cycle
+                if (scriptImport.destPath === this.event.program.bslibPkgPath) {
+                    continue;
+                }
+                let dInfo;
+                if (scriptImport.text.trim().length === 0) {
+                    dInfo = DiagnosticMessages_1.DiagnosticMessages.scriptSrcCannotBeEmpty();
+                }
+                else {
+                    dInfo = DiagnosticMessages_1.DiagnosticMessages.referencedFileDoesNotExist();
+                }
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, dInfo), { range: scriptImport.filePathRange, file: scriptImport.sourceFile, origin: interfaces_1.DiagnosticOrigin.Scope }));
+                //if the character casing of the script import path does not match that of the actual path
+            }
+            else if (scriptImport.destPath !== referencedFile.destPath) {
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.scriptImportCaseMismatch(referencedFile.destPath)), { range: scriptImport.filePathRange, file: scriptImport.sourceFile, origin: interfaces_1.DiagnosticOrigin.Scope }));
+            }
+        }
+    }
+    /**
+     * Validate all classes defined in this scope
+     */
+    validateClasses() {
+        let validator = new ClassValidator_1.BsClassValidator(this.event.scope);
+        validator.validate();
+        for (const diagnostic of validator.diagnostics) {
+            this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, diagnostic), { origin: interfaces_1.DiagnosticOrigin.Scope }));
+        }
+    }
+    /**
+     * Find various function collisions
+     */
+    diagnosticDetectFunctionCollisions(file) {
+        for (let func of file.callables) {
+            const funcName = func.getName(Parser_1.ParseMode.BrighterScript);
+            const lowerFuncName = funcName === null || funcName === void 0 ? void 0 : funcName.toLowerCase();
+            if (lowerFuncName) {
+                //find function declarations with the same name as a stdlib function
+                if (globalCallables_1.globalCallableMap.has(lowerFuncName)) {
+                    this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.scopeFunctionShadowedByBuiltInFunction()), { range: func.nameRange, file: file, origin: interfaces_1.DiagnosticOrigin.Scope }));
+                }
+                //find any functions that have the same name as a class
+                const klassLink = this.event.scope.getClassFileLink(lowerFuncName);
+                if (klassLink) {
+                    this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.functionCannotHaveSameNameAsClass(funcName)), { range: func.nameRange, file: file, origin: interfaces_1.DiagnosticOrigin.Scope, relatedInformation: [{
+                                location: util_1.default.createLocation(vscode_uri_1.URI.file(klassLink.file.srcPath).toString(), klassLink.item.tokens.name.range),
+                                message: 'Original class declared here'
+                            }] }));
+                }
+            }
+        }
+    }
+    detectNameCollisions(file) {
+        var _a;
+        // eslint-disable-next-line @typescript-eslint/dot-notation
+        for (let nsStmt of file['_cachedLookups'].namespaceStatements) {
+            this.validateNameCollision(file, nsStmt, (_a = nsStmt.getNameParts()) === null || _a === void 0 ? void 0 : _a[0]);
+        }
+        // eslint-disable-next-line @typescript-eslint/dot-notation
+        for (let classStmt of file['_cachedLookups'].classStatements) {
+            this.validateNameCollision(file, classStmt, classStmt.tokens.name);
+        }
+        // eslint-disable-next-line @typescript-eslint/dot-notation
+        for (let ifaceStmt of file['_cachedLookups'].interfaceStatements) {
+            this.validateNameCollision(file, ifaceStmt, ifaceStmt.tokens.name);
+        }
+        // eslint-disable-next-line @typescript-eslint/dot-notation
+        for (let constStmt of file['_cachedLookups'].constStatements) {
+            this.validateNameCollision(file, constStmt, constStmt.tokens.name);
+        }
+        // eslint-disable-next-line @typescript-eslint/dot-notation
+        for (let enumStmt of file['_cachedLookups'].enumStatements) {
+            this.validateNameCollision(file, enumStmt, enumStmt.tokens.name);
+        }
+    }
+    validateNameCollision(file, node, nameIdentifier) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+        const name = nameIdentifier === null || nameIdentifier === void 0 ? void 0 : nameIdentifier.text;
+        if (!name || !node) {
+            return;
+        }
+        const nameRange = nameIdentifier.range;
+        const containingNamespace = (_a = node.findAncestor(reflection_1.isNamespaceStatement)) === null || _a === void 0 ? void 0 : _a.getName(Parser_1.ParseMode.BrighterScript);
+        const containingNamespaceLower = containingNamespace === null || containingNamespace === void 0 ? void 0 : containingNamespace.toLowerCase();
+        const links = this.event.scope.getAllFileLinks(name, containingNamespace, !(0, reflection_1.isNamespaceStatement)(node));
+        for (let link of links) {
+            if (!link || link.item === node) {
+                // refers to same node
+                continue;
+            }
+            if ((0, reflection_1.isNamespaceStatement)(link.item) && (0, reflection_1.isNamespaceStatement)(node)) {
+                // namespace can be declared multiple times
+                continue;
+            }
+            if ((0, reflection_1.isFunctionStatement)(link.item) || ((_b = link.file) === null || _b === void 0 ? void 0 : _b.destPath) === 'global') {
+                const linkItemNamespaceLower = (_e = (_d = (_c = link.item) === null || _c === void 0 ? void 0 : _c.findAncestor(reflection_1.isNamespaceStatement)) === null || _d === void 0 ? void 0 : _d.getName(Parser_1.ParseMode.BrighterScript)) === null || _e === void 0 ? void 0 : _e.toLowerCase();
+                if (!(containingNamespaceLower && linkItemNamespaceLower) || linkItemNamespaceLower !== containingNamespaceLower) {
+                    // the thing found is a function OR from global (which is also a function)
+                    if ((0, reflection_1.isNamespaceStatement)(node) ||
+                        (0, reflection_1.isEnumStatement)(node) ||
+                        (0, reflection_1.isConstStatement)(node) ||
+                        (0, reflection_1.isInterfaceStatement)(node)) {
+                        // these are not callable functions in transpiled code - ignore them
+                        continue;
+                    }
+                }
+            }
+            const thisNodeKindName = util_1.default.getAstNodeFriendlyName(node);
+            const thatNodeKindName = link.file.srcPath === 'global' ? 'Global Function' : (_f = util_1.default.getAstNodeFriendlyName(link.item)) !== null && _f !== void 0 ? _f : '';
+            let thatNameRange = (_k = (_j = (_h = (_g = link.item) === null || _g === void 0 ? void 0 : _g.tokens) === null || _h === void 0 ? void 0 : _h.name) === null || _j === void 0 ? void 0 : _j.range) !== null && _k !== void 0 ? _k : (_l = link.item) === null || _l === void 0 ? void 0 : _l.range;
+            if ((0, reflection_1.isNamespaceStatement)(link.item)) {
+                thatNameRange = (_o = (_m = link.item.getNameParts()) === null || _m === void 0 ? void 0 : _m[0]) === null || _o === void 0 ? void 0 : _o.range;
+            }
+            const relatedInformation = thatNameRange ? [{
+                    message: `${thatNodeKindName} declared here`,
+                    location: util_1.default.createLocation(vscode_uri_1.URI.file((_p = link.file) === null || _p === void 0 ? void 0 : _p.srcPath).toString(), thatNameRange)
+                }] : undefined;
+            this.addMultiScopeDiagnostic(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.nameCollision(thisNodeKindName, thatNodeKindName, name)), { origin: interfaces_1.DiagnosticOrigin.Scope, range: nameRange, relatedInformation: relatedInformation }));
+        }
+    }
+    detectShadowedLocalVar(file, varDeclaration) {
+        var _a;
+        const varName = varDeclaration.name;
+        const lowerVarName = varName.toLowerCase();
+        const callableContainerMap = this.event.scope.getCallableContainerMap();
+        const varIsFunction = () => {
+            return (0, reflection_1.isCallableType)(varDeclaration.type);
+        };
+        if (
+        //has same name as stdlib
+        globalCallables_1.globalCallableMap.has(lowerVarName)) {
+            //local var function with same name as stdlib function
+            if (varIsFunction()) {
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarFunctionShadowsParentFunction('stdlib')), { range: varDeclaration.nameRange, file: file, origin: interfaces_1.DiagnosticOrigin.Scope }));
+            }
+        }
+        else if (callableContainerMap.has(lowerVarName)) {
+            const callable = callableContainerMap.get(lowerVarName);
+            //is same name as a callable
+            if (varIsFunction()) {
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarFunctionShadowsParentFunction('scope')), { range: varDeclaration.nameRange, file: file, origin: interfaces_1.DiagnosticOrigin.Scope, relatedInformation: [{
+                            message: 'Function declared here',
+                            location: util_1.default.createLocation(vscode_uri_1.URI.file(callable[0].callable.file.srcPath).toString(), callable[0].callable.nameRange)
+                        }] }));
+            }
+            else {
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarShadowedByScopedFunction()), { range: varDeclaration.nameRange, file: file, origin: interfaces_1.DiagnosticOrigin.Scope, relatedInformation: [{
+                            message: 'Function declared here',
+                            location: util_1.default.createLocation(vscode_uri_1.URI.file(callable[0].callable.file.srcPath).toString(), callable[0].callable.nameRange)
+                        }] }));
+            }
+            //has the same name as an in-scope class
+        }
+        else {
+            const classStmtLink = this.event.scope.getClassFileLink(lowerVarName);
+            if (classStmtLink) {
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarSameNameAsClass((_a = classStmtLink === null || classStmtLink === void 0 ? void 0 : classStmtLink.item) === null || _a === void 0 ? void 0 : _a.getName(Parser_1.ParseMode.BrighterScript))), { range: varDeclaration.nameRange, file: file, origin: interfaces_1.DiagnosticOrigin.Scope, relatedInformation: [{
+                            message: 'Class declared here',
+                            location: util_1.default.createLocation(vscode_uri_1.URI.file(classStmtLink.file.srcPath).toString(), classStmtLink === null || classStmtLink === void 0 ? void 0 : classStmtLink.item.tokens.name.range)
+                        }] }));
+            }
+        }
+    }
+    detectVariableNamespaceCollisions(file) {
+        var _a, _b;
+        //find all function parameters
+        // eslint-disable-next-line @typescript-eslint/dot-notation
+        for (let func of file['_cachedLookups'].functionExpressions) {
+            for (let param of func.parameters) {
+                let lowerParamName = param.tokens.name.text.toLowerCase();
+                let namespace = this.event.scope.getNamespace(lowerParamName, (_a = param.findAncestor(reflection_1.isNamespaceStatement)) === null || _a === void 0 ? void 0 : _a.getName(Parser_1.ParseMode.BrighterScript).toLowerCase());
+                //see if the param matches any starting namespace part
+                if (namespace) {
+                    this.addMultiScopeDiagnostic(Object.assign(Object.assign({ origin: interfaces_1.DiagnosticOrigin.Scope, file: file }, DiagnosticMessages_1.DiagnosticMessages.parameterMayNotHaveSameNameAsNamespace(param.tokens.name.text)), { range: param.tokens.name.range, relatedInformation: [{
+                                message: 'Namespace declared here',
+                                location: util_1.default.createLocation(vscode_uri_1.URI.file(namespace.file.srcPath).toString(), namespace.nameRange)
+                            }] }));
+                }
+            }
+        }
+        // eslint-disable-next-line @typescript-eslint/dot-notation
+        for (let assignment of file['_cachedLookups'].assignmentStatements) {
+            let lowerAssignmentName = assignment.tokens.name.text.toLowerCase();
+            let namespace = this.event.scope.getNamespace(lowerAssignmentName, (_b = assignment.findAncestor(reflection_1.isNamespaceStatement)) === null || _b === void 0 ? void 0 : _b.getName(Parser_1.ParseMode.BrighterScript).toLowerCase());
+            //see if the param matches any starting namespace part
+            if (namespace) {
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({ origin: interfaces_1.DiagnosticOrigin.Scope, file: file }, DiagnosticMessages_1.DiagnosticMessages.variableMayNotHaveSameNameAsNamespace(assignment.tokens.name.text)), { range: assignment.tokens.name.range, relatedInformation: [{
+                            message: 'Namespace declared here',
+                            location: util_1.default.createLocation(vscode_uri_1.URI.file(namespace.file.srcPath).toString(), namespace.nameRange)
+                        }] }));
+            }
+        }
+    }
+    validateXmlInterface(scope) {
+        var _a, _b, _c, _d, _e;
+        if (!((_b = (_a = scope.xmlFile.parser.ast) === null || _a === void 0 ? void 0 : _a.componentElement) === null || _b === void 0 ? void 0 : _b.interfaceElement)) {
+            return;
+        }
+        const iface = scope.xmlFile.parser.ast.componentElement.interfaceElement;
+        const callableContainerMap = scope.getCallableContainerMap();
+        //validate functions
+        for (const func of iface.functions) {
+            const name = func.name;
+            if (!name) {
+                this.addDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.xmlTagMissingAttribute(func.tokens.startTagName.text, 'name')), { range: func.tokens.startTagName.range, file: scope.xmlFile, origin: interfaces_1.DiagnosticOrigin.Scope }));
+            }
+            else if (!callableContainerMap.has(name.toLowerCase())) {
+                this.addDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.xmlFunctionNotFound(name)), { range: (_c = func.getAttribute('name')) === null || _c === void 0 ? void 0 : _c.tokens.value.range, file: scope.xmlFile, origin: interfaces_1.DiagnosticOrigin.Scope }));
+            }
+        }
+        //validate fields
+        for (const field of iface.fields) {
+            const { id, type, onChange } = field;
+            if (!id) {
+                this.addDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.xmlTagMissingAttribute(field.tokens.startTagName.text, 'id')), { range: field.tokens.startTagName.range, file: scope.xmlFile, origin: interfaces_1.DiagnosticOrigin.Scope }));
+            }
+            if (!type) {
+                if (!field.alias) {
+                    this.addDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.xmlTagMissingAttribute(field.tokens.startTagName.text, 'type')), { range: field.tokens.startTagName.range, file: scope.xmlFile, origin: interfaces_1.DiagnosticOrigin.Scope }));
+                }
+            }
+            else if (!SGTypes_1.SGFieldTypes.includes(type.toLowerCase())) {
+                this.addDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.xmlInvalidFieldType(type)), { range: (_d = field.getAttribute('type')) === null || _d === void 0 ? void 0 : _d.tokens.value.range, file: scope.xmlFile, origin: interfaces_1.DiagnosticOrigin.Scope }));
+            }
+            if (onChange) {
+                if (!callableContainerMap.has(onChange.toLowerCase())) {
+                    this.addDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.xmlFunctionNotFound(onChange)), { range: (_e = field.getAttribute('onchange')) === null || _e === void 0 ? void 0 : _e.tokens.value.range, file: scope.xmlFile, origin: interfaces_1.DiagnosticOrigin.Scope }));
+                }
+            }
+        }
+    }
+    /**
+     * Detect when a child has imported a script that an ancestor also imported
+     */
+    diagnosticDetectDuplicateAncestorScriptImports(scope) {
+        var _a, _b;
+        if (scope.xmlFile.parentComponent) {
+            //build a lookup of pkg paths -> FileReference so we can more easily look up collisions
+            let parentScriptImports = scope.xmlFile.getAncestorScriptTagImports();
+            let lookup = {};
+            for (let parentScriptImport of parentScriptImports) {
+                //keep the first occurance of a pkgPath. Parent imports are first in the array
+                if (!lookup[parentScriptImport.destPath]) {
+                    lookup[parentScriptImport.destPath] = parentScriptImport;
+                }
+            }
+            //add warning for every script tag that this file shares with an ancestor
+            for (let scriptImport of scope.xmlFile.scriptTagImports) {
+                let ancestorScriptImport = lookup[scriptImport.destPath];
+                if (ancestorScriptImport) {
+                    let ancestorComponent = ancestorScriptImport.sourceFile;
+                    let ancestorComponentName = (_b = (_a = ancestorComponent.componentName) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : ancestorComponent.destPath;
+                    this.addDiagnostic(Object.assign(Object.assign({ file: scope.xmlFile, range: scriptImport.filePathRange }, DiagnosticMessages_1.DiagnosticMessages.unnecessaryScriptImportInChildFromParent(ancestorComponentName)), { origin: interfaces_1.DiagnosticOrigin.Scope }));
+                }
+            }
+        }
+    }
     /**
      * Adds a diagnostic to the first scope for this key. Prevents duplicate diagnostics
      * for diagnostics where scope isn't important. (i.e. CreateObject validations)
      */
     addDiagnosticOnce(diagnostic) {
-        this.onceCache.getOrAdd(`${diagnostic.code} -${diagnostic.message} -${util_1.default.rangeToString(diagnostic.range)} `, () => {
+        this.onceCache.getOrAdd(`${diagnostic.code} - ${diagnostic.message} - ${util_1.default.rangeToString(diagnostic.range)} `, () => {
             const diagnosticWithOrigin = Object.assign({}, diagnostic);
             if (!diagnosticWithOrigin.origin) {
                 // diagnostic does not have origin.
@@ -636,7 +1045,7 @@ class ScopeValidator {
      */
     addMultiScopeDiagnostic(diagnostic) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
-        diagnostic = this.multiScopeCache.getOrAdd(`${(_a = diagnostic.file) === null || _a === void 0 ? void 0 : _a.srcPath} -${diagnostic.code} -${diagnostic.message} -${util_1.default.rangeToString(diagnostic.range)} `, () => {
+        diagnostic = this.multiScopeCache.getOrAdd(`${(_a = diagnostic.file) === null || _a === void 0 ? void 0 : _a.srcPath} - ${diagnostic.code} - ${diagnostic.message} - ${util_1.default.rangeToString(diagnostic.range)} `, () => {
             if (!diagnostic.relatedInformation) {
                 diagnostic.relatedInformation = [];
             }