Request::Module.module is a Pattern now

Author: mischnic

crates/next-core/src/next_edge/unsupported.rs

@@ -1,6 +1,5 @@
 use anyhow::Result;
 use indoc::formatdoc;
-use turbo_rcstr::RcStr;
 use turbo_tasks::{ResolvedVc, Vc};
 use turbo_tasks_fs::{File, FileSystemPath};
 use turbopack_core::{
@@ -61,7 +60,7 @@ impl ImportMappingReplacement for NextEdgeUnsupportedModuleReplacer {
 }
 
 #[turbo_tasks::function]
-fn unsupported_module_source(root_path: FileSystemPath, module: RcStr) -> Vc<VirtualSource> {
+fn unsupported_module_source(root_path: FileSystemPath, module: Pattern) -> Vc<VirtualSource> {
     // packages/next/src/server/web/globals.ts augments global with
     // `__import_unsupported` and necessary functions.
     let code = formatdoc! {

crates/next-core/src/next_server/resolve.rs

@@ -100,7 +100,9 @@ impl AfterResolvePlugin for ExternalCjsModulesResolvePlugin {
             Regex::new("^(?:private-next-pages\\/|next\\/(?:dist\\/pages\\/|(?:app|cache|document|link|form|head|image|legacy\\/image|constants|dynamic|script|navigation|headers|router|compat\\/router|server)$)|string-hash|private-next-rsc-action-validate|private-next-rsc-action-client-wrapper|private-next-rsc-server-reference|private-next-rsc-cache-wrapper$)").unwrap()
         });
 
-        let Pattern::Constant(package_subpath) = package_subpath else {
+        let (Pattern::Constant(package), Pattern::Constant(package_subpath)) =
+            (package, package_subpath)
+        else {
             return Ok(ResolveResultOption::none());
         };
         let request_str: RcStr = format!("{package}{package_subpath}").into();

crates/next-core/src/next_shared/resolve.rs

@@ -13,6 +13,7 @@ use turbopack_core::{
     resolve::{
         ExternalTraced, ExternalType, ResolveResult, ResolveResultItem, ResolveResultOption,
         parse::Request,
+        pattern::Pattern,
         plugin::{
             AfterResolvePlugin, AfterResolvePluginCondition, BeforeResolvePlugin,
             BeforeResolvePluginCondition,
@@ -39,7 +40,7 @@ static FEATURE_MODULES: LazyLock<FxHashMap<&'static str, Vec<&'static str>>> =
                     "/font/local",
                 ],
             ),
-            ("@next", vec!["/font/google", "/font/local"]),
+            ("@next/font", vec!["/google", "/local"]),
         ])
     });
 
@@ -360,7 +361,7 @@ impl BeforeResolvePlugin for ModuleFeatureReportResolvePlugin {
         request: Vc<Request>,
     ) -> Result<Vc<ResolveResultOption>> {
         if let Request::Module {
-            module,
+            module: Pattern::Constant(module),
             path,
             query: _,
             fragment: _,

turbopack/crates/turbopack-cli/src/build/mod.rs

@@ -268,7 +268,7 @@ async fn build_internal(
                     false,
                 ),
                 EntryRequest::Module(m, p) => Request::module(
-                    m.clone(),
+                    m.clone().into(),
                     p.clone().into(),
                     Default::default(),
                     Default::default(),

turbopack/crates/turbopack-cli/src/dev/mod.rs

@@ -305,7 +305,7 @@ async fn source(
                 false,
             ),
             EntryRequest::Module(m, p) => Request::module(
-                m.clone(),
+                m.clone().into(),
                 p.clone().into(),
                 Default::default(),
                 Default::default(),

turbopack/crates/turbopack-core/src/resolve/alias_map.rs

@@ -497,12 +497,12 @@ where
                     }
                     AliasKey::Wildcard { suffix } => {
                         let mut remaining = self.request.clone();
-                        remaining.strip_prefix(prefix.len());
+                        remaining.strip_prefix_len(prefix.len());
                         let remaining_suffix = remaining.constant_suffix();
                         if !remaining_suffix.ends_with(&**suffix) {
                             continue;
                         }
-                        remaining.strip_suffix(suffix.len());
+                        remaining.strip_suffix_len(suffix.len());
 
                         let output = template.replace(&remaining);
                         return Some(AliasMatch::Replaced(output));

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

@@ -1154,37 +1154,6 @@ async fn type_exists(
     })
 }
 
-async fn any_exists(
-    fs_path: FileSystemPath,
-    refs: &mut Vec<ResolvedVc<Box<dyn Source>>>,
-) -> Result<Option<(FileSystemEntryType, FileSystemPath)>> {
-    let result = fs_path.realpath_with_links().owned().await?;
-    refs.extend(
-        result
-            .symlinks
-            .into_iter()
-            .map(|path| async move {
-                Ok(ResolvedVc::upcast(
-                    FileSource::new(path).to_resolved().await?,
-                ))
-            })
-            .try_join()
-            .await?,
-    );
-    let path = result.path;
-    let ty = *path.get_type().await?;
-    Ok(
-        if matches!(
-            ty,
-            FileSystemEntryType::NotFound | FileSystemEntryType::Error
-        ) {
-            None
-        } else {
-            Some((ty, path))
-        },
-    )
-}
-
 #[turbo_tasks::value(shared)]
 enum ExportsFieldResult {
     Some(#[turbo_tasks(debug_ignore, trace_ignore)] ExportsField),
@@ -1362,11 +1331,12 @@ pub async fn find_context_file_or_package_key(
 
 #[derive(Clone, PartialEq, Eq, Serialize, Deserialize, TraceRawVcs, Debug, NonLocalValue)]
 enum FindPackageItem {
-    PackageDirectory(FileSystemPath),
-    PackageFile(FileSystemPath),
+    PackageDirectory { name: RcStr, dir: FileSystemPath },
+    PackageFile { name: RcStr, file: FileSystemPath },
 }
 
 #[turbo_tasks::value]
+#[derive(Debug)]
 struct FindPackageResult {
     packages: Vec<FindPackageItem>,
     affecting_sources: Vec<ResolvedVc<Box<dyn Source>>>,
@@ -1375,12 +1345,23 @@ struct FindPackageResult {
 #[turbo_tasks::function]
 async fn find_package(
     lookup_path: FileSystemPath,
-    package_name: RcStr,
+    package_name: Pattern,
     options: Vc<ResolveModulesOptions>,
 ) -> Result<Vc<FindPackageResult>> {
     let mut packages = vec![];
     let mut affecting_sources = vec![];
     let options = options.await?;
+    let package_name_cell = Pattern::new(package_name);
+
+    fn get_package_name(basepath: &FileSystemPath, package_dir: &FileSystemPath) -> Result<RcStr> {
+        let name = basepath.get_relative_path_to(package_dir).unwrap();
+        if let Some(name) = name.strip_prefix("./") {
+            Ok(name.into())
+        } else {
+            bail!("Package directory {package_dir} is not inside the lookup path {basepath}");
+        }
+    }
+
     for resolve_modules in &options.modules {
         match resolve_modules {
             ResolveModules::Nested(root_vc, names) => {
@@ -1392,11 +1373,18 @@ async fn find_package(
                     for name in names.iter() {
                         let fs_path = lookup_path.join(name)?;
                         if let Some(fs_path) = dir_exists(fs_path, &mut affecting_sources).await? {
-                            let fs_path = fs_path.join(&package_name.clone())?;
-                            if let Some(fs_path) =
-                                dir_exists(fs_path.clone(), &mut affecting_sources).await?
-                            {
-                                packages.push(FindPackageItem::PackageDirectory(fs_path));
+                            // TODO this is wrong, it should only match match 1 or 2 levels deep
+                            // TODO affecting_sources are not getting added?
+                            let matches =
+                                read_matches(fs_path.clone(), rcstr!(""), true, package_name_cell)
+                                    .await?;
+                            for m in matches {
+                                if let PatternMatch::Directory(_, package_dir) = m {
+                                    packages.push(FindPackageItem::PackageDirectory {
+                                        name: get_package_name(&fs_path, package_dir)?,
+                                        dir: package_dir.clone(),
+                                    });
+                                }
                             }
                         }
                     }
@@ -1413,28 +1401,56 @@ async fn find_package(
                 excluded_extensions,
             } => {
                 let excluded_extensions = excluded_extensions.await?;
-                let package_dir = dir.join(&package_name)?;
-                if let Some((ty, package_dir)) =
-                    any_exists(package_dir.clone(), &mut affecting_sources).await?
-                {
-                    match ty {
-                        FileSystemEntryType::Directory => {
-                            packages.push(FindPackageItem::PackageDirectory(package_dir.clone()));
+                // TODO this is wrong, it should only match match 1 or 2 levels deep
+                // TODO affecting_sources are not getting added?
+                let matches =
+                    read_matches(dir.clone(), rcstr!(""), true, package_name_cell).await?;
+                for m in matches {
+                    match m {
+                        PatternMatch::Directory(_, package_dir) => {
+                            let name = get_package_name(dir, package_dir)?;
+                            packages.push(FindPackageItem::PackageDirectory {
+                                name: name.clone(),
+                                dir: package_dir.clone(),
+                            });
+
+                            for extension in &options.extensions {
+                                if excluded_extensions.contains(extension) {
+                                    continue;
+                                }
+                                let package_file = package_dir.append(&extension.clone())?;
+                                if let Some(package_file) =
+                                    exists(package_file, &mut affecting_sources).await?
+                                {
+                                    packages.push(FindPackageItem::PackageFile {
+                                        name: name.clone(),
+                                        file: package_file,
+                                    });
+                                }
+                            }
                         }
-                        FileSystemEntryType::File => {
-                            packages.push(FindPackageItem::PackageFile(package_dir.clone()));
+                        PatternMatch::File(_, package_file) => {
+                            let name = get_package_name(dir, package_file)?;
+                            packages.push(FindPackageItem::PackageFile {
+                                name: name.clone(),
+                                file: package_file.clone(),
+                            });
+
+                            for extension in &options.extensions {
+                                if excluded_extensions.contains(extension) {
+                                    continue;
+                                }
+                                let package_file = package_file.append(&extension.clone())?;
+                                if let Some(package_file) =
+                                    exists(package_file, &mut affecting_sources).await?
+                                {
+                                    packages.push(FindPackageItem::PackageFile {
+                                        name: name.clone(),
+                                        file: package_file,
+                                    });
+                                }
+                            }
                         }
-                        _ => {}
-                    }
-                }
-                for extension in &options.extensions {
-                    if excluded_extensions.contains(extension) {
-                        continue;
-                    }
-                    let package_file = package_dir.append(&extension.clone())?;
-                    if let Some(package_file) = exists(package_file, &mut affecting_sources).await?
-                    {
-                        packages.push(FindPackageItem::PackageFile(package_file));
                     }
                 }
             }
@@ -2512,7 +2528,7 @@ async fn resolve_module_request(
     request: Vc<Request>,
     options: Vc<ResolveOptions>,
     options_value: &ResolveOptions,
-    module: &RcStr,
+    module: &Pattern,
     path: &Pattern,
     query: RcStr,
     fragment: RcStr,
@@ -2523,7 +2539,7 @@ async fn resolve_module_request(
         options,
         options_value,
         |_| {
-            let full_pattern = Pattern::concat([module.clone().into(), path.clone()]);
+            let full_pattern = Pattern::concat([module.clone(), path.clone()]);
             full_pattern.into_string()
         },
         query.clone(),
@@ -2534,12 +2550,14 @@ async fn resolve_module_request(
         return Ok(result);
     }
 
+    let mut results = vec![];
+
     // Self references, if the nearest package.json has the name of the requested
     // module. This should match only using the exports field and no other
     // fields/fallbacks.
     if let FindSelfReferencePackageResult::Found { name, package_path } =
         &*find_self_reference(lookup_path.clone()).await?
-        && module == name
+        && module.is_match(name)
     {
         let result = resolve_into_package(
             path.clone(),
@@ -2566,46 +2584,47 @@ async fn resolve_module_request(
         ));
     }
 
-    let mut results = vec![];
-
     // There may be more than one package with the same name. For instance, in a
     // TypeScript project, `compilerOptions.baseUrl` can declare a path where to
     // resolve packages. A request to "foo/bar" might resolve to either
     // "[baseUrl]/foo/bar" or "[baseUrl]/node_modules/foo/bar", and we'll need to
     // try both.
     for item in &result.packages {
         match item {
-            FindPackageItem::PackageDirectory(package_path) => {
-                results.push(resolve_into_package(
-                    path.clone(),
-                    package_path.clone(),
-                    query.clone(),
-                    fragment.clone(),
-                    options,
-                ));
+            FindPackageItem::PackageDirectory { name, dir } => {
+                results.push(
+                    resolve_into_package(
+                        path.clone(),
+                        dir.clone(),
+                        query.clone(),
+                        fragment.clone(),
+                        options,
+                    )
+                    .with_replaced_request_key(rcstr!("."), RequestKey::new(name.clone())),
+                );
             }
-            FindPackageItem::PackageFile(package_path) => {
+            FindPackageItem::PackageFile { name, file } => {
                 if path.is_match("") {
                     let resolved = resolved(
                         RequestKey::new(rcstr!(".")),
-                        package_path.clone(),
+                        file.clone(),
                         lookup_path.clone(),
                         request,
                         options_value,
                         options,
                         query.clone(),
                         fragment.clone(),
                     )
-                    .await?;
+                    .await?
+                    .with_replaced_request_key(rcstr!("."), RequestKey::new(name.clone()));
                     results.push(resolved)
                 }
             }
         }
     }
 
     let module_result =
-        merge_results_with_affecting_sources(results, result.affecting_sources.clone())
-            .with_replaced_request_key(rcstr!("."), RequestKey::new(module.clone()));
+        merge_results_with_affecting_sources(results, result.affecting_sources.clone());
 
     if options_value.prefer_relative {
         let module_prefix: RcStr = format!("./{module}").into();
@@ -2623,8 +2642,9 @@ async fn resolve_module_request(
             options,
         ))
         .await?;
-        let relative_result = relative_result
-            .with_replaced_request_key(module_prefix, RequestKey::new(module.clone()));
+        // TODO request key
+        // let relative_result = relative_result
+        //     .with_replaced_request_key(module_prefix, RequestKey::new(module.clone()));
 
         Ok(merge_results(vec![relative_result, module_result]))
     } else {

turbopack/crates/turbopack-core/src/resolve/parse.rs

@@ -100,8 +100,10 @@ static MODULE_PATH: LazyLock<Regex> =
 impl Request {
     /// Turns the request into a string.
     ///
-    /// Note that this is only returns something for the most basic and
-    /// fully constant patterns.
+    /// This is not only used for printing the request to the user, but also for matching inner
+    /// assets.
+    ///
+    /// Note that this is only returns something for the most basic and fully constant patterns.
     pub fn request(&self) -> Option<RcStr> {
         Some(match self {
             Request::Raw {
@@ -113,7 +115,7 @@ impl Request {
                 ..
             } => path.clone(),
             Request::Module {
-                module,
+                module: Pattern::Constant(module),
                 path: Pattern::Constant(path),
                 ..
             } => format!("{module}{path}").into(),