Methods and functions now parsed.

Author: SSlinky

server/src/project/elements/procedure.ts

@@ -19,42 +19,39 @@ import { DiagnosticCapability, IdentifierCapability, SymbolInformationCapability
 
 abstract class BaseProcedureElement<T extends ParserRuleContext> extends BaseContextSyntaxElement<T> implements HasDiagnosticCapability, HasSymbolInformationCapability {
 	diagnosticCapability: DiagnosticCapability;
+	symbolInformationCapability: SymbolInformationCapability;
 	abstract identifierCapability: IdentifierCapability;
-	abstract symbolInformationCapability: SymbolInformationCapability;
 
-	constructor(ctx: T, doc: TextDocument) {
+	constructor(ctx: T, doc: TextDocument, symbolKind: SymbolKind) {
 		super(ctx, doc);
 		this.diagnosticCapability = new DiagnosticCapability(this);
+		this.symbolInformationCapability = new SymbolInformationCapability(this, symbolKind);
 	}
 }
 
 
 export class SubDeclarationElement extends BaseProcedureElement<SubroutineDeclarationContext> {
 	identifierCapability: IdentifierCapability;
-	symbolInformationCapability: SymbolInformationCapability;
 
 	constructor(ctx: SubroutineDeclarationContext, doc: TextDocument) {
-		super(ctx, doc);
+		super(ctx, doc, SymbolKind.Method);
 		this.identifierCapability = new IdentifierCapability({
 			element: this,
 			getNameContext: () => ctx.subroutineName()?.ambiguousIdentifier(),
 		});
-		this.symbolInformationCapability = new SymbolInformationCapability(this, SymbolKind.Method);
 	}
 }
 
 
 export class FunctionDeclarationElement extends BaseProcedureElement<FunctionDeclarationContext> {
 	identifierCapability: IdentifierCapability;
-	symbolInformationCapability: SymbolInformationCapability;
 
 	constructor(ctx: FunctionDeclarationContext, doc: TextDocument) {
-		super(ctx, doc);
+		super(ctx, doc, SymbolKind.Method);
 		this.identifierCapability = new IdentifierCapability({
 			element: this,
 			getNameContext: () => ctx.functionName()?.ambiguousIdentifier(),
 		});
-		this.symbolInformationCapability = new SymbolInformationCapability(this, SymbolKind.Method);
 	}
 }
 
@@ -81,18 +78,16 @@ export class PropertyDeclarationElement {
  */
 abstract class BasePropertyDeclarationElement<T extends ParserRuleContext> extends BaseProcedureElement<T> {
 	identifierCapability: IdentifierCapability;
-	symbolInformationCapability: SymbolInformationCapability;
 
 	private propertyType: string;
 	private nameContext?: AmbiguousIdentifierContext;
 
 	get propertyName(): string { return `${this.identifierCapability.name.split(' ')[1]}`; }
 
 	constructor(ctx: T, doc: TextDocument, propertyType: string, nameCtx?: AmbiguousIdentifierContext) {
-		super(ctx, doc);
+		super(ctx, doc, SymbolKind.Property);
 		this.nameContext = nameCtx;
 		this.propertyType = propertyType;
-		this.symbolInformationCapability = new SymbolInformationCapability(this, SymbolKind.Property);
 		this.identifierCapability = new IdentifierCapability({
 			element: this,
 			getNameContext: () => this.nameContext,

server/src/project/parser/vbaListener.ts

@@ -7,6 +7,7 @@ import {
     AnyOperatorContext,
 	ClassModuleContext,
 	EnumDeclarationContext,
+	FunctionDeclarationContext,
 	GlobalVariableDeclarationContext,
 	IgnoredClassAttrContext,
 	IgnoredProceduralAttrContext,
@@ -20,6 +21,7 @@ import {
 	PublicConstDeclarationContext,
 	PublicTypeDeclarationContext,
 	PublicVariableDeclarationContext,
+	SubroutineDeclarationContext,
 	TypeSuffixContext,
 	UdtDeclarationContext,
 	WhileStatementContext
@@ -30,7 +32,7 @@ import { DuplicateOperatorElement, WhileLoopElement } from '../elements/flow';
 import { CompilerLogicalBlock, GenericCommentElement } from '../elements/precompiled';
 import { ClassElement, ModuleElement, ModuleIgnoredAttributeElement } from '../elements/module';
 import { DocumentSettings, VbaClassDocument, VbaModuleDocument } from '../document';
-import { PropertyGetDeclarationElement, PropertyLetDeclarationElement, PropertySetDeclarationElement } from '../elements/procedure';
+import { FunctionDeclarationElement, PropertyGetDeclarationElement, PropertyLetDeclarationElement, PropertySetDeclarationElement, SubDeclarationElement } from '../elements/procedure';
 import { DeclarationStatementElement, EnumDeclarationElement, TypeDeclarationElement, TypeSuffixElement } from '../elements/typing';
 
 
@@ -134,6 +136,16 @@ export class VbaListener extends vbaListener {
             .registerNamespaceElement(element);
     };
 
+    enterSubroutineDeclaration = (ctx: SubroutineDeclarationContext) => {
+        const element = new SubDeclarationElement(ctx, this.document.textDocument);
+        this.document.registerElement(element);
+    }
+
+    enterFunctionDeclaration = (ctx: FunctionDeclarationContext) => {
+        const element = new FunctionDeclarationElement(ctx, this.document.textDocument);
+        this.document.registerElement(element);
+    }
+
     enterPublicTypeDeclaration = (ctx: PublicTypeDeclarationContext) => this.enterTypeDeclaration(ctx, true);
     enterPrivateTypeDeclaration = (ctx: PrivateTypeDeclarationContext) => this.enterTypeDeclaration(ctx, false);
     private enterTypeDeclaration = (ctx: PublicTypeDeclarationContext | PrivateTypeDeclarationContext, isPrivate: boolean) => {