brighterscript 1.0.0-alpha.26 → 1.0.0-alpha.28

package/dist/bscPlugin/validation/ScopeValidator.js

@@ -6,14 +6,17 @@ const reflection_1 = require("../../astUtils/reflection");
 const Cache_1 = require("../../Cache");
 const DiagnosticMessages_1 = require("../../DiagnosticMessages");
 const interfaces_1 = require("../../interfaces");
-const SymbolTable_1 = require("../../SymbolTable");
 const util_1 = require("../../util");
 const roku_types_1 = require("../../roku-types");
+const AstNode_1 = require("../../parser/AstNode");
 const Expression_1 = require("../../parser/Expression");
 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,13 +56,19 @@ class ScopeValidator {
         this.multiScopeCache.clear();
     }
     walkFiles() {
+        //do many per-file checks for every file in this (and parent) scopes
+        this.event.scope.enumerateBrsFiles((file) => {
+            this.diagnosticDetectFunctionCollisions(file);
+            this.detectVariableNamespaceCollisions(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 [SymbolTable_1.SymbolTypeFlag.runtime, SymbolTable_1.SymbolTypeFlag.typetime]) {
+                    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);
@@ -93,6 +111,9 @@ class ScopeValidator {
                     },
                     AssignmentStatement: (assignStmt) => {
                         this.validateAssignmentStatement(file, assignStmt);
+                    },
+                    NewExpression: (newExpr) => {
+                        this.validateNewExpression(file, newExpr);
                     }
                 });
                 const segmentsToWalkForValidation = (thisFileHasChanges || !hasChangeInfo)
@@ -116,7 +137,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;
@@ -127,6 +148,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);
         }
@@ -241,7 +266,7 @@ class ScopeValidator {
      */
     validateFunctionCall(file, expression) {
         var _a, _b;
-        const getTypeOptions = { flags: SymbolTable_1.SymbolTypeFlag.runtime, data: {} };
+        const getTypeOptions = { flags: 1 /* SymbolTypeFlag.runtime */, data: {} };
         let funcType = (_a = expression === null || expression === void 0 ? void 0 : expression.callee) === null || _a === void 0 ? void 0 : _a.getType(getTypeOptions);
         if ((funcType === null || funcType === void 0 ? void 0 : funcType.isResolvable()) && (0, reflection_1.isClassType)(funcType)) {
             // We're calling a class - get the constructor
@@ -274,7 +299,7 @@ class ScopeValidator {
             let paramIndex = 0;
             for (let arg of expression.args) {
                 const data = {};
-                let argType = arg.getType({ flags: SymbolTable_1.SymbolTypeFlag.runtime, data: data });
+                let argType = arg.getType({ flags: 1 /* SymbolTypeFlag.runtime */, data: data });
                 const paramType = (_b = funcType.params[paramIndex]) === null || _b === void 0 ? void 0 : _b.type;
                 if (!paramType) {
                     // unable to find a paramType -- maybe there are more args than params
@@ -302,8 +327,8 @@ class ScopeValidator {
      */
     validateReturnStatement(file, returnStmt) {
         var _a;
-        const getTypeOptions = { flags: SymbolTable_1.SymbolTypeFlag.runtime };
-        let funcType = returnStmt.findAncestor(reflection_1.isFunctionExpression).getType({ flags: SymbolTable_1.SymbolTypeFlag.typetime });
+        const getTypeOptions = { flags: 1 /* SymbolTypeFlag.runtime */ };
+        let funcType = returnStmt.findAncestor(reflection_1.isFunctionExpression).getType({ flags: 2 /* SymbolTypeFlag.typetime */ });
         if ((0, reflection_1.isTypedFunctionType)(funcType)) {
             const actualReturnType = (_a = returnStmt.value) === null || _a === void 0 ? void 0 : _a.getType(getTypeOptions);
             const compatibilityData = {};
@@ -318,7 +343,7 @@ class ScopeValidator {
     validateDottedSetStatement(file, dottedSetStmt) {
         var _a;
         const typeChainExpectedLHS = [];
-        const getTypeOpts = { flags: SymbolTable_1.SymbolTypeFlag.runtime };
+        const getTypeOpts = { flags: 1 /* SymbolTypeFlag.runtime */ };
         const expectedLHSType = dottedSetStmt === null || dottedSetStmt === void 0 ? void 0 : dottedSetStmt.getType(Object.assign(Object.assign({}, getTypeOpts), { data: {}, typeChain: typeChainExpectedLHS }));
         const actualRHSType = (_a = dottedSetStmt === null || dottedSetStmt === void 0 ? void 0 : dottedSetStmt.value) === null || _a === void 0 ? void 0 : _a.getType(getTypeOpts);
         const compatibilityData = {};
@@ -348,11 +373,14 @@ class ScopeValidator {
             return;
         }
         const typeChainExpectedLHS = [];
-        const getTypeOpts = { flags: SymbolTable_1.SymbolTypeFlag.runtime };
+        const getTypeOpts = { flags: 1 /* SymbolTypeFlag.runtime */ };
         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 }));
         }
     }
@@ -360,7 +388,7 @@ class ScopeValidator {
      * Detect invalid use of a binary operator
      */
     validateBinaryExpression(file, binaryExpr) {
-        const getTypeOpts = { flags: SymbolTable_1.SymbolTypeFlag.runtime };
+        const getTypeOpts = { flags: 1 /* SymbolTypeFlag.runtime */ };
         if (util_1.default.isInTypeExpression(binaryExpr)) {
             return;
         }
@@ -405,7 +433,7 @@ class ScopeValidator {
      * Detect invalid use of a Unary operator
      */
     validateUnaryExpression(file, unaryExpr) {
-        const getTypeOpts = { flags: SymbolTable_1.SymbolTypeFlag.runtime };
+        const getTypeOpts = { flags: 1 /* SymbolTypeFlag.runtime */ };
         let rightType = unaryExpr.right.getType(getTypeOpts);
         if (!rightType.isResolvable()) {
             // Can not find the type. error handled elsewhere
@@ -434,7 +462,7 @@ class ScopeValidator {
         }
     }
     validateVariableAndDottedGetExpressions(file, expression) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         if ((0, reflection_1.isDottedGetExpression)(expression.parent)) {
             // We validate dottedGetExpressions at the top-most level
             return;
@@ -448,13 +476,13 @@ class ScopeValidator {
                 return;
             }
         }
-        let symbolType = SymbolTable_1.SymbolTypeFlag.runtime;
-        let oppositeSymbolType = SymbolTable_1.SymbolTypeFlag.typetime;
+        let symbolType = 1 /* SymbolTypeFlag.runtime */;
+        let oppositeSymbolType = 2 /* SymbolTypeFlag.typetime */;
         const isUsedAsType = util_1.default.isInTypeExpression(expression);
         if (isUsedAsType) {
             // This is used in a TypeExpression - only look up types from SymbolTable
-            symbolType = SymbolTable_1.SymbolTypeFlag.typetime;
-            oppositeSymbolType = SymbolTable_1.SymbolTypeFlag.runtime;
+            symbolType = 2 /* SymbolTypeFlag.typetime */;
+            oppositeSymbolType = 1 /* SymbolTypeFlag.runtime */;
         }
         // Do a complete type check on all DottedGet and Variable expressions
         // this will create a diagnostic if an invalid member is accessed
@@ -465,18 +493,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);
@@ -486,6 +518,14 @@ class ScopeValidator {
         if (isUsedAsType) {
             return;
         }
+        const containingNamespaceName = (_b = expression.findAncestor(reflection_1.isNamespaceStatement)) === null || _b === void 0 ? void 0 : _b.getName(Parser_1.ParseMode.BrighterScript);
+        if (!((0, reflection_1.isCallExpression)(expression.parent) && (0, reflection_1.isNewExpression)((_c = expression.parent) === null || _c === void 0 ? void 0 : _c.parent))) {
+            const classUsedAsVarEntry = this.checkTypeChainForClassUsedAsVar(typeChain, containingNamespaceName);
+            if (classUsedAsVarEntry) {
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.itemCannotBeUsedAsVariable(classUsedAsVarEntry.toString())), { range: expression.range, file: file }));
+                return;
+            }
+        }
         const lastTypeInfo = typeChain[typeChain.length - 1];
         const parentTypeInfo = typeChain[typeChain.length - 2];
         this.checkMemberAccessibility(file, expression, typeChain);
@@ -505,11 +545,35 @@ class ScopeValidator {
             if (enumFileLink) {
                 this.addMultiScopeDiagnostic(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.unknownEnumValue(lastTypeInfo === null || lastTypeInfo === void 0 ? void 0 : lastTypeInfo.name, typeChainScanForParent.fullChainName)), { range: lastTypeInfo === null || lastTypeInfo === void 0 ? void 0 : lastTypeInfo.range, relatedInformation: [{
                             message: 'Enum declared here',
-                            location: util_1.default.createLocation(vscode_uri_1.URI.file(enumFileLink === null || enumFileLink === void 0 ? void 0 : enumFileLink.file.srcPath).toString(), (_b = enumFileLink === null || enumFileLink === void 0 ? void 0 : enumFileLink.item) === null || _b === void 0 ? void 0 : _b.tokens.name.range)
+                            location: util_1.default.createLocation(vscode_uri_1.URI.file(enumFileLink === null || enumFileLink === void 0 ? void 0 : enumFileLink.file.srcPath).toString(), (_d = enumFileLink === null || enumFileLink === void 0 ? void 0 : enumFileLink.item) === null || _d === void 0 ? void 0 : _d.tokens.name.range)
                         }] }));
             }
         }
     }
+    checkTypeChainForClassUsedAsVar(typeChain, containingNamespaceName) {
+        const ignoreKinds = [AstNode_1.AstNodeKind.TypeCastExpression, AstNode_1.AstNodeKind.NewExpression];
+        let lowerNameSoFar = '';
+        let classUsedAsVar;
+        let isFirst = true;
+        for (let i = 0; i < typeChain.length - 1; i++) { // do not look at final entry - we CAN use the constructor as a variable
+            const tce = typeChain[i];
+            lowerNameSoFar += `${lowerNameSoFar ? '.' : ''}${tce.name.toLowerCase()}`;
+            if (!(0, reflection_1.isNamespaceType)(tce.type)) {
+                if (isFirst && containingNamespaceName) {
+                    lowerNameSoFar = `${containingNamespaceName.toLowerCase()}.${lowerNameSoFar}`;
+                }
+                if (!tce.kind || ignoreKinds.includes(tce.kind)) {
+                    break;
+                }
+                else if ((0, reflection_1.isClassType)(tce.type) && lowerNameSoFar.toLowerCase() === tce.type.name.toLowerCase()) {
+                    classUsedAsVar = tce.type;
+                }
+                break;
+            }
+            isFirst = false;
+        }
+        return classUsedAsVar;
+    }
     /**
      * Adds diagnostics for accibility mismatches
      *
@@ -530,7 +594,7 @@ class ScopeValidator {
                     const definingClassName = classStmtThatDefinesChildMember.getName(Parser_1.ParseMode.BrighterScript);
                     const inMatchingClassStmt = (containingClassStmt === null || containingClassStmt === void 0 ? void 0 : containingClassStmt.getName(Parser_1.ParseMode.BrighterScript).toLowerCase()) === parentChainItem.type.name.toLowerCase();
                     // eslint-disable-next-line no-bitwise
-                    if (childChainItem.data.flags & SymbolTable_1.SymbolTypeFlag.private) {
+                    if (childChainItem.data.flags & 8 /* SymbolTypeFlag.private */) {
                         if (!inMatchingClassStmt || childChainItem.data.memberOfAncestor) {
                             this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.memberAccessibilityMismatch(childChainItem.name, childChainItem.data.flags, definingClassName)), { range: expression.range, file: file }));
                             // there's an error... don't worry about the rest of the chain
@@ -538,7 +602,7 @@ class ScopeValidator {
                         }
                     }
                     // eslint-disable-next-line no-bitwise
-                    if (childChainItem.data.flags & SymbolTable_1.SymbolTypeFlag.protected) {
+                    if (childChainItem.data.flags & 16 /* SymbolTypeFlag.protected */) {
                         const containingClassName = containingClassStmt === null || containingClassStmt === void 0 ? void 0 : containingClassStmt.getName(Parser_1.ParseMode.BrighterScript);
                         const containingNamespaceName = (_c = expression.findAncestor(reflection_1.isNamespaceStatement)) === null || _c === void 0 ? void 0 : _c.getName(Parser_1.ParseMode.BrighterScript);
                         const ancestorClasses = this.event.scope.getClassHierarchy(containingClassName, containingNamespaceName).map(link => link.item);
@@ -554,12 +618,356 @@ class ScopeValidator {
         }
         return true;
     }
+    /**
+     * Find all "new" statements in the program,
+     * and make sure we can find a class with that name
+     */
+    validateNewExpression(file, newExpression) {
+        var _a;
+        let potentialClassName = newExpression.className.getName(Parser_1.ParseMode.BrighterScript);
+        const namespaceName = (_a = newExpression.findAncestor(reflection_1.isNamespaceStatement)) === null || _a === void 0 ? void 0 : _a.getName(Parser_1.ParseMode.BrighterScript);
+        let newableClass = this.event.scope.getClass(potentialClassName, namespaceName);
+        if (!newableClass) {
+            //try and find functions with this name.
+            let fullName = util_1.default.getFullyQualifiedClassName(potentialClassName, namespaceName);
+            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) {
+        file.ast.walk((0, visitors_1.createVisitor)({
+            NamespaceStatement: (nsStmt) => {
+                var _a;
+                this.validateNameCollision(file, nsStmt, (_a = nsStmt.getNameParts()) === null || _a === void 0 ? void 0 : _a[0]);
+            },
+            ClassStatement: (classStmt) => {
+                this.validateNameCollision(file, classStmt, classStmt.tokens.name);
+            },
+            InterfaceStatement: (ifaceStmt) => {
+                this.validateNameCollision(file, ifaceStmt, ifaceStmt.tokens.name);
+            },
+            ConstStatement: (constStmt) => {
+                this.validateNameCollision(file, constStmt, constStmt.tokens.name);
+            },
+            EnumStatement: (enumStmt) => {
+                this.validateNameCollision(file, enumStmt, enumStmt.tokens.name);
+            },
+            AssignmentStatement: (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
+                });
+            },
+            ForEachStatement: (forEachStmt) => {
+                this.detectShadowedLocalVar(file, {
+                    name: forEachStmt.tokens.item.text,
+                    type: forEachStmt.getType({ flags: 1 /* SymbolTypeFlag.runtime */ }),
+                    nameRange: forEachStmt.tokens.item.range
+                });
+            }
+        }), {
+            walkMode: visitors_1.WalkMode.visitAllRecursive
+        });
+    }
+    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);
+        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 classMap = this.event.scope.getClassMap();
+        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 if (classMap.has(lowerVarName)) {
+            const classStmtLink = classMap.get(lowerVarName);
+            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.
@@ -586,7 +994,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 = [];
             }