Add command_prelude module (#12291)

# Description
When implementing a `Command`, one must also import all the types
present in the function signatures for `Command`. This makes it so that
we often import the same set of types in each command implementation
file. E.g., something like this:
```rust
use nu_protocol::ast::Call;
use nu_protocol::engine::{Command, EngineState, Stack};
use nu_protocol::{
    record, Category, Example, IntoInterruptiblePipelineData, IntoPipelineData, PipelineData,
    ShellError, Signature, Span, Type, Value,
};
```

This PR adds the `nu_engine::command_prelude` module which contains the
necessary and commonly used types to implement a `Command`:
```rust
// command_prelude.rs
pub use crate::CallExt;
pub use nu_protocol::{
    ast::{Call, CellPath},
    engine::{Command, EngineState, Stack},
    record, Category, Example, IntoInterruptiblePipelineData, IntoPipelineData, IntoSpanned,
    PipelineData, Record, ShellError, Signature, Span, Spanned, SyntaxShape, Type, Value,
};
```

This should reduce the boilerplate needed to implement a command and
also gives us a place to track the breadth of the `Command` API. I tried
to be conservative with what went into the prelude modules, since it
might be hard/annoying to remove items from the prelude in the future.
Let me know if something should be included or excluded.

crates/nu-parser/src/flatten.rs

@@ -1,9 +1,11 @@
-use nu_protocol::ast::{
-    Argument, Block, Expr, Expression, ExternalArgument, ImportPatternMember, MatchPattern,
-    PathMember, Pattern, Pipeline, PipelineElement, PipelineRedirection, RecordItem,
+use nu_protocol::{
+    ast::{
+        Argument, Block, Expr, Expression, ExternalArgument, ImportPatternMember, MatchPattern,
+        PathMember, Pattern, Pipeline, PipelineElement, PipelineRedirection, RecordItem,
+    },
+    engine::StateWorkingSet,
+    DeclId, Span, VarId,
 };
-use nu_protocol::{engine::StateWorkingSet, Span};
-use nu_protocol::{DeclId, VarId};
 use std::fmt::{Display, Formatter, Result};
 
 #[derive(Debug, Eq, PartialEq, Ord, Clone, PartialOrd)]

crates/nu-parser/src/known_external.rs

@@ -1,10 +1,5 @@
-use nu_protocol::engine::{EngineState, Stack};
-use nu_protocol::{
-    ast::{Argument, Call, Expr, Expression},
-    engine::Command,
-    ShellError, Signature,
-};
-use nu_protocol::{PipelineData, Type};
+use nu_engine::command_prelude::*;
+use nu_protocol::ast::{Argument, Expr, Expression};
 
 #[derive(Clone)]
 pub struct KnownExternal {

crates/nu-parser/src/lite_parser.rs

@@ -1,11 +1,9 @@
 //! Lite parsing converts a flat stream of tokens from the lexer to a syntax element structure that
 //! can be parsed.
 
-use std::mem;
-
 use crate::{Token, TokenContents};
-
 use nu_protocol::{ast::RedirectionSource, ParseError, Span};
+use std::mem;
 
 #[derive(Debug, Clone, Copy)]
 pub enum LiteRedirectionTarget {

crates/nu-parser/src/parse_keywords.rs

@@ -18,9 +18,9 @@ use nu_protocol::{
     span, Alias, BlockId, DeclId, Module, ModuleId, ParseError, PositionalArg,
     ResolvedImportPattern, Span, Spanned, SyntaxShape, Type, Value, VarId,
 };
-use std::path::{Path, PathBuf};
 use std::{
     collections::{HashMap, HashSet},
+    path::{Path, PathBuf},
     sync::Arc,
 };
 

crates/nu-parser/src/parse_patterns.rs

@@ -1,14 +1,13 @@
+use crate::{
+    lex, lite_parse,
+    parser::{is_variable, parse_value},
+};
 use nu_protocol::{
     ast::{MatchPattern, Pattern},
     engine::StateWorkingSet,
     ParseError, Span, SyntaxShape, Type, VarId,
 };
 
-use crate::{
-    lex, lite_parse,
-    parser::{is_variable, parse_value},
-};
-
 pub fn garbage(span: Span) -> MatchPattern {
     MatchPattern {
         pattern: Pattern::Garbage,

crates/nu-parser/src/parse_shape_specs.rs

@@ -1,5 +1,4 @@
 use crate::{lex::lex_signature, parser::parse_value, trim_quotes, TokenContents};
-
 use nu_protocol::{engine::StateWorkingSet, ParseError, Span, SyntaxShape, Type};
 
 #[derive(Debug, Clone, Copy, PartialEq)]

crates/nu-parser/src/parser.rs

@@ -1,41 +1,27 @@
 use crate::{
     lex::{lex, lex_signature},
     lite_parser::{lite_parse, LiteCommand, LitePipeline, LiteRedirection, LiteRedirectionTarget},
+    parse_keywords::*,
     parse_mut,
     parse_patterns::parse_pattern,
     parse_shape_specs::{parse_shape_name, parse_type, ShapeDescriptorUse},
     type_check::{self, math_result_type, type_compatible},
     Token, TokenContents,
 };
-
-use nu_engine::DIR_VAR_PARSER_INFO;
-use nu_protocol::{
-    ast::{
-        Argument, Assignment, Bits, Block, Boolean, Call, CellPath, Comparison, Expr, Expression,
-        ExternalArgument, FullCellPath, ImportPattern, ImportPatternHead, ImportPatternMember,
-        MatchPattern, Math, Operator, PathMember, Pattern, Pipeline, PipelineElement,
-        PipelineRedirection, RangeInclusion, RangeOperator, RecordItem, RedirectionTarget,
-    },
-    engine::StateWorkingSet,
-    eval_const::eval_constant,
-    span, BlockId, DidYouMean, Flag, ParseError, PositionalArg, Signature, Span, Spanned,
-    SyntaxShape, Type, Unit, VarId, ENV_VARIABLE_ID, IN_VARIABLE_ID,
-};
-
-use crate::parse_keywords::{
-    find_dirs_var, is_unaliasable_parser_keyword, parse_alias, parse_const, parse_def,
-    parse_def_predecl, parse_export_in_block, parse_extern, parse_for, parse_hide, parse_keyword,
-    parse_let, parse_module, parse_overlay_hide, parse_overlay_new, parse_overlay_use,
-    parse_source, parse_use, parse_where, parse_where_expr, LIB_DIRS_VAR,
-};
-
 use itertools::Itertools;
 use log::trace;
+use nu_engine::DIR_VAR_PARSER_INFO;
+use nu_protocol::{
+    ast::*, engine::StateWorkingSet, eval_const::eval_constant, span, BlockId, DidYouMean, Flag,
+    ParseError, PositionalArg, Signature, Span, Spanned, SyntaxShape, Type, Unit, VarId,
+    ENV_VARIABLE_ID, IN_VARIABLE_ID,
+};
 use std::{
     collections::{HashMap, HashSet},
+    num::ParseIntError,
+    str,
     sync::Arc,
 };
-use std::{num::ParseIntError, str};
 
 #[cfg(feature = "plugin")]
 use crate::parse_keywords::parse_register;

crates/nu-parser/src/parser_path.rs

@@ -1,6 +1,8 @@
 use nu_protocol::engine::{StateWorkingSet, VirtualPath};
-use std::ffi::OsStr;
-use std::path::{Path, PathBuf};
+use std::{
+    ffi::OsStr,
+    path::{Path, PathBuf},
+};
 
 /// An abstraction over a PathBuf that can have virtual paths (files and directories). Virtual
 /// paths always exist and represent a way to ship Nushell code inside the binary without requiring

crates/nu-parser/tests/test_parser.rs

@@ -1196,8 +1196,10 @@ mod range {
 #[cfg(test)]
 mod input_types {
     use super::*;
-    use nu_protocol::ast::Call;
-    use nu_protocol::{ast::Argument, Category, PipelineData, ShellError, Type};
+    use nu_protocol::{
+        ast::{Argument, Call},
+        Category, PipelineData, ShellError, Type,
+    };
 
     #[derive(Clone)]
     pub struct LsTest;