fix(parser): repeated parsing of module blocks

Author: blindFS

crates/nu-parser/src/parse_keywords.rs

@@ -281,7 +281,7 @@ pub fn parse_for(working_set: &mut StateWorkingSet, lite_command: &LiteCommand)
         Some(decl_id) => {
             working_set.enter_scope();
             let ParsedInternalCall { call, output } =
-                parse_internal_call(working_set, spans[0], &spans[1..], decl_id);
+                parse_internal_call(working_set, spans[0], &spans[1..], decl_id, false);
 
             working_set.exit_scope();
 
@@ -589,6 +589,7 @@ fn parse_def_inner(
                 Span::concat(command_spans),
                 rest_spans,
                 decl_id,
+                false,
             );
             // This is to preserve the order of the errors so that
             // the check errors below come first
@@ -842,6 +843,7 @@ fn parse_extern_inner(
                 Span::concat(command_spans),
                 rest_spans,
                 decl_id,
+                false,
             );
             working_set.exit_scope();
 
@@ -1103,6 +1105,7 @@ pub fn parse_alias(
             Span::concat(command_spans),
             rest_spans,
             decl_id,
+            false,
         );
 
         working_set
@@ -1365,6 +1368,7 @@ pub fn parse_export_in_block(
                     &parts[2..]
                 },
                 decl_id,
+                false,
             );
             // don't need errors generated by parse_internal_call
             // further error will be generated by detail `parse_xxx` function.
@@ -1836,7 +1840,7 @@ pub fn parse_export_env(
     let call = match working_set.find_decl(b"export-env") {
         Some(decl_id) => {
             let ParsedInternalCall { call, output } =
-                parse_internal_call(working_set, spans[0], &[spans[1]], decl_id);
+                parse_internal_call(working_set, spans[0], &[spans[1]], decl_id, false);
             let decl = working_set.get_decl(decl_id);
 
             let call_span = Span::concat(spans);
@@ -2348,6 +2352,7 @@ pub fn parse_module(
                 Span::concat(command_spans),
                 rest_spans,
                 decl_id,
+                true,
             );
             let decl = working_set.get_decl(decl_id);
 
@@ -2385,7 +2390,11 @@ pub fn parse_module(
 
     let (module_name_or_path, module_name_or_path_span, module_name_or_path_expr) =
         if let Some(name) = call.positional_nth(0) {
-            if let Some(s) = name.as_string() {
+            // Here name is supposed to be a garbage expression
+            // since argument `lite` is set to true in last `parse_internal_call` call.
+            // Need to parse the name expression here for later override.
+            let name_expr = parse_string(working_set, name.span);
+            if let Some(s) = name_expr.as_string() {
                 if let Some(mod_name) = module_name {
                     if s.as_bytes() == mod_name {
                         working_set.error(ParseError::NamedAsModule(
@@ -2405,7 +2414,7 @@ pub fn parse_module(
                         );
                     }
                 }
-                (s, name.span, name.clone())
+                (s, name.span, name_expr)
             } else {
                 working_set.error(ParseError::UnknownState(
                     "internal error: name not a string".into(),
@@ -2421,14 +2430,21 @@ pub fn parse_module(
             return (garbage_pipeline(working_set, spans), None);
         };
 
-    let pipeline = Pipeline::from_vec(vec![Expression::new(
-        working_set,
-        Expr::Call(call),
-        call_span,
-        Type::Any,
-    )]);
-
     if spans.len() == split_id + 1 {
+        let call = Box::new(Call {
+            head: Span::concat(&spans[..split_id]),
+            decl_id: call.decl_id,
+            arguments: vec![Argument::Positional(module_name_or_path_expr)],
+            parser_info: HashMap::new(),
+        });
+
+        let pipeline = Pipeline::from_vec(vec![Expression::new(
+            working_set,
+            Expr::Call(call),
+            call_span,
+            Type::Any,
+        )]);
+
         if let Some(module_id) = parse_module_file_or_dir(
             working_set,
             module_name_or_path.as_bytes(),
@@ -2561,6 +2577,7 @@ pub fn parse_use(
                 Span::concat(command_spans),
                 rest_spans,
                 decl_id,
+                false,
             );
             let decl = working_set.get_decl(decl_id);
 
@@ -2785,7 +2802,7 @@ pub fn parse_hide(working_set: &mut StateWorkingSet, lite_command: &LiteCommand)
     let (call, args_spans) = match working_set.find_decl(b"hide") {
         Some(decl_id) => {
             let ParsedInternalCall { call, output } =
-                parse_internal_call(working_set, spans[0], &spans[1..], decl_id);
+                parse_internal_call(working_set, spans[0], &spans[1..], decl_id, false);
             let decl = working_set.get_decl(decl_id);
 
             let call_span = Span::concat(spans);
@@ -3399,7 +3416,7 @@ pub fn parse_let(working_set: &mut StateWorkingSet, spans: &[Span]) -> Pipeline
             }
         }
         let ParsedInternalCall { call, output } =
-            parse_internal_call(working_set, spans[0], &spans[1..], decl_id);
+            parse_internal_call(working_set, spans[0], &spans[1..], decl_id, false);
 
         return Pipeline::from_vec(vec![Expression::new(
             working_set,
@@ -3560,7 +3577,7 @@ pub fn parse_const(working_set: &mut StateWorkingSet, spans: &[Span]) -> (Pipeli
             }
         }
         let ParsedInternalCall { call, output } =
-            parse_internal_call(working_set, spans[0], &spans[1..], decl_id);
+            parse_internal_call(working_set, spans[0], &spans[1..], decl_id, false);
 
         return (
             Pipeline::from_vec(vec![Expression::new(
@@ -3682,7 +3699,7 @@ pub fn parse_mut(working_set: &mut StateWorkingSet, spans: &[Span]) -> Pipeline
             }
         }
         let ParsedInternalCall { call, output } =
-            parse_internal_call(working_set, spans[0], &spans[1..], decl_id);
+            parse_internal_call(working_set, spans[0], &spans[1..], decl_id, false);
 
         return Pipeline::from_vec(vec![Expression::new(
             working_set,
@@ -3730,7 +3747,7 @@ pub fn parse_source(working_set: &mut StateWorkingSet, lite_command: &LiteComman
             // Is this the right call to be using here?
             // Some of the others (`parse_let`) use it, some of them (`parse_hide`) don't.
             let ParsedInternalCall { call, output } =
-                parse_internal_call(working_set, spans[0], &spans[1..], decl_id);
+                parse_internal_call(working_set, spans[0], &spans[1..], decl_id, false);
 
             let Ok(is_help) = has_flag_const(working_set, &call, "help") else {
                 return garbage_pipeline(working_set, spans);
@@ -3890,7 +3907,7 @@ pub fn parse_where_expr(working_set: &mut StateWorkingSet, spans: &[Span]) -> Ex
     let call = match working_set.find_decl(b"where") {
         Some(decl_id) => {
             let ParsedInternalCall { call, output } =
-                parse_internal_call(working_set, spans[0], &spans[1..], decl_id);
+                parse_internal_call(working_set, spans[0], &spans[1..], decl_id, false);
             let decl = working_set.get_decl(decl_id);
 
             let call_span = Span::concat(spans);

crates/nu-parser/src/parser.rs

@@ -987,6 +987,7 @@ pub fn parse_internal_call(
     command_span: Span,
     spans: &[Span],
     decl_id: DeclId,
+    lite: bool,
 ) -> ParsedInternalCall {
     trace!("parsing: internal call (decl id: {})", decl_id.get());
 
@@ -1269,23 +1270,29 @@ pub fn parse_internal_call(
                 continue;
             }
 
-            let arg = parse_multispan_value(
-                working_set,
-                &spans[..end],
-                &mut spans_idx,
-                &positional.shape,
-            );
-
-            let arg = if !type_compatible(&positional.shape.to_type(), &arg.ty) {
-                working_set.error(ParseError::TypeMismatch(
-                    positional.shape.to_type(),
-                    arg.ty,
-                    arg.span,
-                ));
-                Expression::garbage(working_set, arg.span)
+            // HACK: avoid repeated parsing of argument values for special cases
+            // see https://github.com/nushell/nushell/issues/16398
+            let arg = if lite {
+                Expression::garbage(working_set, spans[spans_idx])
             } else {
-                arg
+                let arg = parse_multispan_value(
+                    working_set,
+                    &spans[..end],
+                    &mut spans_idx,
+                    &positional.shape,
+                );
+                if !type_compatible(&positional.shape.to_type(), &arg.ty) {
+                    working_set.error(ParseError::TypeMismatch(
+                        positional.shape.to_type(),
+                        arg.ty,
+                        arg.span,
+                    ));
+                    Expression::garbage(working_set, arg.span)
+                } else {
+                    arg
+                }
             };
+
             call.add_positional(arg);
             positional_idx += 1;
         } else if signature.allows_unknown_args {
@@ -1391,6 +1398,7 @@ pub fn parse_call(working_set: &mut StateWorkingSet, spans: &[Span], head: Span)
                     Span::concat(&spans[cmd_start..pos]),
                     &spans[pos..],
                     decl_id,
+                    false,
                 )
             }
         } else {
@@ -1400,6 +1408,7 @@ pub fn parse_call(working_set: &mut StateWorkingSet, spans: &[Span], head: Span)
                 Span::concat(&spans[cmd_start..pos]),
                 &spans[pos..],
                 decl_id,
+                false,
             )
         };
 
@@ -1574,12 +1583,12 @@ pub fn parse_attribute(
             }
             _ => {
                 trace!("parsing: alias of internal call");
-                parse_internal_call(working_set, name_span, &spans[cmd_end..], decl_id)
+                parse_internal_call(working_set, name_span, &spans[cmd_end..], decl_id, false)
             }
         },
         None => {
             trace!("parsing: internal call");
-            parse_internal_call(working_set, name_span, &spans[cmd_end..], decl_id)
+            parse_internal_call(working_set, name_span, &spans[cmd_end..], decl_id, false)
         }
     };