@finos/legend-graph 32.3.37 → 32.3.39

package/src/graph-manager/protocol/pure/v1/V1_PureGraphManager.ts

@@ -378,12 +378,6 @@ import {
 } from './engine/dev-metadata/V1_DevMetadataPushRequest.js';
 import type { MetadataRequestOptions } from '../../../action/dev-metadata/MetadataRequestOptions.js';
 
-/**
- * Number of elements to process synchronously before yielding to the event loop.
- * This avoids per-element setTimeout overhead while keeping the UI responsive.
- */
-const GRAPH_BUILDER_BATCH_SIZE = 100;
-
 class V1_PureModelContextDataIndex {
   elements: V1_PackageableElement[] = [];
   nativeElements: V1_PackageableElement[] = [];
@@ -1278,37 +1272,46 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       graph.allElements.map((el) => el.path),
     );
 
-    for (const input of inputs) {
-      const packageCache = new Map<string, Package>();
-      const createFirstPassBuilder = (
-        element: V1_PackageableElement,
-      ): V1_ElementFirstPassBuilder =>
-        new V1_ElementFirstPassBuilder(
-          this.getBuilderContext(graph, input.model, element, options),
-          packageCache,
-          elementPathCache,
+    await Promise.all(
+      inputs.flatMap(async (input) => {
+        // create the package cache
+        const packageCache = new Map<string, Package>();
+        await Promise.all(
+          input.data.nativeElements.map((element) => {
+            return this.visitWithGraphBuilderErrorHandling(
+              element,
+              new V1_ElementFirstPassBuilder(
+                this.getBuilderContext(graph, input.model, element, options),
+                packageCache,
+                elementPathCache,
+              ),
+            );
+          }),
         );
-
-      // index native elements
-      await this.runBatchedLoop(input.data.nativeElements, (element) =>
-        this.visitWithGraphBuilderErrorHandling(
-          element,
-          createFirstPassBuilder(element),
-        ),
-      );
-
-      // index other (plugin-contributed) elements
-      const otherElements =
-        this.graphBuilderExtensions.sortedExtraElementBuilders.flatMap(
-          (builder) => input.data.otherElementsByBuilder.get(builder) ?? [],
+        await Promise.all(
+          this.graphBuilderExtensions.sortedExtraElementBuilders.flatMap(
+            (builder) =>
+              (input.data.otherElementsByBuilder.get(builder) ?? []).map(
+                (element) => {
+                  return this.visitWithGraphBuilderErrorHandling(
+                    element,
+                    new V1_ElementFirstPassBuilder(
+                      this.getBuilderContext(
+                        graph,
+                        input.model,
+                        element,
+                        options,
+                      ),
+                      packageCache,
+                      elementPathCache,
+                    ),
+                  );
+                },
+              ),
+          ),
         );
-      await this.runBatchedLoop(otherElements, (element) =>
-        this.visitWithGraphBuilderErrorHandling(
-          element,
-          createFirstPassBuilder(element),
-        ),
-      );
-    }
+      }),
+    );
   }
 
   private async buildTypes(
@@ -1317,78 +1320,128 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     options?: GraphBuilderOptions,
   ): Promise<void> {
     // Second pass
-    await this.processElementsInBatches(
-      graph,
-      inputs,
-      (data) => data.profiles,
-      (ctx) => new V1_ElementSecondPassBuilder(ctx),
-      options,
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.profiles.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementSecondPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
     );
-    await this.processElementsInBatches(
-      graph,
-      inputs,
-      (data) => data.classes,
-      (ctx) => new V1_ElementSecondPassBuilder(ctx),
-      options,
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.classes.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementSecondPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
     );
-    await this.processElementsInBatches(
-      graph,
-      inputs,
-      (data) => data.enumerations,
-      (ctx) => new V1_ElementSecondPassBuilder(ctx),
-      options,
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.enumerations.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementSecondPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
     );
-    await this.processElementsInBatches(
-      graph,
-      inputs,
-      (data) => data.measures,
-      (ctx) => new V1_ElementSecondPassBuilder(ctx),
-      options,
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.measures.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementSecondPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
     );
-    await this.processElementsInBatches(
-      graph,
-      inputs,
-      (data) => data.functions,
-      (ctx) => new V1_ElementSecondPassBuilder(ctx),
-      options,
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.functions.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementSecondPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
     );
     // Third pass
-    await this.processElementsInBatches(
-      graph,
-      inputs,
-      (data) => data.classes,
-      (ctx) => new V1_ElementThirdPassBuilder(ctx),
-      options,
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.classes.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementThirdPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
     );
-    await this.processElementsInBatches(
-      graph,
-      inputs,
-      (data) => data.associations,
-      (ctx) => new V1_ElementThirdPassBuilder(ctx),
-      options,
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.associations.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementThirdPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
     );
     // Fourth Pass
-    await this.processElementsInBatches(
-      graph,
-      inputs,
-      (data) => data.classes,
-      (ctx) => new V1_ElementFourthPassBuilder(ctx),
-      options,
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.classes.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementFourthPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
     );
-    await this.processElementsInBatches(
-      graph,
-      inputs,
-      (data) => data.associations,
-      (ctx) => new V1_ElementFourthPassBuilder(ctx),
-      options,
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.associations.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementFourthPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
     );
     // Fifth pass
-    await this.processElementsInBatches(
-      graph,
-      inputs,
-      (data) => data.classes,
-      (ctx) => new V1_ElementFifthPassBuilder(ctx),
-      options,
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.classes.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementFifthPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
     );
   }
 
@@ -1397,12 +1450,17 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
-    await this.processElementsInBatches(
-      graph,
-      inputs,
-      (data) => data.functionActivators,
-      (ctx) => new V1_ElementSecondPassBuilder(ctx),
-      options,
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.functionActivators.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementSecondPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
     );
   }
 
@@ -1411,33 +1469,53 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
-    await this.processElementsInBatches(
-      graph,
-      inputs,
-      (data) => data.stores,
-      (ctx) => new V1_ElementSecondPassBuilder(ctx),
-      options,
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.stores.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementSecondPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
     );
-    await this.processElementsInBatches(
-      graph,
-      inputs,
-      (data) => data.stores,
-      (ctx) => new V1_ElementThirdPassBuilder(ctx),
-      options,
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.stores.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementThirdPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
     );
-    await this.processElementsInBatches(
-      graph,
-      inputs,
-      (data) => data.stores,
-      (ctx) => new V1_ElementFourthPassBuilder(ctx),
-      options,
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.stores.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementFourthPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
     );
-    await this.processElementsInBatches(
-      graph,
-      inputs,
-      (data) => data.stores,
-      (ctx) => new V1_ElementFifthPassBuilder(ctx),
-      options,
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.stores.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementFifthPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
     );
   }
 
@@ -1446,26 +1524,41 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
-    await this.processElementsInBatches(
-      graph,
-      inputs,
-      (data) => data.mappings,
-      (ctx) => new V1_ElementSecondPassBuilder(ctx),
-      options,
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.mappings.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementSecondPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
     );
-    await this.processElementsInBatches(
-      graph,
-      inputs,
-      (data) => data.mappings,
-      (ctx) => new V1_ElementThirdPassBuilder(ctx),
-      options,
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.mappings.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementThirdPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
     );
-    await this.processElementsInBatches(
-      graph,
-      inputs,
-      (data) => data.mappings,
-      (ctx) => new V1_ElementFourthPassBuilder(ctx),
-      options,
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.mappings.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementFourthPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
     );
   }
 
@@ -1475,19 +1568,29 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     options?: GraphBuilderOptions,
   ): Promise<void> {
     // NOTE: connections must be built before runtimes
-    await this.processElementsInBatches(
-      graph,
-      inputs,
-      (data) => data.connections,
-      (ctx) => new V1_ElementSecondPassBuilder(ctx),
-      options,
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.connections.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementSecondPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
     );
-    await this.processElementsInBatches(
-      graph,
-      inputs,
-      (data) => data.runtimes,
-      (ctx) => new V1_ElementSecondPassBuilder(ctx),
-      options,
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.runtimes.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementSecondPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
     );
   }
 
@@ -1496,19 +1599,29 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
-    await this.processElementsInBatches(
-      graph,
-      inputs,
-      (data) => data.services,
-      (ctx) => new V1_ElementSecondPassBuilder(ctx),
-      options,
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.services.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementSecondPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
     );
-    await this.processElementsInBatches(
-      graph,
-      inputs,
-      (data) => data.executionEnvironments,
-      (ctx) => new V1_ElementSecondPassBuilder(ctx),
-      options,
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.executionEnvironments.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementSecondPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
     );
   }
 
@@ -1517,12 +1630,17 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
-    await this.processElementsInBatches(
-      graph,
-      inputs,
-      (data) => data.dataElements,
-      (ctx) => new V1_ElementSecondPassBuilder(ctx),
-      options,
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.dataElements.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementSecondPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
     );
   }
 
@@ -1531,12 +1649,17 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
-    await this.processElementsInBatches(
-      graph,
-      inputs,
-      (data) => data.products,
-      (ctx) => new V1_ElementSecondPassBuilder(ctx),
-      options,
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.products.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementSecondPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
     );
   }
 
@@ -1545,12 +1668,17 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
-    await this.processElementsInBatches(
-      graph,
-      inputs,
-      (data) => data.fileGenerations,
-      (ctx) => new V1_ElementSecondPassBuilder(ctx),
-      options,
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.fileGenerations.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementSecondPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
     );
   }
 
@@ -1559,12 +1687,17 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
-    await this.processElementsInBatches(
-      graph,
-      inputs,
-      (data) => data.generationSpecifications,
-      (ctx) => new V1_ElementSecondPassBuilder(ctx),
-      options,
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.generationSpecifications.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementSecondPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
     );
   }
 
@@ -1573,12 +1706,17 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
-    await this.processElementsInBatches(
-      graph,
-      inputs,
-      (data) => data.sectionIndices,
-      (ctx) => new V1_ElementSecondPassBuilder(ctx),
-      options,
+    await Promise.all(
+      inputs.flatMap((input) =>
+        input.data.sectionIndices.map((element) =>
+          this.visitWithGraphBuilderErrorHandling(
+            element,
+            new V1_ElementSecondPassBuilder(
+              this.getBuilderContext(graph, input.model, element, options),
+            ),
+          ),
+        ),
+      ),
     );
   }
 
@@ -1587,90 +1725,82 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
-    for (const builder of this.graphBuilderExtensions
-      .sortedExtraElementBuilders) {
-      const getElements = (
-        data: V1_PureModelContextDataIndex,
-      ): V1_PackageableElement[] =>
-        data.otherElementsByBuilder.get(builder) ?? [];
-      await this.processElementsInBatches(
-        graph,
-        inputs,
-        getElements,
-        (ctx) => new V1_ElementSecondPassBuilder(ctx),
-        options,
-      );
-      await this.processElementsInBatches(
-        graph,
-        inputs,
-        getElements,
-        (ctx) => new V1_ElementThirdPassBuilder(ctx),
-        options,
-      );
-      await this.processElementsInBatches(
-        graph,
-        inputs,
-        getElements,
-        (ctx) => new V1_ElementFourthPassBuilder(ctx),
-        options,
-      );
-      await this.processElementsInBatches(
-        graph,
-        inputs,
-        getElements,
-        (ctx) => new V1_ElementFifthPassBuilder(ctx),
-        options,
-      );
-    }
-  }
-
-  /**
-   * Run a callback for each item in the array, processing items in batches
-   * of {@link GRAPH_BUILDER_BATCH_SIZE} and yielding to the event loop between
-   * batches to keep the UI responsive.
-   */
-  private async runBatchedLoop<T>(
-    items: T[],
-    process: (item: T) => void,
-  ): Promise<void> {
-    for (let i = 0; i < items.length; i += GRAPH_BUILDER_BATCH_SIZE) {
-      if (i > 0) {
-        await new Promise<void>((resolve) => setTimeout(resolve, 0));
-      }
-      const end = Math.min(i + GRAPH_BUILDER_BATCH_SIZE, items.length);
-      for (let j = i; j < end; j++) {
-        process(guaranteeNonNullable(items[j]));
-      }
-    }
-  }
-
-  /**
-   * Process elements from inputs in batches, yielding to the event loop
-   * between batches to keep the UI responsive.
-   */
-  private async processElementsInBatches(
-    graph: PureModel,
-    inputs: V1_PureGraphBuilderInput[],
-    getElements: (
-      data: V1_PureModelContextDataIndex,
-    ) => V1_PackageableElement[],
-    createVisitor: (
-      ctx: V1_GraphBuilderContext,
-    ) => V1_PackageableElementVisitor<unknown>,
-    options?: GraphBuilderOptions,
-  ): Promise<void> {
-    const allItems = inputs.flatMap((input) =>
-      getElements(input.data).map((element) => ({
-        element,
-        model: input.model,
-      })),
-    );
-    await this.runBatchedLoop(allItems, (item) =>
-      this.visitWithGraphBuilderErrorHandling(
-        item.element,
-        createVisitor(
-          this.getBuilderContext(graph, item.model, item.element, options),
-        ),
+    await Promise.all(
+      this.graphBuilderExtensions.sortedExtraElementBuilders.map(
+        async (builder) => {
+          await Promise.all(
+            inputs.flatMap((input) =>
+              (input.data.otherElementsByBuilder.get(builder) ?? []).map(
+                (element) =>
+                  this.visitWithGraphBuilderErrorHandling(
+                    element,
+                    new V1_ElementSecondPassBuilder(
+                      this.getBuilderContext(
+                        graph,
+                        input.model,
+                        element,
+                        options,
+                      ),
+                    ),
+                  ),
+              ),
+            ),
+          );
+          await Promise.all(
+            inputs.flatMap((input) =>
+              (input.data.otherElementsByBuilder.get(builder) ?? []).map(
+                (element) =>
+                  this.visitWithGraphBuilderErrorHandling(
+                    element,
+                    new V1_ElementThirdPassBuilder(
+                      this.getBuilderContext(
+                        graph,
+                        input.model,
+                        element,
+                        options,
+                      ),
+                    ),
+                  ),
+              ),
+            ),
+          );
+          await Promise.all(
+            inputs.flatMap((input) =>
+              (input.data.otherElementsByBuilder.get(builder) ?? []).map(
+                (element) =>
+                  this.visitWithGraphBuilderErrorHandling(
+                    element,
+                    new V1_ElementFourthPassBuilder(
+                      this.getBuilderContext(
+                        graph,
+                        input.model,
+                        element,
+                        options,
+                      ),
+                    ),
+                  ),
+              ),
+            ),
+          );
+          await Promise.all(
+            inputs.flatMap((input) =>
+              (input.data.otherElementsByBuilder.get(builder) ?? []).map(
+                (element) =>
+                  this.visitWithGraphBuilderErrorHandling(
+                    element,
+                    new V1_ElementFifthPassBuilder(
+                      this.getBuilderContext(
+                        graph,
+                        input.model,
+                        element,
+                        options,
+                      ),
+                    ),
+                  ),
+              ),
+            ),
+          );
+        },
       ),
     );
   }
@@ -1678,9 +1808,9 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
   private visitWithGraphBuilderErrorHandling<T>(
     element: V1_PackageableElement,
     visitor: V1_PackageableElementVisitor<T>,
-  ): T {
+  ): Promise<T> {
     try {
-      return element.accept_PackageableElementVisitor(visitor);
+      return promisify(() => element.accept_PackageableElementVisitor(visitor));
     } catch (err) {
       assertErrorThrown(err);
       const error =