include query and fragment in request pattern

Author: sokra

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

@@ -698,16 +698,68 @@ impl Request {
     #[turbo_tasks::function]
     pub async fn request_pattern(self: Vc<Self>) -> Result<Vc<Pattern>> {
         Ok(match &*self.await? {
-            Request::Raw { path, .. } => path.clone(),
-            Request::Relative { path, .. } => path.clone(),
-            Request::Module { module, path, .. } => {
+            Request::Raw {
+                path,
+                query,
+                fragment,
+                ..
+            } => {
+                let mut path = path.clone();
+                path.push(Pattern::Constant(query.owned().await?));
+                path.push(Pattern::Constant(fragment.owned().await?));
+                path.normalize();
+                path
+            }
+            Request::Relative {
+                path,
+                query,
+                fragment,
+                ..
+            } => {
+                let mut path = path.clone();
+                path.push(Pattern::Constant(query.owned().await?));
+                path.push(Pattern::Constant(fragment.owned().await?));
+                path.normalize();
+                path
+            }
+            Request::Module {
+                module,
+                path,
+                query,
+                fragment,
+                ..
+            } => {
                 let mut path = path.clone();
                 path.push_front(Pattern::Constant(module.clone()));
+                path.push(Pattern::Constant(query.owned().await?));
+                path.push(Pattern::Constant(fragment.owned().await?));
+                path.normalize();
+                path
+            }
+            Request::ServerRelative {
+                path,
+                query,
+                fragment,
+                ..
+            } => {
+                let mut path = path.clone();
+                path.push(Pattern::Constant(query.owned().await?));
+                path.push(Pattern::Constant(fragment.owned().await?));
+                path.normalize();
+                path
+            }
+            Request::Windows {
+                path,
+                query,
+                fragment,
+                ..
+            } => {
+                let mut path = path.clone();
+                path.push(Pattern::Constant(query.owned().await?));
+                path.push(Pattern::Constant(fragment.owned().await?));
                 path.normalize();
                 path
             }
-            Request::ServerRelative { path, .. } => path.clone(),
-            Request::Windows { path, .. } => path.clone(),
             Request::Empty => Pattern::Constant("".into()),
             Request::PackageInternal { path } => path.clone(),
             Request::DataUri {
@@ -722,8 +774,12 @@ impl Request {
             Request::Uri {
                 protocol,
                 remainder,
+                query,
+                fragment,
                 ..
-            } => Pattern::Constant(format!("{protocol}{remainder}").into()),
+            } => Pattern::Constant(
+                format!("{protocol}{remainder}{}{}", query.await?, fragment.await?).into(),
+            ),
             Request::Unknown { path } => path.clone(),
             Request::Dynamic => Pattern::Dynamic,
             Request::Alternatives { requests } => Pattern::Alternatives(

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

@@ -142,6 +142,14 @@ impl Pattern {
         }
     }
 
+    pub fn is_empty_constant(&self) -> bool {
+        if let Pattern::Constant(c) = self {
+            c.is_empty()
+        } else {
+            false
+        }
+    }
+
     pub fn constant_prefix(&self) -> &str {
         // The normalized pattern is an Alternative of maximally merged
         // Concatenations, so extracting the first/only Concatenation child
@@ -367,6 +375,9 @@ impl Pattern {
 
     /// Appends something to end the pattern.
     pub fn push(&mut self, pat: Pattern) {
+        if pat.is_empty_constant() {
+            return;
+        }
         match (self, pat) {
             (Pattern::Concatenation(list), Pattern::Concatenation(more)) => {
                 concatenation_extend_or_merge_items(list, more.into_iter());
@@ -391,6 +402,9 @@ impl Pattern {
 
     /// Prepends something to front of the pattern.
     pub fn push_front(&mut self, pat: Pattern) {
+        if pat.is_empty_constant() {
+            return;
+        }
         match (self, pat) {
             (Pattern::Concatenation(list), Pattern::Concatenation(mut more)) => {
                 concatenation_extend_or_merge_items(&mut more, take(list).into_iter());