Validation Performance: File level providedSymbols and requiredSymbols

.github/workflows/build.yml

@@ -15,7 +15,7 @@ jobs:
       COVERALLS_REPO_TOKEN: "kVPcGJfehOArEQnHb8BT3KS72xbUQCoxI"
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
+        os: [macos-latest, ubuntu-latest, windows-latest]
     steps:
       - uses: actions/checkout@master
       - uses: actions/setup-node@master

.github/workflows/create-package.yml

@@ -34,6 +34,8 @@ jobs:
           echo "ARTIFACT_URL=$ARTIFACT_URL" >> $GITHUB_ENV
 
       - run: npm ci
+      - run: npm config set ignore-scripts true
+      - run: npm run build
       - run: npm version "$BUILD_VERSION" --no-git-tag-version
       - run: npm pack
 

src/AstValidationSegmenter.ts

@@ -1,28 +1,34 @@
-import type { DottedGetExpression, TypeExpression, VariableExpression } from '.';
+import type { DottedGetExpression, TypeExpression, VariableExpression } from './parser/Expression';
 import { SymbolTypeFlag } from './SymbolTable';
-import { UnresolvedNodeSet } from './UnresolvedNodeSet';
-import { isBody, isClassStatement, isCommentStatement, isInterfaceStatement, isNamespaceStatement } from './astUtils/reflection';
+import { isBody, isClassStatement, isCommentStatement, isInterfaceStatement, isNamespaceStatement, isVariableExpression } from './astUtils/reflection';
 import { ChildrenSkipper, WalkMode, createVisitor } from './astUtils/visitors';
-import type { ExtraSymbolData, GetTypeOptions } from './interfaces';
+import type { GetTypeOptions, TypeChainEntry } from './interfaces';
 import type { AstNode } from './parser/AstNode';
 import { util } from './util';
+import type { NamespaceStatement } from '.';
 
 // eslint-disable-next-line no-bitwise
 export const InsideSegmentWalkMode = WalkMode.visitStatements | WalkMode.visitExpressions | WalkMode.recurseChildFunctions;
 
+export interface UnresolvedSymbol {
+    typeChain: TypeChainEntry[];
+    flags: SymbolTypeFlag;
+    endChainFlags: SymbolTypeFlag;
+    containingNamespaces: string[];
+}
+
 export class AstValidationSegmenter {
 
-    public unresolvedSegments = new Map<AstNode, UnresolvedNodeSet>();
     public validatedSegments = new Map<AstNode, boolean>();
     public segmentsForValidation = new Array<AstNode>();
     public singleValidationSegments = new Set<AstNode>();
+    public unresolvedSegmentsSymbols = new Map<AstNode, Set<UnresolvedSymbol>>();
     public ast: AstNode;
 
-
     reset() {
-        this.unresolvedSegments.clear();
         this.validatedSegments.clear();
         this.singleValidationSegments.clear();
+        this.unresolvedSegmentsSymbols.clear();
         this.segmentsForValidation = [];
     }
 
@@ -36,30 +42,39 @@ export class AstValidationSegmenter {
         });
     }
 
-
-    checkExpressionForUnresolved(segment: AstNode, expression: VariableExpression | DottedGetExpression | TypeExpression) {
+    checkExpressionForUnresolved(segment: AstNode, expression: VariableExpression | DottedGetExpression | TypeExpression, assignedSymbols?: Set<string>) {
         if (!expression || isCommentStatement(expression)) {
             return false;
         }
+        if (isVariableExpression(expression) && expression.name.text.toLowerCase() === 'm') {
+            return false;
+        }
         const flag = util.isInTypeExpression(expression) ? SymbolTypeFlag.typetime : SymbolTypeFlag.runtime;
-        const options: GetTypeOptions = { flags: flag, onlyCacheResolvedTypes: true };
+        const typeChain: TypeChainEntry[] = [];
+        const options: GetTypeOptions = { flags: flag, onlyCacheResolvedTypes: true, typeChain: typeChain };
+
         const nodeType = expression.getType(options);
         if (!nodeType.isResolvable()) {
-            let nodeSet: UnresolvedNodeSet;
-            if (!this.unresolvedSegments.has(segment)) {
-                nodeSet = new UnresolvedNodeSet(segment);
-                this.unresolvedSegments.set(segment, nodeSet);
-            } else {
-                nodeSet = this.unresolvedSegments.get(segment);
+            let symbolsSet: Set<UnresolvedSymbol>;
+            if (!assignedSymbols?.has(typeChain[0].name.toLowerCase())) {
+                if (!this.unresolvedSegmentsSymbols.has(segment)) {
+                    symbolsSet = new Set<UnresolvedSymbol>();
+                    this.unresolvedSegmentsSymbols.set(segment, symbolsSet);
+                } else {
+                    symbolsSet = this.unresolvedSegmentsSymbols.get(segment);
+                }
+
+                symbolsSet.add({ typeChain: typeChain, flags: typeChain[0].flags, endChainFlags: flag, containingNamespaces: this.currentNamespaceStatement?.getNameParts()?.map(t => t.text) });
             }
-            nodeSet.addExpression(expression, options);
             return true;
         }
         return false;
     }
 
-    checkSegmentWalk = (segment: AstNode) => {
-        if (isNamespaceStatement(segment) || isBody(segment)) {
+    private currentNamespaceStatement: NamespaceStatement;
+
+    checkSegmentWalk(segment: AstNode) {
+        if (isNamespaceStatement(segment) || isBody(segment) || isCommentStatement(segment)) {
             return;
         }
         if (isClassStatement(segment)) {
@@ -89,19 +104,30 @@ export class AstValidationSegmenter {
         this.validatedSegments.set(segment, false);
         let foundUnresolvedInSegment = false;
         const skipper = new ChildrenSkipper();
+        const assignedSymbols = new Set<string>();
+        this.currentNamespaceStatement = segment.findAncestor(isNamespaceStatement);
+
         segment.walk(createVisitor({
+            AssignmentStatement: (stmt) => {
+                assignedSymbols.add(stmt.name.text.toLowerCase());
+            },
+            FunctionParameterExpression: (expr) => {
+                assignedSymbols.add(expr.name.text.toLowerCase());
+            },
             VariableExpression: (expr) => {
-                const expressionIsUnresolved = this.checkExpressionForUnresolved(segment, expr);
-                foundUnresolvedInSegment = expressionIsUnresolved || foundUnresolvedInSegment;
+                if (!assignedSymbols.has(expr.name.text.toLowerCase())) {
+                    const expressionIsUnresolved = this.checkExpressionForUnresolved(segment, expr, assignedSymbols);
+                    foundUnresolvedInSegment = expressionIsUnresolved || foundUnresolvedInSegment;
+                }
                 skipper.skip();
             },
             DottedGetExpression: (expr) => {
-                const expressionIsUnresolved = this.checkExpressionForUnresolved(segment, expr);
+                const expressionIsUnresolved = this.checkExpressionForUnresolved(segment, expr, assignedSymbols);
                 foundUnresolvedInSegment = expressionIsUnresolved || foundUnresolvedInSegment;
                 skipper.skip();
             },
             TypeExpression: (expr) => {
-                const expressionIsUnresolved = this.checkExpressionForUnresolved(segment, expr);
+                const expressionIsUnresolved = this.checkExpressionForUnresolved(segment, expr, assignedSymbols);
                 foundUnresolvedInSegment = expressionIsUnresolved || foundUnresolvedInSegment;
                 skipper.skip();
             }
@@ -112,34 +138,26 @@ export class AstValidationSegmenter {
         if (!foundUnresolvedInSegment) {
             this.singleValidationSegments.add(segment);
         }
-    };
+    }
 
 
-    getSegments(): AstNode[] {
+    getSegments(changedSymbols: Map<SymbolTypeFlag, Set<string>>): AstNode[] {
         const segmentsToWalkForValidation: AstNode[] = [];
         for (const segment of this.segmentsForValidation) {
-            const unresolvedNodeSet = this.unresolvedSegments.get(segment);
+            const symbolsRequired = this.unresolvedSegmentsSymbols.get(segment);
+
             const isSingleValidationSegment = this.singleValidationSegments.has(segment);
             const singleValidationSegmentAlreadyValidated = isSingleValidationSegment ? this.validatedSegments.get(segment) : false;
             let segmentNeedsRevalidation = !singleValidationSegmentAlreadyValidated;
-            if (unresolvedNodeSet) {
-                for (let node of unresolvedNodeSet.nodes) {
-                    const data: ExtraSymbolData = {};
-                    const options: GetTypeOptions = { flags: util.isInTypeExpression(node) ? SymbolTypeFlag.typetime : SymbolTypeFlag.runtime, data: data };
-                    const type = node.getType(options);
-                    if (!type || !type.isResolvable()) {
-                        // the type that we're checking here is not found - force validation
-                        segmentNeedsRevalidation = true;
+
+            if (symbolsRequired) {
+                for (const requiredSymbol of symbolsRequired.values()) {
+                    const changeSymbolSetForFlag = changedSymbols.get(requiredSymbol.flags);
+                    if (util.setContainsUnresolvedSymbol(changeSymbolSetForFlag, requiredSymbol)) {
+                        segmentsToWalkForValidation.push(segment);
                         break;
-                    } else {
-                        const newTypeToCheck = unresolvedNodeSet.addTypeForExpression(node, options, type);
-                        segmentNeedsRevalidation = segmentNeedsRevalidation || newTypeToCheck;
                     }
                 }
-                if (segmentNeedsRevalidation) {
-                    segmentsToWalkForValidation.push(segment);
-                    continue;
-                }
             } else if (segmentNeedsRevalidation) {
                 segmentsToWalkForValidation.push(segment);
             }

src/DiagnosticMessages.ts

@@ -753,6 +753,11 @@ export let DiagnosticMessages = {
         message: `Operator '${operatorString}' cannot be applied to type${secondType ? 's' : ''} '${firstType}'${secondType ? ` and '${secondType}'` : ''}`,
         code: 1144,
         severity: DiagnosticSeverity.Error
+    }),
+    incompatibleSymbolDefinition: (symbol: string, scopeName: string) => ({
+        message: `'${symbol}' is incompatible across scope group (${scopeName})`, // TODO: Add scopes where it was defined
+        code: 1145,
+        severity: DiagnosticSeverity.Error
     })
 };
 export const defaultMaximumTruncationLength = 160;

src/LanguageServer.ts

@@ -1133,14 +1133,14 @@ export class LanguageServer {
             await this.synchronizeStandaloneProjects();
 
             let projects = this.getProjects();
-
             //validate all programs
             await Promise.all(
                 projects.map((project) => {
                     project.builder.program.validate();
                     return project;
                 })
             );
+
         } catch (e: any) {
             this.connection.console.error(e);
             this.sendCriticalFailure(`Critical error validating project: ${e.message}${e.stack ?? ''}`);
@@ -1267,6 +1267,8 @@ export class LanguageServer {
         await this.waitAllProjectFirstRuns();
         //wait for the file to settle (in case there are multiple file changes in quick succession)
         await this.keyedThrottler.onIdleOnce(util.uriToPath(params.textDocument.uri), true);
+        // make sure validation is complete
+        await this.validateAllThrottled();
         //wait for the validation cycle to settle
         await this.onValidateSettled();