brighterscript 1.0.0-alpha.24 → 1.0.0-alpha.26

package/dist/bscPlugin/validation/ScopeValidator.js

@@ -5,15 +5,21 @@ const vscode_uri_1 = require("vscode-uri");
 const reflection_1 = require("../../astUtils/reflection");
 const Cache_1 = require("../../Cache");
 const DiagnosticMessages_1 = require("../../DiagnosticMessages");
+const interfaces_1 = require("../../interfaces");
+const SymbolTable_1 = require("../../SymbolTable");
 const util_1 = require("../../util");
 const roku_types_1 = require("../../roku-types");
-const UninitializedType_1 = require("../../types/UninitializedType");
-const BscType_1 = require("../../types/BscType");
+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");
 /**
  * The lower-case names of all platform-included scenegraph nodes
  */
-const platformNodeNames = new Set(Object.values(roku_types_1.nodes).map(x => x.name.toLowerCase()));
-const platformComponentNames = new Set(Object.values(roku_types_1.components).map(x => x.name.toLowerCase()));
+// 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();
 /**
  * A validator that handles all scope validations for a program validation cycle.
  * You should create ONE of these to handle all scope events between beforeProgramValidate and afterProgramValidate,
@@ -21,183 +27,120 @@ const platformComponentNames = new Set(Object.values(roku_types_1.components).ma
  */
 class ScopeValidator {
     constructor() {
-        this.events = [];
         this.onceCache = new Cache_1.Cache();
         this.multiScopeCache = new Cache_1.Cache();
     }
     processEvent(event) {
-        this.events.push(event);
-        event.scope.linkSymbolTable();
-        this.detectDuplicateEnums(event);
-        this.validateCreateObjectCalls(event);
-        this.iterateExpressions(event);
-        this.detectInvalidFunctionCalls(event);
-        event.scope.unlinkSymbolTable();
+        this.event = event;
+        if (this.event.program.globalScope === this.event.scope) {
+            return;
+        }
+        this.walkFiles();
+        this.detectDuplicateEnums();
     }
     reset() {
+        this.event = undefined;
         this.onceCache.clear();
         this.multiScopeCache.clear();
-        this.events = [];
-    }
-    /**
-     * Adds a diagnostic to the first scope for this key. Prevents duplicate diagnostics
-     * for diagnostics where scope isn't important. (i.e. CreateObject validations)
-     */
-    addDiagnosticOnce(event, diagnostic) {
-        this.onceCache.getOrAdd(`${diagnostic.code}-${diagnostic.message}-${util_1.default.rangeToString(diagnostic.range)}`, () => {
-            event.scope.addDiagnostics([diagnostic]);
-            return true;
-        });
-    }
-    addDiagnostic(event, diagnostic) {
-        event.scope.addDiagnostics([diagnostic]);
-    }
-    /**
-     * Add a diagnostic (to the first scope) that will have `relatedInformation` for each affected scope
-     */
-    addMultiScopeDiagnostic(event, diagnostic, message = 'Not defined in scope') {
-        var _a, _b;
-        diagnostic = this.multiScopeCache.getOrAdd(`${(_a = diagnostic.file) === null || _a === void 0 ? void 0 : _a.srcPath}-${diagnostic.code}-${diagnostic.message}-${util_1.default.rangeToString(diagnostic.range)}`, () => {
-            if (!diagnostic.relatedInformation) {
-                diagnostic.relatedInformation = [];
-            }
-            this.addDiagnostic(event, diagnostic);
-            return diagnostic;
-        });
-        const info = {
-            message: `${message} '${event.scope.name}'`
-        };
-        if ((0, reflection_1.isXmlScope)(event.scope) && ((_b = event.scope.xmlFile) === null || _b === void 0 ? void 0 : _b.srcPath)) {
-            info.location = util_1.default.createLocation(vscode_uri_1.URI.file(event.scope.xmlFile.srcPath).toString(), util_1.default.createRange(0, 0, 0, 10));
-        }
-        else {
-            info.location = util_1.default.createLocation(vscode_uri_1.URI.file(diagnostic.file.srcPath).toString(), diagnostic.range);
-        }
-        diagnostic.relatedInformation.push(info);
     }
-    /**
-     * Find the closest symbol table for the given position
-     */
-    getSymbolTable(scope, file, position) {
-        var _a, _b;
-        let symbolTable;
-        symbolTable = (_a = file.getFunctionExpressionAtPosition(position)) === null || _a === void 0 ? void 0 : _a.symbolTable;
-        if (!symbolTable) {
-            symbolTable = (_b = file.getNamespaceStatementForPosition(position)) === null || _b === void 0 ? void 0 : _b.symbolTable;
-        }
-        if (!symbolTable) {
-            symbolTable = scope.symbolTable;
-        }
-        return symbolTable;
-    }
-    iterateExpressions(event) {
-        const { scope } = event;
-        event.scope.enumerateOwnFiles((file) => {
-            var _a, _b, _c;
+    walkFiles() {
+        this.event.scope.enumerateOwnFiles((file) => {
             if ((0, reflection_1.isBrsFile)(file)) {
-                const expressions = [
-                    ...file.parser.references.expressions,
-                    //all class "extends <whatever>" expressions
-                    ...file.parser.references.classStatements.map(x => { var _a; return (_a = x.parentClassName) === null || _a === void 0 ? void 0 : _a.expression; }),
-                    //all interface "extends <whatever>" expressions
-                    ...file.parser.references.interfaceStatements.map(x => { var _a; return (_a = x.parentInterfaceName) === null || _a === void 0 ? void 0 : _a.expression; })
-                ];
-                outer: for (let referenceExpression of expressions) {
-                    if (!referenceExpression) {
-                        continue;
-                    }
-                    let expression;
-                    //lift the callee from call expressions to handle namespaced function calls
-                    if ((0, reflection_1.isCallExpression)(referenceExpression)) {
-                        expression = referenceExpression.callee;
-                    }
-                    else if ((0, reflection_1.isNewExpression)(referenceExpression)) {
-                        expression = referenceExpression.call.callee;
-                    }
-                    else {
-                        expression = referenceExpression;
-                    }
-                    if ((0, reflection_1.isCallExpression)(expression.parent) && !(0, reflection_1.isNewExpression)(referenceExpression)) {
-                        // function calls are validated in detectInvalidFunctionCalls
-                        continue;
-                    }
-                    const tokens = util_1.default.getAllDottedGetParts(expression);
-                    if ((tokens === null || tokens === void 0 ? void 0 : tokens.length) > 0) {
-                        const symbolTable = this.getSymbolTable(scope, file, tokens[0].range.start); //flag all unknown left-most variables
-                        if (!symbolTable.hasSymbol((_a = tokens[0]) === null || _a === void 0 ? void 0 : _a.text)) {
-                            this.addMultiScopeDiagnostic(event, Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.cannotFindName(tokens[0].text)), { range: tokens[0].range }));
-                            //skip to the next expression
-                            continue;
-                        }
-                        //at this point, we know the first item is a known symbol. find unknown namespace parts after the first part
-                        if (tokens.length > 1) {
-                            const firstNamespacePart = tokens.shift().text;
-                            const firstNamespacePartLower = firstNamespacePart === null || firstNamespacePart === void 0 ? void 0 : firstNamespacePart.toLowerCase();
-                            const namespaceContainer = scope.namespaceLookup.get(firstNamespacePartLower);
-                            const enumStatement = scope.getEnum(firstNamespacePartLower);
-                            //if this isn't a namespace, skip it
-                            if (!namespaceContainer && !enumStatement) {
-                                continue;
-                            }
-                            //catch unknown namespace items
-                            const processedNames = [firstNamespacePart];
-                            for (const token of tokens !== null && tokens !== void 0 ? tokens : []) {
-                                processedNames.push(token.text);
-                                const entityName = processedNames.join('.');
-                                const entityNameLower = entityName.toLowerCase();
-                                //if this is an enum member, stop validating here to prevent errors further down the chain
-                                if (scope.getEnumMemberMap().has(entityNameLower)) {
-                                    break;
-                                }
-                                if (!scope.getEnumMap().has(entityNameLower) &&
-                                    !scope.getClassMap().has(entityNameLower) &&
-                                    !scope.getConstMap().has(entityNameLower) &&
-                                    !scope.getCallableByName(entityNameLower) &&
-                                    !scope.namespaceLookup.has(entityNameLower)) {
-                                    //if this looks like an enum, provide a nicer error message
-                                    const theEnum = (_b = this.getEnum(scope, entityNameLower)) === null || _b === void 0 ? void 0 : _b.item;
-                                    if (theEnum) {
-                                        this.addMultiScopeDiagnostic(event, Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.unknownEnumValue((_c = token.text) === null || _c === void 0 ? void 0 : _c.split('.').pop(), theEnum.fullName)), { range: tokens[tokens.length - 1].range, relatedInformation: [{
-                                                    message: 'Enum declared here',
-                                                    location: util_1.default.createLocation(vscode_uri_1.URI.file(file.srcPath).toString(), theEnum.tokens.name.range)
-                                                }] }));
-                                    }
-                                    else {
-                                        this.addMultiScopeDiagnostic(event, Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotFindName(token.text, entityName)), { range: token.range, file: file }));
-                                    }
-                                    //no need to add another diagnostic for future unknown items
-                                    continue outer;
-                                }
+                const hasChangeInfo = this.event.changedFiles && this.event.changedSymbols;
+                let thisFileRequiresChangedSymbol = false;
+                for (let requiredSymbol of file.requiredSymbols) {
+                    // eslint-disable-next-line no-bitwise
+                    for (const flag of [SymbolTable_1.SymbolTypeFlag.runtime, SymbolTable_1.SymbolTypeFlag.typetime]) {
+                        // eslint-disable-next-line no-bitwise
+                        if (flag & requiredSymbol.flags) {
+                            const changeSymbolSetForFlag = this.event.changedSymbols.get(flag);
+                            if (util_1.default.setContainsUnresolvedSymbol(changeSymbolSetForFlag, requiredSymbol)) {
+                                thisFileRequiresChangedSymbol = true;
                             }
                         }
                     }
                 }
+                const thisFileHasChanges = this.event.changedFiles.includes(file);
+                if (hasChangeInfo && !thisFileRequiresChangedSymbol && !thisFileHasChanges) {
+                    // this file does not require a symbol that has changed, and this file has not changed
+                    return;
+                }
+                if (thisFileHasChanges) {
+                    this.event.scope.clearAstSegmentDiagnosticsByFile(file);
+                }
+                const validationVisitor = (0, visitors_1.createVisitor)({
+                    VariableExpression: (varExpr) => {
+                        this.validateVariableAndDottedGetExpressions(file, varExpr);
+                    },
+                    DottedGetExpression: (dottedGet) => {
+                        this.validateVariableAndDottedGetExpressions(file, dottedGet);
+                    },
+                    CallExpression: (functionCall) => {
+                        this.validateFunctionCall(file, functionCall);
+                        this.validateCreateObjectCall(file, functionCall);
+                    },
+                    ReturnStatement: (returnStatement) => {
+                        this.validateReturnStatement(file, returnStatement);
+                    },
+                    DottedSetStatement: (dottedSetStmt) => {
+                        this.validateDottedSetStatement(file, dottedSetStmt);
+                    },
+                    BinaryExpression: (binaryExpr) => {
+                        this.validateBinaryExpression(file, binaryExpr);
+                    },
+                    UnaryExpression: (unaryExpr) => {
+                        this.validateUnaryExpression(file, unaryExpr);
+                    },
+                    AssignmentStatement: (assignStmt) => {
+                        this.validateAssignmentStatement(file, assignStmt);
+                    }
+                });
+                const segmentsToWalkForValidation = (thisFileHasChanges || !hasChangeInfo)
+                    ? file.validationSegmenter.segmentsForValidation // validate everything in the file
+                    : file.getValidationSegments(this.event.changedSymbols); // validate only what's needed in the file
+                for (const segment of segmentsToWalkForValidation) {
+                    this.currentSegmentBeingValidated = segment;
+                    this.event.scope.clearAstSegmentDiagnostics(segment);
+                    segment.walk(validationVisitor, {
+                        walkMode: AstValidationSegmenter_1.InsideSegmentWalkMode
+                    });
+                    file.markSegmentAsValidated(segment);
+                }
             }
         });
     }
+    isTypeKnown(exprType) {
+        let isKnownType = exprType === null || exprType === void 0 ? void 0 : exprType.isResolvable();
+        return isKnownType;
+    }
     /**
-     * Given a string optionally separated by dots, find an enum related to it.
-     * For example, all of these would return the enum: `SomeNamespace.SomeEnum.SomeMember`, SomeEnum.SomeMember, `SomeEnum`
+     * If this is the lhs of an assignment, we don't need to flag it as unresolved
      */
-    getEnum(scope, name) {
-        //look for the enum directly
-        let result = scope.getEnumMap().get(name);
-        //assume we've been given the enum.member syntax, so pop the member and try again
-        if (!result) {
-            const parts = name.split('.');
-            parts.pop();
-            result = scope.getEnumMap().get(parts.join('.'));
-        }
-        return result;
+    ignoreUnresolvedAssignmentLHS(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 {
+            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 duplicate enums
      */
-    detectDuplicateEnums(event) {
+    detectDuplicateEnums() {
         const diagnostics = [];
         const enumLocationsByName = new Cache_1.Cache();
-        event.scope.enumerateBrsFiles((file) => {
-            for (const enumStatement of file.parser.references.enumStatements) {
+        this.event.scope.enumerateBrsFiles((file) => {
+            // eslint-disable-next-line @typescript-eslint/dot-notation
+            for (const enumStatement of file['_cachedLookups'].enumStatements) {
                 const fullName = enumStatement.fullName;
                 const nameLower = fullName === null || fullName === void 0 ? void 0 : fullName.toLowerCase();
                 if ((nameLower === null || nameLower === void 0 ? void 0 : nameLower.length) > 0) {
@@ -226,13 +169,13 @@ class ScopeValidator {
             const primaryEnum = enumLocations.shift();
             const fullName = primaryEnum.statement.fullName;
             for (const duplicateEnumInfo of enumLocations) {
-                diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.duplicateEnumDeclaration(event.scope.name, fullName)), { file: duplicateEnumInfo.file, range: duplicateEnumInfo.statement.tokens.name.range, relatedInformation: [{
+                diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.duplicateEnumDeclaration(this.event.scope.name, fullName)), { file: duplicateEnumInfo.file, range: duplicateEnumInfo.statement.tokens.name.range, relatedInformation: [{
                             message: 'Enum declared here',
                             location: util_1.default.createLocation(vscode_uri_1.URI.file(primaryEnum.file.srcPath).toString(), primaryEnum.statement.tokens.name.range)
-                        }] }));
+                        }], origin: interfaces_1.DiagnosticOrigin.Scope }));
             }
         }
-        event.scope.addDiagnostics(diagnostics);
+        this.event.scope.addDiagnostics(diagnostics);
     }
     /**
      * Validate every function call to `CreateObject`.
@@ -240,150 +183,435 @@ class ScopeValidator {
      * 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.
      */
-    validateCreateObjectCalls(event) {
-        const diagnostics = [];
-        event.scope.enumerateBrsFiles((file) => {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
-            for (const call of file.functionCalls) {
-                //skip non CreateObject function calls
-                if (((_a = call.name) === null || _a === void 0 ? void 0 : _a.text.toLowerCase()) !== 'createobject' || !(0, reflection_1.isLiteralExpression)((_b = call === null || call === void 0 ? void 0 : call.args[0]) === null || _b === void 0 ? void 0 : _b.expression)) {
-                    continue;
-                }
-                const firstParamToken = (_d = (_c = call === null || call === void 0 ? void 0 : call.args[0]) === null || _c === void 0 ? void 0 : _c.expression) === null || _d === void 0 ? void 0 : _d.token;
-                const firstParamStringValue = (_e = firstParamToken === null || firstParamToken === void 0 ? void 0 : firstParamToken.text) === null || _e === void 0 ? void 0 : _e.replace(/"/g, '');
-                //if this is a `createObject('roSGNode'` call, only support known sg node types
-                if ((firstParamStringValue === null || firstParamStringValue === void 0 ? void 0 : firstParamStringValue.toLowerCase()) === 'rosgnode' && (0, reflection_1.isLiteralExpression)((_f = call === null || call === void 0 ? void 0 : call.args[1]) === null || _f === void 0 ? void 0 : _f.expression)) {
-                    const componentName = (_h = (_g = call === null || call === void 0 ? void 0 : call.args[1]) === null || _g === void 0 ? void 0 : _g.expression) === null || _h === void 0 ? void 0 : _h.token;
-                    //don't validate any components with a colon in their name (probably component libraries, but regular components can have them too).
-                    if ((_j = componentName === null || componentName === void 0 ? void 0 : componentName.text) === null || _j === void 0 ? void 0 : _j.includes(':')) {
-                        continue;
-                    }
-                    //add diagnostic for unknown components
-                    const unquotedComponentName = (_k = componentName === null || componentName === void 0 ? void 0 : componentName.text) === null || _k === void 0 ? void 0 : _k.replace(/"/g, '');
-                    if (unquotedComponentName && !platformNodeNames.has(unquotedComponentName.toLowerCase()) && !event.program.getComponent(unquotedComponentName)) {
-                        this.addDiagnosticOnce(event, Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.unknownRoSGNode(unquotedComponentName)), { range: componentName.range }));
-                    }
-                    else if ((call === null || call === void 0 ? void 0 : call.args.length) !== 2) {
-                        // roSgNode should only ever have 2 args in `createObject`
-                        this.addDiagnosticOnce(event, Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.mismatchCreateObjectArgumentCount(firstParamStringValue, [2], call === null || call === void 0 ? void 0 : call.args.length)), { range: call.range }));
-                    }
+    validateCreateObjectCall(file, call) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        //skip non CreateObject function calls
+        const callName = (_a = util_1.default.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;
+            //don't validate any components with a colon in their name (probably component libraries, but regular components can have them too).
+            if (!componentName || ((_f = componentName === null || componentName === void 0 ? void 0 : componentName.text) === null || _f === void 0 ? void 0 : _f.includes(':'))) {
+                return;
+            }
+            //add diagnostic for unknown components
+            const unquotedComponentName = (_g = componentName === null || componentName === void 0 ? void 0 : componentName.text) === null || _g === void 0 ? void 0 : _g.replace(/"/g, '');
+            if (unquotedComponentName && !platformNodeNames.has(unquotedComponentName.toLowerCase()) && !this.event.program.getComponent(unquotedComponentName)) {
+                this.addDiagnosticOnce(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.unknownRoSGNode(unquotedComponentName)), { range: componentName.range }));
+            }
+            else if ((call === null || call === void 0 ? void 0 : call.args.length) !== 2) {
+                // roSgNode should only ever have 2 args in `createObject`
+                this.addDiagnosticOnce(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.mismatchCreateObjectArgumentCount(firstParamStringValue, [2], call === null || call === void 0 ? void 0 : call.args.length)), { range: call.range }));
+            }
+        }
+        else if (!platformComponentNames.has(firstParamStringValueLower)) {
+            this.addDiagnosticOnce(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.unknownBrightScriptComponent(firstParamStringValue)), { range: firstParamToken.range }));
+        }
+        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.addDiagnosticOnce(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.mismatchCreateObjectArgumentCount(firstParamStringValue, validArgCounts, call === null || call === void 0 ? void 0 : call.args.length)), { range: call.range }));
+            }
+            // Test for deprecation
+            if (brightScriptComponent === null || brightScriptComponent === void 0 ? void 0 : brightScriptComponent.isDeprecated) {
+                this.addDiagnosticOnce(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.deprecatedBrightScriptComponent(firstParamStringValue, brightScriptComponent.deprecatedDescription)), { range: call.range }));
+            }
+        }
+    }
+    /**
+     * Detect calls to functions with the incorrect number of parameters, or wrong types of arguments
+     */
+    validateFunctionCall(file, expression) {
+        var _a, _b;
+        const getTypeOptions = { flags: SymbolTable_1.SymbolTypeFlag.runtime, data: {} };
+        let funcType = (_a = expression === null || expression === void 0 ? void 0 : expression.callee) === null || _a === void 0 ? void 0 : _a.getType(getTypeOptions);
+        if ((funcType === null || funcType === void 0 ? void 0 : funcType.isResolvable()) && (0, reflection_1.isClassType)(funcType)) {
+            // We're calling a class - get the constructor
+            funcType = funcType.getMemberType('new', getTypeOptions);
+        }
+        if ((funcType === null || funcType === void 0 ? void 0 : funcType.isResolvable()) && (0, reflection_1.isTypedFunctionType)(funcType)) {
+            //funcType.setName(expression.callee. .name);
+            //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++;
                 }
-                else if (!platformComponentNames.has(firstParamStringValue.toLowerCase())) {
-                    this.addDiagnosticOnce(event, Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.unknownBrightScriptComponent(firstParamStringValue)), { range: firstParamToken.range }));
+            }
+            if (funcType.isVariadic) {
+                // function accepts variable number of arguments
+                maxParams = Expression_1.CallExpression.MaximumArguments;
+            }
+            let expCallArgCount = expression.args.length;
+            if (expCallArgCount > maxParams || expCallArgCount < minParams) {
+                let minMaxParamsText = minParams === maxParams ? maxParams : `${minParams}-${maxParams}`;
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.mismatchArgumentCount(minMaxParamsText, expCallArgCount)), { range: expression.callee.range, 
+                    //TODO detect end of expression call
+                    file: file }));
+            }
+            let paramIndex = 0;
+            for (let arg of expression.args) {
+                const data = {};
+                let argType = arg.getType({ flags: SymbolTable_1.SymbolTypeFlag.runtime, data: data });
+                const paramType = (_b = funcType.params[paramIndex]) === null || _b === void 0 ? void 0 : _b.type;
+                if (!paramType) {
+                    // unable to find a paramType -- maybe there are more args than params
+                    break;
                 }
-                else {
-                    // This is valid brightscript component
-                    // Test for invalid arg counts
-                    const brightScriptComponent = roku_types_1.components[firstParamStringValue.toLowerCase()];
-                    // Valid arg counts for createObject are 1+ number of args for constructor
-                    let validArgCounts = 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.addDiagnosticOnce(event, Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.mismatchCreateObjectArgumentCount(firstParamStringValue, validArgCounts, call === null || call === void 0 ? void 0 : call.args.length)), { range: call.range }));
-                    }
-                    // Test for deprecation
-                    if (brightScriptComponent.isDeprecated) {
-                        this.addDiagnosticOnce(event, Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.deprecatedBrightScriptComponent(firstParamStringValue, brightScriptComponent.deprecatedDescription)), { range: call.range }));
+                if ((0, reflection_1.isCallableType)(paramType) && (0, reflection_1.isClassType)(argType) && (0, reflection_1.isClassStatement)(data.definingNode)) {
+                    // the param is expecting a function, but we're passing a Class... are we actually passing the constructor? then we're ok!
+                    const namespace = expression.findAncestor(reflection_1.isNamespaceStatement);
+                    if (file.calleeIsKnownFunction(arg, namespace === null || namespace === void 0 ? void 0 : namespace.getName(Parser_1.ParseMode.BrighterScript))) {
+                        argType = data.definingNode.getConstructorType();
                     }
                 }
+                const compatibilityData = {};
+                if (!(paramType === null || paramType === void 0 ? void 0 : paramType.isTypeCompatible(argType, compatibilityData))) {
+                    this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.argumentTypeMismatch(argType.toString(), paramType.toString(), compatibilityData)), { range: arg.range, 
+                        //TODO detect end of expression call
+                        file: file }));
+                }
+                paramIndex++;
             }
-        });
-        event.scope.addDiagnostics(diagnostics);
+        }
     }
-    detectInvalidFunctionCalls(event) {
-        const diagnostics = [];
-        //get a list of all callables, indexed by their lower case names
-        let callableContainerMap = event.scope.getCallableContainerMap();
-        event.scope.enumerateBrsFiles((file) => {
-            diagnostics.push(...this.detectInvalidFunctionCallsForFile(event.scope, file, callableContainerMap));
-        });
-        event.scope.addDiagnostics(diagnostics);
+    /**
+     * Detect return statements with incompatible types vs. declared return type
+     */
+    validateReturnStatement(file, returnStmt) {
+        var _a;
+        const getTypeOptions = { flags: SymbolTable_1.SymbolTypeFlag.runtime };
+        let funcType = returnStmt.findAncestor(reflection_1.isFunctionExpression).getType({ flags: SymbolTable_1.SymbolTypeFlag.typetime });
+        if ((0, reflection_1.isTypedFunctionType)(funcType)) {
+            const actualReturnType = (_a = returnStmt.value) === null || _a === void 0 ? void 0 : _a.getType(getTypeOptions);
+            const compatibilityData = {};
+            if (actualReturnType && !funcType.returnType.isTypeCompatible(actualReturnType, compatibilityData)) {
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.returnTypeMismatch(actualReturnType.toString(), funcType.returnType.toString(), compatibilityData)), { range: returnStmt.value.range, file: file }));
+            }
+        }
     }
     /**
-    * Find functions with either the wrong type of parameters, or the wrong number of parameters
-    */
-    detectInvalidFunctionCallsForFile(scope, file, callableContainersByLowerName) {
-        var _a, _b, _c, _d;
-        const diagnostics = [];
-        const specialCaseGlobalFunctions = ['val']; //  Global callables with multiple definitions
-        if ((0, reflection_1.isBrsFile)(file)) {
-            for (let expCall of file.functionCalls) {
-                const symbolTypeInfo = file.getSymbolTypeFromToken(expCall.name, expCall.functionExpression, scope);
-                let funcType = symbolTypeInfo.type;
-                if ((!(0, reflection_1.isTypedFunctionType)(funcType) && !(0, reflection_1.isDynamicType)(funcType)) || specialCaseGlobalFunctions.includes(expCall.name.text)) {
-                    // We don't know if this is a function. Try seeing if it is a global
-                    const callableContainer = util_1.default.getCallableContainerByFunctionCall(callableContainersByLowerName, expCall);
-                    if (callableContainer) {
-                        // We found a global callable with correct number of params - use that
-                        funcType = (_a = callableContainer.callable) === null || _a === void 0 ? void 0 : _a.type;
-                    }
-                    else {
-                        const allowedParamCount = util_1.default.getMinMaxParamCountByFunctionCall(callableContainersByLowerName, expCall);
-                        if (allowedParamCount) {
-                            // We found a global callable, but it needs a different number of args
-                            diagnostics.push(this.getMismatchParamCountDiagnostic(allowedParamCount, expCall, file));
-                            continue;
-                        }
-                    }
+     * Detect return statements with incompatible types vs. declared return type
+     */
+    validateDottedSetStatement(file, dottedSetStmt) {
+        var _a;
+        const typeChainExpectedLHS = [];
+        const getTypeOpts = { flags: SymbolTable_1.SymbolTypeFlag.runtime };
+        const expectedLHSType = dottedSetStmt === null || dottedSetStmt === void 0 ? void 0 : dottedSetStmt.getType(Object.assign(Object.assign({}, getTypeOpts), { data: {}, typeChain: typeChainExpectedLHS }));
+        const actualRHSType = (_a = dottedSetStmt === null || dottedSetStmt === void 0 ? void 0 : dottedSetStmt.value) === null || _a === void 0 ? void 0 : _a.getType(getTypeOpts);
+        const compatibilityData = {};
+        const typeChainScan = util_1.default.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 === null || expectedLHSType === void 0 ? void 0 : expectedLHSType.isResolvable())) {
+            this.addMultiScopeDiagnostic(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.cannotFindName(typeChainScan.itemName, typeChainScan.fullNameOfItem)), { range: typeChainScan.range }));
+            return;
+        }
+        const accessibilityIsOk = this.checkMemberAccessibility(file, dottedSetStmt, typeChainExpectedLHS);
+        if (accessibilityIsOk && !(expectedLHSType === null || expectedLHSType === void 0 ? void 0 : expectedLHSType.isTypeCompatible(actualRHSType, compatibilityData))) {
+            this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.assignmentTypeMismatch(actualRHSType.toString(), expectedLHSType.toString(), compatibilityData)), { range: dottedSetStmt.range, file: file }));
+        }
+    }
+    /**
+     * Detect when declared type does not match rhs type
+     */
+    validateAssignmentStatement(file, assignStmt) {
+        var _a;
+        if (!(assignStmt === null || assignStmt === void 0 ? void 0 : assignStmt.typeExpression)) {
+            // nothing to check
+            return;
+        }
+        const typeChainExpectedLHS = [];
+        const getTypeOpts = { flags: SymbolTable_1.SymbolTypeFlag.runtime };
+        const expectedLHSType = assignStmt.typeExpression.getType(Object.assign(Object.assign({}, getTypeOpts), { data: {}, typeChain: typeChainExpectedLHS }));
+        const actualRHSType = (_a = assignStmt.value) === null || _a === void 0 ? void 0 : _a.getType(getTypeOpts);
+        const compatibilityData = {};
+        if (!(expectedLHSType === null || expectedLHSType === void 0 ? void 0 : expectedLHSType.isTypeCompatible(actualRHSType, compatibilityData))) {
+            this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.assignmentTypeMismatch(actualRHSType.toString(), expectedLHSType.toString(), compatibilityData)), { range: assignStmt.range, file: file }));
+        }
+    }
+    /**
+     * Detect invalid use of a binary operator
+     */
+    validateBinaryExpression(file, binaryExpr) {
+        const getTypeOpts = { flags: SymbolTable_1.SymbolTypeFlag.runtime };
+        if (util_1.default.isInTypeExpression(binaryExpr)) {
+            return;
+        }
+        let leftType = binaryExpr.left.getType(getTypeOpts);
+        let rightType = binaryExpr.right.getType(getTypeOpts);
+        if (!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 leftIsPrimitive = (0, reflection_1.isPrimitiveType)(leftTypeToTest);
+        const rightIsPrimitive = (0, reflection_1.isPrimitiveType)(rightTypeToTest);
+        const leftIsAny = (0, reflection_1.isDynamicType)(leftTypeToTest) || (0, reflection_1.isObjectType)(leftTypeToTest);
+        const rightIsAny = (0, reflection_1.isDynamicType)(rightTypeToTest) || (0, reflection_1.isObjectType)(rightTypeToTest);
+        if (leftIsAny && rightIsAny) {
+            // both operands are basically "any" type... ignore;
+            return;
+        }
+        else if ((leftIsAny && rightIsPrimitive) || (leftIsPrimitive && rightIsAny)) {
+            // one operand is basically "any" type... ignore;
+            return;
+        }
+        const opResult = util_1.default.binaryOperatorResultType(leftTypeToTest, binaryExpr.tokens.operator, rightTypeToTest);
+        if ((0, reflection_1.isDynamicType)(opResult)) {
+            // if the result was dynamic, 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())), { range: binaryExpr.range, file: file }));
+        }
+    }
+    /**
+     * Detect invalid use of a Unary operator
+     */
+    validateUnaryExpression(file, unaryExpr) {
+        const getTypeOpts = { flags: SymbolTable_1.SymbolTypeFlag.runtime };
+        let rightType = unaryExpr.right.getType(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.default.unaryOperatorResultType(unaryExpr.tokens.operator, rightTypeToTest);
+            if ((0, reflection_1.isDynamicType)(opResult)) {
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.operatorTypeMismatch(unaryExpr.tokens.operator.text, rightType.toString())), { range: unaryExpr.range, file: file }));
+            }
+        }
+        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())), { range: unaryExpr.range, file: file }));
+        }
+    }
+    validateVariableAndDottedGetExpressions(file, expression) {
+        var _a, _b;
+        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 = SymbolTable_1.SymbolTypeFlag.runtime;
+        let oppositeSymbolType = SymbolTable_1.SymbolTypeFlag.typetime;
+        const isUsedAsType = util_1.default.isInTypeExpression(expression);
+        if (isUsedAsType) {
+            // This is used in a TypeExpression - only look up types from SymbolTable
+            symbolType = SymbolTable_1.SymbolTypeFlag.typetime;
+            oppositeSymbolType = SymbolTable_1.SymbolTypeFlag.runtime;
+        }
+        // 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 = expression.getType({
+            flags: symbolType,
+            typeChain: typeChain,
+            data: typeData
+        });
+        const shouldIgnoreLHS = this.ignoreUnresolvedAssignmentLHS(expression, exprType, typeData === null || typeData === void 0 ? void 0 : typeData.definingNode);
+        if (!this.isTypeKnown(exprType) && !shouldIgnoreLHS) {
+            if ((_a = expression.getType({ flags: oppositeSymbolType })) === null || _a === void 0 ? void 0 : _a.isResolvable()) {
+                const oppoSiteTypeChain = [];
+                const invalidlyUsedResolvedType = expression.getType({ flags: oppositeSymbolType, typeChain: oppoSiteTypeChain });
+                const typeChainScan = util_1.default.processTypeChain(oppoSiteTypeChain);
+                if (isUsedAsType) {
+                    this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.itemCannotBeUsedAsType(typeChainScan.fullChainName)), { range: expression.range, file: file }));
                 }
-                if ((0, reflection_1.isFunctionType)(funcType)) {
-                    // This is a generic function, and it is callable
+                else {
+                    this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.itemCannotBeUsedAsVariable(invalidlyUsedResolvedType.toString())), { range: expression.range, file: file }));
                 }
-                else if ((0, reflection_1.isTypedFunctionType)(funcType)) {
-                    // Check for Argument count mismatch.
-                    //get min/max parameter count for callable
-                    let paramCount = util_1.default.getMinMaxParamCount(funcType.params);
-                    if (expCall.args.length > paramCount.max || expCall.args.length < paramCount.min) {
-                        diagnostics.push(this.getMismatchParamCountDiagnostic(paramCount, expCall, file));
-                    }
-                    // Check for Argument type mismatch.
-                    const paramTypeContext = { file: file, scope: scope, position: (_b = expCall.functionExpression.range) === null || _b === void 0 ? void 0 : _b.start };
-                    const argTypeContext = { file: file, scope: scope, position: (_c = expCall.range) === null || _c === void 0 ? void 0 : _c.start };
-                    for (let index = 0; index < funcType.params.length; index++) {
-                        const param = funcType.params[index];
-                        const arg = expCall.args[index];
-                        if (!arg) {
-                            // not enough args
-                            break;
-                        }
-                        let argType = (_d = arg.type) !== null && _d !== void 0 ? _d : new UninitializedType_1.UninitializedType();
-                        const paramType = (0, BscType_1.getTypeFromContext)(param.type, paramTypeContext);
-                        if (!paramType) {
-                            // other error - can not determine what type this parameter should be
-                            continue;
-                        }
-                        argType = (0, BscType_1.getTypeFromContext)(argType, argTypeContext);
-                        let assignable = argType === null || argType === void 0 ? void 0 : argType.isAssignableTo(paramType, argTypeContext);
-                        if (!assignable) {
-                            // TODO TYPES: perhaps this should be a strict mode setting?
-                            assignable = argType === null || argType === void 0 ? void 0 : argType.isConvertibleTo(paramType, argTypeContext);
+            }
+            else {
+                const typeChainScan = util_1.default.processTypeChain(typeChain);
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.cannotFindName(typeChainScan.itemName, typeChainScan.fullNameOfItem)), { range: typeChainScan.range }));
+            }
+        }
+        if (isUsedAsType) {
+            return;
+        }
+        const lastTypeInfo = typeChain[typeChain.length - 1];
+        const parentTypeInfo = typeChain[typeChain.length - 2];
+        this.checkMemberAccessibility(file, expression, typeChain);
+        if ((0, reflection_1.isNamespaceType)(exprType)) {
+            this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.itemCannotBeUsedAsVariable('namespace')), { range: expression.range, file: file }));
+        }
+        else if ((0, reflection_1.isEnumType)(exprType)) {
+            const enumStatement = this.event.scope.getEnum(util_1.default.getAllDottedGetPartsAsString(expression));
+            if (enumStatement) {
+                // there's an enum with this name
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.itemCannotBeUsedAsVariable('enum')), { range: expression.range, file: file }));
+            }
+        }
+        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.default.getAllDottedGetPartsAsString(expression.obj));
+            const typeChainScanForParent = util_1.default.processTypeChain(typeChain.slice(0, -1));
+            if (enumFileLink) {
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.unknownEnumValue(lastTypeInfo === null || lastTypeInfo === void 0 ? void 0 : lastTypeInfo.name, typeChainScanForParent.fullChainName)), { range: lastTypeInfo === null || lastTypeInfo === void 0 ? void 0 : lastTypeInfo.range, relatedInformation: [{
+                            message: 'Enum declared here',
+                            location: util_1.default.createLocation(vscode_uri_1.URI.file(enumFileLink === null || enumFileLink === void 0 ? void 0 : enumFileLink.file.srcPath).toString(), (_b = enumFileLink === null || enumFileLink === void 0 ? void 0 : enumFileLink.item) === null || _b === void 0 ? void 0 : _b.tokens.name.range)
+                        }] }));
+            }
+        }
+    }
+    /**
+     * 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 & SymbolTable_1.SymbolTypeFlag.private) {
+                        if (!inMatchingClassStmt || childChainItem.data.memberOfAncestor) {
+                            this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.memberAccessibilityMismatch(childChainItem.name, childChainItem.data.flags, definingClassName)), { range: expression.range, file: file }));
+                            // there's an error... don't worry about the rest of the chain
+                            return false;
                         }
-                        if (!assignable) {
-                            diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.argumentTypeMismatch(argType === null || argType === void 0 ? void 0 : argType.toString(argTypeContext), paramType.toString(paramTypeContext))), { range: arg === null || arg === void 0 ? void 0 : arg.range, file: file }));
+                    }
+                    // eslint-disable-next-line no-bitwise
+                    if (childChainItem.data.flags & SymbolTable_1.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)), { range: expression.range, file: file }));
+                            // there's an error... don't worry about the rest of the chain
+                            return false;
                         }
                     }
                 }
-                else if ((0, reflection_1.isInvalidType)(symbolTypeInfo.type)) {
-                    // TODO TYPES: standard member functions like integer.ToStr() are not detectable yet.
-                }
-                else if ((0, reflection_1.isDynamicType)(symbolTypeInfo.type)) {
-                    // maybe this is a function? who knows
-                }
-                else {
-                    diagnostics.push(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotFindName(symbolTypeInfo.expandedTokenText, symbolTypeInfo.fullName)), { range: expCall.range, file: file }));
-                }
             }
         }
-        return diagnostics;
+        return true;
+    }
+    /**
+     * Adds a diagnostic to the first scope for this key. Prevents duplicate diagnostics
+     * for diagnostics where scope isn't important. (i.e. CreateObject validations)
+     */
+    addDiagnosticOnce(diagnostic) {
+        this.onceCache.getOrAdd(`${diagnostic.code}-${diagnostic.message}-${util_1.default.rangeToString(diagnostic.range)}`, () => {
+            const diagnosticWithOrigin = Object.assign({}, diagnostic);
+            if (!diagnosticWithOrigin.origin) {
+                // diagnostic does not have origin.
+                // set the origin to the current astSegment
+                diagnosticWithOrigin.origin = interfaces_1.DiagnosticOrigin.ASTSegment;
+                diagnosticWithOrigin.astSegment = this.currentSegmentBeingValidated;
+            }
+            this.event.scope.addDiagnostics([diagnosticWithOrigin]);
+            return true;
+        });
+    }
+    addDiagnostic(diagnostic) {
+        const diagnosticWithOrigin = Object.assign({}, diagnostic);
+        if (!diagnosticWithOrigin.origin) {
+            // diagnostic does not have origin.
+            // set the origin to the current astSegment
+            diagnosticWithOrigin.origin = interfaces_1.DiagnosticOrigin.ASTSegment;
+            diagnosticWithOrigin.astSegment = this.currentSegmentBeingValidated;
+        }
+        this.event.scope.addDiagnostics([diagnosticWithOrigin]);
     }
-    getMismatchParamCountDiagnostic(paramCount, expCall, file) {
-        const minMaxParamsText = paramCount.min === paramCount.max ? paramCount.max : `${paramCount.min}-${paramCount.max}`;
-        const expCallArgCount = expCall.args.length;
-        return (Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.mismatchArgumentCount(minMaxParamsText, expCallArgCount)), { range: expCall.nameRange, file: file }));
+    /**
+     * Add a diagnostic (to the first scope) that will have `relatedInformation` for each affected scope
+     */
+    addMultiScopeDiagnostic(diagnostic) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+        diagnostic = this.multiScopeCache.getOrAdd(`${(_a = diagnostic.file) === null || _a === void 0 ? void 0 : _a.srcPath}-${diagnostic.code}-${diagnostic.message}-${util_1.default.rangeToString(diagnostic.range)}`, () => {
+            if (!diagnostic.relatedInformation) {
+                diagnostic.relatedInformation = [];
+            }
+            const diagnosticWithOrigin = Object.assign({}, diagnostic);
+            if (!diagnosticWithOrigin.origin) {
+                // diagnostic does not have origin.
+                // set the origin to the current astSegment
+                diagnosticWithOrigin.origin = interfaces_1.DiagnosticOrigin.ASTSegment;
+                diagnosticWithOrigin.astSegment = this.currentSegmentBeingValidated;
+            }
+            this.addDiagnostic(diagnosticWithOrigin);
+            return diagnosticWithOrigin;
+        });
+        if ((0, reflection_1.isXmlScope)(this.event.scope) && ((_b = this.event.scope.xmlFile) === null || _b === void 0 ? void 0 : _b.srcPath)) {
+            diagnostic.relatedInformation.push({
+                message: `In component scope '${(_e = (_d = (_c = this.event.scope) === null || _c === void 0 ? void 0 : _c.xmlFile) === null || _d === void 0 ? void 0 : _d.componentName) === null || _e === void 0 ? void 0 : _e.text}'`,
+                location: util_1.default.createLocation(vscode_uri_1.URI.file(this.event.scope.xmlFile.srcPath).toString(), (_o = (_m = (_l = (_k = (_j = (_h = (_g = (_f = this.event.scope) === null || _f === void 0 ? void 0 : _f.xmlFile) === null || _g === void 0 ? void 0 : _g.ast) === null || _h === void 0 ? void 0 : _h.componentElement) === null || _j === void 0 ? void 0 : _j.getAttribute('name')) === null || _k === void 0 ? void 0 : _k.tokens) === null || _l === void 0 ? void 0 : _l.value) === null || _m === void 0 ? void 0 : _m.range) !== null && _o !== void 0 ? _o : util_1.default.createRange(0, 0, 0, 10))
+            });
+        }
+        else {
+            diagnostic.relatedInformation.push({
+                message: `In scope '${this.event.scope.name}'`,
+                location: util_1.default.createLocation(vscode_uri_1.URI.file(diagnostic.file.srcPath).toString(), diagnostic.range)
+            });
+        }
     }
 }
 exports.ScopeValidator = ScopeValidator;