Allow arguments for the last flag in short flag batch (#8808)

# Description
_Fixes #5923_

Currently `nushell` doesn't allow short flag batches to contain
arguments, despite this being a common pattern in commands like `git
commit -am 'My commit message'`. This PR relaxes this so that the last
flag in the batch can take an argument.

# User-Facing Changes
- `nu::parser::short_flag_arg_cant_take_arg` has been replaced by
`nu::parser::only_last_flag_in_batch_can_take_arg` and is displayed when
a flag other then the last in a short flag batch takes an argument.

# Tests + Formatting
- Both
[`test_parser.rs`](48af0ebc3c/crates/nu-parser/tests/test_parser.rs (L640-L704))
and
[`test_known_external.rs`](48af0ebc3c/src/tests/test_known_external.rs (L42-L61))
have been updated to test the new allowed and disallowed scenarios.

---------

Co-authored-by: sholderbach <sholderbach@users.noreply.github.com>

crates/nu-parser/tests/test_parser.rs

@@ -1,5 +1,5 @@
 use nu_parser::*;
-use nu_protocol::ast::{Call, PathMember};
+use nu_protocol::ast::{Argument, Call, PathMember};
 use nu_protocol::Span;
 use nu_protocol::{
     ast::{Expr, Expression, PipelineElement},
@@ -638,18 +638,68 @@ pub fn parse_call_missing_short_flag_arg() {
 }
 
 #[test]
-pub fn parse_call_too_many_shortflag_args() {
+pub fn parse_call_short_flag_batch_arg_allowed() {
     let engine_state = EngineState::new();
     let mut working_set = StateWorkingSet::new(&engine_state);
 
     let sig = Signature::build("foo")
         .named("--jazz", SyntaxShape::Int, "jazz!!", Some('j'))
-        .named("--math", SyntaxShape::Int, "math!!", Some('m'));
+        .switch("--math", "math!!", Some('m'));
     working_set.add_decl(sig.predeclare());
-    parse(&mut working_set, None, b"foo -mj", true);
+
+    let block = parse(&mut working_set, None, b"foo -mj 10", true);
+
+    assert!(working_set.parse_errors.is_empty());
+    assert_eq!(block.len(), 1);
+    let expressions = &block[0];
+    assert_eq!(expressions.len(), 1);
+
+    if let PipelineElement::Expression(
+        _,
+        Expression {
+            expr: Expr::Call(call),
+            ..
+        },
+    ) = &expressions[0]
+    {
+        assert_eq!(call.decl_id, 0);
+        assert_eq!(call.arguments.len(), 2);
+        matches!(call.arguments[0], Argument::Named((_, None, None)));
+        matches!(call.arguments[1], Argument::Named((_, None, Some(_))));
+    }
+}
+
+#[test]
+pub fn parse_call_short_flag_batch_arg_disallowed() {
+    let engine_state = EngineState::new();
+    let mut working_set = StateWorkingSet::new(&engine_state);
+
+    let sig = Signature::build("foo")
+        .named("--jazz", SyntaxShape::Int, "jazz!!", Some('j'))
+        .switch("--math", "math!!", Some('m'));
+    working_set.add_decl(sig.predeclare());
+
+    parse(&mut working_set, None, b"foo -jm 10", true);
     assert!(matches!(
         working_set.parse_errors.first(),
-        Some(ParseError::ShortFlagBatchCantTakeArg(..))
+        Some(ParseError::OnlyLastFlagInBatchCanTakeArg(..))
+    ));
+}
+
+#[test]
+pub fn parse_call_short_flag_batch_disallow_multiple_args() {
+    let engine_state = EngineState::new();
+    let mut working_set = StateWorkingSet::new(&engine_state);
+
+    let sig = Signature::build("foo")
+        .named("--math", SyntaxShape::Int, "math!!", Some('m'))
+        .named("--jazz", SyntaxShape::Int, "jazz!!", Some('j'));
+    working_set.add_decl(sig.predeclare());
+
+    parse(&mut working_set, None, b"foo -mj 10 20", true);
+    assert!(matches!(
+        working_set.parse_errors.first(),
+        Some(ParseError::OnlyLastFlagInBatchCanTakeArg(..))
     ));
 }