mirror of
https://github.com/nushell/nushell.git
synced 2025-06-30 22:50:14 +02:00
IO and redirection overhaul (#11934)
# Description The PR overhauls how IO redirection is handled, allowing more explicit and fine-grain control over `stdout` and `stderr` output as well as more efficient IO and piping. To summarize the changes in this PR: - Added a new `IoStream` type to indicate the intended destination for a pipeline element's `stdout` and `stderr`. - The `stdout` and `stderr` `IoStream`s are stored in the `Stack` and to avoid adding 6 additional arguments to every eval function and `Command::run`. The `stdout` and `stderr` streams can be temporarily overwritten through functions on `Stack` and these functions will return a guard that restores the original `stdout` and `stderr` when dropped. - In the AST, redirections are now directly part of a `PipelineElement` as a `Option<Redirection>` field instead of having multiple different `PipelineElement` enum variants for each kind of redirection. This required changes to the parser, mainly in `lite_parser.rs`. - `Command`s can also set a `IoStream` override/redirection which will apply to the previous command in the pipeline. This is used, for example, in `ignore` to allow the previous external command to have its stdout redirected to `Stdio::null()` at spawn time. In contrast, the current implementation has to create an os pipe and manually consume the output on nushell's side. File and pipe redirections (`o>`, `e>`, `e>|`, etc.) have precedence over overrides from commands. This PR improves piping and IO speed, partially addressing #10763. Using the `throughput` command from that issue, this PR gives the following speedup on my setup for the commands below: | Command | Before (MB/s) | After (MB/s) | Bash (MB/s) | | --------------------------- | -------------:| ------------:| -----------:| | `throughput o> /dev/null` | 1169 | 52938 | 54305 | | `throughput \| ignore` | 840 | 55438 | N/A | | `throughput \| null` | Error | 53617 | N/A | | `throughput \| rg 'x'` | 1165 | 3049 | 3736 | | `(throughput) \| rg 'x'` | 810 | 3085 | 3815 | (Numbers above are the median samples for throughput) This PR also paves the way to refactor our `ExternalStream` handling in the various commands. For example, this PR already fixes the following code: ```nushell ^sh -c 'echo -n "hello "; sleep 0; echo "world"' | find "hello world" ``` This returns an empty list on 0.90.1 and returns a highlighted "hello world" on this PR. Since the `stdout` and `stderr` `IoStream`s are available to commands when they are run, then this unlocks the potential for more convenient behavior. E.g., the `find` command can disable its ansi highlighting if it detects that the output `IoStream` is not the terminal. Knowing the output streams will also allow background job output to be redirected more easily and efficiently. # User-Facing Changes - External commands returned from closures will be collected (in most cases): ```nushell 1..2 | each {|_| nu -c "print a" } ``` This gives `["a", "a"]` on this PR, whereas this used to print "a\na\n" and then return an empty list. ```nushell 1..2 | each {|_| nu -c "print -e a" } ``` This gives `["", ""]` and prints "a\na\n" to stderr, whereas this used to return an empty list and print "a\na\n" to stderr. - Trailing new lines are always trimmed for external commands when piping into internal commands or collecting it as a value. (Failure to decode the output as utf-8 will keep the trailing newline for the last binary value.) In the current nushell version, the following three code snippets differ only in parenthesis placement, but they all also have different outputs: 1. `1..2 | each { ^echo a }` ``` a a ╭────────────╮ │ empty list │ ╰────────────╯ ``` 2. `1..2 | each { (^echo a) }` ``` ╭───┬───╮ │ 0 │ a │ │ 1 │ a │ ╰───┴───╯ ``` 3. `1..2 | (each { ^echo a })` ``` ╭───┬───╮ │ 0 │ a │ │ │ │ │ 1 │ a │ │ │ │ ╰───┴───╯ ``` But in this PR, the above snippets will all have the same output: ``` ╭───┬───╮ │ 0 │ a │ │ 1 │ a │ ╰───┴───╯ ``` - All existing flags on `run-external` are now deprecated. - File redirections now apply to all commands inside a code block: ```nushell (nu -c "print -e a"; nu -c "print -e b") e> test.out ``` This gives "a\nb\n" in `test.out` and prints nothing. The same result would happen when printing to stdout and using a `o>` file redirection. - External command output will (almost) never be ignored, and ignoring output must be explicit now: ```nushell (^echo a; ^echo b) ``` This prints "a\nb\n", whereas this used to print only "b\n". This only applies to external commands; values and internal commands not in return position will not print anything (e.g., `(echo a; echo b)` still only prints "b"). - `complete` now always captures stderr (`do` is not necessary). # After Submitting The language guide and other documentation will need to be updated.
This commit is contained in:
Ian Manske
GitHub
@ -1,6 +1,6 @@
|
||||
use crate::{
|
||||
lex::{lex, lex_signature},
|
||||
lite_parser::{lite_parse, LiteCommand, LiteElement, LitePipeline},
|
||||
lite_parser::{lite_parse, LiteCommand, LitePipeline, LiteRedirection, LiteRedirectionTarget},
|
||||
parse_mut,
|
||||
parse_patterns::parse_pattern,
|
||||
parse_shape_specs::{parse_shape_name, parse_type, ShapeDescriptorUse},
|
||||
@ -14,7 +14,7 @@ use nu_protocol::{
|
||||
Argument, Assignment, Bits, Block, Boolean, Call, CellPath, Comparison, Expr, Expression,
|
||||
ExternalArgument, FullCellPath, ImportPattern, ImportPatternHead, ImportPatternMember,
|
||||
MatchPattern, Math, Operator, PathMember, Pattern, Pipeline, PipelineElement,
|
||||
RangeInclusion, RangeOperator, RecordItem,
|
||||
PipelineRedirection, RangeInclusion, RangeOperator, RecordItem, RedirectionTarget,
|
||||
},
|
||||
engine::StateWorkingSet,
|
||||
eval_const::eval_constant,
|
||||
@ -303,11 +303,7 @@ fn parse_external_arg(working_set: &mut StateWorkingSet, span: Span) -> External
|
||||
}
|
||||
}
|
||||
|
||||
pub fn parse_external_call(
|
||||
working_set: &mut StateWorkingSet,
|
||||
spans: &[Span],
|
||||
is_subexpression: bool,
|
||||
) -> Expression {
|
||||
pub fn parse_external_call(working_set: &mut StateWorkingSet, spans: &[Span]) -> Expression {
|
||||
trace!("parse external");
|
||||
|
||||
let mut args = vec![];
|
||||
@ -324,7 +320,7 @@ pub fn parse_external_call(
|
||||
|
||||
let head = if head_contents.starts_with(b"$") || head_contents.starts_with(b"(") {
|
||||
// the expression is inside external_call, so it's a subexpression
|
||||
let arg = parse_expression(working_set, &[head_span], true);
|
||||
let arg = parse_expression(working_set, &[head_span]);
|
||||
Box::new(arg)
|
||||
} else {
|
||||
let (contents, err) = unescape_unquote_string(&head_contents, head_span);
|
||||
@ -346,7 +342,7 @@ pub fn parse_external_call(
|
||||
}
|
||||
|
||||
Expression {
|
||||
expr: Expr::ExternalCall(head, args, is_subexpression),
|
||||
expr: Expr::ExternalCall(head, args),
|
||||
span: span(spans),
|
||||
ty: Type::Any,
|
||||
custom_completion: None,
|
||||
@ -708,7 +704,7 @@ pub fn parse_multispan_value(
|
||||
|
||||
// is it subexpression?
|
||||
// Not sure, but let's make it not, so the behavior is the same as previous version of nushell.
|
||||
let arg = parse_expression(working_set, &spans[*spans_idx..], false);
|
||||
let arg = parse_expression(working_set, &spans[*spans_idx..]);
|
||||
*spans_idx = spans.len() - 1;
|
||||
|
||||
arg
|
||||
@ -1095,12 +1091,7 @@ pub fn parse_internal_call(
|
||||
}
|
||||
}
|
||||
|
||||
pub fn parse_call(
|
||||
working_set: &mut StateWorkingSet,
|
||||
spans: &[Span],
|
||||
head: Span,
|
||||
is_subexpression: bool,
|
||||
) -> Expression {
|
||||
pub fn parse_call(working_set: &mut StateWorkingSet, spans: &[Span], head: Span) -> Expression {
|
||||
trace!("parsing: call");
|
||||
|
||||
if spans.is_empty() {
|
||||
@ -1179,7 +1170,7 @@ pub fn parse_call(
|
||||
|
||||
let parsed_call = if let Some(alias) = decl.as_alias() {
|
||||
if let Expression {
|
||||
expr: Expr::ExternalCall(head, args, is_subexpression),
|
||||
expr: Expr::ExternalCall(head, args),
|
||||
span: _,
|
||||
ty,
|
||||
custom_completion,
|
||||
@ -1198,7 +1189,7 @@ pub fn parse_call(
|
||||
head.span = spans[0]; // replacing the spans preserves syntax highlighting
|
||||
|
||||
return Expression {
|
||||
expr: Expr::ExternalCall(head, final_args, *is_subexpression),
|
||||
expr: Expr::ExternalCall(head, final_args),
|
||||
span: span(spans),
|
||||
ty: ty.clone(),
|
||||
custom_completion: *custom_completion,
|
||||
@ -1246,7 +1237,7 @@ pub fn parse_call(
|
||||
trace!("parsing: external call");
|
||||
|
||||
// Otherwise, try external command
|
||||
parse_external_call(working_set, spans, is_subexpression)
|
||||
parse_external_call(working_set, spans)
|
||||
}
|
||||
}
|
||||
|
||||
@ -3139,9 +3130,11 @@ pub fn parse_row_condition(working_set: &mut StateWorkingSet, spans: &[Span]) ->
|
||||
// We have an expression, so let's convert this into a block.
|
||||
let mut block = Block::new();
|
||||
let mut pipeline = Pipeline::new();
|
||||
pipeline
|
||||
.elements
|
||||
.push(PipelineElement::Expression(None, expression));
|
||||
pipeline.elements.push(PipelineElement {
|
||||
pipe: None,
|
||||
expr: expression,
|
||||
redirection: None,
|
||||
});
|
||||
|
||||
block.pipelines.push(pipeline);
|
||||
|
||||
@ -3846,61 +3839,59 @@ pub fn parse_list_expression(
|
||||
let mut contained_type: Option<Type> = None;
|
||||
|
||||
if !output.block.is_empty() {
|
||||
for arg in output.block.remove(0).commands {
|
||||
for mut command in output.block.remove(0).commands {
|
||||
let mut spans_idx = 0;
|
||||
|
||||
if let LiteElement::Command(_, mut command) = arg {
|
||||
while spans_idx < command.parts.len() {
|
||||
let curr_span = command.parts[spans_idx];
|
||||
let curr_tok = working_set.get_span_contents(curr_span);
|
||||
let (arg, ty) = if curr_tok.starts_with(b"...")
|
||||
&& curr_tok.len() > 3
|
||||
&& (curr_tok[3] == b'$' || curr_tok[3] == b'[' || curr_tok[3] == b'(')
|
||||
{
|
||||
// Parse the spread operator
|
||||
// Remove "..." before parsing argument to spread operator
|
||||
command.parts[spans_idx] = Span::new(curr_span.start + 3, curr_span.end);
|
||||
let spread_arg = parse_multispan_value(
|
||||
working_set,
|
||||
&command.parts,
|
||||
&mut spans_idx,
|
||||
&SyntaxShape::List(Box::new(element_shape.clone())),
|
||||
);
|
||||
let elem_ty = match &spread_arg.ty {
|
||||
Type::List(elem_ty) => *elem_ty.clone(),
|
||||
_ => Type::Any,
|
||||
};
|
||||
let span = Span::new(curr_span.start, spread_arg.span.end);
|
||||
let spread_expr = Expression {
|
||||
expr: Expr::Spread(Box::new(spread_arg)),
|
||||
span,
|
||||
ty: elem_ty.clone(),
|
||||
custom_completion: None,
|
||||
};
|
||||
(spread_expr, elem_ty)
|
||||
} else {
|
||||
let arg = parse_multispan_value(
|
||||
working_set,
|
||||
&command.parts,
|
||||
&mut spans_idx,
|
||||
element_shape,
|
||||
);
|
||||
let ty = arg.ty.clone();
|
||||
(arg, ty)
|
||||
while spans_idx < command.parts.len() {
|
||||
let curr_span = command.parts[spans_idx];
|
||||
let curr_tok = working_set.get_span_contents(curr_span);
|
||||
let (arg, ty) = if curr_tok.starts_with(b"...")
|
||||
&& curr_tok.len() > 3
|
||||
&& (curr_tok[3] == b'$' || curr_tok[3] == b'[' || curr_tok[3] == b'(')
|
||||
{
|
||||
// Parse the spread operator
|
||||
// Remove "..." before parsing argument to spread operator
|
||||
command.parts[spans_idx] = Span::new(curr_span.start + 3, curr_span.end);
|
||||
let spread_arg = parse_multispan_value(
|
||||
working_set,
|
||||
&command.parts,
|
||||
&mut spans_idx,
|
||||
&SyntaxShape::List(Box::new(element_shape.clone())),
|
||||
);
|
||||
let elem_ty = match &spread_arg.ty {
|
||||
Type::List(elem_ty) => *elem_ty.clone(),
|
||||
_ => Type::Any,
|
||||
};
|
||||
let span = Span::new(curr_span.start, spread_arg.span.end);
|
||||
let spread_expr = Expression {
|
||||
expr: Expr::Spread(Box::new(spread_arg)),
|
||||
span,
|
||||
ty: elem_ty.clone(),
|
||||
custom_completion: None,
|
||||
};
|
||||
(spread_expr, elem_ty)
|
||||
} else {
|
||||
let arg = parse_multispan_value(
|
||||
working_set,
|
||||
&command.parts,
|
||||
&mut spans_idx,
|
||||
element_shape,
|
||||
);
|
||||
let ty = arg.ty.clone();
|
||||
(arg, ty)
|
||||
};
|
||||
|
||||
if let Some(ref ctype) = contained_type {
|
||||
if *ctype != ty {
|
||||
contained_type = Some(Type::Any);
|
||||
}
|
||||
} else {
|
||||
contained_type = Some(ty);
|
||||
if let Some(ref ctype) = contained_type {
|
||||
if *ctype != ty {
|
||||
contained_type = Some(Type::Any);
|
||||
}
|
||||
|
||||
args.push(arg);
|
||||
|
||||
spans_idx += 1;
|
||||
} else {
|
||||
contained_type = Some(ty);
|
||||
}
|
||||
|
||||
args.push(arg);
|
||||
|
||||
spans_idx += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -4861,7 +4852,7 @@ pub fn parse_math_expression(
|
||||
if first_span == b"if" || first_span == b"match" {
|
||||
// If expression
|
||||
if spans.len() > 1 {
|
||||
return parse_call(working_set, spans, spans[0], false);
|
||||
return parse_call(working_set, spans, spans[0]);
|
||||
} else {
|
||||
working_set.error(ParseError::Expected(
|
||||
"expression",
|
||||
@ -4936,7 +4927,7 @@ pub fn parse_math_expression(
|
||||
// allow `if` to be a special value for assignment.
|
||||
|
||||
if content == b"if" || content == b"match" {
|
||||
let rhs = parse_call(working_set, &spans[idx..], spans[0], false);
|
||||
let rhs = parse_call(working_set, &spans[idx..], spans[0]);
|
||||
expr_stack.push(op);
|
||||
expr_stack.push(rhs);
|
||||
break;
|
||||
@ -5055,11 +5046,7 @@ pub fn parse_math_expression(
|
||||
.expect("internal error: expression stack empty")
|
||||
}
|
||||
|
||||
pub fn parse_expression(
|
||||
working_set: &mut StateWorkingSet,
|
||||
spans: &[Span],
|
||||
is_subexpression: bool,
|
||||
) -> Expression {
|
||||
pub fn parse_expression(working_set: &mut StateWorkingSet, spans: &[Span]) -> Expression {
|
||||
trace!("parsing: expression");
|
||||
|
||||
let mut pos = 0;
|
||||
@ -5134,7 +5121,7 @@ pub fn parse_expression(
|
||||
spans[0],
|
||||
));
|
||||
|
||||
parse_call(working_set, &spans[pos..], spans[0], is_subexpression)
|
||||
parse_call(working_set, &spans[pos..], spans[0])
|
||||
}
|
||||
b"let" | b"const" | b"mut" => {
|
||||
working_set.error(ParseError::AssignInPipeline(
|
||||
@ -5152,19 +5139,19 @@ pub fn parse_expression(
|
||||
.to_string(),
|
||||
spans[0],
|
||||
));
|
||||
parse_call(working_set, &spans[pos..], spans[0], is_subexpression)
|
||||
parse_call(working_set, &spans[pos..], spans[0])
|
||||
}
|
||||
b"overlay" => {
|
||||
if spans.len() > 1 && working_set.get_span_contents(spans[1]) == b"list" {
|
||||
// whitelist 'overlay list'
|
||||
parse_call(working_set, &spans[pos..], spans[0], is_subexpression)
|
||||
parse_call(working_set, &spans[pos..], spans[0])
|
||||
} else {
|
||||
working_set.error(ParseError::BuiltinCommandInPipeline(
|
||||
"overlay".into(),
|
||||
spans[0],
|
||||
));
|
||||
|
||||
parse_call(working_set, &spans[pos..], spans[0], is_subexpression)
|
||||
parse_call(working_set, &spans[pos..], spans[0])
|
||||
}
|
||||
}
|
||||
b"where" => parse_where_expr(working_set, &spans[pos..]),
|
||||
@ -5175,10 +5162,10 @@ pub fn parse_expression(
|
||||
spans[0],
|
||||
));
|
||||
|
||||
parse_call(working_set, &spans[pos..], spans[0], is_subexpression)
|
||||
parse_call(working_set, &spans[pos..], spans[0])
|
||||
}
|
||||
|
||||
_ => parse_call(working_set, &spans[pos..], spans[0], is_subexpression),
|
||||
_ => parse_call(working_set, &spans[pos..], spans[0]),
|
||||
}
|
||||
};
|
||||
|
||||
@ -5217,8 +5204,6 @@ pub fn parse_expression(
|
||||
head: Span::unknown(),
|
||||
decl_id,
|
||||
arguments,
|
||||
redirect_stdout: true,
|
||||
redirect_stderr: false,
|
||||
parser_info: HashMap::new(),
|
||||
}));
|
||||
|
||||
@ -5251,7 +5236,6 @@ pub fn parse_variable(working_set: &mut StateWorkingSet, span: Span) -> Option<V
|
||||
pub fn parse_builtin_commands(
|
||||
working_set: &mut StateWorkingSet,
|
||||
lite_command: &LiteCommand,
|
||||
is_subexpression: bool,
|
||||
) -> Pipeline {
|
||||
trace!("parsing: builtin commands");
|
||||
if !is_math_expression_like(working_set, lite_command.parts[0])
|
||||
@ -5264,12 +5248,7 @@ pub fn parse_builtin_commands(
|
||||
if cmd.is_alias() {
|
||||
// Parse keywords that can be aliased. Note that we check for "unaliasable" keywords
|
||||
// because alias can have any name, therefore, we can't check for "aliasable" keywords.
|
||||
let call_expr = parse_call(
|
||||
working_set,
|
||||
&lite_command.parts,
|
||||
lite_command.parts[0],
|
||||
is_subexpression,
|
||||
);
|
||||
let call_expr = parse_call(working_set, &lite_command.parts, lite_command.parts[0]);
|
||||
|
||||
if let Expression {
|
||||
expr: Expr::Call(call),
|
||||
@ -5299,26 +5278,31 @@ pub fn parse_builtin_commands(
|
||||
b"const" => parse_const(working_set, &lite_command.parts),
|
||||
b"mut" => parse_mut(working_set, &lite_command.parts),
|
||||
b"for" => {
|
||||
let expr = parse_for(working_set, &lite_command.parts);
|
||||
let expr = parse_for(working_set, lite_command);
|
||||
Pipeline::from_vec(vec![expr])
|
||||
}
|
||||
b"alias" => parse_alias(working_set, lite_command, None),
|
||||
b"module" => parse_module(working_set, lite_command, None).0,
|
||||
b"use" => {
|
||||
let (pipeline, _) = parse_use(working_set, &lite_command.parts);
|
||||
pipeline
|
||||
b"use" => parse_use(working_set, lite_command).0,
|
||||
b"overlay" => {
|
||||
if let Some(redirection) = lite_command.redirection.as_ref() {
|
||||
working_set.error(redirecting_builtin_error("overlay", redirection));
|
||||
return garbage_pipeline(&lite_command.parts);
|
||||
}
|
||||
parse_keyword(working_set, lite_command)
|
||||
}
|
||||
b"overlay" => parse_keyword(working_set, lite_command, is_subexpression),
|
||||
b"source" | b"source-env" => parse_source(working_set, &lite_command.parts),
|
||||
b"source" | b"source-env" => parse_source(working_set, lite_command),
|
||||
b"export" => parse_export_in_block(working_set, lite_command),
|
||||
b"hide" => parse_hide(working_set, &lite_command.parts),
|
||||
b"where" => parse_where(working_set, &lite_command.parts),
|
||||
b"hide" => parse_hide(working_set, lite_command),
|
||||
b"where" => parse_where(working_set, lite_command),
|
||||
#[cfg(feature = "plugin")]
|
||||
b"register" => parse_register(working_set, &lite_command.parts),
|
||||
b"register" => parse_register(working_set, lite_command),
|
||||
_ => {
|
||||
let expr = parse_expression(working_set, &lite_command.parts, is_subexpression);
|
||||
let element = parse_pipeline_element(working_set, lite_command);
|
||||
|
||||
Pipeline::from_vec(vec![expr])
|
||||
Pipeline {
|
||||
elements: vec![element],
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -5459,6 +5443,76 @@ pub fn parse_record(working_set: &mut StateWorkingSet, span: Span) -> Expression
|
||||
}
|
||||
}
|
||||
|
||||
fn parse_redirection_target(
|
||||
working_set: &mut StateWorkingSet,
|
||||
target: &LiteRedirectionTarget,
|
||||
) -> RedirectionTarget {
|
||||
match target {
|
||||
LiteRedirectionTarget::File {
|
||||
connector,
|
||||
file,
|
||||
append,
|
||||
} => RedirectionTarget::File {
|
||||
expr: parse_value(working_set, *file, &SyntaxShape::Any),
|
||||
append: *append,
|
||||
span: *connector,
|
||||
},
|
||||
LiteRedirectionTarget::Pipe { connector } => RedirectionTarget::Pipe { span: *connector },
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn parse_redirection(
|
||||
working_set: &mut StateWorkingSet,
|
||||
target: &LiteRedirection,
|
||||
) -> PipelineRedirection {
|
||||
match target {
|
||||
LiteRedirection::Single { source, target } => PipelineRedirection::Single {
|
||||
source: *source,
|
||||
target: parse_redirection_target(working_set, target),
|
||||
},
|
||||
LiteRedirection::Separate { out, err } => PipelineRedirection::Separate {
|
||||
out: parse_redirection_target(working_set, out),
|
||||
err: parse_redirection_target(working_set, err),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
fn parse_pipeline_element(
|
||||
working_set: &mut StateWorkingSet,
|
||||
command: &LiteCommand,
|
||||
) -> PipelineElement {
|
||||
trace!("parsing: pipeline element");
|
||||
|
||||
let expr = parse_expression(working_set, &command.parts);
|
||||
|
||||
let redirection = command
|
||||
.redirection
|
||||
.as_ref()
|
||||
.map(|r| parse_redirection(working_set, r));
|
||||
|
||||
PipelineElement {
|
||||
pipe: command.pipe,
|
||||
expr,
|
||||
redirection,
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn redirecting_builtin_error(
|
||||
name: &'static str,
|
||||
redirection: &LiteRedirection,
|
||||
) -> ParseError {
|
||||
match redirection {
|
||||
LiteRedirection::Single { target, .. } => {
|
||||
ParseError::RedirectingBuiltinCommand(name, target.connector(), None)
|
||||
}
|
||||
LiteRedirection::Separate { out, err } => ParseError::RedirectingBuiltinCommand(
|
||||
name,
|
||||
out.connector().min(err.connector()),
|
||||
Some(out.connector().max(err.connector())),
|
||||
),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn parse_pipeline(
|
||||
working_set: &mut StateWorkingSet,
|
||||
pipeline: &LitePipeline,
|
||||
@ -5467,271 +5521,161 @@ pub fn parse_pipeline(
|
||||
) -> Pipeline {
|
||||
if pipeline.commands.len() > 1 {
|
||||
// Special case: allow `let` and `mut` to consume the whole pipeline, eg) `let abc = "foo" | str length`
|
||||
match &pipeline.commands[0] {
|
||||
LiteElement::Command(_, command) if !command.parts.is_empty() => {
|
||||
if working_set.get_span_contents(command.parts[0]) == b"let"
|
||||
|| working_set.get_span_contents(command.parts[0]) == b"mut"
|
||||
{
|
||||
let mut new_command = LiteCommand {
|
||||
comments: vec![],
|
||||
parts: command.parts.clone(),
|
||||
};
|
||||
if let Some(&first) = pipeline.commands[0].parts.first() {
|
||||
let first = working_set.get_span_contents(first);
|
||||
if first == b"let" || first == b"mut" {
|
||||
let name = if first == b"let" { "let" } else { "mut" };
|
||||
let mut new_command = LiteCommand {
|
||||
comments: vec![],
|
||||
parts: pipeline.commands[0].parts.clone(),
|
||||
pipe: None,
|
||||
redirection: None,
|
||||
};
|
||||
|
||||
for command in &pipeline.commands[1..] {
|
||||
match command {
|
||||
LiteElement::Command(Some(pipe_span), command)
|
||||
| LiteElement::ErrPipedCommand(Some(pipe_span), command)
|
||||
| LiteElement::OutErrPipedCommand(Some(pipe_span), command) => {
|
||||
new_command.parts.push(*pipe_span);
|
||||
if let Some(redirection) = pipeline.commands[0].redirection.as_ref() {
|
||||
working_set.error(redirecting_builtin_error(name, redirection));
|
||||
}
|
||||
|
||||
new_command.comments.extend_from_slice(&command.comments);
|
||||
new_command.parts.extend_from_slice(&command.parts);
|
||||
}
|
||||
LiteElement::Redirection(span, ..) => {
|
||||
working_set.error(ParseError::RedirectionInLetMut(*span, None))
|
||||
}
|
||||
LiteElement::SeparateRedirection { out, err } => {
|
||||
working_set.error(ParseError::RedirectionInLetMut(
|
||||
out.0.min(err.0),
|
||||
Some(out.0.max(err.0)),
|
||||
))
|
||||
}
|
||||
LiteElement::SameTargetRedirection { redirection, .. } => working_set
|
||||
.error(ParseError::RedirectionInLetMut(redirection.0, None)),
|
||||
_ => panic!("unsupported"),
|
||||
}
|
||||
for element in &pipeline.commands[1..] {
|
||||
if let Some(redirection) = pipeline.commands[0].redirection.as_ref() {
|
||||
working_set.error(redirecting_builtin_error(name, redirection));
|
||||
} else {
|
||||
new_command.parts.push(element.pipe.expect("pipe span"));
|
||||
new_command.comments.extend_from_slice(&element.comments);
|
||||
new_command.parts.extend_from_slice(&element.parts);
|
||||
}
|
||||
}
|
||||
|
||||
// if the 'let' is complete enough, use it, if not, fall through for now
|
||||
if new_command.parts.len() > 3 {
|
||||
let rhs_span = nu_protocol::span(&new_command.parts[3..]);
|
||||
// if the 'let' is complete enough, use it, if not, fall through for now
|
||||
if new_command.parts.len() > 3 {
|
||||
let rhs_span = nu_protocol::span(&new_command.parts[3..]);
|
||||
|
||||
new_command.parts.truncate(3);
|
||||
new_command.parts.push(rhs_span);
|
||||
new_command.parts.truncate(3);
|
||||
new_command.parts.push(rhs_span);
|
||||
|
||||
let mut pipeline =
|
||||
parse_builtin_commands(working_set, &new_command, is_subexpression);
|
||||
let mut pipeline = parse_builtin_commands(working_set, &new_command);
|
||||
|
||||
if pipeline_index == 0 {
|
||||
let let_decl_id = working_set.find_decl(b"let");
|
||||
let mut_decl_id = working_set.find_decl(b"mut");
|
||||
for element in pipeline.elements.iter_mut() {
|
||||
if let PipelineElement::Expression(
|
||||
_,
|
||||
Expression {
|
||||
expr: Expr::Call(call),
|
||||
..
|
||||
},
|
||||
) = element
|
||||
if pipeline_index == 0 {
|
||||
let let_decl_id = working_set.find_decl(b"let");
|
||||
let mut_decl_id = working_set.find_decl(b"mut");
|
||||
for element in pipeline.elements.iter_mut() {
|
||||
if let Expr::Call(call) = &element.expr.expr {
|
||||
if Some(call.decl_id) == let_decl_id
|
||||
|| Some(call.decl_id) == mut_decl_id
|
||||
{
|
||||
if Some(call.decl_id) == let_decl_id
|
||||
|| Some(call.decl_id) == mut_decl_id
|
||||
// Do an expansion
|
||||
if let Some(Expression {
|
||||
expr: Expr::Block(block_id),
|
||||
..
|
||||
}) = call.positional_iter().nth(1)
|
||||
{
|
||||
// Do an expansion
|
||||
if let Some(Expression {
|
||||
expr: Expr::Block(block_id),
|
||||
..
|
||||
}) = call.positional_iter_mut().nth(1)
|
||||
let block = working_set.get_block(*block_id);
|
||||
|
||||
if let Some(element) = block
|
||||
.pipelines
|
||||
.first()
|
||||
.and_then(|p| p.elements.first())
|
||||
.cloned()
|
||||
{
|
||||
let block = working_set.get_block(*block_id);
|
||||
|
||||
if let Some(PipelineElement::Expression(
|
||||
prepend,
|
||||
expr,
|
||||
)) = block
|
||||
.pipelines
|
||||
.first()
|
||||
.and_then(|p| p.elements.first())
|
||||
.cloned()
|
||||
{
|
||||
if expr.has_in_variable(working_set) {
|
||||
let new_expr = PipelineElement::Expression(
|
||||
prepend,
|
||||
wrap_expr_with_collect(working_set, &expr),
|
||||
);
|
||||
|
||||
let block =
|
||||
working_set.get_block_mut(*block_id);
|
||||
block.pipelines[0].elements[0] = new_expr;
|
||||
}
|
||||
if element.has_in_variable(working_set) {
|
||||
let element = wrap_element_with_collect(
|
||||
working_set,
|
||||
&element,
|
||||
);
|
||||
let block = working_set.get_block_mut(*block_id);
|
||||
block.pipelines[0].elements[0] = element;
|
||||
}
|
||||
}
|
||||
continue;
|
||||
} else if element.has_in_variable(working_set)
|
||||
&& !is_subexpression
|
||||
{
|
||||
*element = wrap_element_with_collect(working_set, element);
|
||||
}
|
||||
continue;
|
||||
} else if element.has_in_variable(working_set) && !is_subexpression
|
||||
{
|
||||
*element = wrap_element_with_collect(working_set, element);
|
||||
}
|
||||
} else if element.has_in_variable(working_set) && !is_subexpression {
|
||||
*element = wrap_element_with_collect(working_set, element);
|
||||
}
|
||||
}
|
||||
|
||||
return pipeline;
|
||||
}
|
||||
|
||||
return pipeline;
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
};
|
||||
}
|
||||
|
||||
let mut output = pipeline
|
||||
let mut elements = pipeline
|
||||
.commands
|
||||
.iter()
|
||||
.map(|command| match command {
|
||||
LiteElement::Command(span, command) => {
|
||||
trace!("parsing: pipeline element: command");
|
||||
let expr = parse_expression(working_set, &command.parts, is_subexpression);
|
||||
|
||||
PipelineElement::Expression(*span, expr)
|
||||
}
|
||||
LiteElement::ErrPipedCommand(span, command) => {
|
||||
trace!("parsing: pipeline element: err piped command");
|
||||
let expr = parse_expression(working_set, &command.parts, is_subexpression);
|
||||
|
||||
PipelineElement::ErrPipedExpression(*span, expr)
|
||||
}
|
||||
LiteElement::OutErrPipedCommand(span, command) => {
|
||||
trace!("parsing: pipeline element: err piped command");
|
||||
let expr = parse_expression(working_set, &command.parts, is_subexpression);
|
||||
|
||||
PipelineElement::OutErrPipedExpression(*span, expr)
|
||||
}
|
||||
LiteElement::Redirection(span, redirection, command, is_append_mode) => {
|
||||
let expr = parse_value(working_set, command.parts[0], &SyntaxShape::Any);
|
||||
|
||||
PipelineElement::Redirection(*span, redirection.clone(), expr, *is_append_mode)
|
||||
}
|
||||
LiteElement::SeparateRedirection {
|
||||
out: (out_span, out_command, out_append_mode),
|
||||
err: (err_span, err_command, err_append_mode),
|
||||
} => {
|
||||
trace!("parsing: pipeline element: separate redirection");
|
||||
let out_expr =
|
||||
parse_value(working_set, out_command.parts[0], &SyntaxShape::Any);
|
||||
|
||||
let err_expr =
|
||||
parse_value(working_set, err_command.parts[0], &SyntaxShape::Any);
|
||||
|
||||
PipelineElement::SeparateRedirection {
|
||||
out: (*out_span, out_expr, *out_append_mode),
|
||||
err: (*err_span, err_expr, *err_append_mode),
|
||||
}
|
||||
}
|
||||
LiteElement::SameTargetRedirection {
|
||||
cmd: (cmd_span, command),
|
||||
redirection: (redirect_span, redirect_command, is_append_mode),
|
||||
} => {
|
||||
trace!("parsing: pipeline element: same target redirection");
|
||||
let expr = parse_expression(working_set, &command.parts, is_subexpression);
|
||||
let redirect_expr =
|
||||
parse_value(working_set, redirect_command.parts[0], &SyntaxShape::Any);
|
||||
PipelineElement::SameTargetRedirection {
|
||||
cmd: (*cmd_span, expr),
|
||||
redirection: (*redirect_span, redirect_expr, *is_append_mode),
|
||||
}
|
||||
}
|
||||
})
|
||||
.collect::<Vec<PipelineElement>>();
|
||||
.map(|element| parse_pipeline_element(working_set, element))
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
if is_subexpression {
|
||||
for element in output.iter_mut().skip(1) {
|
||||
for element in elements.iter_mut().skip(1) {
|
||||
if element.has_in_variable(working_set) {
|
||||
*element = wrap_element_with_collect(working_set, element);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for element in output.iter_mut() {
|
||||
for element in elements.iter_mut() {
|
||||
if element.has_in_variable(working_set) {
|
||||
*element = wrap_element_with_collect(working_set, element);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Pipeline { elements: output }
|
||||
Pipeline { elements }
|
||||
} else {
|
||||
match &pipeline.commands[0] {
|
||||
LiteElement::Command(_, command)
|
||||
| LiteElement::ErrPipedCommand(_, command)
|
||||
| LiteElement::OutErrPipedCommand(_, command)
|
||||
| LiteElement::Redirection(_, _, command, _)
|
||||
| LiteElement::SeparateRedirection {
|
||||
out: (_, command, _),
|
||||
..
|
||||
} => {
|
||||
let mut pipeline = parse_builtin_commands(working_set, command, is_subexpression);
|
||||
|
||||
let let_decl_id = working_set.find_decl(b"let");
|
||||
let mut_decl_id = working_set.find_decl(b"mut");
|
||||
|
||||
if pipeline_index == 0 {
|
||||
for element in pipeline.elements.iter_mut() {
|
||||
if let PipelineElement::Expression(
|
||||
_,
|
||||
Expression {
|
||||
expr: Expr::Call(call),
|
||||
..
|
||||
},
|
||||
) = element
|
||||
{
|
||||
if Some(call.decl_id) == let_decl_id
|
||||
|| Some(call.decl_id) == mut_decl_id
|
||||
{
|
||||
// Do an expansion
|
||||
if let Some(Expression {
|
||||
expr: Expr::Block(block_id),
|
||||
..
|
||||
}) = call.positional_iter_mut().nth(1)
|
||||
{
|
||||
let block = working_set.get_block(*block_id);
|
||||
|
||||
if let Some(PipelineElement::Expression(prepend, expr)) = block
|
||||
.pipelines
|
||||
.first()
|
||||
.and_then(|p| p.elements.first())
|
||||
.cloned()
|
||||
{
|
||||
if expr.has_in_variable(working_set) {
|
||||
let new_expr = PipelineElement::Expression(
|
||||
prepend,
|
||||
wrap_expr_with_collect(working_set, &expr),
|
||||
);
|
||||
|
||||
let block = working_set.get_block_mut(*block_id);
|
||||
block.pipelines[0].elements[0] = new_expr;
|
||||
}
|
||||
}
|
||||
}
|
||||
continue;
|
||||
} else if element.has_in_variable(working_set) && !is_subexpression {
|
||||
*element = wrap_element_with_collect(working_set, element);
|
||||
}
|
||||
} else if element.has_in_variable(working_set) && !is_subexpression {
|
||||
*element = wrap_element_with_collect(working_set, element);
|
||||
}
|
||||
}
|
||||
}
|
||||
pipeline
|
||||
}
|
||||
LiteElement::SameTargetRedirection {
|
||||
cmd: (span, command),
|
||||
redirection: (redirect_span, redirect_cmd, is_append_mode),
|
||||
} => {
|
||||
trace!("parsing: pipeline element: same target redirection");
|
||||
let expr = parse_expression(working_set, &command.parts, is_subexpression);
|
||||
|
||||
let redirect_expr =
|
||||
parse_value(working_set, redirect_cmd.parts[0], &SyntaxShape::Any);
|
||||
|
||||
Pipeline {
|
||||
elements: vec![PipelineElement::SameTargetRedirection {
|
||||
cmd: (*span, expr),
|
||||
redirection: (*redirect_span, redirect_expr, *is_append_mode),
|
||||
}],
|
||||
if let Some(&first) = pipeline.commands[0].parts.first() {
|
||||
let first = working_set.get_span_contents(first);
|
||||
if first == b"let" || first == b"mut" {
|
||||
if let Some(redirection) = pipeline.commands[0].redirection.as_ref() {
|
||||
let name = if first == b"let" { "let" } else { "mut" };
|
||||
working_set.error(redirecting_builtin_error(name, redirection));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let mut pipeline = parse_builtin_commands(working_set, &pipeline.commands[0]);
|
||||
|
||||
let let_decl_id = working_set.find_decl(b"let");
|
||||
let mut_decl_id = working_set.find_decl(b"mut");
|
||||
|
||||
if pipeline_index == 0 {
|
||||
for element in pipeline.elements.iter_mut() {
|
||||
if let Expr::Call(call) = &element.expr.expr {
|
||||
if Some(call.decl_id) == let_decl_id || Some(call.decl_id) == mut_decl_id {
|
||||
// Do an expansion
|
||||
if let Some(Expression {
|
||||
expr: Expr::Block(block_id),
|
||||
..
|
||||
}) = call.positional_iter().nth(1)
|
||||
{
|
||||
let block = working_set.get_block(*block_id);
|
||||
|
||||
if let Some(element) = block
|
||||
.pipelines
|
||||
.first()
|
||||
.and_then(|p| p.elements.first())
|
||||
.cloned()
|
||||
{
|
||||
if element.has_in_variable(working_set) {
|
||||
let element = wrap_element_with_collect(working_set, &element);
|
||||
let block = working_set.get_block_mut(*block_id);
|
||||
block.pipelines[0].elements[0] = element;
|
||||
}
|
||||
}
|
||||
}
|
||||
continue;
|
||||
} else if element.has_in_variable(working_set) && !is_subexpression {
|
||||
*element = wrap_element_with_collect(working_set, element);
|
||||
}
|
||||
} else if element.has_in_variable(working_set) && !is_subexpression {
|
||||
*element = wrap_element_with_collect(working_set, element);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pipeline
|
||||
}
|
||||
}
|
||||
|
||||
@ -5757,19 +5701,7 @@ pub fn parse_block(
|
||||
// that share the same block can see each other
|
||||
for pipeline in &lite_block.block {
|
||||
if pipeline.commands.len() == 1 {
|
||||
match &pipeline.commands[0] {
|
||||
LiteElement::Command(_, command)
|
||||
| LiteElement::ErrPipedCommand(_, command)
|
||||
| LiteElement::OutErrPipedCommand(_, command)
|
||||
| LiteElement::Redirection(_, _, command, _)
|
||||
| LiteElement::SeparateRedirection {
|
||||
out: (_, command, _),
|
||||
..
|
||||
}
|
||||
| LiteElement::SameTargetRedirection {
|
||||
cmd: (_, command), ..
|
||||
} => parse_def_predecl(working_set, &command.parts),
|
||||
}
|
||||
parse_def_predecl(working_set, &pipeline.commands[0].parts)
|
||||
}
|
||||
}
|
||||
|
||||
@ -5852,32 +5784,27 @@ pub fn discover_captures_in_pipeline_element(
|
||||
seen_blocks: &mut HashMap<BlockId, Vec<(VarId, Span)>>,
|
||||
output: &mut Vec<(VarId, Span)>,
|
||||
) -> Result<(), ParseError> {
|
||||
match element {
|
||||
PipelineElement::Expression(_, expression)
|
||||
| PipelineElement::ErrPipedExpression(_, expression)
|
||||
| PipelineElement::OutErrPipedExpression(_, expression)
|
||||
| PipelineElement::Redirection(_, _, expression, _)
|
||||
| PipelineElement::And(_, expression)
|
||||
| PipelineElement::Or(_, expression) => {
|
||||
discover_captures_in_expr(working_set, expression, seen, seen_blocks, output)
|
||||
}
|
||||
PipelineElement::SeparateRedirection {
|
||||
out: (_, out_expr, _),
|
||||
err: (_, err_expr, _),
|
||||
} => {
|
||||
discover_captures_in_expr(working_set, out_expr, seen, seen_blocks, output)?;
|
||||
discover_captures_in_expr(working_set, err_expr, seen, seen_blocks, output)?;
|
||||
Ok(())
|
||||
}
|
||||
PipelineElement::SameTargetRedirection {
|
||||
cmd: (_, cmd_expr),
|
||||
redirection: (_, redirect_expr, _),
|
||||
} => {
|
||||
discover_captures_in_expr(working_set, cmd_expr, seen, seen_blocks, output)?;
|
||||
discover_captures_in_expr(working_set, redirect_expr, seen, seen_blocks, output)?;
|
||||
Ok(())
|
||||
discover_captures_in_expr(working_set, &element.expr, seen, seen_blocks, output)?;
|
||||
|
||||
if let Some(redirection) = element.redirection.as_ref() {
|
||||
match redirection {
|
||||
PipelineRedirection::Single { target, .. } => {
|
||||
if let Some(expr) = target.expr() {
|
||||
discover_captures_in_expr(working_set, expr, seen, seen_blocks, output)?;
|
||||
}
|
||||
}
|
||||
PipelineRedirection::Separate { out, err } => {
|
||||
if let Some(expr) = out.expr() {
|
||||
discover_captures_in_expr(working_set, expr, seen, seen_blocks, output)?;
|
||||
}
|
||||
if let Some(expr) = err.expr() {
|
||||
discover_captures_in_expr(working_set, expr, seen, seen_blocks, output)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn discover_captures_in_pattern(pattern: &MatchPattern, seen: &mut Vec<VarId>) {
|
||||
@ -6043,7 +5970,7 @@ pub fn discover_captures_in_expr(
|
||||
}
|
||||
Expr::CellPath(_) => {}
|
||||
Expr::DateTime(_) => {}
|
||||
Expr::ExternalCall(head, args, _) => {
|
||||
Expr::ExternalCall(head, args) => {
|
||||
discover_captures_in_expr(working_set, head, seen, seen_blocks, output)?;
|
||||
|
||||
for ExternalArgument::Regular(expr) | ExternalArgument::Spread(expr) in args {
|
||||
@ -6193,66 +6120,37 @@ pub fn discover_captures_in_expr(
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn wrap_redirection_with_collect(
|
||||
working_set: &mut StateWorkingSet,
|
||||
target: &RedirectionTarget,
|
||||
) -> RedirectionTarget {
|
||||
match target {
|
||||
RedirectionTarget::File { expr, append, span } => RedirectionTarget::File {
|
||||
expr: wrap_expr_with_collect(working_set, expr),
|
||||
span: *span,
|
||||
append: *append,
|
||||
},
|
||||
RedirectionTarget::Pipe { span } => RedirectionTarget::Pipe { span: *span },
|
||||
}
|
||||
}
|
||||
|
||||
fn wrap_element_with_collect(
|
||||
working_set: &mut StateWorkingSet,
|
||||
element: &PipelineElement,
|
||||
) -> PipelineElement {
|
||||
match element {
|
||||
PipelineElement::Expression(span, expression) => {
|
||||
PipelineElement::Expression(*span, wrap_expr_with_collect(working_set, expression))
|
||||
}
|
||||
PipelineElement::ErrPipedExpression(span, expression) => {
|
||||
PipelineElement::ErrPipedExpression(
|
||||
*span,
|
||||
wrap_expr_with_collect(working_set, expression),
|
||||
)
|
||||
}
|
||||
PipelineElement::OutErrPipedExpression(span, expression) => {
|
||||
PipelineElement::OutErrPipedExpression(
|
||||
*span,
|
||||
wrap_expr_with_collect(working_set, expression),
|
||||
)
|
||||
}
|
||||
PipelineElement::Redirection(span, redirection, expression, is_append_mode) => {
|
||||
PipelineElement::Redirection(
|
||||
*span,
|
||||
redirection.clone(),
|
||||
wrap_expr_with_collect(working_set, expression),
|
||||
*is_append_mode,
|
||||
)
|
||||
}
|
||||
PipelineElement::SeparateRedirection {
|
||||
out: (out_span, out_exp, out_append_mode),
|
||||
err: (err_span, err_exp, err_append_mode),
|
||||
} => PipelineElement::SeparateRedirection {
|
||||
out: (
|
||||
*out_span,
|
||||
wrap_expr_with_collect(working_set, out_exp),
|
||||
*out_append_mode,
|
||||
),
|
||||
err: (
|
||||
*err_span,
|
||||
wrap_expr_with_collect(working_set, err_exp),
|
||||
*err_append_mode,
|
||||
),
|
||||
},
|
||||
PipelineElement::SameTargetRedirection {
|
||||
cmd: (cmd_span, cmd_exp),
|
||||
redirection: (redirect_span, redirect_exp, is_append_mode),
|
||||
} => PipelineElement::SameTargetRedirection {
|
||||
cmd: (*cmd_span, wrap_expr_with_collect(working_set, cmd_exp)),
|
||||
redirection: (
|
||||
*redirect_span,
|
||||
wrap_expr_with_collect(working_set, redirect_exp),
|
||||
*is_append_mode,
|
||||
),
|
||||
},
|
||||
PipelineElement::And(span, expression) => {
|
||||
PipelineElement::And(*span, wrap_expr_with_collect(working_set, expression))
|
||||
}
|
||||
PipelineElement::Or(span, expression) => {
|
||||
PipelineElement::Or(*span, wrap_expr_with_collect(working_set, expression))
|
||||
}
|
||||
PipelineElement {
|
||||
pipe: element.pipe,
|
||||
expr: wrap_expr_with_collect(working_set, &element.expr),
|
||||
redirection: element.redirection.as_ref().map(|r| match r {
|
||||
PipelineRedirection::Single { source, target } => PipelineRedirection::Single {
|
||||
source: *source,
|
||||
target: wrap_redirection_with_collect(working_set, target),
|
||||
},
|
||||
PipelineRedirection::Separate { out, err } => PipelineRedirection::Separate {
|
||||
out: wrap_redirection_with_collect(working_set, out),
|
||||
err: wrap_redirection_with_collect(working_set, err),
|
||||
},
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
@ -6304,8 +6202,6 @@ fn wrap_expr_with_collect(working_set: &mut StateWorkingSet, expr: &Expression)
|
||||
head: Span::new(0, 0),
|
||||
arguments: output,
|
||||
decl_id,
|
||||
redirect_stdout: true,
|
||||
redirect_stderr: false,
|
||||
parser_info: HashMap::new(),
|
||||
})),
|
||||
span,
|
||||
|
||||
Reference in New Issue
Block a user