Turbopack: fix strip_prefix prefix is too long

bench/app-router-server/app/page.js

@@ -0,0 +1,11 @@
+import(`@/${globalThis.type}/${globalThis.processedSlugPath}`)
+
+// globalThis.docs = 'docs'
+// console.trace(require(`@/${globalThis.docs}/foo`))
+
+// globalThis.foo = 'foo'
+// console.trace(require(`@/docs/${globalThis.foo}`))
+
+export default function page() {
+  return <div>hello</div>
+}

bench/app-router-server/docs/foo.ts

@@ -0,0 +1 @@
+export default 'docs'

bench/app-router-server/docs2/foo.ts

@@ -0,0 +1 @@
+export default 'docs2'

bench/app-router-server/next-env.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+import './.next/types/routes.d.ts'
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

bench/app-router-server/tsconfig.json

@@ -0,0 +1,37 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./*"],
+      "@/docs/*": ["./docs2/*"]
+    },
+    "strictNullChecks": true
+  },
+  "include": [
+    "**/*.mts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    "next-env.d.ts",
+    "next.config.mjs",
+    ".next/dev/types/**/*.ts"
+  ],
+  "exclude": ["node_modules", "**/*.test.ts", "**/*.test.tsx"]
+}

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

@@ -562,6 +562,12 @@ where
                         }
                     }
                     AliasKey::Wildcard { suffix } => {
+                        println!(
+                            "AliasKey::Wildcard {} {}*{}",
+                            self.request.describe_as_string(),
+                            prefix,
+                            suffix
+                        );
                         // This is quite messy as we'd have to match against the FS to do this
                         // properly. For now, try to support as many cases as possible (and as are
                         // actually used).
@@ -570,6 +576,7 @@ where
                             // The request is a constant string, so the PatriciaMap lookup already
                             // ensured that the prefix is matching the request.
                             let remaining = &request[prefix.len()..];
+                            println!("1");
                             remaining.ends_with(&**suffix)
                         } else if let Pattern::Concatenation(req) = self.request
                             && let [
@@ -582,6 +589,7 @@ where
 
                             // The request might be more specific than the mapping, e.g. for
                             // `require('@/foo/' + dyn)` into a `@/*` mapping
+                            println!("2");
                             req_prefix.starts_with(&**prefix)
                         } else if let Pattern::Concatenation(req) = self.request
                             && let [
@@ -590,12 +598,16 @@ where
                                 Pattern::Constant(req_suffix),
                             ] = req.as_slice()
                         {
+                            println!("3");
                             req_prefix.starts_with(&**prefix) && req_suffix.ends_with(&**suffix)
                         } else if !self.request.could_match(prefix) {
-                            // There's no way it could match if the prefix can't match.
+                            // If the whole of the prefix doesn't match, then it can't possibly
+                            // match.
+                            println!("4");
                             false
                         } else if suffix.is_empty() {
-                            // Prefix matches the request, and suffix is empty.
+                            // Prefix could match the request, and suffix is empty.
+                            println!("5");
                             true
                         } else {
                             // It may or may not match, throw an error.
@@ -607,13 +619,24 @@ where
                                 suffix,
                             )));
                         };
+                        println!(
+                            "AliasKey::Wildcard {} {}*{}, {}",
+                            self.request.describe_as_string(),
+                            prefix,
+                            suffix,
+                            is_match
+                        );
 
                         if is_match {
                             let mut remaining = self.request.clone();
-                            if let Err(e) = remaining.strip_prefix_len(prefix.len()) {
-                                return Some(Err(e.context(self.request.describe_as_string())));
+                            if let Err(e) = remaining.strip_constant_prefix_len(prefix.len()) {
+                                return Some(Err(e.context(format!(
+                                    "{}.strip_constant_prefix_len({:?}.len())",
+                                    self.request.describe_as_string(),
+                                    prefix
+                                ))));
                             }
-                            remaining.strip_suffix_len(suffix.len());
+                            remaining.strip_constant_suffix_len(suffix.len());
 
                             let output = template.replace(&remaining);
                             return Some(Ok(AliasMatch {

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

@@ -227,18 +227,18 @@ impl Pattern {
         longest_common_suffix(&strings)
     }
 
-    pub fn strip_prefix(&self, prefix: &str) -> Result<Option<Self>> {
+    pub fn strip_constant_prefix(&self, prefix: &str) -> Result<Option<Self>> {
         if self.must_match(prefix) {
             let mut pat = self.clone();
-            pat.strip_prefix_len(prefix.len())?;
+            pat.strip_constant_prefix_len(prefix.len())?;
             Ok(Some(pat))
         } else {
             Ok(None)
         }
     }
 
-    pub fn strip_prefix_len(&mut self, len: usize) -> Result<()> {
-        fn strip_prefix_internal(pattern: &mut Pattern, chars_to_strip: &mut usize) -> Result<()> {
+    pub fn strip_constant_prefix_len(&mut self, len: usize) -> Result<()> {
+        fn strip_internal(pattern: &mut Pattern, chars_to_strip: &mut usize) -> Result<()> {
             match pattern {
                 Pattern::Constant(c) => {
                     let c_len = c.len();
@@ -252,15 +252,15 @@ impl Pattern {
                 Pattern::Concatenation(list) => {
                     for c in list {
                         if *chars_to_strip > 0 {
-                            strip_prefix_internal(c, chars_to_strip)?;
+                            strip_internal(c, chars_to_strip)?;
                         }
                     }
                 }
                 Pattern::Alternatives(_) => {
-                    bail!("strip_prefix pattern must be normalized");
+                    bail!("strip_constant_prefix_len pattern must be normalized");
                 }
                 Pattern::Dynamic | Pattern::DynamicNoSlash => {
-                    bail!("strip_prefix prefix is too long");
+                    bail!("strip_constant_prefix_len prefix is too long");
                 }
             }
             Ok(())
@@ -269,21 +269,17 @@ impl Pattern {
         match &mut *self {
             c @ Pattern::Constant(_) | c @ Pattern::Concatenation(_) => {
                 let mut len_local = len;
-                strip_prefix_internal(c, &mut len_local)?;
+                strip_internal(c, &mut len_local)?;
             }
             Pattern::Alternatives(list) => {
                 for c in list {
                     let mut len_local = len;
-                    strip_prefix_internal(c, &mut len_local)?;
+                    strip_internal(c, &mut len_local)?;
                 }
             }
             Pattern::Dynamic | Pattern::DynamicNoSlash => {
                 if len > 0 {
-                    bail!(
-                        "strip_prefix prefix ({}) is too long: {}",
-                        len,
-                        self.describe_as_string()
-                    );
+                    bail!("strip_constant_prefix_len prefix is too long",);
                 }
             }
         };
@@ -293,8 +289,8 @@ impl Pattern {
         Ok(())
     }
 
-    pub fn strip_suffix_len(&mut self, len: usize) {
-        fn strip_suffix_internal(pattern: &mut Pattern, chars_to_strip: &mut usize) {
+    pub fn strip_constant_suffix_len(&mut self, len: usize) {
+        fn strip_internal(pattern: &mut Pattern, chars_to_strip: &mut usize) {
             match pattern {
                 Pattern::Constant(c) => {
                     let c_len = c.len();
@@ -308,7 +304,7 @@ impl Pattern {
                 Pattern::Concatenation(list) => {
                     for c in list.iter_mut().rev() {
                         if *chars_to_strip > 0 {
-                            strip_suffix_internal(c, chars_to_strip);
+                            strip_internal(c, chars_to_strip);
                         }
                     }
                 }
@@ -324,12 +320,12 @@ impl Pattern {
         match &mut *self {
             c @ Pattern::Constant(_) | c @ Pattern::Concatenation(_) => {
                 let mut len_local = len;
-                strip_suffix_internal(c, &mut len_local);
+                strip_internal(c, &mut len_local);
             }
             Pattern::Alternatives(list) => {
                 for c in list {
                     let mut len_local = len;
-                    strip_suffix_internal(c, &mut len_local);
+                    strip_internal(c, &mut len_local);
                 }
             }
             Pattern::Dynamic | Pattern::DynamicNoSlash => {
@@ -2169,9 +2165,9 @@ mod tests {
     }
 
     #[test]
-    fn strip_prefix() {
+    fn strip_constant_prefix() {
         fn strip(mut pat: Pattern, n: usize) -> Pattern {
-            pat.strip_prefix_len(n).unwrap();
+            pat.strip_constant_prefix_len(n).unwrap();
             pat
         }
 
@@ -2212,7 +2208,7 @@ mod tests {
     #[test]
     fn strip_suffix() {
         fn strip(mut pat: Pattern, n: usize) -> Pattern {
-            pat.strip_suffix_len(n);
+            pat.strip_constant_suffix_len(n);
             pat
         }
 

turbopack/crates/turbopack-resolve/src/typescript.rs

@@ -426,7 +426,7 @@ pub async fn type_resolve(
         fragment: _,
     } = &*request.await?
     {
-        let mut m = if let Some(mut stripped) = m.strip_prefix("@")? {
+        let mut m = if let Some(mut stripped) = m.strip_constant_prefix("@")? {
             stripped.replace_constants(&|c| Some(Pattern::Constant(c.replace("/", "__").into())));
             stripped
         } else {

turbopack/crates/turbopack-tests/tests/execution/turbopack/resolving/tsconfig-paths-dynamic/input/index.js

@@ -1,11 +1,19 @@
-import { loadSub, loadSubNested, loadSubFallback } from './src/foo'
+import {
+  load,
+  loadComplex,
+  loadSub,
+  loadSubNested,
+  loadSubFallback,
+} from './src/foo'
 
 it('should support dynamic requests with tsconfig.paths', () => {
-  expect(loadSub('file2.js').default).toBe('file2')
+  expect(load('sub/file2.js').default).toBe('file2')
+  expect(loadSub('file2.js').default).toBe('file2-override')
+  expect(loadComplex('sub', 'file2', 'js').default).toBe('file2')
 })
 
 it('should support dynamic requests with tsconfig.paths and without extension', () => {
-  expect(loadSub('file2').default).toBe('file2')
+  expect(loadSub('file2').default).toBe('file2-override')
 })
 
 it('should support dynamic requests with tsconfig.paths and multiple dynamic parts', () => {

turbopack/crates/turbopack-tests/tests/execution/turbopack/resolving/tsconfig-paths-dynamic/input/src/foo.ts

@@ -1,3 +1,11 @@
+export function load(v: string) {
+  return require(`@/${v}`)
+}
+
+export function loadComplex(dir: string, name: string, ext: string) {
+  return require(`@/${dir}/${name}/${ext}`)
+}
+
 export function loadSub(v: string) {
   return require(`@/sub/${v}`)
 }

turbopack/crates/turbopack-tests/tests/execution/turbopack/resolving/tsconfig-paths-dynamic/input/sub-override/file1.js

@@ -0,0 +1 @@
+export default 'file1-override'

turbopack/crates/turbopack-tests/tests/execution/turbopack/resolving/tsconfig-paths-dynamic/input/sub-override/file2.js

@@ -0,0 +1 @@
+export default 'file2-override'

turbopack/crates/turbopack-tests/tests/execution/turbopack/resolving/tsconfig-paths-dynamic/input/sub-override/file3.js

@@ -0,0 +1 @@
+export default 'file3-override'

turbopack/crates/turbopack-tests/tests/execution/turbopack/resolving/tsconfig-paths-dynamic/input/tsconfig.json

@@ -2,6 +2,7 @@
   "compilerOptions": {
     "paths": {
       "@/*": ["./*"],
+      "@/sub/*": ["./sub-override/*"],
       "@sub/*": ["./sub/*", "./sub-fallback/*"]
     }
   }