Fix scoped overlay use not finding a module (#6474)

* Add source-env test for dynamic path

* Use correct module ID for env overlay imports

* Remove parser check from "overlay list"

It would cause unnecessary errors from some inner scope if some
overlay module was also defined in some inner scope.

* Restore Cargo.lock back

* Remove comments

crates/nu-parser/src/flatten.rs

@@ -260,6 +260,9 @@ pub fn flatten_expression(
 
             output
         }
+        Expr::Overlay(_) => {
+            vec![(expr.span, FlatShape::String)]
+        }
         Expr::Range(from, next, to, op) => {
             let mut output = vec![];
             if let Some(f) = from {

crates/nu-parser/src/parse_keywords.rs

@@ -2422,7 +2422,7 @@ pub fn parse_overlay_use(
     let has_prefix = call.has_flag("prefix");
 
     let pipeline = Pipeline::from_vec(vec![Expression {
-        expr: Expr::Call(call),
+        expr: Expr::Call(call.clone()),
         span: span(spans),
         ty: Type::Any,
         custom_completion: None,
@@ -2432,7 +2432,14 @@ pub fn parse_overlay_use(
 
     let mut error = None;
 
-    let result = if let Some(overlay_frame) = working_set.find_overlay(overlay_name.as_bytes()) {
+    let (final_overlay_name, origin_module, origin_module_id, is_module_updated) = if let Some(
+        overlay_frame,
+    ) =
+        working_set.find_overlay(overlay_name.as_bytes())
+    {
+        // Activate existing overlay
+
+        // First, check for errors
         if has_prefix && !overlay_frame.prefixed {
             return (
                 pipeline,
@@ -2467,22 +2474,22 @@ pub fn parse_overlay_use(
             }
         }
 
-        // Activate existing overlay
         let module_id = overlay_frame.origin;
 
         if let Some(new_module_id) = working_set.find_module(overlay_name.as_bytes()) {
             if module_id == new_module_id {
-                Some((overlay_name, Module::new(), module_id))
+                (overlay_name, Module::new(), module_id, false)
             } else {
                 // The origin module of an overlay changed => update it
-                Some((
+                (
                     overlay_name,
                     working_set.get_module(new_module_id).clone(),
                     new_module_id,
-                ))
+                    true,
+                )
             }
         } else {
-            Some((overlay_name, Module::new(), module_id))
+            (overlay_name, Module::new(), module_id, true)
         }
     } else {
         // Create a new overlay from a module
@@ -2490,11 +2497,12 @@ pub fn parse_overlay_use(
             // the name is a module
             working_set.find_module(overlay_name.as_bytes())
         {
-            Some((
+            (
                 new_name.map(|spanned| spanned.item).unwrap_or(overlay_name),
                 working_set.get_module(module_id).clone(),
                 module_id,
-            ))
+                true,
+            )
         } else {
             // try if the name is a file
             if let Ok(module_filename) =
@@ -2541,11 +2549,12 @@ pub fn parse_overlay_use(
                         let _ = working_set.add_block(block);
                         let module_id = working_set.add_module(&overlay_name, module.clone());
 
-                        Some((
+                        (
                             new_name.map(|spanned| spanned.item).unwrap_or(overlay_name),
                             module,
                             module_id,
-                        ))
+                            true,
+                        )
                     } else {
                         return (
                             pipeline,
@@ -2553,8 +2562,10 @@ pub fn parse_overlay_use(
                         );
                     }
                 } else {
-                    error = error.or(Some(ParseError::ModuleOrOverlayNotFound(overlay_name_span)));
-                    None
+                    return (
+                        pipeline,
+                        Some(ParseError::ModuleOrOverlayNotFound(overlay_name_span)),
+                    );
                 }
             } else {
                 return (garbage_pipeline(spans), Some(ParseError::NonUtf8(spans[1])));
@@ -2562,24 +2573,39 @@ pub fn parse_overlay_use(
         }
     };
 
-    if let Some((name, module, module_id)) = result {
-        let (decls_to_lay, aliases_to_lay) = if has_prefix {
-            (
-                module.decls_with_head(name.as_bytes()),
-                module.aliases_with_head(name.as_bytes()),
-            )
-        } else {
-            (module.decls(), module.aliases())
-        };
+    let (decls_to_lay, aliases_to_lay) = if has_prefix {
+        (
+            origin_module.decls_with_head(final_overlay_name.as_bytes()),
+            origin_module.aliases_with_head(final_overlay_name.as_bytes()),
+        )
+    } else {
+        (origin_module.decls(), origin_module.aliases())
+    };
 
-        working_set.add_overlay(
-            name.as_bytes().to_vec(),
-            module_id,
-            decls_to_lay,
-            aliases_to_lay,
-            has_prefix,
-        );
-    }
+    working_set.add_overlay(
+        final_overlay_name.as_bytes().to_vec(),
+        origin_module_id,
+        decls_to_lay,
+        aliases_to_lay,
+        has_prefix,
+    );
+
+    // Change the call argument to include the Overlay expression with the module ID
+    let mut call = call;
+    if let Some(overlay_expr) = call.positional_nth_mut(0) {
+        overlay_expr.expr = Expr::Overlay(if is_module_updated {
+            Some(origin_module_id)
+        } else {
+            None
+        });
+    } // no need to check for else since it was already checked
+
+    let pipeline = Pipeline::from_vec(vec![Expression {
+        expr: Expr::Call(call),
+        span: span(spans),
+        ty: Type::Any,
+        custom_completion: None,
+    }]);
 
     (pipeline, error)
 }

crates/nu-parser/src/parser.rs

@@ -5221,6 +5221,7 @@ pub fn discover_captures_in_expr(
             output.extend(&result);
         }
         Expr::ImportPattern(_) => {}
+        Expr::Overlay(_) => {}
         Expr::Garbage => {}
         Expr::Nothing => {}
         Expr::GlobPattern(_) => {}