brighterscript 0.66.0-alpha.1 → 0.66.0-alpha.11

package/dist/bscPlugin/validation/ScopeValidator.js

@@ -5,16 +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 Parser_1 = require("../../parser/Parser");
+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,
@@ -22,12 +27,14 @@ const platformComponentNames = new Set(Object.values(roku_types_1.components).ma
  */
 class ScopeValidator {
     constructor() {
-        this.expressionsByFile = new Cache_1.Cache();
         this.onceCache = new Cache_1.Cache();
         this.multiScopeCache = new Cache_1.Cache();
     }
     processEvent(event) {
         this.event = event;
+        if (this.event.program.globalScope === this.event.scope) {
+            return;
+        }
         this.walkFiles();
         this.detectDuplicateEnums();
     }
@@ -39,163 +46,82 @@ class ScopeValidator {
     walkFiles() {
         this.event.scope.enumerateOwnFiles((file) => {
             if ((0, reflection_1.isBrsFile)(file)) {
-                this.iterateFileExpressions(file);
-                this.validateCreateObjectCalls(file);
-            }
-        });
-    }
-    checkIfUsedAsTypeExpression(expression) {
-        //TODO: this is much faster than node.findAncestor(), but will not work for "complicated" type expressions
-        // like UnionTypes
-        if ((0, reflection_1.isTypeExpression)(expression) ||
-            (0, reflection_1.isTypeExpression)(expression.parent)) {
-            return true;
-        }
-        if ((0, reflection_1.isBinaryExpression)(expression.parent)) {
-            let currentExpr = expression.parent;
-            while ((0, reflection_1.isBinaryExpression)(currentExpr) && currentExpr.operator.kind === TokenKind_1.TokenKind.Or) {
-                currentExpr = currentExpr.parent;
-            }
-            return (0, reflection_1.isTypeExpression)(currentExpr);
-        }
-        return false;
-    }
-    iterateFileExpressions(file) {
-        var _a, _b, _c, _d, _e;
-        const { scope } = this.event;
-        //build an expression collection ONCE per file
-        const expressionInfos = this.expressionsByFile.getOrAdd(file, () => {
-            var _a, _b;
-            const result = [];
-            const expressions = [...file.parser.references.expressions];
-            for (let expression of expressions) {
-                if (!expression) {
-                    continue;
-                }
-                //walk left-to-right on every expression, only keep the ones that start with VariableExpression, and then keep subsequent DottedGet parts
-                const parts = util_1.default.getDottedGetPath(expression);
-                if (parts.length > 0) {
-                    result.push({
-                        parts: parts,
-                        expression: expression,
-                        enclosingNamespaceNameLower: (_b = (_a = expression.findAncestor(reflection_1.isNamespaceStatement)) === null || _a === void 0 ? void 0 : _a.getName(Parser_1.ParseMode.BrighterScript)) === null || _b === void 0 ? void 0 : _b.toLowerCase()
-                    });
-                }
-            }
-            return result;
-        });
-        outer: for (const info of expressionInfos) {
-            const firstNamespacePart = info.parts[0].name.text;
-            const firstNamespacePartLower = firstNamespacePart === null || firstNamespacePart === void 0 ? void 0 : firstNamespacePart.toLowerCase();
-            //get the namespace container (accounting for namespace-relative as well)
-            const namespaceContainer = scope.getNamespace(firstNamespacePartLower, info.enclosingNamespaceNameLower);
-            const isUsedAsType = this.checkIfUsedAsTypeExpression(info.expression);
-            let symbolType = SymbolTable_1.SymbolTypeFlag.runtime;
-            let oppositeSymbolType = SymbolTable_1.SymbolTypeFlag.typetime;
-            if (isUsedAsType) {
-                // This is used in a TypeExpression - only look up types from SymbolTable
-                symbolType = SymbolTable_1.SymbolTypeFlag.typetime;
-                oppositeSymbolType = SymbolTable_1.SymbolTypeFlag.runtime;
-            }
-            if (scope.program.options.enableTypeValidation) {
-                // Do a complete type check on all DottedGet and Variable expressions
-                // this will create a diagnostic if an invalid member is accessed
-                const typeChain = [];
-                let exprType = info.expression.getType({
-                    flags: symbolType,
-                    typeChain: typeChain
-                });
-                if (!exprType || !exprType.isResolvable()) {
-                    if ((_a = info.expression.getType({ flags: oppositeSymbolType })) === null || _a === void 0 ? void 0 : _a.isResolvable()) {
-                        const oppoSiteTypeChain = [];
-                        const invalidlyUsedResolvedType = info.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: info.expression.range, file: file }), 'When used in scope');
-                        }
-                        else {
-                            this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.itemCannotBeUsedAsVariable(invalidlyUsedResolvedType.toString())), { range: info.expression.range, file: file }), 'When used in scope');
-                        }
-                        continue;
+                const hasChangeInfo = this.event.changedFiles && this.event.changedSymbols;
+                let thisFileRequiresChangedSymbol = false;
+                for (let requiredSymbol of file.requiredSymbols) {
+                    const changeSymbolSetForFlag = this.event.changedSymbols.get(requiredSymbol.flags);
+                    if (util_1.default.setContainsUnresolvedSymbol(changeSymbolSetForFlag, requiredSymbol)) {
+                        thisFileRequiresChangedSymbol = true;
                     }
-                    const typeChainScan = util_1.default.processTypeChain(typeChain);
-                    this.addMultiScopeDiagnostic(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.cannotFindName(typeChainScan.missingItemName, typeChainScan.fullNameOfMissingItem)), { range: typeChainScan.range }));
-                    //skip to the next expression
-                    continue;
                 }
-            }
-            else {
-                //flag all unknown left-most variables only
-                const symbolTable = info.expression.getSymbolTable();
-                const firstPart = info.parts[0];
-                if (!(symbolTable === null || symbolTable === void 0 ? void 0 : symbolTable.hasSymbol((_b = firstPart.name) === null || _b === void 0 ? void 0 : _b.text, symbolType)) &&
-                    !namespaceContainer) {
-                    this.addMultiScopeDiagnostic(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.cannotFindName((_c = firstPart.name) === null || _c === void 0 ? void 0 : _c.text)), { range: firstPart.name.range }));
-                    //skip to the next expression
-                    continue;
+                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;
                 }
-            }
-            const enumStatement = scope.getEnum(firstNamespacePartLower, info.enclosingNamespaceNameLower);
-            //if this isn't a namespace, skip it
-            if (!namespaceContainer && !enumStatement) {
-                continue;
-            }
-            //catch unknown namespace items
-            let entityName = firstNamespacePart;
-            let entityNameLower = firstNamespacePart.toLowerCase();
-            for (let i = 1; i < info.parts.length; i++) {
-                const part = info.parts[i];
-                entityName += '.' + part.name.text;
-                entityNameLower += '.' + part.name.text.toLowerCase();
-                //if this is an enum member, stop validating here to prevent errors further down the chain
-                if (scope.getEnumMemberFileLink(entityName, info.enclosingNamespaceNameLower)) {
-                    break;
+                if (thisFileHasChanges) {
+                    this.event.scope.clearAstSegmentDiagnosticsByFile(file);
                 }
-                if (!scope.getEnumMap().has(entityNameLower) &&
-                    !scope.getClassMap().has(entityNameLower) &&
-                    !scope.getInterfaceMap().has(entityNameLower) &&
-                    !scope.getConstMap().has(entityNameLower) &&
-                    !scope.getCallableByName(entityNameLower) &&
-                    !scope.getNamespace(entityNameLower, info.enclosingNamespaceNameLower)) {
-                    //if this looks like an enum, provide a nicer error message
-                    const theEnum = (_d = this.getEnum(scope, entityNameLower)) === null || _d === void 0 ? void 0 : _d.item;
-                    if (theEnum) {
-                        this.addMultiScopeDiagnostic(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.unknownEnumValue((_e = part.name.text) === null || _e === void 0 ? void 0 : _e.split('.').pop(), theEnum.fullName)), { range: part.name.range, relatedInformation: [{
-                                    message: 'Enum declared here',
-                                    location: util_1.default.createLocation(vscode_uri_1.URI.file(file.srcPath).toString(), theEnum.tokens.name.range)
-                                }] }));
+                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);
                     }
-                    else {
-                        this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.cannotFindName(part.name.text, entityName)), { range: part.name.range, file: file }));
-                    }
-                    //no need to add another diagnostic for future unknown items
-                    continue outer;
+                });
+                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);
                 }
             }
-            //if the full expression is just an enum name, this is an illegal statement because enums don't exist at runtime
-            if (!isUsedAsType && enumStatement && info.parts.length === 1) {
-                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.itemCannotBeUsedAsVariable('enum')), { range: info.expression.range, file: file }), 'When used in scope');
-            }
-            //if the full expression is a namespace path, this is an illegal statement because namespaces don't exist at runtme
-            if (scope.getNamespace(entityNameLower, info.enclosingNamespaceNameLower)) {
-                this.addMultiScopeDiagnostic(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.itemCannotBeUsedAsVariable('namespace')), { range: info.expression.range, file: file }), 'When used in scope');
-            }
-        }
+        });
+    }
+    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.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
@@ -236,7 +162,7 @@ class ScopeValidator {
                 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 }));
             }
         }
         this.event.scope.addDiagnostics(diagnostics);
@@ -247,57 +173,296 @@ 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(file) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
-        const diagnostics = [];
-        for (const call of file.functionCalls) {
-            //skip non CreateObject function calls
-            if (((_a = call.name) === null || _a === void 0 ? void 0 : _a.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];
             }
-            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;
+            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 };
+        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++;
                 }
-                //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()) && !this.event.program.getComponent(unquotedComponentName)) {
-                    this.addDiagnosticOnce(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.unknownRoSGNode(unquotedComponentName)), { range: componentName.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 ((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 }));
+                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++;
             }
-            else if (!platformComponentNames.has(firstParamStringValue.toLowerCase())) {
-                this.addDiagnosticOnce(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.unknownBrightScriptComponent(firstParamStringValue)), { range: firstParamToken.range }));
+        }
+    }
+    /**
+     * 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 }));
             }
-            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 }));
+        }
+    }
+    /**
+     * Detect return statements with incompatible types vs. declared return type
+     */
+    validateDottedSetStatement(file, dottedSetStmt) {
+        var _a, _b, _c;
+        const getTypeOpts = { flags: SymbolTable_1.SymbolTypeFlag.runtime };
+        const expectedLHSType = (_b = (_a = dottedSetStmt === null || dottedSetStmt === void 0 ? void 0 : dottedSetStmt.obj) === null || _a === void 0 ? void 0 : _a.getType(getTypeOpts)) === null || _b === void 0 ? void 0 : _b.getMemberType(dottedSetStmt.name.text, getTypeOpts);
+        const actualRHSType = (_c = dottedSetStmt === null || dottedSetStmt === void 0 ? void 0 : dottedSetStmt.value) === null || _c === void 0 ? void 0 : _c.getType(getTypeOpts);
+        const compatibilityData = {};
+        if ((expectedLHSType === null || expectedLHSType === void 0 ? void 0 : expectedLHSType.isResolvable()) && !(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 }));
                 }
-                // Test for deprecation
-                if (brightScriptComponent.isDeprecated) {
-                    this.addDiagnosticOnce(Object.assign(Object.assign({ file: file }, DiagnosticMessages_1.DiagnosticMessages.deprecatedBrightScriptComponent(firstParamStringValue, brightScriptComponent.deprecatedDescription)), { range: call.range }));
+                else {
+                    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];
+        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)
+                        }] }));
+            }
         }
-        this.event.scope.addDiagnostics(diagnostics);
     }
     /**
      * Adds a diagnostic to the first scope for this key. Prevents duplicate diagnostics
@@ -305,35 +470,58 @@ class ScopeValidator {
      */
     addDiagnosticOnce(diagnostic) {
         this.onceCache.getOrAdd(`${diagnostic.code}-${diagnostic.message}-${util_1.default.rangeToString(diagnostic.range)}`, () => {
-            this.event.scope.addDiagnostics([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]);
             return true;
         });
     }
     addDiagnostic(diagnostic) {
-        this.event.scope.addDiagnostics([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, message = 'Not defined in scope') {
-        var _a, _b;
+    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 = [];
             }
-            this.addDiagnostic(diagnostic);
-            return 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.addDiagnostic(diagnosticWithOrigin);
+            return diagnosticWithOrigin;
         });
-        const info = {
-            message: `${message} '${this.event.scope.name}'`
-        };
         if ((0, reflection_1.isXmlScope)(this.event.scope) && ((_b = this.event.scope.xmlFile) === null || _b === void 0 ? void 0 : _b.srcPath)) {
-            info.location = util_1.default.createLocation(vscode_uri_1.URI.file(this.event.scope.xmlFile.srcPath).toString(), util_1.default.createRange(0, 0, 0, 10));
+            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 {
-            info.location = util_1.default.createLocation(vscode_uri_1.URI.file(diagnostic.file.srcPath).toString(), diagnostic.range);
+            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)
+            });
         }
-        diagnostic.relatedInformation.push(info);
     }
 }
 exports.ScopeValidator = ScopeValidator;