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

package/dist/bscPlugin/validation/BrsFileValidator.js

@@ -0,0 +1,714 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrsFileValidator = void 0;
+const reflection_1 = require("../../astUtils/reflection");
+const visitors_1 = require("../../astUtils/visitors");
+const DiagnosticMessages_1 = require("../../DiagnosticMessages");
+const TokenKind_1 = require("../../lexer/TokenKind");
+const Expression_1 = require("../../parser/Expression");
+const Parser_1 = require("../../parser/Parser");
+const AssociativeArrayType_1 = require("../../types/AssociativeArrayType");
+const DynamicType_1 = require("../../types/DynamicType");
+const util_1 = require("../../util");
+const BrightScriptDocParser_1 = require("../../parser/BrightScriptDocParser");
+const TypeStatementType_1 = require("../../types/TypeStatementType");
+const semver = require("semver");
+class BrsFileValidator {
+    constructor(event) {
+        this.event = event;
+    }
+    process() {
+        const unlinkGlobalSymbolTable = this.event.file.parser.symbolTable.pushParentProvider(() => this.event.program.globalScope.symbolTable);
+        util_1.default.validateTooDeepFile(this.event.file);
+        // Invalidate cache on this file
+        // It could have potentially changed before this from plugins, after this, it will not change
+        // eslint-disable-next-line @typescript-eslint/dot-notation
+        this.event.file['_cachedLookups'].invalidate();
+        // make a copy of the bsConsts, because they might be added to
+        const bsConstsBackup = new Map(this.event.file.ast.getBsConsts());
+        this.walk();
+        this.flagTopLevelStatements();
+        //only validate the file if it was actually parsed (skip files containing typedefs)
+        if (!this.event.file.hasTypedef) {
+            this.validateTopOfFileStatements();
+            this.validateTypecastStatements();
+        }
+        this.event.file.ast.bsConsts = bsConstsBackup;
+        unlinkGlobalSymbolTable();
+    }
+    /**
+     * Walk the full AST
+     */
+    walk() {
+        const isBrighterscript = this.event.file.parser.options.mode === Parser_1.ParseMode.BrighterScript;
+        const visitor = (0, visitors_1.createVisitor)({
+            MethodStatement: (node) => {
+                //add the `super` symbol to class methods
+                if ((0, reflection_1.isClassStatement)(node.parent) && node.parent.hasParentClass()) {
+                    const data = {};
+                    const parentClassType = node.parent.parentClassName.getType({ flags: 2 /* SymbolTypeFlag.typetime */, data: data });
+                    node.func.body.getSymbolTable().addSymbol('super', Object.assign(Object.assign({}, data), { isInstance: true }), parentClassType, 1 /* SymbolTypeFlag.runtime */);
+                }
+            },
+            CallfuncExpression: (node) => {
+                if (node.args.length > 5) {
+                    this.event.program.diagnostics.register(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.callfuncHasToManyArgs(node.args.length)), { location: node.tokens.methodName.location }));
+                }
+            },
+            DottedGetExpression: (node) => {
+                var _a, _b, _c;
+                if (((_a = node.tokens.dot) === null || _a === void 0 ? void 0 : _a.kind) === TokenKind_1.TokenKind.QuestionDot) {
+                    this.validateMinFirmwareVersionForOptionalChaining((_c = (_b = node.tokens.dot) === null || _b === void 0 ? void 0 : _b.location) === null || _c === void 0 ? void 0 : _c.range);
+                }
+            },
+            IndexedGetExpression: (node) => {
+                var _a, _b, _c, _d, _e, _f;
+                if (node.tokens.questionDot || ((_a = node.tokens.openingSquare) === null || _a === void 0 ? void 0 : _a.kind) === TokenKind_1.TokenKind.QuestionLeftSquare) {
+                    const range = (_d = (_c = (_b = node.tokens.questionDot) === null || _b === void 0 ? void 0 : _b.location) === null || _c === void 0 ? void 0 : _c.range) !== null && _d !== void 0 ? _d : (_f = (_e = node.tokens.openingSquare) === null || _e === void 0 ? void 0 : _e.location) === null || _f === void 0 ? void 0 : _f.range;
+                    this.validateMinFirmwareVersionForOptionalChaining(range);
+                }
+            },
+            CallExpression: (node) => {
+                var _a, _b, _c;
+                if (((_a = node.tokens.openingParen) === null || _a === void 0 ? void 0 : _a.kind) === TokenKind_1.TokenKind.QuestionLeftParen) {
+                    this.validateMinFirmwareVersionForOptionalChaining((_c = (_b = node.tokens.openingParen) === null || _b === void 0 ? void 0 : _b.location) === null || _c === void 0 ? void 0 : _c.range);
+                }
+            },
+            EnumStatement: (node) => {
+                var _a;
+                this.validateDeclarationLocations(node, 'enum', () => util_1.default.createBoundingRange(node.tokens.enum, node.tokens.name));
+                this.validateEnumDeclaration(node);
+                if (!node.tokens.name) {
+                    return;
+                }
+                //register this enum declaration
+                const nodeType = node.getType({ flags: 2 /* SymbolTypeFlag.typetime */ });
+                // eslint-disable-next-line no-bitwise
+                (_a = node.parent.getSymbolTable()) === null || _a === void 0 ? void 0 : _a.addSymbol(node.tokens.name.text, { definingNode: node }, nodeType, 2 /* SymbolTypeFlag.typetime */ | 1 /* SymbolTypeFlag.runtime */);
+            },
+            ClassStatement: (node) => {
+                var _a, _b, _c;
+                if (!((_a = node === null || node === void 0 ? void 0 : node.tokens) === null || _a === void 0 ? void 0 : _a.name)) {
+                    return;
+                }
+                this.validateDeclarationLocations(node, 'class', () => util_1.default.createBoundingRange(node.tokens.class, node.tokens.name));
+                //register this class
+                const nodeType = node.getType({ flags: 2 /* SymbolTypeFlag.typetime */ });
+                node.getSymbolTable().addSymbol('m', { definingNode: node, isInstance: true }, nodeType, 1 /* SymbolTypeFlag.runtime */);
+                // eslint-disable-next-line no-bitwise
+                (_b = node.parent.getSymbolTable()) === null || _b === void 0 ? void 0 : _b.addSymbol((_c = node.tokens.name) === null || _c === void 0 ? void 0 : _c.text, { definingNode: node }, nodeType, 2 /* SymbolTypeFlag.typetime */ | 1 /* SymbolTypeFlag.runtime */);
+                if (node.findAncestor(reflection_1.isNamespaceStatement)) {
+                    //add the transpiled name for namespaced constructors to the root symbol table
+                    const transpiledClassConstructor = node.getName(Parser_1.ParseMode.BrightScript);
+                    this.event.file.parser.ast.symbolTable.addSymbol(transpiledClassConstructor, { definingNode: node }, node.getConstructorType(), 
+                    // eslint-disable-next-line no-bitwise
+                    1 /* SymbolTypeFlag.runtime */ | 32 /* SymbolTypeFlag.postTranspile */);
+                }
+            },
+            AssignmentStatement: (node) => {
+                var _a, _b;
+                if (!((_a = node === null || node === void 0 ? void 0 : node.tokens) === null || _a === void 0 ? void 0 : _a.name)) {
+                    return;
+                }
+                if ((0, reflection_1.isForStatement)(node.parent) && node.parent.counterDeclaration === node) {
+                    // for loop variable variable is added to the block symbol table elsewhere
+                    return;
+                }
+                const data = {};
+                //register this variable
+                let nodeType = node.getType({ flags: 1 /* SymbolTypeFlag.runtime */, data: data });
+                if ((0, reflection_1.isInvalidType)(nodeType) || (0, reflection_1.isVoidType)(nodeType)) {
+                    nodeType = DynamicType_1.DynamicType.instance;
+                }
+                (_b = node.parent.getSymbolTable()) === null || _b === void 0 ? void 0 : _b.addSymbol(node.tokens.name.text, { definingNode: node, isInstance: true, isFromDocComment: data.isFromDocComment, isFromCallFunc: data.isFromCallFunc }, nodeType, 1 /* SymbolTypeFlag.runtime */);
+            },
+            DottedSetStatement: (node) => {
+                this.validateNoOptionalChainingInVarSet(node, [node.obj]);
+            },
+            IndexedSetStatement: (node) => {
+                this.validateNoOptionalChainingInVarSet(node, [node.obj]);
+            },
+            ForEachStatement: (node) => {
+                //registering the for loop variable happens in the visitor for Block, since the loop variable is scoped to the loop body
+            },
+            NamespaceStatement: (node) => {
+                if (!(node === null || node === void 0 ? void 0 : node.nameExpression)) {
+                    return;
+                }
+                this.validateDeclarationLocations(node, 'namespace', () => util_1.default.createBoundingRange(node.tokens.namespace, node.nameExpression));
+                //Namespace Types are added at the Scope level - This is handled when the SymbolTables get linked
+            },
+            FunctionStatement: (node) => {
+                var _a, _b, _c;
+                this.validateDeclarationLocations(node, 'function', () => util_1.default.createBoundingRange(node.func.tokens.functionType, node.tokens.name));
+                const funcType = node.getType({ flags: 2 /* SymbolTypeFlag.typetime */ });
+                if ((_a = node.tokens.name) === null || _a === void 0 ? void 0 : _a.text) {
+                    node.parent.getSymbolTable().addSymbol(node.tokens.name.text, { definingNode: node }, funcType, 1 /* SymbolTypeFlag.runtime */);
+                }
+                const namespace = node.findAncestor(reflection_1.isNamespaceStatement);
+                //this function is declared inside a namespace
+                if (namespace) {
+                    namespace.getSymbolTable().addSymbol((_b = node.tokens.name) === null || _b === void 0 ? void 0 : _b.text, { definingNode: node }, funcType, 1 /* SymbolTypeFlag.runtime */);
+                    if (!((_c = node.tokens) === null || _c === void 0 ? void 0 : _c.name)) {
+                        return;
+                    }
+                    //add the transpiled name for namespaced functions to the root symbol table
+                    const transpiledNamespaceFunctionName = node.getName(Parser_1.ParseMode.BrightScript);
+                    this.event.file.parser.ast.symbolTable.addSymbol(transpiledNamespaceFunctionName, { definingNode: node }, funcType, 
+                    // eslint-disable-next-line no-bitwise
+                    1 /* SymbolTypeFlag.runtime */ | 32 /* SymbolTypeFlag.postTranspile */);
+                }
+            },
+            FunctionExpression: (node) => {
+                var _a, _b;
+                const funcSymbolTable = node.getSymbolTable();
+                const isInlineFunc = !((0, reflection_1.isFunctionStatement)(node.parent) || (0, reflection_1.isMethodStatement)(node.parent));
+                if (isInlineFunc) {
+                    // symbol table should not include any symbols from parent func
+                    funcSymbolTable.pushParentProvider(() => node.findAncestor(reflection_1.isBody).getSymbolTable());
+                }
+                if (!(funcSymbolTable === null || funcSymbolTable === void 0 ? void 0 : funcSymbolTable.hasSymbol('m', 1 /* SymbolTypeFlag.runtime */)) || isInlineFunc) {
+                    if (!(0, reflection_1.isTypecastStatement)((_b = (_a = node.body) === null || _a === void 0 ? void 0 : _a.statements) === null || _b === void 0 ? void 0 : _b[0])) {
+                        // if this is an inline function, or if the function body does not start with a typecast statement, add the `m` symbol to the function scope. If the function body starts with a typecast statement, the `m` symbol will be added in the visitor for TypecastStatement, and it will be typed as the type from the typecast statement
+                        funcSymbolTable === null || funcSymbolTable === void 0 ? void 0 : funcSymbolTable.addSymbol('m', { isInstance: true }, new AssociativeArrayType_1.AssociativeArrayType(), 1 /* SymbolTypeFlag.runtime */);
+                    }
+                }
+                this.validateFunctionParameterCount(node);
+            },
+            FunctionParameterExpression: (node) => {
+                var _a, _b, _c;
+                if ((0, reflection_1.isTypedFunctionTypeExpression)(node.parent)) {
+                    return;
+                }
+                const paramName = (_b = (_a = node.tokens) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.text;
+                if (!paramName) {
+                    return;
+                }
+                const data = {};
+                const nodeType = node.getType({ flags: 2 /* SymbolTypeFlag.typetime */, data: data });
+                // add param symbol at expression level, so it can be used as default value in other params
+                const funcExpr = node.findAncestor(reflection_1.isFunctionExpression);
+                const funcSymbolTable = funcExpr === null || funcExpr === void 0 ? void 0 : funcExpr.getSymbolTable();
+                const extraSymbolData = {
+                    definingNode: node,
+                    isInstance: true,
+                    isFromDocComment: data.isFromDocComment,
+                    description: data.description
+                };
+                funcSymbolTable === null || funcSymbolTable === void 0 ? void 0 : funcSymbolTable.addSymbol(paramName, extraSymbolData, nodeType, 1 /* SymbolTypeFlag.runtime */);
+                //also add param symbol at block level, as it may be redefined, and if so, should show a union
+                (_c = funcExpr.body.getSymbolTable()) === null || _c === void 0 ? void 0 : _c.addSymbol(paramName, extraSymbolData, nodeType, 1 /* SymbolTypeFlag.runtime */);
+            },
+            InterfaceStatement: (node) => {
+                if (!node.tokens.name) {
+                    return;
+                }
+                this.validateDeclarationLocations(node, 'interface', () => util_1.default.createBoundingRange(node.tokens.interface, node.tokens.name));
+                const nodeType = node.getType({ flags: 2 /* SymbolTypeFlag.typetime */ });
+                // eslint-disable-next-line no-bitwise
+                node.parent.getSymbolTable().addSymbol(node.tokens.name.text, { definingNode: node }, nodeType, 2 /* SymbolTypeFlag.typetime */);
+            },
+            ConstStatement: (node) => {
+                if (!node.tokens.name) {
+                    return;
+                }
+                this.validateDeclarationLocations(node, 'const', () => util_1.default.createBoundingRange(node.tokens.const, node.tokens.name));
+                const nodeType = node.getType({ flags: 1 /* SymbolTypeFlag.runtime */ });
+                node.parent.getSymbolTable().addSymbol(node.tokens.name.text, { definingNode: node, isInstance: true }, nodeType, 1 /* SymbolTypeFlag.runtime */);
+            },
+            CatchStatement: (node) => {
+                var _a, _b, _c;
+                //brs and bs both support variableExpression for the exception variable
+                if ((0, reflection_1.isVariableExpression)(node.exceptionVariableExpression)) {
+                    node.parent.getSymbolTable().addSymbol(node.exceptionVariableExpression.getName(), { definingNode: node, isInstance: true }, 
+                    //TODO I think we can produce a slightly more specific type here (like an AA but with the known exception properties)
+                    DynamicType_1.DynamicType.instance, 1 /* SymbolTypeFlag.runtime */);
+                    //brighterscript allows catch without an exception variable
+                }
+                else if (isBrighterscript && !node.exceptionVariableExpression) {
+                    //this is fine
+                    //brighterscript allows a typecast expression here
+                }
+                else if (isBrighterscript && (0, reflection_1.isTypecastExpression)(node.exceptionVariableExpression) && (0, reflection_1.isVariableExpression)(node.exceptionVariableExpression.obj)) {
+                    node.parent.getSymbolTable().addSymbol(node.exceptionVariableExpression.obj.getName(), { definingNode: node, isInstance: true }, node.exceptionVariableExpression.getType({ flags: 1 /* SymbolTypeFlag.runtime */ }), 1 /* SymbolTypeFlag.runtime */);
+                    //no other expressions are allowed here
+                }
+                else {
+                    this.event.program.diagnostics.register(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.expectedExceptionVarToFollowCatch()), { location: (_b = (_a = node.exceptionVariableExpression) === null || _a === void 0 ? void 0 : _a.location) !== null && _b !== void 0 ? _b : (_c = node.tokens.catch) === null || _c === void 0 ? void 0 : _c.location }));
+                }
+            },
+            DimStatement: (node) => {
+                if (node.tokens.name) {
+                    node.parent.getSymbolTable().addSymbol(node.tokens.name.text, { definingNode: node, isInstance: true }, node.getType({ flags: 1 /* SymbolTypeFlag.runtime */ }), 1 /* SymbolTypeFlag.runtime */);
+                }
+            },
+            ReturnStatement: (node) => {
+                var _a, _b, _c, _d, _e;
+                const func = node.findAncestor(reflection_1.isFunctionExpression);
+                //these situations cannot have a value next to `return`
+                if (
+                //`function as void`, `sub as void`
+                ((0, reflection_1.isVariableExpression)((_a = func === null || func === void 0 ? void 0 : func.returnTypeExpression) === null || _a === void 0 ? void 0 : _a.expression) && ((_b = func.returnTypeExpression.expression.tokens.name.text) === null || _b === void 0 ? void 0 : _b.toLowerCase()) === 'void') ||
+                    //`sub` <without return value>
+                    (((_c = func.tokens.functionType) === null || _c === void 0 ? void 0 : _c.kind) === TokenKind_1.TokenKind.Sub && !func.returnTypeExpression)) {
+                    //there may not be a return value
+                    if (node.value) {
+                        this.event.program.diagnostics.register(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.voidFunctionMayNotReturnValue((_d = func.tokens.functionType) === null || _d === void 0 ? void 0 : _d.text)), { location: node.location }));
+                    }
+                }
+                else {
+                    //there MUST be a return value
+                    if (!node.value) {
+                        this.event.program.diagnostics.register(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.nonVoidFunctionMustReturnValue((_e = func === null || func === void 0 ? void 0 : func.tokens.functionType) === null || _e === void 0 ? void 0 : _e.text)), { location: node.location }));
+                    }
+                }
+            },
+            ContinueStatement: (node) => {
+                this.validateContinueStatement(node);
+            },
+            TypecastStatement: (node) => {
+                const obj = node.typecastExpression.obj;
+                if ((0, reflection_1.isVariableExpression)(obj)) {
+                    node.parent.getSymbolTable().addSymbol(obj.tokens.name.text, { definingNode: node, doNotMerge: true, isInstance: true }, node.getType({ flags: 2 /* SymbolTypeFlag.typetime */ }), 1 /* SymbolTypeFlag.runtime */);
+                }
+            },
+            ConditionalCompileConstStatement: (node) => {
+                var _a;
+                const assign = node.assignment;
+                const constNameLower = (_a = assign.tokens.name) === null || _a === void 0 ? void 0 : _a.text.toLowerCase();
+                const astBsConsts = this.event.file.ast.bsConsts;
+                if ((0, reflection_1.isLiteralExpression)(assign.value)) {
+                    astBsConsts.set(constNameLower, assign.value.tokens.value.text.toLowerCase() === 'true');
+                }
+                else if ((0, reflection_1.isVariableExpression)(assign.value)) {
+                    if (this.validateConditionalCompileConst(assign.value.tokens.name)) {
+                        astBsConsts.set(constNameLower, astBsConsts.get(assign.value.tokens.name.text.toLowerCase()));
+                    }
+                }
+            },
+            ConditionalCompileStatement: (node) => {
+                this.validateConditionalCompileConst(node.tokens.condition);
+            },
+            ConditionalCompileErrorStatement: (node) => {
+                this.event.program.diagnostics.register(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.hashError(node.tokens.message.text)), { location: node.location }));
+            },
+            AliasStatement: (node) => {
+                // eslint-disable-next-line no-bitwise
+                const targetType = node.value.getType({ flags: 2 /* SymbolTypeFlag.typetime */ | 1 /* SymbolTypeFlag.runtime */ });
+                // eslint-disable-next-line no-bitwise
+                node.parent.getSymbolTable().addSymbol(node.tokens.name.text, { definingNode: node, doNotMerge: true, isAlias: true }, targetType, 1 /* SymbolTypeFlag.runtime */ | 2 /* SymbolTypeFlag.typetime */);
+            },
+            TypeStatement: (node) => {
+                this.validateDeclarationLocations(node, 'type', () => util_1.default.createBoundingRange(node.tokens.type, node.tokens.name));
+                const wrappedNodeType = node.getType({ flags: 1 /* SymbolTypeFlag.runtime */ });
+                const typeStmtType = new TypeStatementType_1.TypeStatementType(node.tokens.name.text, wrappedNodeType);
+                node.parent.getSymbolTable().addSymbol(node.tokens.name.text, { definingNode: node, isFromTypeStatement: true }, typeStmtType, 2 /* SymbolTypeFlag.typetime */);
+            },
+            IfStatement: (node) => {
+                this.setUpComplementSymbolTables(node, reflection_1.isIfStatement);
+            },
+            Block: (node) => {
+                var _a, _b, _c;
+                const blockSymbolTable = node.symbolTable;
+                if (node.findAncestor(reflection_1.isFunctionExpression)) {
+                    // this block is in a function. order matters!
+                    blockSymbolTable.isOrdered = true;
+                }
+                if (!(0, reflection_1.isFunctionExpression)(node.parent) && node.parent) {
+                    node.symbolTable.name = `Block-${node.parent.kind}@${(_c = (_b = (_a = node.location) === null || _a === void 0 ? void 0 : _a.range) === null || _b === void 0 ? void 0 : _b.start) === null || _c === void 0 ? void 0 : _c.line}`;
+                    // we're a block inside another block (or body). This block is a pocket in the bigger block
+                    node.parent.getSymbolTable().addPocketTable({
+                        index: node.parent.statementIndex,
+                        table: blockSymbolTable,
+                        // code always flows through ConditionalCompiles, because we walk according to defined BSConsts
+                        willAlwaysBeExecuted: (0, reflection_1.isConditionalCompileStatement)(node.parent)
+                    });
+                    if ((0, reflection_1.isForStatement)(node.parent)) {
+                        const counterDecl = node.parent.counterDeclaration;
+                        const loopVar = counterDecl.tokens.name;
+                        const loopVarType = counterDecl.getType({ flags: 1 /* SymbolTypeFlag.runtime */ });
+                        blockSymbolTable.addSymbol(loopVar.text, { isInstance: true }, loopVarType, 1 /* SymbolTypeFlag.runtime */);
+                    }
+                    else if ((0, reflection_1.isForEachStatement)(node.parent)) {
+                        const loopVarType = node.parent.getLoopVariableType({ flags: 1 /* SymbolTypeFlag.runtime */ });
+                        blockSymbolTable.addSymbol(node.parent.tokens.item.text, { isInstance: true }, loopVarType, 1 /* SymbolTypeFlag.runtime */);
+                    }
+                }
+            },
+            VariableExpression: (node) => {
+                var _a;
+                //flag reserved unreferencable builtins (e.g. `ObjFun`, `type`) used in non-call position.
+                //these compile cleanly as values today but are device compile errors
+                //(`Syntax Error. Builtin function call expected`).
+                const name = (_a = node.tokens.name) === null || _a === void 0 ? void 0 : _a.text;
+                if (name &&
+                    TokenKind_1.UnreferencableBuiltins.has(name.toLowerCase()) &&
+                    //only valid use is as the callee of a CallExpression
+                    !((0, reflection_1.isCallExpression)(node.parent) && node.parent.callee === node)) {
+                    this.event.program.diagnostics.register(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.reservedBuiltinUsedAsValue(name)), { location: node.tokens.name.location }));
+                }
+            },
+            AstNode: (node) => {
+                //check for doc comments
+                if (!node.leadingTrivia || node.leadingTrivia.length === 0) {
+                    return;
+                }
+                const doc = BrightScriptDocParser_1.default.parseNode(node);
+                if (doc.tags.length === 0) {
+                    return;
+                }
+                let funcExpr = node.findAncestor(reflection_1.isFunctionExpression);
+                if (funcExpr) {
+                    // handle comment tags inside a function expression
+                    this.processDocTagsInFunction(doc, node, funcExpr);
+                }
+                else {
+                    //handle comment tags outside of a function expression
+                    this.processDocTagsAtTopLevel(doc, node);
+                }
+            }
+        });
+        this.event.file.ast.walk((node, parent) => {
+            visitor(node, parent);
+        }, {
+            walkMode: visitors_1.WalkMode.visitAllRecursive
+        });
+    }
+    processDocTagsInFunction(doc, node, funcExpr) {
+        //TODO: Handle doc tags that influence the function they're in
+        // For example, declaring variable types:
+        // const symbolTable = funcExpr.body.getSymbolTable();
+        // for (const varTag of doc.getAllTags(BrsDocTagKind.Var)) {
+        //     const varName = (varTag as BrsDocParamTag).name;
+        //     const varTypeStr = (varTag as BrsDocParamTag).type;
+        //     const data: ExtraSymbolData = {};
+        //     const type = doc.getTypeFromContext(varTypeStr, node, { flags: SymbolTypeFlag.typetime, fullName: varTypeStr, data: data, tableProvider: () => symbolTable });
+        //     if (type) {
+        //         symbolTable.addSymbol(varName, { ...data, isFromDocComment: true }, type, SymbolTypeFlag.runtime);
+        //     }
+        // }
+    }
+    processDocTagsAtTopLevel(doc, node) {
+        //TODO:
+        // - handle import statements?
+        // - handle library statements?
+        // - handle typecast statements?
+        // - handle alias statements?
+        // - handle const statements?
+        // - allow interface definitions?
+    }
+    /**
+     * Validate that a statement is defined in one of these specific locations
+     *  - the root of the AST
+     *  - inside a namespace
+     * This is applicable to things like FunctionStatement, ClassStatement, NamespaceStatement, EnumStatement, InterfaceStatement
+     */
+    validateDeclarationLocations(statement, keyword, rangeFactory) {
+        var _a;
+        //if nested inside a namespace, or defined at the root of the AST (i.e. in a body that has no parent)
+        const isOkDeclarationLocation = (parentNode) => {
+            return (0, reflection_1.isNamespaceStatement)(parentNode === null || parentNode === void 0 ? void 0 : parentNode.parent) || ((0, reflection_1.isBody)(parentNode) && !(parentNode === null || parentNode === void 0 ? void 0 : parentNode.parent));
+        };
+        if (isOkDeclarationLocation(statement.parent)) {
+            return;
+        }
+        // is this in a top levelconditional compile?
+        if ((0, reflection_1.isConditionalCompileStatement)((_a = statement.parent) === null || _a === void 0 ? void 0 : _a.parent)) {
+            if (isOkDeclarationLocation(statement.parent.parent.parent)) {
+                return;
+            }
+        }
+        //the statement was defined in the wrong place. Flag it.
+        this.event.program.diagnostics.register(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.keywordMustBeDeclaredAtNamespaceLevel(keyword)), { location: rangeFactory ? util_1.default.createLocationFromFileRange(this.event.file, rangeFactory()) : statement.location }));
+    }
+    validateFunctionParameterCount(func) {
+        var _a, _b, _c, _d, _e;
+        if (func.parameters.length > Expression_1.CallExpression.MaximumArguments) {
+            //flag every parameter over the limit
+            for (let i = Expression_1.CallExpression.MaximumArguments; i < func.parameters.length; i++) {
+                this.event.program.diagnostics.register(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.tooManyCallableParameters(func.parameters.length, Expression_1.CallExpression.MaximumArguments)), { location: (_e = (_c = (_b = (_a = func.parameters[i]) === null || _a === void 0 ? void 0 : _a.tokens.name) === null || _b === void 0 ? void 0 : _b.location) !== null && _c !== void 0 ? _c : (_d = func.parameters[i]) === null || _d === void 0 ? void 0 : _d.location) !== null && _e !== void 0 ? _e : func.location }));
+            }
+        }
+    }
+    validateEnumDeclaration(stmt) {
+        var _a, _b, _c, _d, _e, _f;
+        const members = stmt.getMembers();
+        //the enum data type is based on the first member value
+        const enumValueKind = (_e = (_d = (_c = (_b = (_a = members.find(x => x.value)) === null || _a === void 0 ? void 0 : _a.value) === null || _b === void 0 ? void 0 : _b.tokens) === null || _c === void 0 ? void 0 : _c.value) === null || _d === void 0 ? void 0 : _d.kind) !== null && _e !== void 0 ? _e : TokenKind_1.TokenKind.IntegerLiteral;
+        const memberNames = new Set();
+        for (const member of members) {
+            const memberNameLower = (_f = member.name) === null || _f === void 0 ? void 0 : _f.toLowerCase();
+            /**
+             * flag duplicate member names
+             */
+            if (memberNames.has(memberNameLower)) {
+                this.event.program.diagnostics.register(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.duplicateIdentifier(member.name)), { location: member.location }));
+            }
+            else {
+                memberNames.add(memberNameLower);
+            }
+            //Enforce all member values are the same type
+            this.validateEnumValueTypes(member, enumValueKind);
+        }
+    }
+    validateEnumValueTypes(member, enumValueKind) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        let memberValueKind;
+        let memberValue;
+        if ((0, reflection_1.isUnaryExpression)(member.value)) {
+            memberValueKind = (_d = (_c = (_b = (_a = member.value) === null || _a === void 0 ? void 0 : _a.right) === null || _b === void 0 ? void 0 : _b.tokens) === null || _c === void 0 ? void 0 : _c.value) === null || _d === void 0 ? void 0 : _d.kind;
+            memberValue = (_e = member.value) === null || _e === void 0 ? void 0 : _e.right;
+        }
+        else {
+            memberValueKind = (_h = (_g = (_f = member.value) === null || _f === void 0 ? void 0 : _f.tokens) === null || _g === void 0 ? void 0 : _g.value) === null || _h === void 0 ? void 0 : _h.kind;
+            memberValue = member.value;
+        }
+        const range = (_k = (_j = (memberValue !== null && memberValue !== void 0 ? memberValue : member)) === null || _j === void 0 ? void 0 : _j.location) === null || _k === void 0 ? void 0 : _k.range;
+        if (
+        //is integer enum, has value, that value type is not integer
+        (enumValueKind === TokenKind_1.TokenKind.IntegerLiteral && memberValueKind && memberValueKind !== enumValueKind) ||
+            //has value, that value is not a literal
+            (memberValue && !(0, reflection_1.isLiteralExpression)(memberValue))) {
+            this.event.program.diagnostics.register(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.enumValueMustBeType(enumValueKind.replace(/literal$/i, '').toLowerCase())), { location: util_1.default.createLocationFromFileRange(this.event.file, range) }));
+        }
+        //is non integer value
+        if (enumValueKind !== TokenKind_1.TokenKind.IntegerLiteral) {
+            //default value present
+            if (memberValueKind) {
+                //member value is same as enum
+                if (memberValueKind !== enumValueKind) {
+                    this.event.program.diagnostics.register(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.enumValueMustBeType(enumValueKind.replace(/literal$/i, '').toLowerCase())), { location: util_1.default.createLocationFromFileRange(this.event.file, range) }));
+                }
+                //default value missing
+            }
+            else {
+                this.event.program.diagnostics.register(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.enumValueIsRequired(enumValueKind.replace(/literal$/i, '').toLowerCase())), { location: util_1.default.createLocationFromFileRange(this.event.file, range) }));
+            }
+        }
+    }
+    validateConditionalCompileConst(ccConst) {
+        const isBool = ccConst.kind === TokenKind_1.TokenKind.True || ccConst.kind === TokenKind_1.TokenKind.False;
+        if (!isBool && !this.event.file.ast.bsConsts.has(ccConst.text.toLowerCase())) {
+            this.event.program.diagnostics.register(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.hashConstDoesNotExist()), { location: ccConst.location }));
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Find statements defined at the top level (or inside a namespace body) that are not allowed to be there
+     */
+    flagTopLevelStatements() {
+        const statements = [...this.event.file.ast.statements];
+        while (statements.length > 0) {
+            const statement = statements.pop();
+            if ((0, reflection_1.isNamespaceStatement)(statement)) {
+                statements.push(...statement.body.statements);
+            }
+            else {
+                //only allow these statement types
+                if (!(0, reflection_1.isFunctionStatement)(statement) &&
+                    !(0, reflection_1.isClassStatement)(statement) &&
+                    !(0, reflection_1.isEnumStatement)(statement) &&
+                    !(0, reflection_1.isInterfaceStatement)(statement) &&
+                    !(0, reflection_1.isLibraryStatement)(statement) &&
+                    !(0, reflection_1.isImportStatement)(statement) &&
+                    !(0, reflection_1.isConstStatement)(statement) &&
+                    !(0, reflection_1.isTypecastStatement)(statement) &&
+                    !(0, reflection_1.isConditionalCompileConstStatement)(statement) &&
+                    !(0, reflection_1.isConditionalCompileErrorStatement)(statement) &&
+                    !(0, reflection_1.isConditionalCompileStatement)(statement) &&
+                    !(0, reflection_1.isAliasStatement)(statement) &&
+                    !(0, reflection_1.isTypeStatement)(statement)) {
+                    this.event.program.diagnostics.register(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedStatementOutsideFunction()), { location: statement.location }));
+                }
+            }
+        }
+    }
+    isAllowedAtTopOfFile(statement) {
+        return (0, reflection_1.isLibraryStatement)(statement) || (0, reflection_1.isImportStatement)(statement) || (0, reflection_1.isTypecastStatement)(statement) || (0, reflection_1.isAliasStatement)(statement);
+    }
+    getTopOfFileStatements() {
+        let topOfFileIncludeStatements = [];
+        for (let stmt of this.event.file.parser.ast.statements) {
+            //if we found a non-library statement, this statement is not at the top of the file
+            if (this.isAllowedAtTopOfFile(stmt)) {
+                topOfFileIncludeStatements.push(stmt);
+            }
+            else {
+                //break out of the loop, we found all of our library statements
+                break;
+            }
+        }
+        return topOfFileIncludeStatements;
+    }
+    validateTopOfFileStatements() {
+        let topOfFileStatements = this.getTopOfFileStatements();
+        let statements = [
+            // eslint-disable-next-line @typescript-eslint/dot-notation
+            ...this.event.file['_cachedLookups'].libraryStatements,
+            // eslint-disable-next-line @typescript-eslint/dot-notation
+            ...this.event.file['_cachedLookups'].importStatements,
+            // eslint-disable-next-line @typescript-eslint/dot-notation
+            ...this.event.file['_cachedLookups'].aliasStatements
+        ];
+        for (let result of statements) {
+            //if this statement is not one of the top-of-file statements,
+            //then add a diagnostic explaining that it is invalid
+            if (!topOfFileStatements.includes(result)) {
+                if ((0, reflection_1.isLibraryStatement)(result)) {
+                    this.event.program.diagnostics.register(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedStatementLocation('library', 'at the top of the file')), { location: result.location }));
+                }
+                else if ((0, reflection_1.isImportStatement)(result)) {
+                    this.event.program.diagnostics.register(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedStatementLocation('import', 'at the top of the file')), { location: result.location }));
+                }
+                else if ((0, reflection_1.isAliasStatement)(result)) {
+                    this.event.program.diagnostics.register(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedStatementLocation('alias', 'at the top of the file')), { location: result.location }));
+                }
+            }
+        }
+    }
+    validateTypecastStatements() {
+        // eslint-disable-next-line @typescript-eslint/dot-notation
+        for (let typecastStmt of this.event.file['_cachedLookups'].typecastStatements) {
+            let isBadTypecastObj = false;
+            const block = typecastStmt.findAncestor(node => ((0, reflection_1.isBody)(node) || (0, reflection_1.isBlock)(node)));
+            const resultVarStr = util_1.default.getAllDottedGetPartsAsString(typecastStmt.typecastExpression.obj);
+            const hasFunctionAncestor = !!typecastStmt.findAncestor(reflection_1.isFunctionExpression);
+            if (!(0, reflection_1.isVariableExpression)(typecastStmt.typecastExpression.obj)) {
+                isBadTypecastObj = true;
+            }
+            else if (!hasFunctionAncestor && resultVarStr.toLowerCase() !== 'm') {
+                // only 'm' can be typecast outside of a function body
+                isBadTypecastObj = true;
+            }
+            else if (block.getSymbolTable().hasSymbol(resultVarStr, 2 /* SymbolTypeFlag.typetime */)) {
+                // can only typecast runtime symbols
+                isBadTypecastObj = true;
+            }
+            if (isBadTypecastObj) {
+                this.event.program.diagnostics.register(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.invalidTypecastStatementApplication(resultVarStr, hasFunctionAncestor)), { location: typecastStmt.typecastExpression.obj.location }));
+            }
+            let isFirst = true;
+            for (let i = 0; i < typecastStmt.statementIndex; i++) {
+                const targetStatement = block.statements[i];
+                // allow multiple typecast statements at the top of a block or namespace, but no other statements before them
+                isFirst = isFirst && this.isAllowedAtTopOfFile(targetStatement);
+                if ((0, reflection_1.isTypecastStatement)(targetStatement) && targetStatement !== typecastStmt) {
+                    // do not allow multiple typecast statements that typecast the same variable, even if they are at the top of the block/namespace
+                    const otherResultVarStr = util_1.default.getAllDottedGetPartsAsString(targetStatement.typecastExpression.obj);
+                    if (otherResultVarStr.toLowerCase() === resultVarStr.toLowerCase()) {
+                        isFirst = false;
+                    }
+                }
+                if (!isFirst) {
+                    break;
+                }
+            }
+            if (!isFirst) {
+                this.event.program.diagnostics.register(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.unexpectedStatementLocation('typecast', 'at the top of the file or beginning of block or namespace')), { location: typecastStmt.location }));
+            }
+        }
+    }
+    validateContinueStatement(statement) {
+        const validateLoopTypeMatch = (expectedLoopType) => {
+            var _a;
+            //coerce ForEach to For
+            expectedLoopType = expectedLoopType === TokenKind_1.TokenKind.ForEach ? TokenKind_1.TokenKind.For : expectedLoopType;
+            const actualLoopType = statement.tokens.loopType;
+            if (actualLoopType && (expectedLoopType === null || expectedLoopType === void 0 ? void 0 : expectedLoopType.toLowerCase()) !== ((_a = actualLoopType.text) === null || _a === void 0 ? void 0 : _a.toLowerCase())) {
+                this.event.program.diagnostics.register(Object.assign({ location: statement.tokens.loopType.location }, DiagnosticMessages_1.DiagnosticMessages.expectedToken(expectedLoopType)));
+            }
+        };
+        //find the parent loop statement
+        const parent = statement.findAncestor((node) => {
+            if ((0, reflection_1.isWhileStatement)(node)) {
+                validateLoopTypeMatch(node.tokens.while.kind);
+                return true;
+            }
+            else if ((0, reflection_1.isForStatement)(node)) {
+                validateLoopTypeMatch(node.tokens.for.kind);
+                return true;
+            }
+            else if ((0, reflection_1.isForEachStatement)(node)) {
+                validateLoopTypeMatch(node.tokens.forEach.kind);
+                return true;
+            }
+        });
+        //flag continue statements found outside of a loop
+        if (!parent) {
+            this.event.program.diagnostics.register(Object.assign({ location: statement.location }, DiagnosticMessages_1.DiagnosticMessages.illegalContinueStatement()));
+        }
+    }
+    /**
+     * Validate that there are no optional chaining operators on the left-hand-side of an assignment, indexed set, or dotted get
+     */
+    validateNoOptionalChainingInVarSet(parent, children) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const nodes = [...children, parent];
+        //flag optional chaining anywhere in the left of this statement
+        while (nodes.length > 0) {
+            const node = nodes.shift();
+            if (
+            // a?.b = true or a.b?.c = true
+            (((0, reflection_1.isDottedSetStatement)(node) || (0, reflection_1.isDottedGetExpression)(node)) && ((_a = node.tokens.dot) === null || _a === void 0 ? void 0 : _a.kind) === TokenKind_1.TokenKind.QuestionDot) ||
+                // a.b?[2] = true
+                ((0, reflection_1.isIndexedGetExpression)(node) && (((_b = node === null || node === void 0 ? void 0 : node.tokens.questionDot) === null || _b === void 0 ? void 0 : _b.kind) === TokenKind_1.TokenKind.QuestionDot || ((_c = node.tokens.openingSquare) === null || _c === void 0 ? void 0 : _c.kind) === TokenKind_1.TokenKind.QuestionLeftSquare)) ||
+                // a?[1] = true
+                ((0, reflection_1.isIndexedSetStatement)(node) && ((_d = node.tokens.openingSquare) === null || _d === void 0 ? void 0 : _d.kind) === TokenKind_1.TokenKind.QuestionLeftSquare)) {
+                //try to highlight the entire left-hand-side expression if possible
+                let range;
+                if ((0, reflection_1.isDottedSetStatement)(parent)) {
+                    range = util_1.default.createBoundingRange((_e = parent.obj) === null || _e === void 0 ? void 0 : _e.location, parent.tokens.dot, parent.tokens.name);
+                }
+                else if ((0, reflection_1.isIndexedSetStatement)(parent)) {
+                    range = util_1.default.createBoundingRange((_f = parent.obj) === null || _f === void 0 ? void 0 : _f.location, parent.tokens.openingSquare, ...parent.indexes, parent.tokens.closingSquare);
+                }
+                else {
+                    range = (_g = node.location) === null || _g === void 0 ? void 0 : _g.range;
+                }
+                this.event.program.diagnostics.register(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.noOptionalChainingInLeftHandSideOfAssignment()), { location: util_1.default.createLocationFromFileRange(this.event.file, range) }));
+            }
+            if (node === parent) {
+                break;
+            }
+            else {
+                nodes.push(node.parent);
+            }
+        }
+    }
+    setUpComplementSymbolTables(node, predicate) {
+        if ((0, reflection_1.isBlock)(node.elseBranch)) {
+            const elseTable = node.elseBranch.symbolTable;
+            let currentNode = node;
+            while (predicate(currentNode)) {
+                const thenBranch = currentNode.thenBranch;
+                elseTable.complementOtherTable(thenBranch.symbolTable);
+                currentNode = currentNode.parent;
+            }
+        }
+    }
+    /**
+     * Add a diagnostic if the configured minFirmwareVersion is lower than the version that
+     * introduced optional chaining support (Roku OS 11).
+     * This applies to both .brs and .bs files because optional chaining is not transpiled —
+     * it is emitted as-is, so the target device must natively support it.
+     */
+    validateMinFirmwareVersionForOptionalChaining(range) {
+        const minFirmwareVersion = this.event.file.program.options.minFirmwareVersion;
+        if (!minFirmwareVersion) {
+            return;
+        }
+        const coercedMinVersion = semver.coerce(minFirmwareVersion);
+        if (coercedMinVersion && semver.lt(coercedMinVersion, BrsFileValidator.OPTIONAL_CHAINING_MIN_VERSION)) {
+            this.event.program.diagnostics.register(Object.assign(Object.assign({}, DiagnosticMessages_1.DiagnosticMessages.featureRequiresMinFirmwareVersion('optional chaining', BrsFileValidator.OPTIONAL_CHAINING_MIN_VERSION, minFirmwareVersion)), { location: util_1.default.createLocationFromFileRange(this.event.file, range) }));
+        }
+    }
+}
+exports.BrsFileValidator = BrsFileValidator;
+/**
+ * The minimum Roku firmware version that introduced optional chaining support (Roku OS 11).
+ * Optional chaining is NOT transpiled by BrighterScript, so this restriction applies to both
+ * .brs and .bs files.
+ */
+BrsFileValidator.OPTIONAL_CHAINING_MIN_VERSION = '11.0.0';
+//# sourceMappingURL=BrsFileValidator.js.map