[3/n] no-context: migrate turbopack-core (vercel/turborepo#5661)

This migrates `turbopack-core` to the no-context rule.

Notably, this addresses an issue where function names were not caught
and renames `Issue`'s `context` method to `file_path`.

Author: wbinnssmith

crates/node-file-trace/src/lib.rs

@@ -44,7 +44,7 @@ use turbopack_core::{
     context::AssetContext,
     environment::{Environment, ExecutionEnvironment, NodeJsEnvironment},
     file_source::FileSource,
-    issue::{IssueContextExt, IssueReporter, IssueSeverity},
+    issue::{IssueFilePathExt, IssueReporter, IssueSeverity},
     module::{Module, Modules},
     output::OutputAsset,
     reference::all_modules,
@@ -566,7 +566,7 @@ async fn main_operation(
             .await?;
             for module in modules.iter() {
                 let set = all_modules(*module)
-                    .issue_context(module.ident().path(), "gathering list of assets")
+                    .issue_file_path(module.ident().path(), "gathering list of assets")
                     .await?;
                 for asset in set.await?.iter() {
                     let path = asset.ident().path().await?;

crates/turbo-tasks-fetch/src/lib.rs

@@ -134,7 +134,7 @@ pub struct FetchIssue {
 #[turbo_tasks::value_impl]
 impl Issue for FetchIssue {
     #[turbo_tasks::function]
-    fn context(&self) -> Vc<FileSystemPath> {
+    fn file_path(&self) -> Vc<FileSystemPath> {
         self.issue_context
     }
 

crates/turbopack-cli-utils/src/issue.rs

@@ -97,7 +97,7 @@ fn format_optional_path(
         let mut last_context = None;
         for item in path.iter().rev() {
             let PlainIssueProcessingPathItem {
-                ref context,
+                file_path: ref context,
                 ref description,
             } = **item;
             if let Some(context) = context {
@@ -138,7 +138,7 @@ pub fn format_issue(
     let severity = plain_issue.severity;
     // TODO CLICKABLE PATHS
     let context_path = plain_issue
-        .context
+        .file_path
         .replace("[project]", &current_dir.to_string_lossy())
         .replace("/./", "/")
         .replace("\\\\?\\", "");
@@ -187,7 +187,7 @@ pub fn format_issue(
         "{} - [{}] {}",
         severity.style(severity_to_style(severity)),
         category,
-        plain_issue.context
+        plain_issue.file_path
     )
     .unwrap();
 
@@ -392,7 +392,8 @@ impl IssueReporter for ConsoleUi {
                 has_fatal = true;
             }
 
-            let context_path = make_relative_to_cwd(&plain_issue.context, project_dir, current_dir);
+            let context_path =
+                make_relative_to_cwd(&plain_issue.file_path, project_dir, current_dir);
             let category = &plain_issue.category;
             let title = &plain_issue.title;
             let processing_path = &*plain_issue.processing_path;

crates/turbopack-core/src/chunk/evaluate.rs

@@ -20,7 +20,7 @@ pub trait EvaluatableAsset: Asset + Module + ChunkableModule {}
 pub trait EvaluatableAssetExt {
     fn to_evaluatable(
         self: Vc<Self>,
-        context: Vc<Box<dyn AssetContext>>,
+        asset_context: Vc<Box<dyn AssetContext>>,
     ) -> Vc<Box<dyn EvaluatableAsset>>;
 }
 
@@ -30,18 +30,18 @@ where
 {
     fn to_evaluatable(
         self: Vc<Self>,
-        context: Vc<Box<dyn AssetContext>>,
+        asset_context: Vc<Box<dyn AssetContext>>,
     ) -> Vc<Box<dyn EvaluatableAsset>> {
-        to_evaluatable(Vc::upcast(self), context)
+        to_evaluatable(Vc::upcast(self), asset_context)
     }
 }
 
 #[turbo_tasks::function]
 async fn to_evaluatable(
     asset: Vc<Box<dyn Source>>,
-    context: Vc<Box<dyn AssetContext>>,
+    asset_context: Vc<Box<dyn AssetContext>>,
 ) -> Result<Vc<Box<dyn EvaluatableAsset>>> {
-    let asset = context.process(
+    let asset = asset_context.process(
         asset,
         Value::new(ReferenceType::Entry(EntryReferenceSubType::Runtime)),
     );

crates/turbopack-core/src/chunk/mod.rs

@@ -87,13 +87,16 @@ pub struct ModuleIds(Vec<Vc<ModuleId>>);
 pub trait ChunkableModule: Module + Asset {
     fn as_chunk(
         self: Vc<Self>,
-        context: Vc<Box<dyn ChunkingContext>>,
+        chunking_context: Vc<Box<dyn ChunkingContext>>,
         availability_info: Value<AvailabilityInfo>,
     ) -> Vc<Box<dyn Chunk>>;
 
-    fn as_root_chunk(self: Vc<Self>, context: Vc<Box<dyn ChunkingContext>>) -> Vc<Box<dyn Chunk>> {
+    fn as_root_chunk(
+        self: Vc<Self>,
+        chunking_context: Vc<Box<dyn ChunkingContext>>,
+    ) -> Vc<Box<dyn Chunk>> {
         self.as_chunk(
-            context,
+            chunking_context,
             Value::new(AvailabilityInfo::Root {
                 current_availability_root: Vc::upcast(self),
             }),
@@ -254,41 +257,53 @@ pub struct ChunkContentResult<I> {
 #[async_trait::async_trait]
 pub trait FromChunkableModule: ChunkItem {
     async fn from_asset(
-        context: Vc<Box<dyn ChunkingContext>>,
+        chunking_context: Vc<Box<dyn ChunkingContext>>,
         asset: Vc<Box<dyn Module>>,
     ) -> Result<Option<Vc<Self>>>;
     async fn from_async_asset(
-        context: Vc<Box<dyn ChunkingContext>>,
+        chunking_context: Vc<Box<dyn ChunkingContext>>,
         asset: Vc<Box<dyn ChunkableModule>>,
         availability_info: Value<AvailabilityInfo>,
     ) -> Result<Option<Vc<Self>>>;
 }
 
 pub async fn chunk_content_split<I>(
-    context: Vc<Box<dyn ChunkingContext>>,
+    chunking_context: Vc<Box<dyn ChunkingContext>>,
     entry: Vc<Box<dyn Module>>,
     additional_entries: Option<Vc<Modules>>,
     availability_info: Value<AvailabilityInfo>,
 ) -> Result<ChunkContentResult<Vc<I>>>
 where
     I: FromChunkableModule,
 {
-    chunk_content_internal_parallel(context, entry, additional_entries, availability_info, true)
-        .await
-        .map(|o| o.unwrap())
+    chunk_content_internal_parallel(
+        chunking_context,
+        entry,
+        additional_entries,
+        availability_info,
+        true,
+    )
+    .await
+    .map(|o| o.unwrap())
 }
 
 pub async fn chunk_content<I>(
-    context: Vc<Box<dyn ChunkingContext>>,
+    chunking_context: Vc<Box<dyn ChunkingContext>>,
     entry: Vc<Box<dyn Module>>,
     additional_entries: Option<Vc<Modules>>,
     availability_info: Value<AvailabilityInfo>,
 ) -> Result<Option<ChunkContentResult<Vc<I>>>>
 where
     I: FromChunkableModule,
 {
-    chunk_content_internal_parallel(context, entry, additional_entries, availability_info, false)
-        .await
+    chunk_content_internal_parallel(
+        chunking_context,
+        entry,
+        additional_entries,
+        availability_info,
+        false,
+    )
+    .await
 }
 
 #[derive(Eq, PartialEq, Clone, Hash)]
@@ -314,7 +329,7 @@ struct ChunkContentContext {
 }
 
 async fn reference_to_graph_nodes<I>(
-    context: ChunkContentContext,
+    chunk_content_context: ChunkContentContext,
     reference: Vc<Box<dyn ModuleReference>>,
 ) -> Result<
     Vec<(
@@ -347,7 +362,8 @@ where
 
     for &module in &modules {
         let module = module.resolve().await?;
-        if let Some(available_modules) = context.availability_info.available_modules() {
+        if let Some(available_modules) = chunk_content_context.availability_info.available_modules()
+        {
             if *available_modules.includes(module).await? {
                 graph_nodes.push((
                     Some((module, chunking_type)),
@@ -381,7 +397,9 @@ where
 
         match chunking_type {
             ChunkingType::Placed => {
-                if let Some(chunk_item) = I::from_asset(context.chunking_context, module).await? {
+                if let Some(chunk_item) =
+                    I::from_asset(chunk_content_context.chunking_context, module).await?
+                {
                     graph_nodes.push((
                         Some((module, chunking_type)),
                         ChunkContentGraphNode::ChunkItem {
@@ -398,31 +416,33 @@ where
                 }
             }
             ChunkingType::Parallel => {
-                let chunk =
-                    chunkable_module.as_chunk(context.chunking_context, context.availability_info);
+                let chunk = chunkable_module.as_chunk(
+                    chunk_content_context.chunking_context,
+                    chunk_content_context.availability_info,
+                );
                 graph_nodes.push((
                     Some((module, chunking_type)),
                     ChunkContentGraphNode::Chunk(chunk),
                 ));
             }
             ChunkingType::IsolatedParallel => {
-                let chunk = chunkable_module.as_root_chunk(context.chunking_context);
+                let chunk = chunkable_module.as_root_chunk(chunk_content_context.chunking_context);
                 graph_nodes.push((
                     Some((module, chunking_type)),
                     ChunkContentGraphNode::Chunk(chunk),
                 ));
             }
             ChunkingType::PlacedOrParallel => {
                 // heuristic for being in the same chunk
-                if !context.split
-                    && *context
+                if !chunk_content_context.split
+                    && *chunk_content_context
                         .chunking_context
-                        .can_be_in_same_chunk(context.entry, module)
+                        .can_be_in_same_chunk(chunk_content_context.entry, module)
                         .await?
                 {
                     // chunk item, chunk or other asset?
                     if let Some(chunk_item) =
-                        I::from_asset(context.chunking_context, module).await?
+                        I::from_asset(chunk_content_context.chunking_context, module).await?
                     {
                         graph_nodes.push((
                             Some((module, chunking_type)),
@@ -435,18 +455,20 @@ where
                     }
                 }
 
-                let chunk =
-                    chunkable_module.as_chunk(context.chunking_context, context.availability_info);
+                let chunk = chunkable_module.as_chunk(
+                    chunk_content_context.chunking_context,
+                    chunk_content_context.availability_info,
+                );
                 graph_nodes.push((
                     Some((module, chunking_type)),
                     ChunkContentGraphNode::Chunk(chunk),
                 ));
             }
             ChunkingType::Async => {
                 if let Some(manifest_loader_item) = I::from_async_asset(
-                    context.chunking_context,
+                    chunk_content_context.chunking_context,
                     chunkable_module,
-                    context.availability_info,
+                    chunk_content_context.availability_info,
                 )
                 .await?
                 {
@@ -475,7 +497,7 @@ where
 const MAX_CHUNK_ITEMS_COUNT: usize = 5000;
 
 struct ChunkContentVisit<I> {
-    context: ChunkContentContext,
+    chunk_content_context: ChunkContentContext,
     chunk_items_count: usize,
     processed_assets: HashSet<(ChunkingType, Vc<Box<dyn Module>>)>,
     _phantom: PhantomData<I>,
@@ -522,7 +544,8 @@ where
 
             // Make sure the chunk doesn't become too large.
             // This will hurt performance in many aspects.
-            if !self.context.split && self.chunk_items_count >= MAX_CHUNK_ITEMS_COUNT {
+            if !self.chunk_content_context.split && self.chunk_items_count >= MAX_CHUNK_ITEMS_COUNT
+            {
                 // Chunk is too large, cancel this algorithm and restart with splitting from the
                 // start.
                 return VisitControlFlow::Abort(());
@@ -535,7 +558,7 @@ where
     fn edges(&mut self, node: &ChunkContentGraphNode<Vc<I>>) -> Self::EdgesFuture {
         let node = node.clone();
 
-        let context = self.context;
+        let chunk_content_context = self.chunk_content_context;
 
         async move {
             let references = match node {
@@ -549,7 +572,7 @@ where
             Ok(references
                 .await?
                 .into_iter()
-                .map(|reference| reference_to_graph_nodes::<I>(context, *reference))
+                .map(|reference| reference_to_graph_nodes::<I>(chunk_content_context, *reference))
                 .try_join()
                 .await?
                 .into_iter()
@@ -597,15 +620,15 @@ where
         .try_join()
         .await?;
 
-    let context = ChunkContentContext {
+    let chunk_content_context = ChunkContentContext {
         chunking_context,
         entry,
         split,
         availability_info,
     };
 
     let visit = ChunkContentVisit {
-        context,
+        chunk_content_context,
         chunk_items_count: 0,
         processed_assets: Default::default(),
         _phantom: PhantomData,

crates/turbopack-core/src/compile_time_info.rs

@@ -122,7 +122,7 @@ impl CompileTimeDefines {
 pub enum FreeVarReference {
     EcmaScriptModule {
         request: String,
-        context: Option<Vc<FileSystemPath>>,
+        lookup_path: Option<Vc<FileSystemPath>>,
         export: Option<String>,
     },
     Value(CompileTimeDefineValue),

crates/turbopack-core/src/issue/analyze.rs

@@ -38,7 +38,7 @@ impl Issue for AnalyzeIssue {
     }
 
     #[turbo_tasks::function]
-    fn context(&self) -> Vc<FileSystemPath> {
+    fn file_path(&self) -> Vc<FileSystemPath> {
         self.source_ident.path()
     }
 

crates/turbopack-core/src/issue/code_gen.rs

@@ -29,7 +29,7 @@ impl Issue for CodeGenerationIssue {
     }
 
     #[turbo_tasks::function]
-    fn context(&self) -> Vc<FileSystemPath> {
+    fn file_path(&self) -> Vc<FileSystemPath> {
         self.path
     }