Allow complex types in input/output and let (#10405)

# Description
This PR fixes #9702 on the side of parse. I.e. input/output types in
signature and type annotations in `let` now should correctly parse with
type annotations that contain commas and spaces:

![image](https://github.com/nushell/nushell/assets/17511668/babc0a69-5cb3-46c2-98ef-6da69ee3d3be)

# User-Facing Changes
Return values and let type annotations now can contain stuff like
`table<a: int b: record<c: string d: datetime>>` e.t.c

crates/nu-parser/tests/test_parser.rs

@@ -1354,6 +1354,38 @@ mod input_types {
         }
     }
 
+    #[derive(Clone)]
+    pub struct Def;
+
+    impl Command for Def {
+        fn name(&self) -> &str {
+            "def"
+        }
+
+        fn usage(&self) -> &str {
+            "Mock def command."
+        }
+
+        fn signature(&self) -> nu_protocol::Signature {
+            Signature::build("def")
+                .input_output_types(vec![(Type::Nothing, Type::Nothing)])
+                .required("def_name", SyntaxShape::String, "definition name")
+                .required("params", SyntaxShape::Signature, "parameters")
+                .required("body", SyntaxShape::Closure(None), "body of the definition")
+                .category(Category::Core)
+        }
+
+        fn run(
+            &self,
+            _engine_state: &EngineState,
+            _stack: &mut Stack,
+            _call: &Call,
+            _input: PipelineData,
+        ) -> Result<PipelineData, ShellError> {
+            todo!()
+        }
+    }
+
     #[derive(Clone)]
     pub struct GroupBy;
 
@@ -1608,6 +1640,7 @@ mod input_types {
         let delta = {
             let mut working_set = StateWorkingSet::new(engine_state);
             working_set.add_decl(Box::new(Let));
+            working_set.add_decl(Box::new(Def));
             working_set.add_decl(Box::new(AggCustom));
             working_set.add_decl(Box::new(GroupByCustom));
             working_set.add_decl(Box::new(GroupBy));
@@ -1833,4 +1866,52 @@ mod input_types {
             Some(ParseError::VariableNotFound(_, _))
         ));
     }
+
+    #[rstest]
+    #[case::input_output(b"def q []: int -> int {1}", false)]
+    #[case::input_output(b"def q []: string -> string {'qwe'}", false)]
+    #[case::input_output(b"def q []: nothing -> nothing {null}", false)]
+    #[case::input_output(b"def q []: list<string> -> list<string> {[]}", false)]
+    #[case::input_output(
+        b"def q []: record<a: int b: int> -> record<c: int e: int> {{c: 1 e: 1}}",
+        false
+    )]
+    #[case::input_output(
+        b"def q []: table<a: int b: int> -> table<c: int e: int> {[{c: 1 e: 1}]}",
+        false
+    )]
+    #[case::input_output(
+        b"def q []: nothing -> record<c: record<a: int b: int> e: int> {{c: {a: 1 b: 2} e: 1}}",
+        false
+    )]
+    #[case::input_output(b"def q []: nothing -> list<string {[]}", true)]
+    #[case::input_output(b"def q []: nothing -> record<c: int e: int {{c: 1 e: 1}}", true)]
+    #[case::input_output(b"def q []: record<c: int e: int -> record<a: int> {{a: 1}}", true)]
+    #[case::input_output(b"def q []: nothing -> record<a: record<a: int> {{a: {a: 1}}}", true)]
+    #[case::vardecl(b"let a: int = 1", false)]
+    #[case::vardecl(b"let a: string = 'qwe'", false)]
+    #[case::vardecl(b"let a: nothing = null", false)]
+    #[case::vardecl(b"let a: list<string> = []", false)]
+    #[case::vardecl(b"let a: record<a: int b: int> = {a: 1 b: 1}", false)]
+    #[case::vardecl(
+        b"let a: record<c: record<a: int b: int> e: int> = {c: {a: 1 b: 2} e: 1}",
+        false
+    )]
+    #[case::vardecl(b"let a: table<a: int b: int> = [[a b]; [1 1]]", false)]
+    #[case::vardecl(b"let a: list<string asd> = []", true)]
+    #[case::vardecl(b"let a: record<a: int b: record<a: int> = {a: 1 b: {a: 1}}", true)]
+    fn test_type_annotations(#[case] phrase: &[u8], #[case] expect_errors: bool) {
+        let mut engine_state = EngineState::new();
+        add_declarations(&mut engine_state);
+        let mut working_set = StateWorkingSet::new(&engine_state);
+        // this should not panic
+        let _block = parse(&mut working_set, None, phrase, false);
+        // check that no parse errors happened
+        assert_eq!(
+            !working_set.parse_errors.is_empty(),
+            expect_errors,
+            "Got errors {:?}",
+            working_set.parse_errors
+        )
+    }
 }