@atlaspack/core 2.29.2 → 2.30.0

package/src/applyRuntimes.ts

@@ -9,6 +9,7 @@ import type {
   DevDepRequest,
   AtlaspackOptions,
   DevDepRequestRef,
+  DependencyNode,
 } from './types';
 import type {AtlaspackConfig} from './AtlaspackConfig';
 import type PluginOptions from './public/PluginOptions';
@@ -19,6 +20,7 @@ import assert from 'assert';
 import invariant from 'assert';
 import nullthrows from 'nullthrows';
 import {nodeFromAssetGroup} from './AssetGraph';
+import type AssetGraph from './AssetGraph';
 import BundleGraph from './public/BundleGraph';
 import InternalBundleGraph, {bundleGraphEdgeTypes} from './BundleGraph';
 import {NamedBundle} from './public/Bundle';
@@ -33,6 +35,7 @@ import {toProjectPath, fromProjectPathRelative} from './projectPath';
 import {tracer, PluginTracer} from '@atlaspack/profiler';
 import {DefaultMap} from '@atlaspack/utils';
 import {fromEnvironmentId} from './EnvironmentManager';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 type RuntimeConnection = {
   bundle: InternalBundle;
@@ -152,6 +155,7 @@ export default async function applyRuntimes<TResult extends RequestResult>({
             env,
             runtimeAssetRequiringExecutionOnLoad,
             priority,
+            symbolData,
           } of runtimeAssets) {
             let sourceName = path.join(
               path.dirname(filePath),
@@ -170,6 +174,7 @@ export default async function applyRuntimes<TResult extends RequestResult>({
               // Runtime assets should be considered source, as they should be
               // e.g. compiled to run in the target environment
               isSource: true,
+              symbolData,
             };
 
             let connectionBundle = bundle;
@@ -276,6 +281,11 @@ export default async function applyRuntimes<TResult extends RequestResult>({
   let {assetGraph: runtimesAssetGraph, changedAssets} =
     await reconcileNewRuntimes(api, connections, optionsRef);
 
+  if (getFeatureFlag('skipRuntimeSymbolProp')) {
+    // Apply pre-computed symbol data from runtime assets to skip symbol propagation
+    applyRuntimeSymbolData(runtimesAssetGraph, connections);
+  }
+
   // Convert the runtime AssetGraph into a BundleGraph, this includes assigning
   // the assets their public ids
   let runtimesBundleGraph = InternalBundleGraph.fromAssetGraph(
@@ -398,6 +408,93 @@ export default async function applyRuntimes<TResult extends RequestResult>({
   return changedAssets;
 }
 
+/**
+ * Apply pre-computed symbol data from runtime assets to the asset graph
+ * to avoid running symbol propagation on runtime code we control.
+ */
+function applyRuntimeSymbolData(
+  assetGraph: AssetGraph,
+  connections: Array<RuntimeConnection>,
+) {
+  for (let {assetGroup} of connections) {
+    let assetGroupNode = nodeFromAssetGroup(assetGroup);
+    let assetGroupAssetNodeIds = assetGraph.getNodeIdsConnectedFrom(
+      assetGraph.getNodeIdByContentKey(assetGroupNode.id),
+    );
+
+    if (assetGroupAssetNodeIds.length !== 1) {
+      continue;
+    }
+
+    let runtimeAssetNodeId = assetGroupAssetNodeIds[0];
+    let runtimeAssetNode = assetGraph.getNode(runtimeAssetNodeId);
+    if (!runtimeAssetNode || runtimeAssetNode.type !== 'asset') {
+      continue;
+    }
+
+    let symbolData = assetGroup.symbolData;
+    if (!symbolData) {
+      // We completely skip symbol propagation for runtime assets, so symbolData
+      // is required
+      throw new Error('Runtime asset is missing symbol data');
+    }
+
+    if (symbolData.symbols) {
+      // Convert from SymbolData format to internal Asset.symbols format
+      let internalSymbols = new Map();
+      for (let [symbol, data] of symbolData.symbols) {
+        internalSymbols.set(symbol, {
+          local: data.local,
+          loc: data.loc || null,
+          meta: data.meta,
+        });
+      }
+      runtimeAssetNode.value.symbols = internalSymbols;
+    }
+
+    if (symbolData.dependencies && symbolData.dependencies.length > 0) {
+      let outgoingDeps = assetGraph
+        .getNodeIdsConnectedFrom(runtimeAssetNodeId)
+        .map((id) => assetGraph.getNode(id))
+        .filter((node) => node?.type === 'dependency')
+        .map((node) => node as DependencyNode);
+
+      for (let depSymbolData of symbolData.dependencies) {
+        let matchingDep = outgoingDeps.find(
+          (depNode) => depNode.value.specifier === depSymbolData.specifier,
+        );
+
+        if (matchingDep) {
+          if (depSymbolData.symbols) {
+            let internalDepSymbols = new Map();
+            for (let [symbol, data] of depSymbolData.symbols) {
+              internalDepSymbols.set(symbol, {
+                local: data.local,
+                loc: data.loc || null,
+                isWeak: data.isWeak,
+                meta: data.meta,
+              });
+            }
+            matchingDep.value.symbols = internalDepSymbols;
+          }
+
+          if (depSymbolData.usedSymbols) {
+            matchingDep.usedSymbolsDown = new Set(depSymbolData.usedSymbols);
+            // For runtime assets, usedSymbolsUp will be the same as usedSymbolsDown
+            // since we know exactly what we're using
+            let usedSymbolsUp = new Map();
+            for (let symbol of depSymbolData.usedSymbols) {
+              // Mark as resolved to external (null) since runtime deps are typically external
+              usedSymbolsUp.set(symbol, null);
+            }
+            matchingDep.usedSymbolsUp = usedSymbolsUp;
+          }
+        }
+      }
+    }
+  }
+}
+
 function reconcileNewRuntimes<TResult extends RequestResult>(
   api: RunAPI<TResult>,
   connections: Array<RuntimeConnection>,
@@ -408,6 +505,7 @@ function reconcileNewRuntimes<TResult extends RequestResult>(
     name: 'Runtimes',
     assetGroups,
     optionsRef,
+    skipSymbolProp: getFeatureFlag('skipRuntimeSymbolProp'),
   });
 
   // rebuild the graph

package/src/requests/AssetGraphRequest.ts

@@ -43,6 +43,7 @@ export type AssetGraphRequestInput = {
   lazyIncludes?: RegExp[];
   lazyExcludes?: RegExp[];
   requestedAssetIds?: Set<string>;
+  skipSymbolProp?: boolean;
 };
 
 export type AssetGraphRequestResult = {
@@ -128,6 +129,7 @@ export class AssetGraphBuilder {
   isSingleChangeRebuild: boolean;
   assetGroupsWithRemovedParents: Set<NodeId>;
   previousSymbolPropagationErrors: Map<NodeId, Array<Diagnostic>>;
+  skipSymbolProp: boolean;
 
   constructor(
     {input, api, options}: RunInput,
@@ -167,6 +169,8 @@ export class AssetGraphBuilder {
     this.shouldBuildLazily = shouldBuildLazily ?? false;
     this.lazyIncludes = lazyIncludes ?? [];
     this.lazyExcludes = lazyExcludes ?? [];
+    this.skipSymbolProp = input.skipSymbolProp ?? false;
+
     if (getFeatureFlag('cachePerformanceImprovements')) {
       const key = hashString(
         `${ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${
@@ -298,41 +302,51 @@ export class AssetGraphBuilder {
         this.assetGraph,
         'AssetGraph_' + this.name + '_before_prop',
       );
-      try {
-        let errors = propagateSymbols({
-          options: this.options,
-          assetGraph: this.assetGraph,
-          changedAssetsPropagation: this.changedAssetsPropagation,
-          assetGroupsWithRemovedParents: this.assetGroupsWithRemovedParents,
-          previousErrors: this.previousSymbolPropagationErrors,
-        });
-        this.changedAssetsPropagation.clear();
-
-        if (errors.size > 0) {
-          this.api.storeResult(
-            {
-              assetGraph: this.assetGraph,
-              changedAssets: this.changedAssets,
-              changedAssetsPropagation: this.changedAssetsPropagation,
-              assetGroupsWithRemovedParents: this.assetGroupsWithRemovedParents,
-              previousSymbolPropagationErrors: errors,
-              assetRequests: [],
-            },
-            this.cacheKey,
-          );
 
-          // Just throw the first error. Since errors can bubble (e.g. reexporting a reexported symbol also fails),
-          // determining which failing export is the root cause is nontrivial (because of circular dependencies).
-          throw new ThrowableDiagnostic({
-            diagnostic: [...errors.values()][0],
+      // Skip symbol propagation for runtime assets - they have pre-computed symbol data
+      if (this.skipSymbolProp) {
+        logger.verbose({
+          origin: '@atlaspack/core',
+          message: 'Skipping symbol propagation for runtime asset graph',
+        });
+      } else {
+        try {
+          let errors = propagateSymbols({
+            options: this.options,
+            assetGraph: this.assetGraph,
+            changedAssetsPropagation: this.changedAssetsPropagation,
+            assetGroupsWithRemovedParents: this.assetGroupsWithRemovedParents,
+            previousErrors: this.previousSymbolPropagationErrors,
           });
+          this.changedAssetsPropagation.clear();
+
+          if (errors.size > 0) {
+            this.api.storeResult(
+              {
+                assetGraph: this.assetGraph,
+                changedAssets: this.changedAssets,
+                changedAssetsPropagation: this.changedAssetsPropagation,
+                assetGroupsWithRemovedParents:
+                  this.assetGroupsWithRemovedParents,
+                previousSymbolPropagationErrors: errors,
+                assetRequests: [],
+              },
+              this.cacheKey,
+            );
+
+            // Just throw the first error. Since errors can bubble (e.g. reexporting a reexported symbol also fails),
+            // determining which failing export is the root cause is nontrivial (because of circular dependencies).
+            throw new ThrowableDiagnostic({
+              diagnostic: [...errors.values()][0],
+            });
+          }
+        } catch (e: any) {
+          await dumpGraphToGraphViz(
+            this.assetGraph,
+            'AssetGraph_' + this.name + '_failed',
+          );
+          throw e;
         }
-      } catch (e: any) {
-        await dumpGraphToGraphViz(
-          this.assetGraph,
-          'AssetGraph_' + this.name + '_failed',
-        );
-        throw e;
       }
     }
     await dumpGraphToGraphViz(this.assetGraph, 'AssetGraph_' + this.name);

package/src/requests/BundleGraphRequest.ts

@@ -523,17 +523,19 @@ class BundlerRunner {
         ),
       );
 
-      changedRuntimes = await applyRuntimes({
-        bundleGraph: internalBundleGraph,
-        api: this.api,
-        config: this.config,
-        options: this.options,
-        optionsRef: this.optionsRef,
-        pluginOptions: this.pluginOptions,
-        previousDevDeps: this.previousDevDeps,
-        devDepRequests: this.devDepRequests,
-        configs: this.configs,
-      });
+      changedRuntimes = await instrumentAsync('applyRuntimes', () =>
+        applyRuntimes({
+          bundleGraph: internalBundleGraph,
+          api: this.api,
+          config: this.config,
+          options: this.options,
+          optionsRef: this.optionsRef,
+          pluginOptions: this.pluginOptions,
+          previousDevDeps: this.previousDevDeps,
+          devDepRequests: this.devDepRequests,
+          configs: this.configs,
+        }),
+      );
 
       // Add dev deps for namers, AFTER running them to account for lazy require().
       for (let namer of namers) {

package/src/types.ts

@@ -23,6 +23,7 @@ import type {
   HMROptions,
   DetailedReportOptions,
   Symbol,
+  SymbolData,
 } from '@atlaspack/types';
 import type {SharedReference} from '@atlaspack/workers';
 import type {FileSystem} from '@atlaspack/fs';
@@ -438,6 +439,7 @@ export type AssetRequestInput = {
   isURL?: boolean;
   query?: string | null | undefined;
   isSingleChangeRebuild?: boolean;
+  symbolData?: SymbolData;
 };
 
 export type AssetRequestResult = Array<Asset>;