Merge branch 'master' of https://github.com/SSlinky/VBA-LanguageServer

Author: SSlinky

server/src/docInfo.ts

@@ -3,7 +3,7 @@ import { TextDocument } from 'vscode-languageserver-textdocument';
 import { LiteralContext } from './antlr/out/vbaParser';
 import { SemanticToken, sortSemanticTokens } from './capabilities/vbaSemanticTokens';
 import {  sleep, rangeIsChildOfElement } from './utils/helpers';
-import { IdentifierElement, MethodElement, ModuleAttribute, ModuleElement, SyntaxElement, VariableAssignElement, VariableDeclarationElement, VariableStatementElement } from './utils/vbaSyntaxElements';
+import { IdentifiableSyntaxElement, IdentifierElement, MethodElement, ModuleAttribute, ModuleElement, SyntaxElement, VariableDeclarationElement, VariableStatementElement } from './utils/vbaSyntaxElements';
 import { ResultsContainer, SyntaxParser } from './utils/vbaSyntaxParser';
 
 
@@ -151,15 +151,14 @@ export class DocumentInformation implements ResultsContainer {
 	elements: SyntaxElement[] = [];
 	attrubutes: Map<string, string> = new Map();
 	isBusy = true;
+	scope: Scope;
 
 	private docUri: string;
 	private ancestors: SyntaxElement[] = [];
-	private localNames: Map<string, SyntaxElement> = new Map();
-	private documentScope: Scope;
 
 	constructor(scope: Scope, docUri: string) {
 		scope.links.set(docUri, new Map());
-		this.documentScope = scope;
+		this.scope = scope;
 		this.docUri = docUri;
 	}
 
@@ -208,15 +207,27 @@ export class DocumentInformation implements ResultsContainer {
 	// 	emt.hoverText = hoverText;
 	// }
 
-	addScopeDeclaration(emt: MethodElement | VariableDeclarationElement) {
+	/**
+	 * Use this method to set as the current scope.
+	 * @param emt The function, sub, or property to scope to.
+	 */
+	pushScopeElement(emt: MethodElement) {
+		this.addScopedDeclaration(emt);
+	}
+
+	popScopeElement() {
+		//
+	}
+
+	addScopedDeclaration(emt: MethodElement | VariableDeclarationElement) {
 		// Add a declared scope.
 		// this.addElement(emt);
 		const elId = emt.identifier!.text;
 		const link = this.getNameLink(elId, emt.parent?.fqName ?? '', emt.hasPrivateModifier);
 		link.declarations.push(emt);
 
 		// Check the undeclared links and merge if found.
-		const undeclaredScope = this.documentScope.getScope(`undeclared|${this.docUri}`);
+		const undeclaredScope = this.scope.getScope(`undeclared|${this.docUri}`);
 		const undeclaredLink = undeclaredScope.get(elId);
 		if (undeclaredLink) {
 			link.merge(undeclaredLink);
@@ -226,7 +237,7 @@ export class DocumentInformation implements ResultsContainer {
 		this.addElement(emt);
 	}
 
-	addScopeReference(emt: VariableAssignElement) {
+	addScopedReference(emt: IdentifierElement) {
 		const link = this.getNameLink(emt.identifier!.text, emt.parent?.fqName ?? '', false, true);
 		link.references.push(emt);
 		this.addElement(emt);
@@ -247,8 +258,8 @@ export class DocumentInformation implements ResultsContainer {
 	}
 
 	private getScope(fqName: string, isPrivate: boolean): Map<string, NameLink> {
-		const globalScope = this.documentScope.getScope('global');
-		const localScope = this.documentScope.getScope(this.docUri);
+		const globalScope = this.scope.getScope('global');
+		const localScope = this.scope.getScope(this.docUri);
 
 		const isAtModuleLevel = (fqName ?? '') === this.docUri;
 		return (isAtModuleLevel && !isPrivate) ? globalScope : localScope;
@@ -257,17 +268,17 @@ export class DocumentInformation implements ResultsContainer {
 	private searchScopes(identifier: string): Map<string, NameLink> {
 		const scopeNames = [this.docUri, 'global'];
 		for (let i = 0; i < scopeNames.length; i++) {
-			const scope = this.documentScope.getScope(scopeNames[i]);
+			const scope = this.scope.getScope(scopeNames[i]);
 			if (scope.has(identifier)) {
 				return scope;
 			}
 		}
-		return this.documentScope.getScope(`undeclared|${this.docUri}`);
+		return this.scope.getScope(`undeclared|${this.docUri}`);
 	}
 
 
 	finalise() {
-		this.documentScope.processLinks(this.docUri, true);
+		this.scope.processLinks(this.docUri, true);
 		this.isBusy = false;
 	}
 
@@ -366,18 +377,32 @@ export class DocumentInformation implements ResultsContainer {
 class Scope {
 	// { docUri: { identifier: [ declarationElement, elementLink... ] } }
 	links: Map<string, Map<string, NameLink>> = new Map();
+	private subScopes: string[] = [];
+	private currentDoc = '';
 
 	constructor() {
 		this.links.set('global', new Map());
 	}
 
 	getScope(key: string): Map<string, NameLink> {
+		if (key !== this.currentDoc) {
+			this.currentDoc = key;
+			this.subScopes = ['module'];
+		}
 		if (!this.links.has(key)) {
 			this.links.set(key, new Map());
 		}
 		return this.links.get(key)!;
 	}
 
+	pushSubScope(namespace: string) {
+		this.subScopes.push(namespace);
+	}
+
+	popSubScope() {
+		this.subScopes.pop();
+	}
+
 	processLinks(key: string, optExplicit = false) {
 		// TODO: check global for undeclareds
 		const undeclared = this.getScope(`undeclared|${key}`);
@@ -482,4 +507,31 @@ class NameLink {
 	private validateMethodSignatures() {
 		// TODO: implement.
 	}
+}
+
+class Scope2 {
+	context: SyntaxElement;
+	parent?: Scope2;
+	nameRefs: Map<string, NameLink> = new Map();
+
+	constructor(ctx: SyntaxElement);
+	constructor(ctx: SyntaxElement, pnt: Scope2);
+	constructor(ctx: SyntaxElement, pnt?: Scope2) {
+		this.context = ctx;
+		this.parent = pnt;
+	}
+
+	addRef(ctx: IdentifiableSyntaxElement) {
+		const nameLink = this.getName(ctx.identifier.text);
+		// if dec
+
+		// if not dec
+	}
+
+	getName(identifier: string): NameLink {
+		if (!this.nameRefs.has(identifier)) {
+			this.nameRefs.set(identifier, new NameLink());
+		}
+		return this.nameRefs.get(identifier)!;
+	}
 }

server/src/utils/nameTree.ts

@@ -0,0 +1,137 @@
+import { Diagnostic, DiagnosticRelatedInformation, DiagnosticSeverity } from 'vscode-languageserver';
+import { AmbiguousIdentifierContext, CertainIdentifierContext } from '../antlr/out/vbaParser';
+import { MethodElement, SyntaxElement, VariableDeclarationElement } from './vbaSyntaxElements';
+
+
+enum NameLinkType {
+	'variable' = 0,
+	'method' = 1,
+}
+
+class Scope {
+	context: SyntaxElement;
+	parent?: Scope;
+	nameRefs: Map<string, NameLink> = new Map();
+
+	constructor(ctx: SyntaxElement);
+	constructor(ctx: SyntaxElement, pnt: Scope);
+	constructor(ctx: SyntaxElement, pnt?: Scope) {
+		this.context = ctx;
+		this.parent = pnt;
+	}
+
+	addDeclaration(element: VariableDeclarationElement | MethodElement) {
+		//
+	}
+
+	addRef(ctx: CertainIdentifierContext | AmbiguousIdentifierContext) {
+		const nameLink = this.getName(ctx.text);
+		// if dec
+
+		// if not dec
+	}
+
+	getName(identifier: string): NameLink {
+		if (!this.nameRefs.has(identifier)) {
+			this.nameRefs.set(identifier, new NameLink());
+		}
+		return this.nameRefs.get(identifier)!;
+	}
+}
+
+class NameLink {
+	type: NameLinkType = NameLinkType.variable;
+
+	// The original decalarations that affect this name.
+	// 0: Variable or method not declared.
+	// 1: Declared once.
+	// 2: Multiple conflicting declarations.
+	declarations: SyntaxElement[] = [];
+
+	// The places this name is referenced.
+	references: SyntaxElement[] = [];
+	diagnostics: Diagnostic[] = [];
+
+	private diagnosticRelatedInfo: DiagnosticRelatedInformation[] = [];
+
+	merge(link: NameLink) {
+		this.declarations.concat(link.declarations);
+		this.references.concat(link.references);
+		this.diagnostics.concat(link.diagnostics);
+
+		if (link.declarations.length > 0) {
+			this.type = link.type;
+		}
+	}
+
+	process(optExplicit = false) {
+		this.processDiagnosticRelatedInformation();
+		this.validateDeclarationCount(optExplicit);
+		this.validateMethodSignatures();
+
+		this.assignSemanticTokens();
+		this.assignDiagnostics();
+	}
+
+	private processDiagnosticRelatedInformation() {
+		this.diagnosticRelatedInfo = this.declarations
+			.concat(this.references)
+			.map((x) => DiagnosticRelatedInformation.create(
+				x.location(),
+				x.text
+			));
+	}
+
+	private validateDeclarationCount(optExplicit: boolean) {
+		if (this.declarations.length === 1) {
+			return;
+		}
+
+		const undecSeverity = (optExplicit) ? DiagnosticSeverity.Error : DiagnosticSeverity.Warning;
+		if (this.declarations.length === 0) {
+			if (optExplicit || this.type !== NameLinkType.variable)
+				this.references.forEach((x) =>
+					this.diagnostics.push(Diagnostic.create(
+						x.range,
+						"No declaration for variable or method.",
+						undecSeverity,
+						404,
+						'VbaPro',
+						this.diagnosticRelatedInfo
+					)));
+			return;
+		}
+		this.declarations.forEach((x) =>
+			this.diagnostics.push(Diagnostic.create(
+				x.range,
+				"Ambiguous variable declaration",
+				DiagnosticSeverity.Error,
+				500,
+				'VbaPro',
+				this.diagnosticRelatedInfo
+			)));
+	}
+
+	private assignSemanticTokens() {
+		if (this.declarations.length === 0) {
+			return;
+		}
+
+		this.references.forEach((x) => x.semanticToken = 
+			this.declarations[0]
+				.semanticToken
+				?.toNewRange(x.range));
+	}
+
+	private assignDiagnostics() {
+		if (this.diagnostics.length === 0) {
+			return;
+		}
+		const els = this.declarations.concat(this.references);
+		els.forEach((x) => x.addDiagnostics(this.diagnostics));
+	}
+
+	private validateMethodSignatures() {
+		// TODO: implement.
+	}
+}