brighterscript 1.0.0-alpha.5 → 1.0.0-alpha.51

package/dist/bscPlugin/validation/ScopeValidator.js

@@ -0,0 +1,1481 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScopeValidator = void 0;
+const path = require("path");
+const vscode_languageserver_1 = require("vscode-languageserver");
+const reflection_1 = require("../../astUtils/reflection");
+const DiagnosticMessages_1 = require("../../DiagnosticMessages");
+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");
+const DynamicType_1 = require("../../types/DynamicType");
+const BscTypeKind_1 = require("../../types/BscTypeKind");
+const BrightScriptDocParser_1 = require("../../parser/BrightScriptDocParser");
+const InvalidType_1 = require("../../types/InvalidType");
+const VoidType_1 = require("../../types/VoidType");
+const Logger_1 = require("../../Logger");
+const Stopwatch_1 = require("../../Stopwatch");
+const chalk_1 = require("chalk");
+const IntegerType_1 = require("../../types/IntegerType");
+/**
+ * The lower-case names of all platform-included scenegraph nodes
+ */
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+const platformNodeNames = roku_types_1.nodes ? new Set(Object.values(roku_types_1.nodes).map(x => x === null || x === void 0 ? void 0 : x.name.toLowerCase())) : new Set();
+const platformComponentNames = roku_types_1.components ? new Set(Object.values(roku_types_1.components).map(x => x === null || x === void 0 ? void 0 : x.name.toLowerCase())) : new Set();
+var ScopeValidatorDiagnosticTag;
+(function (ScopeValidatorDiagnosticTag) {
+    ScopeValidatorDiagnosticTag["Imports"] = "ScopeValidatorImports";
+    ScopeValidatorDiagnosticTag["NamespaceCollisions"] = "ScopeValidatorNamespaceCollisions";
+    ScopeValidatorDiagnosticTag["DuplicateFunctionDeclaration"] = "ScopeValidatorDuplicateFunctionDeclaration";
+    ScopeValidatorDiagnosticTag["FunctionCollisions"] = "ScopeValidatorFunctionCollisions";
+    ScopeValidatorDiagnosticTag["Classes"] = "ScopeValidatorClasses";
+    ScopeValidatorDiagnosticTag["XMLInterface"] = "ScopeValidatorXML";
+    ScopeValidatorDiagnosticTag["XMLImports"] = "ScopeValidatorXMLImports";
+    ScopeValidatorDiagnosticTag["Default"] = "ScopeValidator";
+    ScopeValidatorDiagnosticTag["Segment"] = "ScopeValidatorSegment";
+})(ScopeValidatorDiagnosticTag || (ScopeValidatorDiagnosticTag = {}));
+/**
+ * A validator that handles all scope validations for a program validation cycle.
+ * You should create ONE of these to handle all scope events between beforeValidateProgram and afterValidateProgram,
+ * and call reset() before using it again in the next cycle
+ */
+class ScopeValidator {
+    constructor() {
+        this.segmentsMetrics = new Map();
+        this.validationKindsMetrics = new Map();
+    }
+    processEvent(event) {
+        this.event = event;
+        if (this.event.program.globalScope === this.event.scope) {
+            return;
+        }
+        const logger = this.event.program.logger;
+        const metrics = {
+            fileWalkTime: '',
+            flagDuplicateFunctionTime: '',
+            classValidationTime: '',
+            scriptImportValidationTime: '',
+            xmlValidationTime: '',
+            circularConstTime: ''
+        };
+        this.segmentsMetrics.clear();
+        this.validationKindsMetrics.clear();
+        const validationStopwatch = new Stopwatch_1.Stopwatch();
+        logger.time(Logger_1.LogLevel.debug, ['Validating scope', this.event.scope.name], () => {
+            metrics.fileWalkTime = validationStopwatch.getDurationTextFor(() => {
+                this.walkFiles();
+            }).durationText;
+            this.currentSegmentBeingValidated = null;
+            metrics.flagDuplicateFunctionTime = validationStopwatch.getDurationTextFor(() => {
+                this.flagDuplicateFunctionDeclarations();
+            }).durationText;
+            metrics.scriptImportValidationTime = validationStopwatch.getDurationTextFor(() => {
+                this.validateScriptImportPaths();
+            }).durationText;
+            metrics.classValidationTime = validationStopwatch.getDurationTextFor(() => {
+                this.validateClasses();
+            }).durationText;
+            metrics.xmlValidationTime = validationStopwatch.getDurationTextFor(() => {
+                if ((0, reflection_1.isXmlScope)(this.event.scope)) {
+                    //detect when the child imports a script that its ancestor also imports
+                    this.diagnosticDetectDuplicateAncestorScriptImports(this.event.scope);
+                    //validate component interface
+                    this.validateXmlInterface(this.event.scope);
+                }
+            }).durationText;
+            metrics.circularConstTime = validationStopwatch.getDurationTextFor(() => {
+                this.detectCircularConstReferences();
+            }).durationText;
+        });
+        logger.debug(this.event.scope.name, 'segment metrics:');
+        let totalSegments = 0;
+        for (const [filePath, metric] of this.segmentsMetrics) {
+            this.event.program.logger.debug(' - ', filePath, metric.segments, metric.time);
+            totalSegments += metric.segments;
+        }
+        logger.debug(this.event.scope.name, 'total segments validated', totalSegments);
+        this.logValidationMetrics(metrics);
+    }
+    // eslint-disable-next-line @typescript-eslint/consistent-indexed-object-style
+    logValidationMetrics(metrics) {
+        let logs = [];
+        for (let key in metrics) {
+            logs.push(`${key}=${chalk_1.default.yellow(metrics[key].toString())}`);
+        }
+        this.event.program.logger.debug(`Validation Metrics (Scope: ${this.event.scope.name}): ${logs.join(', ')}`);
+        let kindsLogs = [];
+        const kindsArray = Array.from(this.validationKindsMetrics.keys()).sort();
+        for (let key of kindsArray) {
+            const timeData = this.validationKindsMetrics.get(key);
+            kindsLogs.push(`${key}=${chalk_1.default.yellow(timeData.timeMs.toFixed(3).toString()) + 'ms'} (${timeData.count})`);
+        }
+        this.event.program.logger.debug(`Validation Walk Metrics (Scope: ${this.event.scope.name}): ${kindsLogs.join(', ')}`);
+    }
+    reset() {
+        this.event = undefined;
+    }
+    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);
+            if (thisFileHasChanges || this.doesFileProvideChangedSymbol(file, this.event.changedSymbols)) {
+                this.diagnosticDetectFunctionCollisions(file);
+            }
+        });
+        const fileWalkStopWatch = new Stopwatch_1.Stopwatch();
+        this.event.scope.enumerateOwnFiles((file) => {
+            if ((0, reflection_1.isBrsFile)(file)) {
+                if (this.event.program.diagnostics.shouldFilterFile(file)) {
+                    return;
+                }
+                fileWalkStopWatch.reset();
+                fileWalkStopWatch.start();
+                const fileUri = util_1.util.pathToUri(file.srcPath);
+                const thisFileHasChanges = this.event.changedFiles.includes(file);
+                const hasUnvalidatedSegments = file.validationSegmenter.hasUnvalidatedSegments();
+                if (hasChangeInfo && !hasUnvalidatedSegments) {
+                    return;
+                }
+                const validationVisitor = (0, visitors_1.createVisitor)({
+                    VariableExpression: (varExpr) => {
+                        this.addValidationKindMetric('VariableExpression', () => {
+                            this.validateVariableAndDottedGetExpressions(file, varExpr);
+                        });
+                    },
+                    DottedGetExpression: (dottedGet) => {
+                        this.addValidationKindMetric('DottedGetExpression', () => {
+                            this.validateVariableAndDottedGetExpressions(file, dottedGet);
+                        });
+                    },
+                    CallExpression: (functionCall) => {
+                        this.addValidationKindMetric('CallExpression', () => {
+                            this.validateCallExpression(file, functionCall);
+                            this.validateCreateObjectCall(file, functionCall);
+                            this.validateComponentMethods(file, functionCall);
+                        });
+                    },
+                    CallfuncExpression: (functionCall) => {
+                        this.addValidationKindMetric('CallfuncExpression', () => {
+                            this.validateCallFuncExpression(file, functionCall);
+                        });
+                    },
+                    ReturnStatement: (returnStatement) => {
+                        this.addValidationKindMetric('ReturnStatement', () => {
+                            this.validateReturnStatement(file, returnStatement);
+                        });
+                    },
+                    DottedSetStatement: (dottedSetStmt) => {
+                        this.addValidationKindMetric('DottedSetStatement', () => {
+                            this.validateDottedSetStatement(file, dottedSetStmt);
+                        });
+                    },
+                    BinaryExpression: (binaryExpr) => {
+                        this.addValidationKindMetric('BinaryExpression', () => {
+                            this.validateBinaryExpression(file, binaryExpr);
+                        });
+                    },
+                    UnaryExpression: (unaryExpr) => {
+                        this.addValidationKindMetric('UnaryExpression', () => {
+                            this.validateUnaryExpression(file, unaryExpr);
+                        });
+                    },
+                    AssignmentStatement: (assignStmt) => {
+                        this.addValidationKindMetric('AssignmentStatement', () => {
+                            var _a;
+                            this.validateAssignmentStatement(file, assignStmt);
+                            // Note: this also includes For statements
+                            this.detectShadowedLocalVar(file, {
+                                expr: assignStmt,
+                                name: assignStmt.tokens.name.text,
+                                type: this.getNodeTypeWrapper(file, assignStmt, { flags: 1 /* SymbolTypeFlag.runtime */ }),
+                                nameRange: (_a = assignStmt.tokens.name.location) === null || _a === void 0 ? void 0 : _a.range
+                            });
+                        });
+                    },
+                    AugmentedAssignmentStatement: (binaryExpr) => {
+                        this.addValidationKindMetric('AugmentedAssignmentStatement', () => {
+                            this.validateBinaryExpression(file, binaryExpr);
+                        });
+                    },
+                    IncrementStatement: (stmt) => {
+                        this.addValidationKindMetric('IncrementStatement', () => {
+                            this.validateIncrementStatement(file, stmt);
+                        });
+                    },
+                    NewExpression: (newExpr) => {
+                        this.addValidationKindMetric('NewExpression', () => {
+                            this.validateNewExpression(file, newExpr);
+                        });
+                    },
+                    ForEachStatement: (forEachStmt) => {
+                        this.addValidationKindMetric('ForEachStatement', () => {
+                            var _a;
+                            this.detectShadowedLocalVar(file, {
+                                expr: forEachStmt,
+                                name: forEachStmt.tokens.item.text,
+                                type: this.getNodeTypeWrapper(file, forEachStmt, { flags: 1 /* SymbolTypeFlag.runtime */ }),
+                                nameRange: (_a = forEachStmt.tokens.item.location) === null || _a === void 0 ? void 0 : _a.range
+                            });
+                            this.validateForEachStatement(file, forEachStmt);
+                        });
+                    },
+                    FunctionParameterExpression: (funcParam) => {
+                        this.addValidationKindMetric('FunctionParameterExpression', () => {
+                            var _a;
+                            this.detectShadowedLocalVar(file, {
+                                expr: funcParam,
+                                name: funcParam.tokens.name.text,
+                                type: this.getNodeTypeWrapper(file, funcParam, { flags: 1 /* SymbolTypeFlag.runtime */ }),
+                                nameRange: (_a = funcParam.tokens.name.location) === null || _a === void 0 ? void 0 : _a.range
+                            });
+                        });
+                    },
+                    FunctionExpression: (func) => {
+                        if (file.isTypedef) {
+                            return;
+                        }
+                        this.addValidationKindMetric('FunctionExpression', () => {
+                            this.validateFunctionExpressionForReturn(func);
+                        });
+                    },
+                    ForStatement: (forStmt) => {
+                        this.addValidationKindMetric('ForStatement', () => {
+                            this.validateForStatement(file, forStmt);
+                        });
+                    },
+                    AAIndexedMemberExpression: (member) => {
+                        this.addValidationKindMetric('AAIndexedMemberExpression', () => {
+                            this.validateAAIndexedMemberExpression(file, member);
+                        });
+                    },
+                    AstNode: (node) => {
+                        //check for doc comments
+                        if (!node.leadingTrivia || node.leadingTrivia.filter(triviaToken => triviaToken.kind === TokenKind_1.TokenKind.Comment).length === 0) {
+                            return;
+                        }
+                        this.addValidationKindMetric('AstNode', () => {
+                            this.validateDocComments(node);
+                        });
+                    }
+                });
+                // validate only what's needed in the file
+                const segmentsToWalkForValidation = thisFileHasChanges
+                    ? file.validationSegmenter.getAllUnvalidatedSegments()
+                    : file.validationSegmenter.getSegmentsWithChangedSymbols(this.event.changedSymbols);
+                let segmentsValidated = 0;
+                if (thisFileHasChanges) {
+                    // clear all ScopeValidatorSegment diagnostics for this file
+                    this.event.program.diagnostics.clearByFilter({ scope: this.event.scope, fileUri: fileUri, tag: "ScopeValidatorSegment" /* ScopeValidatorDiagnosticTag.Segment */ });
+                }
+                for (const segment of segmentsToWalkForValidation) {
+                    if (!thisFileHasChanges && !file.validationSegmenter.checkIfSegmentNeedsRevalidation(segment, this.event.changedSymbols)) {
+                        continue;
+                    }
+                    this.currentSegmentBeingValidated = segment;
+                    if (!thisFileHasChanges) {
+                        // just clear the affected diagnostics
+                        this.event.program.diagnostics.clearByFilter({ scope: this.event.scope, fileUri: fileUri, segment: segment, tag: "ScopeValidatorSegment" /* ScopeValidatorDiagnosticTag.Segment */ });
+                    }
+                    segmentsValidated++;
+                    segment.walk(validationVisitor, {
+                        walkMode: AstValidationSegmenter_1.InsideSegmentWalkMode
+                    });
+                    file.markSegmentAsValidated(segment);
+                    this.currentSegmentBeingValidated = null;
+                }
+                fileWalkStopWatch.stop();
+                const timeString = fileWalkStopWatch.getDurationText();
+                this.segmentsMetrics.set(file.pkgPath, { segments: segmentsValidated, time: timeString });
+            }
+        });
+    }
+    addValidationKindMetric(name, funcToTime) {
+        if (!this.validationKindsMetrics.has(name)) {
+            this.validationKindsMetrics.set(name, { timeMs: 0, count: 0 });
+        }
+        const timeData = this.validationKindsMetrics.get(name);
+        const validationKindStopWatch = new Stopwatch_1.Stopwatch();
+        validationKindStopWatch.start();
+        funcToTime();
+        validationKindStopWatch.stop();
+        this.validationKindsMetrics.set(name, { timeMs: timeData.timeMs + validationKindStopWatch.totalMilliseconds, count: timeData.count + 1 });
+    }
+    validateAAIndexedMemberExpression(file, member) {
+        var _a, _b;
+        const scope = this.event.scope;
+        // Direct string literal (e.g. ["my-key"]) is valid
+        if ((0, reflection_1.isLiteralExpression)(member.key)) {
+            if (member.key.tokens.value.kind !== TokenKind_1.TokenKind.StringLiteral) {
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.computedAAKeyMustBeStringExpression()), { location: member.key.location }));
+            }
+            return;
+        }
+        const parts = util_1.util.getAllDottedGetParts(member.key);
+        //getAllDottedGetParts returns undefined for keys that aren't dotted-get / variable
+        //chains (e.g. arithmetic expressions like `[1 + 2]: "value"`). Those are not
+        //compile-time constants, so the diagnostic still applies.
+        if (!parts || parts.length === 0) {
+            this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.computedPropertyKeyMustBeConstantExpression()), { location: member.key.location }));
+            return;
+        }
+        const enclosingNamespace = (_b = (_a = member.key.findAncestor(reflection_1.isNamespaceStatement)) === null || _a === void 0 ? void 0 : _a.getName(Parser_1.ParseMode.BrighterScript)) === null || _b === void 0 ? void 0 : _b.toLowerCase();
+        const entityName = parts.map(p => p.text.toLowerCase()).join('.');
+        // Check enum member
+        const memberLink = scope.getEnumMemberFileLink(entityName, enclosingNamespace);
+        if (memberLink) {
+            const value = memberLink.item.getValue();
+            if (!(value === null || value === void 0 ? void 0 : value.startsWith('"'))) {
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.computedAAKeyMustBeStringExpression()), { location: member.key.location }));
+            }
+            return;
+        }
+        // Check const — follow the chain to find the root literal type
+        const constLink = scope.getConstFileLink(entityName, enclosingNamespace);
+        if (constLink) {
+            if (!this.constResolvesToString(constLink.item.value, enclosingNamespace, scope)) {
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.computedAAKeyMustBeStringExpression()), { location: member.key.location }));
+            }
+            return;
+        }
+        this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.computedPropertyKeyMustBeConstantExpression()), { location: member.key.location }));
+    }
+    /**
+     * Recursively resolve a const/enum reference to determine if its ultimate value is a string.
+     * Returns true only if the value is confirmed to be a string.
+     */
+    constResolvesToString(value, enclosingNamespace, scope, visited = new Set()) {
+        if ((0, reflection_1.isLiteralExpression)(value)) {
+            return value.tokens.value.kind === TokenKind_1.TokenKind.StringLiteral;
+        }
+        const parts = util_1.util.getAllDottedGetParts(value);
+        if (parts.length === 0) {
+            return false;
+        }
+        const entityName = parts.map(p => p.text.toLowerCase()).join('.');
+        if (visited.has(entityName)) {
+            return false; // circular reference — cannot confirm string
+        }
+        visited.add(entityName);
+        const constLink = scope.getConstFileLink(entityName, enclosingNamespace);
+        if (constLink) {
+            return this.constResolvesToString(constLink.item.value, enclosingNamespace, scope, visited);
+        }
+        const memberLink = scope.getEnumMemberFileLink(entityName, enclosingNamespace);
+        if (memberLink) {
+            return this.constResolvesToString(memberLink.item.value, enclosingNamespace, scope, visited);
+        }
+        return false;
+    }
+    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;
+    }
+    isTypeKnown(exprType) {
+        let isKnownType = exprType === null || exprType === void 0 ? void 0 : exprType.isResolvable();
+        return isKnownType;
+    }
+    getCircularReference(exprType) {
+        if (exprType === null || exprType === void 0 ? void 0 : exprType.isResolvable()) {
+            return { isCircularReference: false };
+        }
+        if ((0, reflection_1.isReferenceType)(exprType)) {
+            const info = exprType.getCircularReferenceInfo();
+            return info;
+        }
+        return { isCircularReference: false };
+    }
+    /**
+     * If this is the lhs of an assignment, we don't need to flag it as unresolved
+     */
+    hasValidDeclaration(expression, exprType, definingNode) {
+        var _a, _b;
+        if (!(0, reflection_1.isVariableExpression)(expression)) {
+            return false;
+        }
+        let assignmentAncestor;
+        if ((0, reflection_1.isAssignmentStatement)(definingNode) && definingNode.tokens.equals.kind === TokenKind_1.TokenKind.Equal) {
+            // this symbol was defined in a "normal" assignment (eg. not a compound assignment)
+            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);
+        }
+        return (assignmentAncestor === null || assignmentAncestor === void 0 ? void 0 : assignmentAncestor.tokens.name) === (expression === null || expression === void 0 ? void 0 : expression.tokens.name) && (0, reflection_1.isUnionType)(exprType);
+    }
+    /**
+     * Flag circular references between consts (e.g. const A = B; const B = A, or
+     * aggregate cycles like const A = { x: B }; const B = { y: A }). Without this
+     * check, the transpile pass silently emits unresolved refs at the cycle break
+     * point, producing code that fails at runtime.
+     *
+     * Mirrors the existing class-hierarchy circular-reference detection: each const
+     * starts its own walk, and an N-cycle produces N diagnostics (one rooted at
+     * each member of the cycle).
+     */
+    detectCircularConstReferences() {
+        const scope = this.event.scope;
+        const followConstRef = (expression, namespace, chain) => {
+            var _a, _b;
+            const parts = util_1.util.splitExpression(expression);
+            const processedNames = [];
+            for (const part of parts) {
+                if (!(0, reflection_1.isVariableExpression)(part) && !(0, reflection_1.isDottedGetExpression)(part)) {
+                    return;
+                }
+                processedNames.push((_b = (_a = part.tokens.name) === null || _a === void 0 ? void 0 : _a.text) === null || _b === void 0 ? void 0 : _b.toLowerCase());
+                const link = scope.getConstFileLink(processedNames.join('.'), namespace);
+                if (link) {
+                    walkConst(link.item, link.file, chain);
+                    return;
+                }
+            }
+        };
+        const walkConst = (constStatement, file, chain) => {
+            var _a;
+            const cycleStart = chain.indexOf(constStatement);
+            if (cycleStart >= 0) {
+                const items = chain.slice(cycleStart).map(c => c.fullName).concat(constStatement.fullName);
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.circularReferenceDetected(items)), { location: constStatement.tokens.name.location }));
+                return;
+            }
+            chain.push(constStatement);
+            const innerNamespace = (_a = constStatement.findAncestor(reflection_1.isNamespaceStatement)) === null || _a === void 0 ? void 0 : _a.getName(Parser_1.ParseMode.BrighterScript);
+            const value = constStatement.value;
+            if (value) {
+                if ((0, reflection_1.isVariableExpression)(value) || (0, reflection_1.isDottedGetExpression)(value)) {
+                    followConstRef(value, innerNamespace, chain);
+                }
+                else {
+                    value.walk((0, visitors_1.createVisitor)({
+                        VariableExpression: (varExpr) => {
+                            if ((0, reflection_1.isDottedGetExpression)(varExpr.parent)) {
+                                return;
+                            }
+                            followConstRef(varExpr, innerNamespace, chain);
+                        },
+                        DottedGetExpression: (dottedExpr) => {
+                            if ((0, reflection_1.isDottedGetExpression)(dottedExpr.parent)) {
+                                return;
+                            }
+                            followConstRef(dottedExpr, innerNamespace, chain);
+                        }
+                    }), { walkMode: visitors_1.WalkMode.visitExpressionsRecursive });
+                }
+            }
+            chain.pop();
+        };
+        for (const [, link] of scope.getConstMap()) {
+            walkConst(link.item, link.file, []);
+        }
+    }
+    /**
+     * Validate every function call to `CreateObject`.
+     * Ideally we would create better type checking/handling for this, but in the mean time, we know exactly
+     * what these calls are supposed to look like, and this is a very common thing for brs devs to do, so just
+     * do this manually for now.
+     */
+    validateCreateObjectCall(file, call) {
+        var _a, _b, _c, _d, _e;
+        //skip non CreateObject function calls
+        const callName = (_a = util_1.util.getAllDottedGetPartsAsString(call.callee)) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        if (callName !== 'createobject' || !(0, reflection_1.isLiteralExpression)(call === null || call === void 0 ? void 0 : call.args[0])) {
+            return;
+        }
+        const firstParamToken = (_c = (_b = call === null || call === void 0 ? void 0 : call.args[0]) === null || _b === void 0 ? void 0 : _b.tokens) === null || _c === void 0 ? void 0 : _c.value;
+        const firstParamStringValue = (_d = firstParamToken === null || firstParamToken === void 0 ? void 0 : firstParamToken.text) === null || _d === void 0 ? void 0 : _d.replace(/"/g, '');
+        if (!firstParamStringValue) {
+            return;
+        }
+        const firstParamStringValueLower = firstParamStringValue.toLowerCase();
+        //if this is a `createObject('roSGNode'` call, only support known sg node types
+        if (firstParamStringValueLower === 'rosgnode' && (0, reflection_1.isLiteralExpression)(call === null || call === void 0 ? void 0 : call.args[1])) {
+            const componentName = (_e = call === null || call === void 0 ? void 0 : call.args[1]) === null || _e === void 0 ? void 0 : _e.tokens.value;
+            this.checkComponentName(componentName);
+            if ((call === null || call === void 0 ? void 0 : call.args.length) !== 2) {
+                // roSgNode should only ever have 2 args in `createObject`
+                this.addDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.mismatchCreateObjectArgumentCount(firstParamStringValue, [2], call === null || call === void 0 ? void 0 : call.args.length)), { location: call.location }));
+            }
+        }
+        else if (!platformComponentNames.has(firstParamStringValueLower)) {
+            this.addDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unknownBrightScriptComponent(firstParamStringValue)), { location: firstParamToken.location }));
+        }
+        else {
+            // This is valid brightscript component
+            // Test for invalid arg counts
+            const brightScriptComponent = roku_types_1.components[firstParamStringValueLower];
+            // Valid arg counts for createObject are 1+ number of args for constructor
+            let validArgCounts = brightScriptComponent === null || brightScriptComponent === void 0 ? void 0 : brightScriptComponent.constructors.map(cnstr => cnstr.params.length + 1);
+            if (validArgCounts.length === 0) {
+                // no constructors for this component, so createObject only takes 1 arg
+                validArgCounts = [1];
+            }
+            if (!validArgCounts.includes(call === null || call === void 0 ? void 0 : call.args.length)) {
+                // Incorrect number of arguments included in `createObject()`
+                this.addDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.mismatchCreateObjectArgumentCount(firstParamStringValue, validArgCounts, call === null || call === void 0 ? void 0 : call.args.length)), { location: call.location }));
+            }
+            // Test for deprecation
+            if (brightScriptComponent === null || brightScriptComponent === void 0 ? void 0 : brightScriptComponent.isDeprecated) {
+                this.addDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.itemIsDeprecated(firstParamStringValue, brightScriptComponent.deprecatedDescription)), { location: call.location }));
+            }
+        }
+    }
+    checkComponentName(componentName) {
+        var _a, _b;
+        //don't validate any components with a colon in their name (probably component libraries, but regular components can have them too).
+        if (!componentName || ((_a = componentName === null || componentName === void 0 ? void 0 : componentName.text) === null || _a === void 0 ? void 0 : _a.includes(':'))) {
+            return;
+        }
+        //add diagnostic for unknown components
+        const unquotedComponentName = (_b = componentName === null || componentName === void 0 ? void 0 : componentName.text) === null || _b === void 0 ? void 0 : _b.replace(/"/g, '');
+        if (unquotedComponentName && !platformNodeNames.has(unquotedComponentName.toLowerCase()) && !this.event.program.getComponent(unquotedComponentName)) {
+            this.addDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unknownRoSGNode(unquotedComponentName)), { location: componentName.location }));
+        }
+    }
+    /**
+     * Validate every method call to `component.callfunc()`, `component.createChild()`, etc.
+     */
+    validateComponentMethods(file, call) {
+        var _a, _b, _c, _d, _e;
+        const lowerMethodNamesChecked = ['callfunc', 'createchild'];
+        if (!(0, reflection_1.isDottedGetExpression)(call.callee)) {
+            return;
+        }
+        const callName = (_c = (_b = (_a = call.callee.tokens) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.text) === null || _c === void 0 ? void 0 : _c.toLowerCase();
+        if (!callName || !lowerMethodNamesChecked.includes(callName) || !(0, reflection_1.isLiteralExpression)(call === null || call === void 0 ? void 0 : call.args[0])) {
+            return;
+        }
+        const callerType = (_d = call.callee.obj) === null || _d === void 0 ? void 0 : _d.getType({ flags: 1 /* SymbolTypeFlag.runtime */ });
+        if (!(0, reflection_1.isCallFuncableTypeLike)(callerType)) {
+            return;
+        }
+        const firstArgToken = (_e = call === null || call === void 0 ? void 0 : call.args[0]) === null || _e === void 0 ? void 0 : _e.tokens.value;
+        if (callName === 'createchild') {
+            this.checkComponentName(firstArgToken);
+        }
+        else if (callName === 'callfunc' && !util_1.util.isGenericNodeType(callerType)) {
+            const funcType = util_1.util.getCallFuncType(call, firstArgToken, { flags: 1 /* SymbolTypeFlag.runtime */, ignoreCall: true });
+            if (!(funcType === null || funcType === void 0 ? void 0 : funcType.isResolvable())) {
+                const functionName = firstArgToken.text.replace(/"/g, '');
+                const functionFullname = `${callerType.toString()}@.${functionName}`;
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotFindCallFuncFunction(functionName, functionFullname, callerType.toString())), { location: firstArgToken === null || firstArgToken === void 0 ? void 0 : firstArgToken.location }));
+            }
+            else {
+                this.validateFunctionCall(file, call, funcType, firstArgToken.location, call.args, 1);
+            }
+        }
+    }
+    validateCallExpression(file, expression) {
+        var _a;
+        const getTypeOptions = { flags: 1 /* SymbolTypeFlag.runtime */, data: {} };
+        let funcType = this.getNodeTypeWrapper(file, expression === null || expression === void 0 ? void 0 : expression.callee, getTypeOptions);
+        if ((funcType === null || funcType === void 0 ? void 0 : funcType.isResolvable()) && (0, reflection_1.isClassType)(funcType)) {
+            // We're calling a class - get the constructor
+            funcType = funcType.getMemberType('new', getTypeOptions);
+        }
+        const callErrorLocation = (_a = expression === null || expression === void 0 ? void 0 : expression.callee) === null || _a === void 0 ? void 0 : _a.location;
+        return this.validateFunctionCall(file, expression.callee, funcType, callErrorLocation, expression.args);
+    }
+    validateCallFuncExpression(file, expression) {
+        var _a, _b;
+        const callerType = (_a = expression.callee) === null || _a === void 0 ? void 0 : _a.getType({ flags: 1 /* SymbolTypeFlag.runtime */ });
+        if ((0, reflection_1.isDynamicType)(callerType)) {
+            return;
+        }
+        const methodToken = expression.tokens.methodName;
+        const methodName = (_b = methodToken === null || methodToken === void 0 ? void 0 : methodToken.text) !== null && _b !== void 0 ? _b : '';
+        if (!methodName) {
+            return;
+        }
+        const functionFullname = `${callerType.toString()}@.${methodName}`;
+        const callErrorLocation = expression.location;
+        if (util_1.util.isGenericNodeType(callerType) || (0, reflection_1.isObjectType)(callerType) || (0, reflection_1.isDynamicType)(callerType)) {
+            // ignore "general" node
+            return;
+        }
+        const funcType = util_1.util.getCallFuncType(expression, methodToken, { flags: 1 /* SymbolTypeFlag.runtime */, ignoreCall: true });
+        if (!(funcType === null || funcType === void 0 ? void 0 : funcType.isResolvable())) {
+            this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotFindCallFuncFunction(methodName, functionFullname, callerType.toString())), { location: callErrorLocation }));
+        }
+        return this.validateFunctionCall(file, expression, funcType, callErrorLocation, expression.args);
+    }
+    /**
+     * Detect calls to functions with the incorrect number of parameters, or wrong types of arguments
+     */
+    validateFunctionCall(file, callee, funcType, callErrorLocation, args, argOffset = 0) {
+        var _a, _b, _c;
+        while ((0, reflection_1.isTypeStatementType)(funcType)) {
+            funcType = funcType.wrappedType;
+        }
+        if (!(funcType === null || funcType === void 0 ? void 0 : funcType.isResolvable()) || !(0, reflection_1.isCallableType)(funcType) || (0, reflection_1.isCompoundType)(funcType)) {
+            const funcName = util_1.util.getAllDottedGetPartsAsString(callee, Parser_1.ParseMode.BrighterScript, (0, reflection_1.isCallfuncExpression)(callee) ? '@.' : '.');
+            if ((0, reflection_1.isUnionType)(funcType)) {
+                if (!util_1.util.isUnionOfFunctions(funcType) && !(0, reflection_1.isCallfuncExpression)(callee)) {
+                    // union of func and non func. not callable
+                    this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.notCallable(funcName)), { location: callErrorLocation }));
+                    return;
+                }
+                const callablesInUnion = funcType.types.filter(reflection_1.isCallableType);
+                const funcsInUnion = callablesInUnion.filter(reflection_1.isTypedFunctionType);
+                if (funcsInUnion.length < callablesInUnion.length) {
+                    // potentially a non-typed func in union
+                    // cannot validate
+                    return;
+                }
+                // check all funcs to see if they work
+                for (let i = 1; i < funcsInUnion.length; i++) {
+                    const compatibilityData = {};
+                    if (!funcsInUnion[0].isTypeCompatible(funcsInUnion[i], compatibilityData)) {
+                        if (!compatibilityData.returnTypeMismatch) {
+                            // param differences!
+                            this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.incompatibleSymbolDefinition(funcName, { isUnion: true, data: compatibilityData })), { location: callErrorLocation }));
+                            return;
+                        }
+                    }
+                }
+                // The only thing different was return type
+                funcType = util_1.util.getFunctionTypeFromUnion(funcType);
+            }
+            if (funcType && !(0, reflection_1.isCallableType)(funcType) && !(0, reflection_1.isReferenceType)(funcType)) {
+                const globalFuncWithVarName = globalCallables_1.globalCallableMap.get(funcName.toLowerCase());
+                if (globalFuncWithVarName) {
+                    funcType = globalFuncWithVarName.type;
+                }
+                else {
+                    this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.notCallable(funcName)), { location: callErrorLocation }));
+                    return;
+                }
+            }
+        }
+        if (!(0, reflection_1.isTypedFunctionType)(funcType)) {
+            // non typed function. nothing to check
+            return;
+        }
+        //get min/max parameter count for callable
+        let minParams = 0;
+        let maxParams = 0;
+        for (let param of funcType.params) {
+            maxParams++;
+            //optional parameters must come last, so we can assume that minParams won't increase once we hit
+            //the first isOptional
+            if (param.isOptional !== true) {
+                minParams++;
+            }
+        }
+        if (funcType.isVariadic) {
+            // function accepts variable number of arguments
+            maxParams = Expression_1.CallExpression.MaximumArguments;
+        }
+        const argsForCall = argOffset < 1 ? args : args.slice(argOffset);
+        let expCallArgCount = argsForCall.length;
+        if (expCallArgCount > maxParams || expCallArgCount < minParams) {
+            let minMaxParamsText = minParams === maxParams ? maxParams + argOffset : `${minParams + argOffset}-${maxParams + argOffset}`;
+            this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.mismatchArgumentCount(minMaxParamsText, expCallArgCount + argOffset)), { location: callErrorLocation }));
+        }
+        let paramIndex = 0;
+        for (let arg of argsForCall) {
+            const data = {};
+            let argType = this.getNodeTypeWrapper(file, arg, { flags: 1 /* SymbolTypeFlag.runtime */, data: data });
+            const paramType = (_a = funcType.params[paramIndex]) === null || _a === void 0 ? void 0 : _a.type;
+            if (!paramType) {
+                // unable to find a paramType -- maybe there are more args than params
+                break;
+            }
+            if ((0, reflection_1.isCallableType)(paramType) && (0, reflection_1.isClassType)(argType) && (0, reflection_1.isClassStatement)(data.definingNode)) {
+                argType = data.definingNode.getConstructorType();
+            }
+            const compatibilityData = {};
+            const isAllowedArgConversion = this.checkAllowedArgConversions(paramType, argType);
+            if (!isAllowedArgConversion && !(paramType === null || paramType === void 0 ? void 0 : paramType.isTypeCompatible(argType, compatibilityData))) {
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.argumentTypeMismatch((_b = argType === null || argType === void 0 ? void 0 : argType.toString()) !== null && _b !== void 0 ? _b : 'unknown', (_c = paramType === null || paramType === void 0 ? void 0 : paramType.toString()) !== null && _c !== void 0 ? _c : 'unknown', compatibilityData)), { location: arg.location }));
+            }
+            paramIndex++;
+        }
+    }
+    checkAllowedArgConversions(paramType, argType) {
+        if ((0, reflection_1.isNumberTypeLike)(argType) && (0, reflection_1.isBooleanTypeLike)(paramType)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Detect return statements with incompatible types vs. declared return type
+     */
+    validateReturnStatement(file, returnStmt) {
+        var _a, _b, _c;
+        const data = {};
+        const getTypeOptions = { flags: 1 /* SymbolTypeFlag.runtime */, data: data };
+        let funcType = (_a = returnStmt.findAncestor(reflection_1.isFunctionExpression)) === null || _a === void 0 ? void 0 : _a.getType({ flags: 2 /* SymbolTypeFlag.typetime */ });
+        if ((0, reflection_1.isTypedFunctionType)(funcType)) {
+            let actualReturnType = (returnStmt === null || returnStmt === void 0 ? void 0 : returnStmt.value)
+                ? this.getNodeTypeWrapper(file, returnStmt === null || returnStmt === void 0 ? void 0 : returnStmt.value, getTypeOptions)
+                : VoidType_1.VoidType.instance;
+            const compatibilityData = {};
+            // `return` statement by itself in non-built-in function will actually result in `invalid`
+            const valueReturnType = (0, reflection_1.isVoidType)(actualReturnType) ? InvalidType_1.InvalidType.instance : actualReturnType;
+            if (funcType.returnType.isResolvable()) {
+                if (!(returnStmt === null || returnStmt === void 0 ? void 0 : returnStmt.value) && (0, reflection_1.isVoidType)(funcType.returnType)) {
+                    // allow empty return when function is return `as void`
+                    // eslint-disable-next-line no-useless-return
+                    return;
+                }
+                else if (!funcType.returnType.isTypeCompatible(valueReturnType, compatibilityData)) {
+                    this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.returnTypeMismatch(actualReturnType.toString(), funcType.returnType.toString(), compatibilityData)), { location: (_c = (_b = returnStmt.value) === null || _b === void 0 ? void 0 : _b.location) !== null && _c !== void 0 ? _c : returnStmt.location }));
+                }
+            }
+        }
+    }
+    /**
+     * Detect assigned type different from expected member type
+     */
+    validateDottedSetStatement(file, dottedSetStmt) {
+        var _a, _b, _c;
+        const typeChainExpectedLHS = [];
+        const getTypeOpts = { flags: 1 /* SymbolTypeFlag.runtime */ };
+        const expectedLHSType = this.getNodeTypeWrapper(file, dottedSetStmt, Object.assign(Object.assign({}, getTypeOpts), { data: {}, typeChain: typeChainExpectedLHS }));
+        const actualRHSType = this.getNodeTypeWrapper(file, dottedSetStmt === null || dottedSetStmt === void 0 ? void 0 : dottedSetStmt.value, getTypeOpts);
+        const compatibilityData = {};
+        const typeChainScan = util_1.util.processTypeChain(typeChainExpectedLHS);
+        // check if anything in typeChain is an AA - if so, just allow it
+        if (typeChainExpectedLHS.find(typeChainItem => (0, reflection_1.isAssociativeArrayType)(typeChainItem.type))) {
+            // something in the chain is an AA
+            // treat members as dynamic - they could have been set without the type system's knowledge
+            return;
+        }
+        if (!expectedLHSType || !(expectedLHSType === null || expectedLHSType === void 0 ? void 0 : expectedLHSType.isResolvable())) {
+            this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotFindName(typeChainScan.itemName, typeChainScan.fullNameOfItem, typeChainScan.itemParentTypeName, this.getParentTypeDescriptor(typeChainScan))), { location: typeChainScan === null || typeChainScan === void 0 ? void 0 : typeChainScan.location }));
+            return;
+        }
+        let accessibilityIsOk = this.checkMemberAccessibility(file, dottedSetStmt, typeChainExpectedLHS);
+        //Most Component fields can be set with strings
+        //TODO: be more precise about which fields can actually accept strings
+        //TODO: if RHS is a string literal, we can do more validation to make sure it's the correct type
+        if ((0, reflection_1.isComponentType)((_a = dottedSetStmt.obj) === null || _a === void 0 ? void 0 : _a.getType({ flags: 1 /* SymbolTypeFlag.runtime */ }))) {
+            if ((0, reflection_1.isStringTypeLike)(actualRHSType)) {
+                return;
+            }
+        }
+        if (accessibilityIsOk && !(expectedLHSType === null || expectedLHSType === void 0 ? void 0 : expectedLHSType.isTypeCompatible(actualRHSType, compatibilityData))) {
+            this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.assignmentTypeMismatch((_b = actualRHSType === null || actualRHSType === void 0 ? void 0 : actualRHSType.toString()) !== null && _b !== void 0 ? _b : 'unknown', (_c = expectedLHSType === null || expectedLHSType === void 0 ? void 0 : expectedLHSType.toString()) !== null && _c !== void 0 ? _c : 'unknown', compatibilityData)), { location: dottedSetStmt.location }));
+        }
+    }
+    /**
+     * Detect when declared type does not match rhs type
+     */
+    validateAssignmentStatement(file, assignStmt) {
+        if (!(assignStmt === null || assignStmt === void 0 ? void 0 : assignStmt.typeExpression)) {
+            // nothing to check
+            return;
+        }
+        const typeChainExpectedLHS = [];
+        const getTypeOpts = { flags: 1 /* SymbolTypeFlag.runtime */ };
+        const expectedLHSType = this.getNodeTypeWrapper(file, assignStmt.typeExpression, Object.assign(Object.assign({}, getTypeOpts), { data: {}, typeChain: typeChainExpectedLHS }));
+        const actualRHSType = this.getNodeTypeWrapper(file, assignStmt.value, getTypeOpts);
+        const compatibilityData = {};
+        if (!expectedLHSType || !expectedLHSType.isResolvable()) {
+            // LHS is not resolvable... handled elsewhere
+        }
+        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)), { location: assignStmt.location }));
+        }
+    }
+    /**
+     * Detect invalid use of a binary operator
+     */
+    validateBinaryExpression(file, binaryExpr) {
+        const getTypeOpts = { flags: 1 /* SymbolTypeFlag.runtime */ };
+        if (util_1.util.isInTypeExpression(binaryExpr)) {
+            return;
+        }
+        let leftType = (0, reflection_1.isBinaryExpression)(binaryExpr)
+            ? this.getNodeTypeWrapper(file, binaryExpr.left, getTypeOpts)
+            : this.getNodeTypeWrapper(file, binaryExpr.item, getTypeOpts);
+        let rightType = (0, reflection_1.isBinaryExpression)(binaryExpr)
+            ? this.getNodeTypeWrapper(file, binaryExpr.right, getTypeOpts)
+            : this.getNodeTypeWrapper(file, binaryExpr.value, getTypeOpts);
+        if (!leftType || !rightType || !leftType.isResolvable() || !rightType.isResolvable()) {
+            // Can not find the type. error handled elsewhere
+            return;
+        }
+        let leftTypeToTest = leftType;
+        let rightTypeToTest = rightType;
+        if ((0, reflection_1.isEnumMemberType)(leftType) || (0, reflection_1.isEnumType)(leftType)) {
+            leftTypeToTest = leftType.underlyingType;
+        }
+        if ((0, reflection_1.isEnumMemberType)(rightType) || (0, reflection_1.isEnumType)(rightType)) {
+            rightTypeToTest = rightType.underlyingType;
+        }
+        if ((0, reflection_1.isUnionType)(leftType) || (0, reflection_1.isUnionType)(rightType)) {
+            // TODO: it is possible to validate based on innerTypes, but more complicated
+            // Because you need to verify each combination of types
+            return;
+        }
+        const opResult = util_1.util.binaryOperatorResultType(leftTypeToTest, binaryExpr.tokens.operator, rightTypeToTest);
+        if (!opResult) {
+            // if the result was dynamic or void, that means there wasn't a valid operation
+            this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.operatorTypeMismatch(binaryExpr.tokens.operator.text, leftType.toString(), rightType.toString())), { location: binaryExpr.location }));
+        }
+    }
+    /**
+     * Detect invalid use of a Unary operator
+     */
+    validateUnaryExpression(file, unaryExpr) {
+        const getTypeOpts = { flags: 1 /* SymbolTypeFlag.runtime */ };
+        let rightType = this.getNodeTypeWrapper(file, unaryExpr.right, getTypeOpts);
+        if (!rightType.isResolvable()) {
+            // Can not find the type. error handled elsewhere
+            return;
+        }
+        let rightTypeToTest = rightType;
+        if ((0, reflection_1.isEnumMemberType)(rightType)) {
+            rightTypeToTest = rightType.underlyingType;
+        }
+        if ((0, reflection_1.isUnionType)(rightTypeToTest)) {
+            // TODO: it is possible to validate based on innerTypes, but more complicated
+            // Because you need to verify each combination of types
+        }
+        else if ((0, reflection_1.isDynamicType)(rightTypeToTest) || (0, reflection_1.isObjectType)(rightTypeToTest)) {
+            // operand is basically "any" type... ignore;
+        }
+        else if ((0, reflection_1.isPrimitiveType)(rightType)) {
+            const opResult = util_1.util.unaryOperatorResultType(unaryExpr.tokens.operator, rightTypeToTest);
+            if (!opResult) {
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.operatorTypeMismatch(unaryExpr.tokens.operator.text, rightType.toString())), { location: unaryExpr.location }));
+            }
+        }
+        else {
+            // rhs is not a primitive, so no binary operator is allowed
+            this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.operatorTypeMismatch(unaryExpr.tokens.operator.text, rightType.toString())), { location: unaryExpr.location }));
+        }
+    }
+    validateIncrementStatement(file, incStmt) {
+        const getTypeOpts = { flags: 1 /* SymbolTypeFlag.runtime */ };
+        let rightType = this.getNodeTypeWrapper(file, incStmt.value, getTypeOpts);
+        if (!rightType.isResolvable()) {
+            // Can not find the type. error handled elsewhere
+            return;
+        }
+        if ((0, reflection_1.isUnionType)(rightType)) {
+            // TODO: it is possible to validate based on innerTypes, but more complicated
+            // because you need to verify each combination of types
+        }
+        else if ((0, reflection_1.isDynamicType)(rightType) || (0, reflection_1.isObjectType)(rightType)) {
+            // operand is basically "any" type... ignore
+        }
+        else if ((0, reflection_1.isNumberTypeLike)(rightType)) {
+            // operand is a number.. this is ok
+        }
+        else {
+            // rhs is not a number, so no increment operator is not allowed
+            this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.operatorTypeMismatch(incStmt.tokens.operator.text, rightType.toString())), { location: incStmt.location }));
+        }
+    }
+    validateVariableAndDottedGetExpressions(file, expression) {
+        var _a, _b, _c, _d;
+        if ((0, reflection_1.isDottedGetExpression)(expression.parent)) {
+            // We validate dottedGetExpressions at the top-most level
+            return;
+        }
+        if ((0, reflection_1.isVariableExpression)(expression)) {
+            if ((0, reflection_1.isAssignmentStatement)(expression.parent) && expression.parent.tokens.name === expression.tokens.name) {
+                // Don't validate LHS of assignments
+                return;
+            }
+            else if ((0, reflection_1.isNamespaceStatement)(expression.parent)) {
+                return;
+            }
+        }
+        let symbolType = 1 /* SymbolTypeFlag.runtime */;
+        let oppositeSymbolType = 2 /* SymbolTypeFlag.typetime */;
+        const isUsedAsType = util_1.util.isInTypeExpression(expression);
+        if (isUsedAsType) {
+            // This is used in a TypeExpression - only look up types from SymbolTable
+            symbolType = 2 /* SymbolTypeFlag.typetime */;
+            oppositeSymbolType = 1 /* SymbolTypeFlag.runtime */;
+            //roku built-in type names (rosgnode*, ifArray, etc.) aren't tracked in any
+            //symbol table; skip cannot-find-name validation when used as a type.
+            if ((0, reflection_1.isVariableExpression)(expression) && util_1.util.isBuiltInType(expression.tokens.name.text)) {
+                return;
+            }
+        }
+        // Do a complete type check on all DottedGet and Variable expressions
+        // this will create a diagnostic if an invalid member is accessed
+        const typeChain = [];
+        const typeData = {};
+        let exprType = this.getNodeTypeWrapper(file, expression, {
+            flags: symbolType,
+            typeChain: typeChain,
+            data: typeData
+        });
+        const hasValidDeclaration = this.hasValidDeclaration(expression, exprType, typeData === null || typeData === void 0 ? void 0 : typeData.definingNode);
+        //include a hint diagnostic if this type is marked as deprecated
+        if (typeData.flags & 64 /* SymbolTypeFlag.deprecated */) { // eslint-disable-line no-bitwise
+            this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.itemIsDeprecated()), { location: expression.tokens.name.location, tags: [vscode_languageserver_1.DiagnosticTag.Deprecated] }));
+        }
+        if (!this.isTypeKnown(exprType) && !hasValidDeclaration) {
+            if ((_a = this.getNodeTypeWrapper(file, expression, { flags: oppositeSymbolType, isExistenceTest: true })) === null || _a === void 0 ? void 0 : _a.isResolvable()) {
+                const oppoSiteTypeChain = [];
+                const invalidlyUsedResolvedType = this.getNodeTypeWrapper(file, expression, { flags: oppositeSymbolType, typeChain: oppoSiteTypeChain, isExistenceTest: true });
+                const typeChainScan = util_1.util.processTypeChain(oppoSiteTypeChain);
+                if (isUsedAsType) {
+                    this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.itemCannotBeUsedAsType(typeChainScan.fullChainName)), { location: expression.location }));
+                }
+                else if (invalidlyUsedResolvedType && !(0, reflection_1.isReferenceType)(invalidlyUsedResolvedType)) {
+                    if (!(0, reflection_1.isAliasStatement)(expression.parent)) {
+                        // alias rhs CAN be a type!
+                        this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.itemCannotBeUsedAsVariable(invalidlyUsedResolvedType.toString())), { location: expression.location }));
+                    }
+                }
+                else {
+                    const typeChainScan = util_1.util.processTypeChain(typeChain);
+                    //if this is a function call, provide a different diagnostic code
+                    if ((0, reflection_1.isCallExpression)(typeChainScan.astNode.parent) && typeChainScan.astNode.parent.callee === expression) {
+                        this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotFindFunction(typeChainScan.itemName, typeChainScan.fullNameOfItem, typeChainScan.itemParentTypeName, this.getParentTypeDescriptor(typeChainScan))), { location: typeChainScan === null || typeChainScan === void 0 ? void 0 : typeChainScan.location }));
+                    }
+                    else {
+                        this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotFindName(typeChainScan.itemName, typeChainScan.fullNameOfItem, typeChainScan.itemParentTypeName, this.getParentTypeDescriptor(typeChainScan))), { location: typeChainScan === null || typeChainScan === void 0 ? void 0 : typeChainScan.location }));
+                    }
+                }
+            }
+            else if (!(typeData === null || typeData === void 0 ? void 0 : typeData.isFromDocComment)) {
+                // only show "cannot find... " errors if the type is not defined from a doc comment
+                const typeChainScan = util_1.util.processTypeChain(typeChain);
+                const circularReferenceInfo = this.getCircularReference(exprType);
+                if ((0, reflection_1.isCallExpression)(typeChainScan.astNode.parent) && typeChainScan.astNode.parent.callee === expression) {
+                    this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotFindFunction(typeChainScan.itemName, typeChainScan.fullNameOfItem, typeChainScan.itemParentTypeName, this.getParentTypeDescriptor(typeChainScan))), { location: typeChainScan === null || typeChainScan === void 0 ? void 0 : typeChainScan.location }));
+                }
+                else if (circularReferenceInfo === null || circularReferenceInfo === void 0 ? void 0 : circularReferenceInfo.isCircularReference) {
+                    let diagnosticDetail = util_1.util.getCircularReferenceDiagnosticDetail(circularReferenceInfo, typeChainScan.fullNameOfItem);
+                    this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.circularReferenceDetected(diagnosticDetail)), { location: typeChainScan === null || typeChainScan === void 0 ? void 0 : typeChainScan.location }));
+                }
+                else {
+                    this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotFindName(typeChainScan.itemName, typeChainScan.fullNameOfItem, typeChainScan.itemParentTypeName, this.getParentTypeDescriptor(typeChainScan))), { location: typeChainScan === null || typeChainScan === void 0 ? void 0 : typeChainScan.location }));
+                }
+            }
+        }
+        if (isUsedAsType) {
+            return;
+        }
+        const containingNamespace = expression.findAncestor(reflection_1.isNamespaceStatement);
+        const containingNamespaceName = containingNamespace === null || containingNamespace === void 0 ? void 0 : containingNamespace.getName(Parser_1.ParseMode.BrighterScript);
+        if (!((0, reflection_1.isCallExpression)(expression.parent) && (0, reflection_1.isNewExpression)((_b = expression.parent) === null || _b === void 0 ? void 0 : _b.parent))) {
+            const classUsedAsVarEntry = this.checkTypeChainForClassUsedAsVar(typeChain, containingNamespaceName);
+            const isClassInNamespace = containingNamespace === null || containingNamespace === void 0 ? void 0 : containingNamespace.getSymbolTable().hasSymbol(typeChain[0].name, 1 /* SymbolTypeFlag.runtime */);
+            if (classUsedAsVarEntry && !isClassInNamespace) {
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.itemCannotBeUsedAsVariable(classUsedAsVarEntry.toString())), { location: expression.location }));
+                return;
+            }
+        }
+        const lastTypeInfo = typeChain[typeChain.length - 1];
+        const parentTypeInfo = typeChain[typeChain.length - 2];
+        this.checkMemberAccessibility(file, expression, typeChain);
+        if ((0, reflection_1.isNamespaceType)(exprType) && !(0, reflection_1.isAliasStatement)(expression.parent)) {
+            this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.itemCannotBeUsedAsVariable('namespace')), { location: expression.location }));
+        }
+        else if ((0, reflection_1.isEnumType)(exprType) && !(0, reflection_1.isAliasStatement)(expression.parent)) {
+            const enumStatement = this.event.scope.getEnum(util_1.util.getAllDottedGetPartsAsString(expression));
+            if (enumStatement) {
+                // there's an enum with this name
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.itemCannotBeUsedAsVariable('enum')), { location: expression.location }));
+            }
+        }
+        else if ((0, reflection_1.isDynamicType)(exprType) && (0, reflection_1.isEnumType)(parentTypeInfo === null || parentTypeInfo === void 0 ? void 0 : parentTypeInfo.type) && (0, reflection_1.isDottedGetExpression)(expression)) {
+            const enumFileLink = this.event.scope.getEnumFileLink(util_1.util.getAllDottedGetPartsAsString(expression.obj));
+            const typeChainScanForItem = util_1.util.processTypeChain(typeChain);
+            const typeChainScanForParent = util_1.util.processTypeChain(typeChain.slice(0, -1));
+            if (enumFileLink) {
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotFindName(lastTypeInfo === null || lastTypeInfo === void 0 ? void 0 : lastTypeInfo.name, typeChainScanForItem.fullChainName, typeChainScanForParent.fullNameOfItem, 'enum')), { location: lastTypeInfo === null || lastTypeInfo === void 0 ? void 0 : lastTypeInfo.location, relatedInformation: [{
+                            message: 'Enum declared here',
+                            location: util_1.util.createLocationFromRange(util_1.util.pathToUri(enumFileLink === null || enumFileLink === void 0 ? void 0 : enumFileLink.file.srcPath), (_d = (_c = enumFileLink === null || enumFileLink === void 0 ? void 0 : enumFileLink.item) === null || _c === void 0 ? void 0 : _c.tokens.name.location) === null || _d === void 0 ? void 0 : _d.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.astNode || ignoreKinds.includes(tce.astNode.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
+     *
+     * @param file file
+     * @param expression containing expression
+     * @param typeChain type chain to check
+     * @returns true if member accesiibility is okay
+     */
+    checkMemberAccessibility(file, expression, typeChain) {
+        var _a, _b, _c;
+        for (let i = 0; i < typeChain.length - 1; i++) {
+            const parentChainItem = typeChain[i];
+            const childChainItem = typeChain[i + 1];
+            if ((0, reflection_1.isClassType)(parentChainItem.type)) {
+                const containingClassStmt = expression.findAncestor(reflection_1.isClassStatement);
+                const classStmtThatDefinesChildMember = (_b = (_a = childChainItem.data) === null || _a === void 0 ? void 0 : _a.definingNode) === null || _b === void 0 ? void 0 : _b.findAncestor(reflection_1.isClassStatement);
+                if (classStmtThatDefinesChildMember) {
+                    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 & 8 /* SymbolTypeFlag.private */) {
+                        if (!inMatchingClassStmt || childChainItem.data.memberOfAncestor) {
+                            this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.memberAccessibilityMismatch(childChainItem.name, childChainItem.data.flags, definingClassName)), { location: expression.location }));
+                            // there's an error... don't worry about the rest of the chain
+                            return false;
+                        }
+                    }
+                    // eslint-disable-next-line no-bitwise
+                    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);
+                        const isSubClassOfDefiningClass = ancestorClasses.includes(classStmtThatDefinesChildMember);
+                        if (!isSubClassOfDefiningClass) {
+                            this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.memberAccessibilityMismatch(childChainItem.name, childChainItem.data.flags, definingClassName)), { location: expression.location }));
+                            // there's an error... don't worry about the rest of the chain
+                            return false;
+                        }
+                    }
+                }
+            }
+        }
+        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;
+        const newExprType = this.getNodeTypeWrapper(file, newExpression, { flags: 2 /* SymbolTypeFlag.typetime */ });
+        if ((0, reflection_1.isClassType)(newExprType)) {
+            return;
+        }
+        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.util.getFullyQualifiedClassName(potentialClassName, namespaceName);
+            this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expressionIsNotConstructable(fullName)), { location: newExpression.className.location }));
+        }
+    }
+    validateFunctionExpressionForReturn(func) {
+        var _a, _b;
+        const returnType = (_a = func === null || func === void 0 ? void 0 : func.returnTypeExpression) === null || _a === void 0 ? void 0 : _a.getType({ flags: 2 /* SymbolTypeFlag.typetime */ });
+        if (!returnType || !returnType.isResolvable() || (0, reflection_1.isVoidType)(returnType) || (0, reflection_1.isDynamicType)(returnType)) {
+            return;
+        }
+        const returns = (_b = func.body) === null || _b === void 0 ? void 0 : _b.findChild(reflection_1.isReturnStatement, { walkMode: visitors_1.WalkMode.visitAll });
+        if (!returns && (0, reflection_1.isStringTypeLike)(returnType)) {
+            this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.returnTypeCoercionMismatch(returnType.toString())), { location: func.location }));
+        }
+    }
+    /**
+     * Create diagnostics for any duplicate function declarations
+     */
+    flagDuplicateFunctionDeclarations() {
+        var _a;
+        this.event.program.diagnostics.clearByFilter({ scope: this.event.scope, tag: "ScopeValidatorDuplicateFunctionDeclaration" /* ScopeValidatorDiagnosticTag.DuplicateFunctionDeclaration */ });
+        //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)), { location: util_1.util.createLocationFromFileRange(container.callable.file, container.callable.nameRange) }), "ScopeValidatorDuplicateFunctionDeclaration" /* ScopeValidatorDiagnosticTag.DuplicateFunctionDeclaration */);
+                    }
+                }
+            }
+            //add error diagnostics about duplicate functions in the same scope
+            if (ownCallables.length > 1) {
+                for (let callableContainer of ownCallables) {
+                    let callable = callableContainer.callable;
+                    const related = [];
+                    for (const ownCallable of ownCallables) {
+                        const thatNameRange = ownCallable.callable.nameRange;
+                        if (ownCallable.callable.nameRange !== callable.nameRange) {
+                            related.push({
+                                message: `Function declared here`,
+                                location: util_1.util.createLocationFromRange(util_1.util.pathToUri((_a = ownCallable.callable.file) === null || _a === void 0 ? void 0 : _a.srcPath), thatNameRange)
+                            });
+                        }
+                    }
+                    this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.duplicateFunctionImplementation(callable.name)), { location: util_1.util.createLocationFromFileRange(callable.file, callable.nameRange), relatedInformation: related }), "ScopeValidatorDuplicateFunctionDeclaration" /* ScopeValidatorDiagnosticTag.DuplicateFunctionDeclaration */);
+                }
+            }
+        }
+    }
+    /**
+     * Verify that all of the scripts imported by each file in this scope actually exist, and have the correct case
+     */
+    validateScriptImportPaths() {
+        this.event.program.diagnostics.clearByFilter({ scope: this.event.scope, tag: "ScopeValidatorImports" /* ScopeValidatorDiagnosticTag.Imports */ });
+        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), { location: util_1.util.createLocationFromFileRange(scriptImport.sourceFile, scriptImport.filePathRange) }), "ScopeValidatorImports" /* ScopeValidatorDiagnosticTag.Imports */);
+                //if the character casing of the script import path does not match that of the actual path
+            }
+            else if (scriptImport.destPath !== referencedFile.destPath) {
+                //preserve the original import shape (pkg:/... vs relative) when reporting the
+                //correct path so the quick-fix replacement matches what the user authored.
+                const correctUri = scriptImport.text.startsWith('pkg:/')
+                    ? util_1.util.sanitizePkgPath(referencedFile.destPath)
+                    : path.posix.relative(path.dirname(scriptImport.sourceFile.destPath).replace(/\\/g, '/'), referencedFile.destPath.replace(/\\/g, '/'));
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.scriptImportCaseMismatch(referencedFile.destPath, correctUri)), { location: util_1.util.createLocationFromFileRange(scriptImport.sourceFile, scriptImport.filePathRange) }), "ScopeValidatorImports" /* ScopeValidatorDiagnosticTag.Imports */);
+            }
+        }
+    }
+    /**
+     * Validate all classes defined in this scope
+     */
+    validateClasses() {
+        this.event.program.diagnostics.clearByFilter({ scope: this.event.scope, tag: "ScopeValidatorClasses" /* ScopeValidatorDiagnosticTag.Classes */ });
+        let validator = new ClassValidator_1.BsClassValidator(this.event.scope);
+        validator.validate();
+        for (const diagnostic of validator.diagnostics) {
+            this.addMultiScopeDiagnostic(Object.assign({}, diagnostic), "ScopeValidatorClasses" /* ScopeValidatorDiagnosticTag.Classes */);
+        }
+    }
+    /**
+     * Find various function collisions
+     */
+    diagnosticDetectFunctionCollisions(file) {
+        const fileUri = util_1.util.pathToUri(file.srcPath);
+        this.event.program.diagnostics.clearByFilter({ scope: this.event.scope, fileUri: fileUri, tag: "ScopeValidatorFunctionCollisions" /* ScopeValidatorDiagnosticTag.FunctionCollisions */ });
+        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()), { location: util_1.util.createLocationFromRange(fileUri, func.nameRange) }));
+                }
+            }
+        }
+    }
+    detectShadowedLocalVar(file, varDeclaration) {
+        var _a, _b;
+        const varName = varDeclaration.name;
+        const lowerVarName = varName.toLowerCase();
+        const callableContainerMap = this.event.scope.getCallableContainerMap();
+        const containingNamespace = (_a = varDeclaration.expr) === null || _a === void 0 ? void 0 : _a.findAncestor(reflection_1.isNamespaceStatement);
+        const localVarIsInNamespace = util_1.util.isVariableMemberOfNamespace(varDeclaration.name, varDeclaration.expr, containingNamespace);
+        const varIsFunction = () => {
+            return (0, reflection_1.isCallableType)(varDeclaration.type) && !(0, reflection_1.isDynamicType)(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')), { location: util_1.util.createLocationFromFileRange(file, varDeclaration.nameRange) }));
+            }
+        }
+        else if (callableContainerMap.has(lowerVarName) && !localVarIsInNamespace) {
+            const callable = callableContainerMap.get(lowerVarName);
+            //is same name as a callable
+            if (varIsFunction()) {
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarFunctionShadowsParentFunction('scope')), { location: util_1.util.createLocationFromFileRange(file, varDeclaration.nameRange), relatedInformation: [{
+                            message: 'Function declared here',
+                            location: util_1.util.createLocationFromFileRange(callable[0].callable.file, callable[0].callable.nameRange)
+                        }] }));
+            }
+            else {
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarShadowedByScopedFunction()), { location: util_1.util.createLocationFromFileRange(file, varDeclaration.nameRange), relatedInformation: [{
+                            message: 'Function declared here',
+                            location: util_1.util.createLocationFromRange(util_1.util.pathToUri(callable[0].callable.file.srcPath), callable[0].callable.nameRange)
+                        }] }));
+            }
+            //has the same name as an in-scope class
+        }
+        else if (!localVarIsInNamespace) {
+            const classStmtLink = this.event.scope.getClassFileLink(lowerVarName);
+            if (classStmtLink) {
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.localVarShadowedByScopedFunction()), { location: util_1.util.createLocationFromFileRange(file, varDeclaration.nameRange), relatedInformation: [{
+                            message: 'Class declared here',
+                            location: util_1.util.createLocationFromRange(util_1.util.pathToUri(classStmtLink.file.srcPath), (_b = classStmtLink === null || classStmtLink === void 0 ? void 0 : classStmtLink.item.tokens.name.location) === null || _b === void 0 ? void 0 : _b.range)
+                        }] }));
+            }
+        }
+    }
+    validateForStatement(file, forStmt) {
+        const assignStmt = forStmt.counterDeclaration;
+        const assignValueType = this.getNodeTypeWrapper(file, assignStmt.value, { flags: 1 /* SymbolTypeFlag.runtime */, statementIndex: forStmt.statementIndex });
+        if (!IntegerType_1.IntegerType.instance.isTypeCompatible(assignValueType)) {
+            this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.assignmentTypeMismatch(assignValueType.toString(), 'integer')), { location: assignStmt.location }));
+        }
+        if (forStmt.increment) {
+            const incrementValueType = this.getNodeTypeWrapper(file, forStmt.increment, { flags: 1 /* SymbolTypeFlag.runtime */, statementIndex: forStmt.statementIndex });
+            if (!IntegerType_1.IntegerType.instance.isTypeCompatible(incrementValueType)) {
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.assignmentTypeMismatch(incrementValueType.toString(), 'integer')), { location: forStmt.increment.location }));
+            }
+        }
+        const finalValueType = this.getNodeTypeWrapper(file, forStmt.finalValue, { flags: 1 /* SymbolTypeFlag.runtime */, statementIndex: forStmt.statementIndex });
+        if (!IntegerType_1.IntegerType.instance.isTypeCompatible(finalValueType)) {
+            this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.assignmentTypeMismatch(finalValueType.toString(), 'integer')), { location: forStmt.finalValue.location }));
+        }
+    }
+    validateForEachStatement(file, forEachStmt) {
+        const targetType = this.getNodeTypeWrapper(file, forEachStmt.target, { flags: 1 /* SymbolTypeFlag.runtime */, statementIndex: forEachStmt.statementIndex });
+        if ((0, reflection_1.isDynamicType)(targetType) || (0, reflection_1.isObjectType)(targetType)) {
+            // unable to determine type, skip further validation
+            return;
+        }
+        let targetItemType;
+        if (!(0, reflection_1.isArrayType)(targetType)) {
+            if ((0, reflection_1.isIterableType)(targetType)) {
+                // this is enumerable
+                targetItemType = util_1.util.getIteratorDefaultType(targetType);
+            }
+            else {
+                // target is not an array nor enumerable
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.notIterable(targetType.toString())), { location: forEachStmt.target.location }));
+                return;
+            }
+        }
+        else {
+            targetItemType = targetType.defaultType;
+        }
+        const loopType = forEachStmt.getLoopVariableType({ flags: 1 /* SymbolTypeFlag.runtime */, statementIndex: forEachStmt.statementIndex });
+        if (forEachStmt.typeExpression && (loopType === null || loopType === void 0 ? void 0 : loopType.isResolvable())) {
+            const data = {};
+            if (!loopType.isTypeCompatible(targetItemType, data)) {
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.assignmentTypeMismatch(targetItemType.toString(), loopType.toString(), data)), { location: forEachStmt.typeExpression.location }));
+            }
+        }
+    }
+    validateXmlInterface(scope) {
+        var _a, _b, _c, _d, _e, _f;
+        if (!((_b = (_a = scope.xmlFile.parser.ast) === null || _a === void 0 ? void 0 : _a.componentElement) === null || _b === void 0 ? void 0 : _b.interfaceElement)) {
+            return;
+        }
+        this.event.program.diagnostics.clearByFilter({ scope: this.event.scope, fileUri: util_1.util.pathToUri((_c = scope.xmlFile) === null || _c === void 0 ? void 0 : _c.srcPath), tag: "ScopeValidatorXML" /* ScopeValidatorDiagnosticTag.XMLInterface */ });
+        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')), { location: func.tokens.startTagName.location }), "ScopeValidatorXML" /* ScopeValidatorDiagnosticTag.XMLInterface */);
+            }
+            else if (!callableContainerMap.has(name.toLowerCase())) {
+                this.addDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.xmlFunctionNotFound(name)), { location: (_d = func.getAttribute('name')) === null || _d === void 0 ? void 0 : _d.tokens.value.location }), "ScopeValidatorXML" /* ScopeValidatorDiagnosticTag.XMLInterface */);
+            }
+        }
+        //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')), { location: field.tokens.startTagName.location }), "ScopeValidatorXML" /* ScopeValidatorDiagnosticTag.XMLInterface */);
+            }
+            if (!type) {
+                if (!field.alias) {
+                    this.addDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.xmlTagMissingAttribute(field.tokens.startTagName.text, 'type')), { location: field.tokens.startTagName.location }), "ScopeValidatorXML" /* ScopeValidatorDiagnosticTag.XMLInterface */);
+                }
+            }
+            else if (!SGTypes_1.SGFieldTypes.includes(type.toLowerCase())) {
+                this.addDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.xmlInvalidFieldType(type)), { location: (_e = field.getAttribute('type')) === null || _e === void 0 ? void 0 : _e.tokens.value.location }), "ScopeValidatorXML" /* ScopeValidatorDiagnosticTag.XMLInterface */);
+            }
+            if (onChange) {
+                if (!callableContainerMap.has(onChange.toLowerCase())) {
+                    this.addDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.xmlFunctionNotFound(onChange)), { location: (_f = field.getAttribute('onchange')) === null || _f === void 0 ? void 0 : _f.tokens.value.location }), "ScopeValidatorXML" /* ScopeValidatorDiagnosticTag.XMLInterface */);
+                }
+            }
+        }
+    }
+    validateDocComments(node) {
+        var _a, _b;
+        const doc = BrightScriptDocParser_1.default.parseNode(node);
+        for (const docTag of doc.tags) {
+            const docTypeTag = docTag;
+            if (!docTypeTag.typeExpression || !docTypeTag.location) {
+                continue;
+            }
+            const foundType = (_a = docTypeTag.typeExpression) === null || _a === void 0 ? void 0 : _a.getType({ flags: 2 /* SymbolTypeFlag.typetime */ });
+            if (!(foundType === null || foundType === void 0 ? void 0 : foundType.isResolvable())) {
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotFindName(docTypeTag.typeString)), { location: (_b = BrightScriptDocParser_1.default.getTypeLocationFromToken(docTypeTag.token)) !== null && _b !== void 0 ? _b : docTypeTag.location }));
+            }
+        }
+    }
+    /**
+     * Detect when a child has imported a script that an ancestor also imported
+     */
+    diagnosticDetectDuplicateAncestorScriptImports(scope) {
+        var _a, _b, _c;
+        this.event.program.diagnostics.clearByFilter({ scope: this.event.scope, fileUri: util_1.util.pathToUri((_a = scope.xmlFile) === null || _a === void 0 ? void 0 : _a.srcPath), tag: "ScopeValidatorXMLImports" /* ScopeValidatorDiagnosticTag.XMLImports */ });
+        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 = (_c = (_b = ancestorComponent.componentName) === null || _b === void 0 ? void 0 : _b.text) !== null && _c !== void 0 ? _c : ancestorComponent.destPath;
+                    this.addDiagnostic(Object.assign({ location: util_1.util.createLocationFromFileRange(scope.xmlFile, scriptImport.filePathRange) }, DiagnosticMessages_1.DiagnosticMessages.unnecessaryScriptImportInChildFromParent(ancestorComponentName)), "ScopeValidatorXMLImports" /* ScopeValidatorDiagnosticTag.XMLImports */);
+                }
+            }
+        }
+    }
+    /**
+     * Wraps the AstNode.getType() method, so that we can do extra processing on the result based on the current file
+     * In particular, since BrightScript does not support Unions, and there's no way to cast them to something else
+     * if the result of .getType() is a union, and we're in a .brs (brightScript) file, treat the result as Dynamic
+     *
+     * Also, for BrightScript parse-mode, if .getType() returns a node type, do not validate unknown members.
+     *
+     * In most cases, this returns the result of node.getType()
+     *
+     * @param file the current file being processed
+     * @param node the node to get the type of
+     * @param getTypeOpts any options to pass to node.getType()
+     * @returns the processed result type
+     */
+    getNodeTypeWrapper(file, node, getTypeOpts) {
+        const type = node === null || node === void 0 ? void 0 : node.getType(getTypeOpts);
+        if (file.parseMode === Parser_1.ParseMode.BrightScript) {
+            // this is a brightscript file
+            const typeChain = getTypeOpts.typeChain;
+            if (typeChain) {
+                const hasUnion = typeChain.reduce((hasUnion, tce) => {
+                    return hasUnion || (0, reflection_1.isUnionType)(tce.type);
+                }, false);
+                if (hasUnion) {
+                    // there was a union somewhere in the typechain
+                    return DynamicType_1.DynamicType.instance;
+                }
+            }
+            if ((0, reflection_1.isUnionType)(type)) {
+                //this is a union
+                return DynamicType_1.DynamicType.instance;
+            }
+            if ((0, reflection_1.isComponentType)(type)) {
+                // modify type to allow any member access for Node types
+                type.changeUnknownMemberToDynamic = true;
+            }
+        }
+        // by default return the result of node.getType()
+        return type;
+    }
+    getParentTypeDescriptor(typeChainResult) {
+        if (typeChainResult.itemParentTypeKind === BscTypeKind_1.BscTypeKind.NamespaceType) {
+            return 'namespace';
+        }
+        return 'type';
+    }
+    addDiagnostic(diagnostic, diagnosticTag) {
+        diagnosticTag = diagnosticTag !== null && diagnosticTag !== void 0 ? diagnosticTag : (this.currentSegmentBeingValidated ? "ScopeValidatorSegment" /* ScopeValidatorDiagnosticTag.Segment */ : "ScopeValidator" /* ScopeValidatorDiagnosticTag.Default */);
+        this.event.program.diagnostics.register(diagnostic, {
+            tags: [diagnosticTag],
+            segment: this.currentSegmentBeingValidated
+        });
+    }
+    /**
+     * Add a diagnostic (to the first scope) that will have `relatedInformation` for each affected scope
+     */
+    addMultiScopeDiagnostic(diagnostic, diagnosticTag) {
+        diagnosticTag = diagnosticTag !== null && diagnosticTag !== void 0 ? diagnosticTag : (this.currentSegmentBeingValidated ? "ScopeValidatorSegment" /* ScopeValidatorDiagnosticTag.Segment */ : "ScopeValidator" /* ScopeValidatorDiagnosticTag.Default */);
+        this.event.program.diagnostics.register(diagnostic, {
+            tags: [diagnosticTag],
+            segment: this.currentSegmentBeingValidated,
+            scope: this.event.scope
+        });
+    }
+}
+exports.ScopeValidator = ScopeValidator;
+//# sourceMappingURL=ScopeValidator.js.map