perf: improve performance by doument cache and precomputed scopes

Author: warmthdawn

packages/shared/src/tree/hierarchy-tree.ts

@@ -37,6 +37,7 @@ export class HierarchyNode<V> {
   readonly parent?: HierarchyNode<V>
   readonly children: Map<string, HierarchyNode<V>>
   readonly data: Set<V>
+  syntehticData: V | undefined
 
   constructor(name: string, parent?: HierarchyNode<V>) {
     this.name = name

packages/zenscript/src/module.ts

@@ -16,6 +16,7 @@ import { ZenScriptScopeProvider } from './reference/scope-provider'
 import { ZenScriptTypeComputer } from './typing/type-computer'
 import { registerValidationChecks, ZenScriptValidator } from './validation/validator'
 import { ZenScriptBracketManager } from './workspace/bracket-manager'
+import { ZenScriptClassIndex } from './workspace/class-index'
 import { ZenScriptConfigurationManager } from './workspace/configuration-manager'
 import { ZenScriptPackageManager } from './workspace/package-manager'
 import { ZenScriptWorkspaceManager } from './workspace/workspace-manager'
@@ -37,6 +38,7 @@ export interface ZenScriptAddedServices {
   workspace: {
     PackageManager: ZenScriptPackageManager
     BracketManager: ZenScriptBracketManager
+    ClassIndex: ZenScriptClassIndex
   }
 }
 
@@ -74,6 +76,7 @@ export const ZenScriptModule: Module<ZenScriptServices, PartialLangiumServices &
   workspace: {
     PackageManager: services => new ZenScriptPackageManager(services),
     BracketManager: services => new ZenScriptBracketManager(services),
+    ClassIndex: services => new ZenScriptClassIndex(services),
   },
   parser: {
     TokenBuilder: () => new CustomTokenBuilder(),

packages/zenscript/src/reference/dynamic-provider.ts

@@ -2,9 +2,10 @@ import type { AstNode, AstNodeDescription, AstNodeDescriptionProvider } from 'la
 import type { ZenScriptAstType } from '../generated/ast'
 import type { ZenScriptServices } from '../module'
 import type { TypeComputer } from '../typing/type-computer'
+import type { ZenScriptClassIndex } from '../workspace/class-index'
 import type { MemberProvider } from './member-provider'
 import { AstUtils, stream } from 'langium'
-import { isCallExpression, isClassDeclaration, isFunctionDeclaration, isOperatorFunctionDeclaration } from '../generated/ast'
+import { isCallExpression, isClassDeclaration, isFunctionDeclaration } from '../generated/ast'
 import { isClassType, isFunctionType } from '../typing/type-description'
 
 export interface DynamicProvider {
@@ -18,11 +19,13 @@ export class ZenScriptDynamicProvider implements DynamicProvider {
   private readonly descriptions: AstNodeDescriptionProvider
   private readonly typeComputer: TypeComputer
   private readonly memberProvider: MemberProvider
+  private readonly classIndex: ZenScriptClassIndex
 
   constructor(services: ZenScriptServices) {
     this.descriptions = services.workspace.AstNodeDescriptionProvider
     this.typeComputer = services.typing.TypeComputer
     this.memberProvider = services.references.MemberProvider
+    this.classIndex = services.workspace.ClassIndex
   }
 
   getDynamics(source: AstNode): AstNodeDescription[] {
@@ -37,7 +40,7 @@ export class ZenScriptDynamicProvider implements DynamicProvider {
       // dynamic this
       const classDecl = AstUtils.getContainerOfType(source, isClassDeclaration)
       if (classDecl) {
-        dynamics.push(this.descriptions.createDescription(classDecl, 'this'))
+        dynamics.push(this.classIndex.get(classDecl).thisSymbol)
       }
 
       // dynamic arguments
@@ -48,11 +51,10 @@ export class ZenScriptDynamicProvider implements DynamicProvider {
           const paramType = receiverType.paramTypes[index]
           if (isClassType(paramType)) {
             stream(this.memberProvider.getMembers(paramType.declaration))
-              .map(it => it.node)
-              .filter(it => isFunctionDeclaration(it))
-              .filter(it => it.prefix === 'static')
-              .filter(it => it.parameters.length === 0)
-              .forEach(it => dynamics.push(this.descriptions.createDescription(it, it.name)))
+              .filter(it => isFunctionDeclaration(it.node)
+                && it.node.prefix === 'static'
+                && it.node.parameters.length === 0)
+              .forEach(it => dynamics.push(it))
           }
         }
       }
@@ -63,14 +65,14 @@ export class ZenScriptDynamicProvider implements DynamicProvider {
     MemberAccess: (source) => {
       const dynamics: AstNodeDescription[] = []
 
-      // dynamic member
-      const operatorDecl = stream(this.memberProvider.getMembers(source.receiver))
-        .map(it => it.node)
-        .filter(it => isOperatorFunctionDeclaration(it))
-        .filter(it => it.parameters.length === 1)
-        .find(it => it.op === '.')
-      if (operatorDecl) {
-        dynamics.push(this.descriptions.createDescription(operatorDecl.parameters[0], source.target.$refText))
+      const receiverType = this.typeComputer.inferType(source.receiver)
+
+      if (isClassType(receiverType)) {
+        // dynamic member
+        const operatorDecl = this.classIndex.findOperators(receiverType.declaration, '.').at(0)
+        if (operatorDecl) {
+          dynamics.push(this.descriptions.createDescription(operatorDecl.parameters[0], source.target.$refText))
+        }
       }
 
       return dynamics

packages/zenscript/src/reference/member-provider.ts

@@ -1,45 +1,54 @@
-import type { AstNode, AstNodeDescription, AstNodeDescriptionProvider } from 'langium'
+import type { AstNode, AstNodeDescription, AstNodeDescriptionProvider, Stream } from 'langium'
 import type { ZenScriptAstType } from '../generated/ast'
 import type { ZenScriptServices } from '../module'
 import type { TypeComputer } from '../typing/type-computer'
+import type { ZenScriptClassIndex } from '../workspace/class-index'
+import type { PackageManager } from '../workspace/package-manager'
 import type { ZenScriptSyntheticAstType } from './synthetic'
-import { stream } from 'langium'
+import { AstUtils, stream } from 'langium'
 import { isClassDeclaration, isVariableDeclaration } from '../generated/ast'
 import { ClassType, isAnyType, isClassType, isFunctionType, type Type, type ZenScriptType } from '../typing/type-description'
-import { getClassChain, isStatic } from '../utils/ast'
-import { createSyntheticAstNodeDescription, isSyntheticAstNode } from './synthetic'
+import { getPrecomputedDescription } from '../utils/document'
+import { isSyntheticAstNode } from './synthetic'
 
 export interface MemberProvider {
-  getMembers: (source: AstNode | Type | undefined) => AstNodeDescription[]
+  getMembers: (source: AstNode | Type | undefined) => Stream<AstNodeDescription>
 }
 
 type SourceMap = ZenScriptAstType & ZenScriptType & ZenScriptSyntheticAstType
-type RuleMap = { [K in keyof SourceMap]?: (source: SourceMap[K]) => AstNodeDescription[] }
+type RuleMap = { [K in keyof SourceMap]?: (source: SourceMap[K]) => Stream<AstNodeDescription> }
 
 export class ZenScriptMemberProvider implements MemberProvider {
   private readonly descriptions: AstNodeDescriptionProvider
   private readonly typeComputer: TypeComputer
+  private readonly classIndex: ZenScriptClassIndex
+  private readonly packageManager: PackageManager
 
   constructor(services: ZenScriptServices) {
     this.descriptions = services.workspace.AstNodeDescriptionProvider
     this.typeComputer = services.typing.TypeComputer
+    this.classIndex = services.workspace.ClassIndex
+    this.packageManager = services.workspace.PackageManager
   }
 
-  getMembers(source: AstNode | Type | undefined): AstNodeDescription[] {
+  getMembers(source: AstNode | Type | undefined): Stream<AstNodeDescription> {
     // @ts-expect-error allowed index type
-    return this.rules[source?.$type]?.call(this, source) ?? []
+    return this.rules[source?.$type]?.call(this, source) ?? stream()
   }
 
   private readonly rules: RuleMap = {
     SyntheticHierarchyNode: (source) => {
       const declarations = stream(source.children.values())
         .filter(it => it.isDataNode())
         .flatMap(it => it.data)
-        .map(it => this.descriptions.createDescription(it, undefined))
+        .map((it) => {
+          const document = AstUtils.getDocument(it)
+          return getPrecomputedDescription(document, it)
+        })
       const packages = stream(source.children.values())
         .filter(it => it.isInternalNode())
-        .map(it => createSyntheticAstNodeDescription('SyntheticHierarchyNode', it.name, it))
-      return stream(declarations, packages).toArray()
+        .map(it => this.packageManager.syntheticDescriptionOf(it))
+      return stream(declarations, packages)
     },
 
     Script: (source) => {
@@ -49,18 +58,21 @@ export class ZenScriptMemberProvider implements MemberProvider {
       source.statements.filter(it => isVariableDeclaration(it))
         .filter(it => it.prefix === 'static')
         .forEach(it => members.push(it))
-      return members.map(it => this.descriptions.createDescription(it, undefined))
+      return stream(members
+        .map((it) => {
+          const document = AstUtils.getDocument(it)
+          return getPrecomputedDescription(document, it)
+        }))
     },
 
     ImportDeclaration: (source) => {
       return this.getMembers(source.path.at(-1)?.ref)
     },
 
     ClassDeclaration: (source) => {
-      return getClassChain(source)
-        .flatMap(it => it.members)
-        .filter(it => isStatic(it))
-        .map(it => this.descriptions.createDescription(it, undefined))
+      const index = this.classIndex.get(source)
+
+      return index.streamDescriptions(true)
     },
 
     VariableDeclaration: (source) => {
@@ -81,7 +93,7 @@ export class ZenScriptMemberProvider implements MemberProvider {
     MemberAccess: (source) => {
       const target = source.target.ref
       if (!target) {
-        return []
+        return stream()
       }
 
       if (isSyntheticAstNode(target)) {
@@ -120,7 +132,7 @@ export class ZenScriptMemberProvider implements MemberProvider {
       if (isAnyType(receiverType)) {
         return this.getMembers(receiverType)
       }
-      return []
+      return stream()
     },
 
     BracketExpression: (source) => {
@@ -159,10 +171,8 @@ export class ZenScriptMemberProvider implements MemberProvider {
     },
 
     ClassType: (source) => {
-      return getClassChain(source.declaration)
-        .flatMap(it => it.members)
-        .filter(it => !isStatic(it))
-        .map(it => this.descriptions.createDescription(it, undefined))
+      const index = this.classIndex.get(source.declaration)
+      return index.streamDescriptions(false)
     },
   }
 }

packages/zenscript/src/reference/scope-computation.ts

@@ -1,4 +1,4 @@
-import type { AstNode, AstNodeDescription, LangiumDocument } from 'langium'
+import type { AstNode, AstNodeDescription, LangiumDocument, PrecomputedScopes } from 'langium'
 import type { Script } from '../generated/ast'
 import type { ZenScriptServices } from '../module'
 import { DefaultScopeComputation } from 'langium'

packages/zenscript/src/reference/scope-provider.ts

@@ -1,15 +1,16 @@
 import type { AstNode, AstNodeDescription, ReferenceInfo, Scope } from 'langium'
 import type { ZenScriptAstType } from '../generated/ast'
 import type { ZenScriptServices } from '../module'
+import type { ZenScriptClassIndex } from '../workspace/class-index'
 import type { PackageManager } from '../workspace/package-manager'
 import type { DynamicProvider } from './dynamic-provider'
 import type { MemberProvider } from './member-provider'
 import { substringBeforeLast } from '@intellizen/shared'
-import { AstUtils, DefaultScopeProvider, EMPTY_SCOPE, stream } from 'langium'
+import { AstUtils, DefaultScopeProvider, EMPTY_SCOPE, MapScope, stream, StreamScope } from 'langium'
 import { ClassDeclaration, ImportDeclaration, isClassDeclaration, TypeParameter } from '../generated/ast'
 import { getPathAsString } from '../utils/ast'
+import { getPrecomputedDescription } from '../utils/document'
 import { generateStream } from '../utils/stream'
-import { createSyntheticAstNodeDescription } from './synthetic'
 
 type SourceMap = ZenScriptAstType
 type RuleMap = { [K in keyof SourceMap]?: (source: ReferenceInfo & { container: SourceMap[K] }) => Scope }
@@ -18,12 +19,14 @@ export class ZenScriptScopeProvider extends DefaultScopeProvider {
   private readonly packageManager: PackageManager
   private readonly memberProvider: MemberProvider
   private readonly dynamicProvider: DynamicProvider
+  private readonly classIndex: ZenScriptClassIndex
 
   constructor(services: ZenScriptServices) {
     super(services)
     this.packageManager = services.workspace.PackageManager
     this.memberProvider = services.references.MemberProvider
     this.dynamicProvider = services.references.DynamicProvider
+    this.classIndex = services.workspace.ClassIndex
   }
 
   override getScope(context: ReferenceInfo): Scope {
@@ -41,7 +44,7 @@ export class ZenScriptScopeProvider extends DefaultScopeProvider {
       .map(container => precomputed?.get(container))
       .nonNullable()
       .map(descriptions => stream(descriptions).map(processor).nonNullable())
-      .reduce((outer, descriptions) => this.createScope(descriptions, outer), outside as Scope)
+      .reduce((outer, descriptions) => new StreamScope(descriptions, outer), outside as Scope)
   }
 
   private dynamicScope(astNode: AstNode, outside?: Scope) {
@@ -50,22 +53,45 @@ export class ZenScriptScopeProvider extends DefaultScopeProvider {
 
   private globalScope(outside?: Scope) {
     return this.createScope(this.indexManager.allElements(), outside)
+    // return new MapScope(this.indexManager.allElements(), outside)
   }
 
   private packageScope(outside?: Scope) {
     const packages = stream(this.packageManager.root.children.values())
       .filter(it => it.isInternalNode())
-      .map(it => createSyntheticAstNodeDescription('SyntheticHierarchyNode', it.name, it))
-    return this.createScope(packages, outside)
+      .map(it => this.packageManager.syntheticDescriptionOf(it))
+    return new StreamScope(packages, outside)
   }
 
   private classScope(outside?: Scope) {
     const classes = stream(this.packageManager.root.children.values())
       .filter(it => it.isDataNode())
       .flatMap(it => it.data)
       .filter(isClassDeclaration)
-      .map(it => this.descriptions.createDescription(it, it.name))
-    return this.createScope(classes, outside)
+      .map((it) => {
+        const document = AstUtils.getDocument(it)
+        return getPrecomputedDescription(document, it)
+      })
+    return new StreamScope(classes, outside)
+  }
+
+  private getImportDescription(importDecl: ImportDeclaration): AstNodeDescription | undefined {
+    const refNode = importDecl.path.at(-1)
+    if (!refNode) {
+      return
+    }
+
+    // access the ref to ensure the lookup of the import
+    const ref = refNode?.ref
+    if (!ref) {
+      return
+    }
+
+    if (!importDecl.alias) {
+      return refNode?.$nodeDescription
+    }
+
+    return this.descriptions.createDescription(ref, this.nameProvider.getName(importDecl), AstUtils.getDocument(ref))
   }
 
   private readonly rules: RuleMap = {
@@ -80,10 +106,13 @@ export class ZenScriptScopeProvider extends DefaultScopeProvider {
       const elements: AstNodeDescription[] = []
       for (const sibling of siblings) {
         if (sibling.isDataNode()) {
-          sibling.data.forEach(it => elements.push(this.descriptions.createDescription(it, sibling.name)))
+          sibling.data.forEach((it) => {
+            const document = AstUtils.getDocument(it)
+            elements.push(getPrecomputedDescription(document, it))
+          })
         }
         else {
-          elements.push(createSyntheticAstNodeDescription('SyntheticHierarchyNode', sibling.name, sibling))
+          elements.push(this.packageManager.syntheticDescriptionOf(sibling))
         }
       }
       return this.createScope(elements)
@@ -101,8 +130,7 @@ export class ZenScriptScopeProvider extends DefaultScopeProvider {
             return
           case ImportDeclaration: {
             const importDecl = desc.node as ImportDeclaration
-            const ref = importDecl.path.at(-1)?.ref ?? importDecl
-            return this.descriptions.createDescription(ref, this.nameProvider.getName(importDecl))
+            return this.getImportDescription(importDecl) ?? desc
           }
           default:
             return desc
@@ -114,7 +142,7 @@ export class ZenScriptScopeProvider extends DefaultScopeProvider {
     MemberAccess: (source) => {
       const outer = this.dynamicScope(source.container)
       const members = this.memberProvider.getMembers(source.container.receiver)
-      return this.createScope(members, outer)
+      return new StreamScope(members, outer)
     },
 
     NamedTypeReference: (source) => {
@@ -127,8 +155,7 @@ export class ZenScriptScopeProvider extends DefaultScopeProvider {
               return desc
             case ImportDeclaration: {
               const importDecl = desc.node as ImportDeclaration
-              const ref = importDecl.path.at(-1)?.ref ?? importDecl
-              return this.descriptions.createDescription(ref, this.nameProvider.getName(importDecl))
+              return this.getImportDescription(importDecl) ?? desc
             }
           }
         }
@@ -137,7 +164,7 @@ export class ZenScriptScopeProvider extends DefaultScopeProvider {
       else {
         const prev = source.container.path[source.index - 1].ref
         const members = this.memberProvider.getMembers(prev)
-        return this.createScope(members)
+        return new StreamScope(members)
       }
     },
   }

packages/zenscript/src/reference/synthetic.ts

@@ -10,9 +10,10 @@ export function createSyntheticAstNodeDescription<K extends keyof ZenScriptSynth
   $type: K,
   name: string,
   origin?: ZenScriptSyntheticAstType[K],
+  node?: AstNode,
 ): AstNodeDescription {
   return {
-    node: createSyntheticAstNode($type, origin),
+    node: node ?? createSyntheticAstNode($type, origin),
     type: $type,
     name,
     documentUri: URI.from({ scheme: 'synthetic', path: `/${$type}/${name}` }),