brighterscript 1.0.0-alpha.23 → 1.0.0-alpha.25

package/dist/bscPlugin/validation/ScopeValidator.js

@@ -1,18 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ScopeValidator = void 0;
-const vscode_languageserver_1 = require("vscode-languageserver");
 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 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,
@@ -20,85 +27,117 @@ const platformComponentNames = new Set(Object.values(roku_types_1.components).ma
  */
 class ScopeValidator {
     constructor() {
-        this.events = [];
-        this.cache = new Map();
+        this.onceCache = new Cache_1.Cache();
+        this.multiScopeCache = new Cache_1.Cache();
     }
     processEvent(event) {
-        this.events.push(event);
-        this.validateEnumUsage(event);
-        this.detectDuplicateEnums(event);
-        this.validateCreateObjectCalls(event);
+        this.event = event;
+        if (this.event.program.globalScope === this.event.scope) {
+            return;
+        }
+        this.walkFiles();
+        this.detectDuplicateEnums();
     }
     reset() {
-        this.cache.clear();
-        this.events = [];
+        this.event = undefined;
+        this.onceCache.clear();
+        this.multiScopeCache.clear();
     }
-    /**
-     * 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) {
-        const key = `${diagnostic.code}-${diagnostic.message}-${util_1.default.rangeToString(diagnostic.range)}`;
-        if (!this.cache.has(key)) {
-            this.cache.set(key, true);
-            event.scope.addDiagnostics([diagnostic]);
-        }
-    }
-    /**
-     * Find all expressions and validate the ones that look like enums
-     */
-    validateEnumUsage(event) {
-        const diagnostics = [];
-        //if there are any enums defined in this scope
-        const enumLookup = event.scope.getEnumMap();
-        //skip enum validation if there are no enums defined in this scope
-        if (enumLookup.size === 0) {
-            return;
-        }
-        event.scope.enumerateOwnFiles((file) => {
-            var _a;
-            //skip non-brs files
-            if (!(0, reflection_1.isBrsFile)(file)) {
-                return;
-            }
-            // const namespaceLookup = this.event.scopes[0]?.namespaceLookup;
-            for (const referenceExpression of file.parser.references.expressions) {
-                const actualExpressions = [];
-                //binary expressions actually have two expressions (left and right), so handle them independently
-                if ((0, reflection_1.isBinaryExpression)(referenceExpression)) {
-                    actualExpressions.push(referenceExpression.left, referenceExpression.right);
+    walkFiles() {
+        this.event.scope.enumerateOwnFiles((file) => {
+            if ((0, reflection_1.isBrsFile)(file)) {
+                const hasChangeInfo = this.event.changedFiles && this.event.changedSymbols;
+                let thisFileRequiresChangedSymbol = false;
+                for (let requiredSymbol of file.requiredSymbols) {
+                    // eslint-disable-next-line no-bitwise
+                    for (const flag of [SymbolTable_1.SymbolTypeFlag.runtime, SymbolTable_1.SymbolTypeFlag.typetime]) {
+                        // 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;
+                            }
+                        }
+                    }
                 }
-                else {
-                    //assume all other expressions are a single chain
-                    actualExpressions.push(referenceExpression);
+                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;
                 }
-                for (let expression of actualExpressions) {
-                    const tokens = util_1.default.getAllDottedGetParts(expression);
-                    if (tokens) {
-                        //build the full name of the thing
-                        const parts = tokens.map(x => x.text);
-                        const fullName = parts.join('.');
-                        const memberName = parts.pop();
-                        const fullParentName = parts.join('.');
-                        const theEnum = (_a = event.scope.getEnumMap().get(fullParentName.toLowerCase())) === null || _a === void 0 ? void 0 : _a.item;
-                        //is an enum and this field does not exist
-                        if (theEnum && !event.scope.getEnumMemberMap().has(fullName.toLowerCase())) {
-                            diagnostics.push(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.unknownEnumValue(memberName, fullParentName)), { range: tokens[tokens.length - 1].range, relatedInformation: [{
-                                        message: 'Enum declared here',
-                                        location: vscode_languageserver_1.Location.create(vscode_uri_1.URI.file(file.srcPath).toString(), theEnum.tokens.name.range)
-                                    }] }));
-                        }
+                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);
                     }
+                });
+                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);
                 }
             }
         });
-        event.scope.addDiagnostics(diagnostics);
     }
-    detectDuplicateEnums(event) {
+    isTypeKnown(exprType) {
+        let isKnownType = exprType === null || exprType === void 0 ? void 0 : exprType.isResolvable();
+        return isKnownType;
+    }
+    /**
+     * If this is the lhs of an assignment, we don't need to flag it as unresolved
+     */
+    ignoreUnresolvedAssignmentLHS(expression, exprType, definingNode) {
+        var _a, _b;
+        if (!(0, reflection_1.isVariableExpression)(expression)) {
+            return false;
+        }
+        let assignmentAncestor;
+        if ((0, reflection_1.isAssignmentStatement)(definingNode) && definingNode.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.name) === null || _a === void 0 ? void 0 : _a.text.toLowerCase()) === ((_b = expression === null || expression === void 0 ? void 0 : expression.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.name) === (expression === null || expression === void 0 ? void 0 : expression.name) && (0, reflection_1.isUnionType)(exprType);
+    }
+    /**
+     * Flag duplicate enums
+     */
+    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) {
@@ -112,17 +151,28 @@ class ScopeValidator {
         //now that we've collected all enum declarations, flag duplicates
         for (const enumLocations of enumLocationsByName.values()) {
             //sort by srcPath to keep the primary enum location consistent
-            enumLocations.sort((a, b) => { var _a, _b, _c; return (_b = (_a = a.file) === null || _a === void 0 ? void 0 : _a.srcPath) === null || _b === void 0 ? void 0 : _b.localeCompare((_c = b.file) === null || _c === void 0 ? void 0 : _c.srcPath); });
+            enumLocations.sort((a, b) => {
+                var _a, _b;
+                const pathA = (_a = a.file) === null || _a === void 0 ? void 0 : _a.srcPath;
+                const pathB = (_b = b.file) === null || _b === void 0 ? void 0 : _b.srcPath;
+                if (pathA < pathB) {
+                    return -1;
+                }
+                else if (pathA > pathB) {
+                    return 1;
+                }
+                return 0;
+            });
             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: vscode_languageserver_1.Location.create(vscode_uri_1.URI.file(primaryEnum.file.srcPath).toString(), primaryEnum.statement.tokens.name.range)
-                        }] }));
+                            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`.
@@ -130,59 +180,407 @@ 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;
+    validateCreateObjectCall(file, call) {
+        var _a, _b, _c, _d, _e, _f;
+        //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 = (_b = call === null || call === void 0 ? void 0 : call.args[0]) === null || _b === void 0 ? void 0 : _b.token;
+        const firstParamStringValue = (_c = firstParamToken === null || firstParamToken === void 0 ? void 0 : firstParamToken.text) === null || _c === void 0 ? void 0 : _c.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)(call === null || call === void 0 ? void 0 : call.args[1])) {
+            const componentName = (_d = call === null || call === void 0 ? void 0 : call.args[1]) === null || _d === void 0 ? void 0 : _d.token;
+            //don't validate any components with a colon in their name (probably component libraries, but regular components can have them too).
+            if ((_e = componentName === null || componentName === void 0 ? void 0 : componentName.text) === null || _e === void 0 ? void 0 : _e.includes(':')) {
+                return;
+            }
+            //add diagnostic for unknown components
+            const unquotedComponentName = (_f = componentName === null || componentName === void 0 ? void 0 : componentName.text) === null || _f === void 0 ? void 0 : _f.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(firstParamStringValue.toLowerCase())) {
+            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[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(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(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++;
                 }
-                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 }));
+            }
+            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;
+                }
+                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();
                     }
                 }
-                else if (!platformComponentNames.has(firstParamStringValue.toLowerCase())) {
-                    this.addDiagnosticOnce(event, Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.unknownBrightScriptComponent(firstParamStringValue)), { range: firstParamToken.range }));
+                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++;
+            }
+        }
+    }
+    /**
+     * 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 }));
+            }
+        }
+    }
+    /**
+     * 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);
+        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 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.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.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.operator, rightTypeToTest);
+            if ((0, reflection_1.isDynamicType)(opResult)) {
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.operatorTypeMismatch(unaryExpr.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.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.name === expression.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 }));
                 }
                 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 }));
+                    this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.itemCannotBeUsedAsVariable(invalidlyUsedResolvedType.toString())), { range: expression.range, file: file }));
+                }
+            }
+            else {
+                const typeChainScan = util_1.default.processTypeChain(typeChain);
+                this.addMultiScopeDiagnostic(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.cannotFindName(typeChainScan.itemName, typeChainScan.fullNameOfItem)), { range: typeChainScan.range }));
+            }
+        }
+        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;
+                        }
                     }
-                    // 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 }));
+                    // 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;
+                        }
                     }
                 }
             }
+        }
+        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;
         });
-        event.scope.addDiagnostics(diagnostics);
+    }
+    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]);
+    }
+    /**
+     * 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;