@finos/legend-graph 32.3.35 → 32.3.37

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

@@ -378,6 +378,12 @@ 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[] = [];
@@ -1272,46 +1278,37 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       graph.allElements.map((el) => el.path),
     );
 
-    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,
-              ),
-            );
-          }),
+    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(
-          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,
-                    ),
-                  );
-                },
-              ),
-          ),
+
+      // 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 this.runBatchedLoop(otherElements, (element) =>
+        this.visitWithGraphBuilderErrorHandling(
+          element,
+          createFirstPassBuilder(element),
+        ),
+      );
+    }
   }
 
   private async buildTypes(
@@ -1320,128 +1317,78 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     options?: GraphBuilderOptions,
   ): Promise<void> {
     // Second pass
-    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.profiles,
+      (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.classes,
+      (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.enumerations,
+      (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.measures,
+      (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),
-            ),
-          ),
-        ),
-      ),
+    await this.processElementsInBatches(
+      graph,
+      inputs,
+      (data) => data.functions,
+      (ctx) => new V1_ElementSecondPassBuilder(ctx),
+      options,
     );
     // Third pass
-    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.classes,
+      (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),
-            ),
-          ),
-        ),
-      ),
+    await this.processElementsInBatches(
+      graph,
+      inputs,
+      (data) => data.associations,
+      (ctx) => new V1_ElementThirdPassBuilder(ctx),
+      options,
     );
     // Fourth Pass
-    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.classes,
+      (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),
-            ),
-          ),
-        ),
-      ),
+    await this.processElementsInBatches(
+      graph,
+      inputs,
+      (data) => data.associations,
+      (ctx) => new V1_ElementFourthPassBuilder(ctx),
+      options,
     );
     // Fifth pass
-    await Promise.all(
-      inputs.flatMap((input) =>
-        input.data.classes.map((element) =>
-          this.visitWithGraphBuilderErrorHandling(
-            element,
-            new V1_ElementFifthPassBuilder(
-              this.getBuilderContext(graph, input.model, element, options),
-            ),
-          ),
-        ),
-      ),
+    await this.processElementsInBatches(
+      graph,
+      inputs,
+      (data) => data.classes,
+      (ctx) => new V1_ElementFifthPassBuilder(ctx),
+      options,
     );
   }
 
@@ -1450,17 +1397,12 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
-    await Promise.all(
-      inputs.flatMap((input) =>
-        input.data.functionActivators.map((element) =>
-          this.visitWithGraphBuilderErrorHandling(
-            element,
-            new V1_ElementSecondPassBuilder(
-              this.getBuilderContext(graph, input.model, element, options),
-            ),
-          ),
-        ),
-      ),
+    await this.processElementsInBatches(
+      graph,
+      inputs,
+      (data) => data.functionActivators,
+      (ctx) => new V1_ElementSecondPassBuilder(ctx),
+      options,
     );
   }
 
@@ -1469,53 +1411,33 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
-    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_ElementSecondPassBuilder(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_ElementThirdPassBuilder(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_ElementFourthPassBuilder(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),
-            ),
-          ),
-        ),
-      ),
+    await this.processElementsInBatches(
+      graph,
+      inputs,
+      (data) => data.stores,
+      (ctx) => new V1_ElementFifthPassBuilder(ctx),
+      options,
     );
   }
 
@@ -1524,41 +1446,26 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
-    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_ElementSecondPassBuilder(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_ElementThirdPassBuilder(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),
-            ),
-          ),
-        ),
-      ),
+    await this.processElementsInBatches(
+      graph,
+      inputs,
+      (data) => data.mappings,
+      (ctx) => new V1_ElementFourthPassBuilder(ctx),
+      options,
     );
   }
 
@@ -1568,29 +1475,19 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     options?: GraphBuilderOptions,
   ): Promise<void> {
     // NOTE: connections must be built before runtimes
-    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.connections,
+      (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),
-            ),
-          ),
-        ),
-      ),
+    await this.processElementsInBatches(
+      graph,
+      inputs,
+      (data) => data.runtimes,
+      (ctx) => new V1_ElementSecondPassBuilder(ctx),
+      options,
     );
   }
 
@@ -1599,29 +1496,19 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
-    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.services,
+      (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),
-            ),
-          ),
-        ),
-      ),
+    await this.processElementsInBatches(
+      graph,
+      inputs,
+      (data) => data.executionEnvironments,
+      (ctx) => new V1_ElementSecondPassBuilder(ctx),
+      options,
     );
   }
 
@@ -1630,17 +1517,12 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
-    await Promise.all(
-      inputs.flatMap((input) =>
-        input.data.dataElements.map((element) =>
-          this.visitWithGraphBuilderErrorHandling(
-            element,
-            new V1_ElementSecondPassBuilder(
-              this.getBuilderContext(graph, input.model, element, options),
-            ),
-          ),
-        ),
-      ),
+    await this.processElementsInBatches(
+      graph,
+      inputs,
+      (data) => data.dataElements,
+      (ctx) => new V1_ElementSecondPassBuilder(ctx),
+      options,
     );
   }
 
@@ -1649,17 +1531,12 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
-    await Promise.all(
-      inputs.flatMap((input) =>
-        input.data.products.map((element) =>
-          this.visitWithGraphBuilderErrorHandling(
-            element,
-            new V1_ElementSecondPassBuilder(
-              this.getBuilderContext(graph, input.model, element, options),
-            ),
-          ),
-        ),
-      ),
+    await this.processElementsInBatches(
+      graph,
+      inputs,
+      (data) => data.products,
+      (ctx) => new V1_ElementSecondPassBuilder(ctx),
+      options,
     );
   }
 
@@ -1668,17 +1545,12 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
-    await Promise.all(
-      inputs.flatMap((input) =>
-        input.data.fileGenerations.map((element) =>
-          this.visitWithGraphBuilderErrorHandling(
-            element,
-            new V1_ElementSecondPassBuilder(
-              this.getBuilderContext(graph, input.model, element, options),
-            ),
-          ),
-        ),
-      ),
+    await this.processElementsInBatches(
+      graph,
+      inputs,
+      (data) => data.fileGenerations,
+      (ctx) => new V1_ElementSecondPassBuilder(ctx),
+      options,
     );
   }
 
@@ -1687,17 +1559,12 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
-    await Promise.all(
-      inputs.flatMap((input) =>
-        input.data.generationSpecifications.map((element) =>
-          this.visitWithGraphBuilderErrorHandling(
-            element,
-            new V1_ElementSecondPassBuilder(
-              this.getBuilderContext(graph, input.model, element, options),
-            ),
-          ),
-        ),
-      ),
+    await this.processElementsInBatches(
+      graph,
+      inputs,
+      (data) => data.generationSpecifications,
+      (ctx) => new V1_ElementSecondPassBuilder(ctx),
+      options,
     );
   }
 
@@ -1706,17 +1573,12 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
-    await Promise.all(
-      inputs.flatMap((input) =>
-        input.data.sectionIndices.map((element) =>
-          this.visitWithGraphBuilderErrorHandling(
-            element,
-            new V1_ElementSecondPassBuilder(
-              this.getBuilderContext(graph, input.model, element, options),
-            ),
-          ),
-        ),
-      ),
+    await this.processElementsInBatches(
+      graph,
+      inputs,
+      (data) => data.sectionIndices,
+      (ctx) => new V1_ElementSecondPassBuilder(ctx),
+      options,
     );
   }
 
@@ -1725,82 +1587,90 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     inputs: V1_PureGraphBuilderInput[],
     options?: GraphBuilderOptions,
   ): Promise<void> {
-    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,
-                      ),
-                    ),
-                  ),
-              ),
-            ),
-          );
-        },
+    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),
+        ),
       ),
     );
   }
@@ -1808,9 +1678,9 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
   private visitWithGraphBuilderErrorHandling<T>(
     element: V1_PackageableElement,
     visitor: V1_PackageableElementVisitor<T>,
-  ): Promise<T> {
+  ): T {
     try {
-      return promisify(() => element.accept_PackageableElementVisitor(visitor));
+      return element.accept_PackageableElementVisitor(visitor);
     } catch (err) {
       assertErrorThrown(err);
       const error =