Skip to content

turbopack-230404.4

turbopack-230404.4: ChunkingContext refactor pt. 1 (#4397)
@alexkirsz alexkirsz tagged this 04 Apr 14:56 
Next.js side: https://github.com/vercel/next.js/pull/47693

### Description

This is part one of a larger ChunkingContext refactor.

In this episode, we:
1. Move the runtime and evaluation code off of the entry JS chunk and
into a dedicated chunk. This means that, within a chunk group, instead
of having one chunk that contains modules + runtime code and chunks that
only contain modules, we'll have chunks that only contain modules and
one chunk that only contains runtime code.
2. Start a larger enterprise of differentiating between "intermediate"
chunks (`ChunkVc`s), and "output" chunks (raw `AssetVc`s). Before, we
used `EcmascriptChunkVc`s to represent both intermediate chunks that
would never actually be created (optimized away) AND final chunks that
would be served or written to disk. Now, `EcmascriptChunkVc`s are only
intermediate assets, and `DevEcmascriptChunkVc`s are the final chunks.
3. Move a few modules from `turbopack-core` to `turbopack-dev`, as their
existence (or the implementation) is only meaningful in a dev context
(`ChunkList` and `Manifest*`, the latter of which depends on the chunk
list for now).

Things left to figure out:
1. What does the `Chunk` trait represent here? We no longer use
`.chunking_context()`, and `.path()` is redundant with `Asset::path`.
However, it no longer makes sense for `Chunk`s to be `Asset`s as their
content is determined by the chunking context. Should we have two
traits, one for intermediate chunks and one for output chunks?
2. Should `EvalutatedEntryVc` just be `ChunkableAssetVc`? We don't need
*all* of the trait methods of either, just an ident and a way to convert
to a chunk.

The `Chunk` trait could look like this:

```rust
trait Chunk {
  fn ident(&self) -> IdentVc;
  fn parallel_chunks(&self) -> ChunksVc;
  fn references(&self) -> AssetReferencesVc;
}
```

Things that will happen in the next part(s):
1. The `ChunkGroupVc::evaluated` logic will move into `turbopack-dev`,
as it doesn't make sense in a build context. This will essentially make
`ChunkGroupVc` obsolete: the only thing we need it to do is to compute
all parallel chunks, but I'm thinking this should be a method on the
`Chunk` trait instead.

Things I'll leave for future refactors:
* Figure out the whole Input, Intermediate, and Output asset story.

### Testing Instructions

Snapshots + Next integration tests
fix WEB-815 ([link](https://linear.app/vercel/issue/WEB-815))
Assets 2
Loading