Public/nushell
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
400a9d3b1e
nushell/crates/nu-parser/src/parse_keywords.rs
StevenDoesStuffs 400a9d3b1e
Allow NU_LIBS_DIR and friends to be const (#8310) 
# Description

Allow NU_LIBS_DIR and friends to be const they can be updated within the
same parse pass. This will allow us to remove having multiple config
files eventually.

Small implementation detail: I've changed `call.parser_info` to a
hashmap with string keys, so the information can have names rather than
indices, and we don't have to worry too much about the order in which we
put things into it.

Closes https://github.com/nushell/nushell/issues/8422

# User-Facing Changes

In a single file, users can now do stuff like
```
const NU_LIBS_DIR = ['/some/path/here']
source script.nu
```
and the source statement will use the value of NU_LIBS_DIR declared the
line before.

Currently, if there is no `NU_LIBS_DIR` const, then we fallback to using
the value of the `NU_LIBS_DIR` env-var, so there are no breaking changes
(unless someone named a const NU_LIBS_DIR for some reason).


![2023-03-04-014103_hyprshot](https://user-images.githubusercontent.com/13265529/222885263-135cdd0d-7884-438b-b2ed-c3979fa44463.png)

# Tests + Formatting

~~TODO: write tests~~ Done

# After Submitting

~~TODO: update docs~~ Will do when we update default_env.nu/merge
default_env.nu into default_config.nu.
2023-03-17 07:23:29 -05:00

3938 lines
135 KiB
Rust
Raw Blame History

use log::trace;
use nu_engine::get_dirs_var_from_call;
use nu_path::canonicalize_with;
use nu_protocol::{
ast::{
Argument, Block, Call, Expr, Expression, ImportPattern, ImportPatternHead,
ImportPatternMember, PathMember, Pipeline, PipelineElement,
},
engine::{StateWorkingSet, DEFAULT_OVERLAY_NAME},
span, Alias, BlockId, Exportable, Module, PositionalArg, Span, Spanned, SyntaxShape, Type,
VarId,
};
use std::collections::{HashMap, HashSet};
use std::path::{Path, PathBuf};
pub const LIB_DIRS_VAR: &str = "NU_LIB_DIRS";
#[cfg(feature = "plugin")]
pub const PLUGIN_DIRS_VAR: &str = "NU_PLUGIN_DIRS";
use crate::{
eval::{eval_constant, value_as_string},
known_external::KnownExternal,
lex,
lite_parser::{lite_parse, LiteCommand, LiteElement},
parser::{
check_call, check_name, garbage, garbage_pipeline, parse, parse_call, parse_import_pattern,
parse_internal_call, parse_multispan_value, parse_signature, parse_string, parse_value,
parse_var_with_opt_type, trim_quotes, ParsedInternalCall,
},
unescape_unquote_string, ParseError, Token, TokenContents,
};
/// These parser keywords can be aliased
pub const ALIASABLE_PARSER_KEYWORDS: &[&[u8]] = &[b"overlay hide", b"overlay new", b"overlay use"];
/// These parser keywords cannot be aliased (either not possible, or support not yet added)
pub const UNALIASABLE_PARSER_KEYWORDS: &[&[u8]] = &[
b"export",
b"def",
b"export def",
b"for",
b"extern",
b"export extern",
b"alias",
b"export alias",
b"export-env",
b"module",
b"use",
b"export use",
b"hide",
// b"overlay",
// b"overlay hide",
// b"overlay new",
// b"overlay use",
b"let",
b"const",
b"mut",
b"source",
b"where",
b"register",
];
/// Check whether spans start with a parser keyword that can be aliased
pub fn is_unaliasable_parser_keyword(working_set: &StateWorkingSet, spans: &[Span]) -> bool {
// try two words
if let (Some(span1), Some(span2)) = (spans.get(0), spans.get(1)) {
let cmd_name = working_set.get_span_contents(span(&[*span1, *span2]));
return UNALIASABLE_PARSER_KEYWORDS.contains(&cmd_name);
}
// try one word
if let Some(span1) = spans.get(0) {
let cmd_name = working_set.get_span_contents(*span1);
UNALIASABLE_PARSER_KEYWORDS.contains(&cmd_name)
} else {
false
}
}
/// This is a new more compact method of calling parse_xxx() functions without repeating the
/// parse_call() in each function. Remaining keywords can be moved here.
pub fn parse_keyword(
working_set: &mut StateWorkingSet,
lite_command: &LiteCommand,
expand_aliases_denylist: &[usize],
is_subexpression: bool,
) -> (Pipeline, Option<ParseError>) {
let (call_expr, err) = parse_call(
working_set,
&lite_command.parts,
lite_command.parts[0],
expand_aliases_denylist,
is_subexpression,
);
if err.is_some() {
return (Pipeline::from_vec(vec![call_expr]), err);
}
if let Expression {
expr: Expr::Call(call),
..
} = call_expr.clone()
{
// Apply parse keyword side effects
let cmd = working_set.get_decl(call.decl_id);
match cmd.name() {
"overlay hide" => parse_overlay_hide(working_set, call),
"overlay new" => parse_overlay_new(working_set, call),
"overlay use" => parse_overlay_use(working_set, call, expand_aliases_denylist),
_ => (Pipeline::from_vec(vec![call_expr]), err),
}
} else {
(Pipeline::from_vec(vec![call_expr]), err)
}
}
pub fn parse_def_predecl(
working_set: &mut StateWorkingSet,
spans: &[Span],
expand_aliases_denylist: &[usize],
) -> Option<ParseError> {
let name = working_set.get_span_contents(spans[0]);
// handle "export def" same as "def"
let (name, spans) = if name == b"export" && spans.len() >= 2 {
(working_set.get_span_contents(spans[1]), &spans[1..])
} else {
(name, spans)
};
if (name == b"def" || name == b"def-env") && spans.len() >= 4 {
let (name_expr, ..) = parse_string(working_set, spans[1], expand_aliases_denylist);
let name = name_expr.as_string();
working_set.enter_scope();
// FIXME: because parse_signature will update the scope with the variables it sees
// we end up parsing the signature twice per def. The first time is during the predecl
// so that we can see the types that are part of the signature, which we need for parsing.
// The second time is when we actually parse the body itworking_set.
// We can't reuse the first time because the variables that are created during parse_signature
// are lost when we exit the scope below.
let (sig, ..) = parse_signature(working_set, spans[2], expand_aliases_denylist);
let signature = sig.as_signature();
working_set.exit_scope();
if let (Some(name), Some(mut signature)) = (name, signature) {
if name.contains('#')
|| name.contains('^')
|| name.parse::<bytesize::ByteSize>().is_ok()
|| name.parse::<f64>().is_ok()
{
return Some(ParseError::CommandDefNotValid(spans[1]));
}
signature.name = name;
let decl = signature.predeclare();
if working_set.add_predecl(decl).is_some() {
return Some(ParseError::DuplicateCommandDef(spans[1]));
}
}
} else if name == b"extern" && spans.len() == 3 {
let (name_expr, ..) = parse_string(working_set, spans[1], expand_aliases_denylist);
let name = name_expr.as_string();
working_set.enter_scope();
// FIXME: because parse_signature will update the scope with the variables it sees
// we end up parsing the signature twice per def. The first time is during the predecl
// so that we can see the types that are part of the signature, which we need for parsing.
// The second time is when we actually parse the body itworking_set.
// We can't reuse the first time because the variables that are created during parse_signature
// are lost when we exit the scope below.
let (sig, ..) = parse_signature(working_set, spans[2], expand_aliases_denylist);
let signature = sig.as_signature();
working_set.exit_scope();
if let (Some(name), Some(mut signature)) = (name, signature) {
if name.contains('#')
|| name.parse::<bytesize::ByteSize>().is_ok()
|| name.parse::<f64>().is_ok()
{
return Some(ParseError::CommandDefNotValid(spans[1]));
}
signature.name = name.clone();
//let decl = signature.predeclare();
let decl = KnownExternal {
name,
usage: "run external command".into(),
signature,
};
if working_set.add_predecl(Box::new(decl)).is_some() {
return Some(ParseError::DuplicateCommandDef(spans[1]));
}
}
} else if name == b"alias" && spans.len() >= 4 {
let (name_expr, ..) = parse_string(working_set, spans[1], expand_aliases_denylist);
let name = name_expr.as_string();
if let Some(name) = name {
if name.contains('#')
|| name.contains('^')
|| name.parse::<bytesize::ByteSize>().is_ok()
|| name.parse::<f64>().is_ok()
{
return Some(ParseError::CommandDefNotValid(spans[1]));
}
// The signature will get replaced by the replacement signature
// let mut signature = Signature::new(name.clone());
// signature.name = name;
// The fields get replaced during parsing
let decl = Alias {
name,
command: None,
wrapped_call: Expression::garbage(name_expr.span),
};
if working_set.add_predecl(Box::new(decl)).is_some() {
return Some(ParseError::DuplicateCommandDef(spans[1]));
}
}
}
None
}
pub fn parse_for(
working_set: &mut StateWorkingSet,
spans: &[Span],
expand_aliases_denylist: &[usize],
) -> (Expression, Option<ParseError>) {
// Checking that the function is used with the correct name
// Maybe this is not necessary but it is a sanity check
if working_set.get_span_contents(spans[0]) != b"for" {
return (
garbage(spans[0]),
Some(ParseError::UnknownState(
"internal error: Wrong call name for 'for' function".into(),
span(spans),
)),
);
}
// Parsing the spans and checking that they match the register signature
// Using a parsed call makes more sense than checking for how many spans are in the call
// Also, by creating a call, it can be checked if it matches the declaration signature
let (call, call_span) = match working_set.find_decl(b"for", &Type::Any) {
None => {
return (
garbage(spans[0]),
Some(ParseError::UnknownState(
"internal error: for declaration not found".into(),
span(spans),
)),
)
}
Some(decl_id) => {
working_set.enter_scope();
let ParsedInternalCall {
call,
error: mut err,
output,
} = parse_internal_call(
working_set,
spans[0],
&spans[1..],
decl_id,
expand_aliases_denylist,
);
working_set.exit_scope();
let call_span = span(spans);
let decl = working_set.get_decl(decl_id);
let sig = decl.signature();
// Let's get our block and make sure it has the right signature
if let Some(arg) = call.positional_nth(2) {
match arg {
Expression {
expr: Expr::Block(block_id),
..
}
| Expression {
expr: Expr::RowCondition(block_id),
..
} => {
let block = working_set.get_block_mut(*block_id);
block.signature = Box::new(sig.clone());
}
_ => {}
}
}
err = check_call(call_span, &sig, &call).or(err);
if err.is_some() || call.has_flag("help") {
return (
Expression {
expr: Expr::Call(call),
span: call_span,
ty: output,
custom_completion: None,
},
err,
);
}
(call, call_span)
}
};
// All positional arguments must be in the call positional vector by this point
let var_decl = call.positional_nth(0).expect("for call already checked");
let block = call.positional_nth(2).expect("for call already checked");
let error = None;
if let (Some(var_id), Some(block_id)) = (&var_decl.as_var(), block.as_block()) {
let block = working_set.get_block_mut(block_id);
block.signature.required_positional.insert(
0,
PositionalArg {
name: String::new(),
desc: String::new(),
shape: SyntaxShape::Any,
var_id: Some(*var_id),
default_value: None,
},
);
}
(
Expression {
expr: Expr::Call(call),
span: call_span,
ty: Type::Any,
custom_completion: None,
},
error,
)
}
pub fn parse_def(
working_set: &mut StateWorkingSet,
lite_command: &LiteCommand,
module_name: Option<&[u8]>,
expand_aliases_denylist: &[usize],
) -> (Pipeline, Option<ParseError>) {
let spans = &lite_command.parts[..];
let (usage, extra_usage) = working_set.build_usage(&lite_command.comments);
// Checking that the function is used with the correct name
// Maybe this is not necessary but it is a sanity check
// Note: "export def" is treated the same as "def"
let (name_span, split_id) =
if spans.len() > 1 && working_set.get_span_contents(spans[0]) == b"export" {
(spans[1], 2)
} else {
(spans[0], 1)
};
let def_call = working_set.get_span_contents(name_span).to_vec();
if def_call != b"def" && def_call != b"def-env" {
return (
garbage_pipeline(spans),
Some(ParseError::UnknownState(
"internal error: Wrong call name for def function".into(),
span(spans),
)),
);
}
// Parsing the spans and checking that they match the register signature
// Using a parsed call makes more sense than checking for how many spans are in the call
// Also, by creating a call, it can be checked if it matches the declaration signature
let (call, call_span) = match working_set.find_decl(&def_call, &Type::Any) {
None => {
return (
garbage_pipeline(spans),
Some(ParseError::UnknownState(
"internal error: def declaration not found".into(),
span(spans),
)),
)
}
Some(decl_id) => {
working_set.enter_scope();
let (command_spans, rest_spans) = spans.split_at(split_id);
let ParsedInternalCall {
call,
error: mut err,
output,
} = parse_internal_call(
working_set,
span(command_spans),
rest_spans,
decl_id,
expand_aliases_denylist,
);
working_set.exit_scope();
let call_span = span(spans);
let decl = working_set.get_decl(decl_id);
let sig = decl.signature();
// Let's get our block and make sure it has the right signature
if let Some(arg) = call.positional_nth(2) {
match arg {
Expression {
expr: Expr::Block(block_id),
..
}
| Expression {
expr: Expr::RowCondition(block_id),
..
} => {
let block = working_set.get_block_mut(*block_id);
block.signature = Box::new(sig.clone());
}
_ => {}
}
}
err = check_call(call_span, &sig, &call).or(err);
if err.is_some() || call.has_flag("help") {
return (
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: call_span,
ty: output,
custom_completion: None,
}]),
err,
);
}
(call, call_span)
}
};
// All positional arguments must be in the call positional vector by this point
let name_expr = call.positional_nth(0).expect("def call already checked");
let sig = call.positional_nth(1).expect("def call already checked");
let block = call.positional_nth(2).expect("def call already checked");
let mut error = None;
let name = if let Some(name) = name_expr.as_string() {
if let Some(mod_name) = module_name {
if name.as_bytes() == mod_name {
let name_expr_span = name_expr.span;
return (
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: call_span,
ty: Type::Any,
custom_completion: None,
}]),
Some(ParseError::NamedAsModule(
"command".to_string(),
name,
name_expr_span,
)),
);
}
}
name
} else {
return (
garbage_pipeline(spans),
Some(ParseError::UnknownState(
"Could not get string from string expression".into(),
name_expr.span,
)),
);
};
if let (Some(mut signature), Some(block_id)) = (sig.as_signature(), block.as_block()) {
if let Some(decl_id) = working_set.find_predecl(name.as_bytes()) {
let declaration = working_set.get_decl_mut(decl_id);
signature.name = name.clone();
*signature = signature.add_help();
signature.usage = usage;
signature.extra_usage = extra_usage;
*declaration = signature.clone().into_block_command(block_id);
let mut block = working_set.get_block_mut(block_id);
let calls_itself = block.pipelines.iter().any(|pipeline| {
pipeline
.elements
.iter()
.any(|pipe_element| match pipe_element {
PipelineElement::Expression(
_,
Expression {
expr: Expr::Call(call_expr),
..
},
) => {
if call_expr.decl_id == decl_id {
return true;
}
call_expr.arguments.iter().any(|arg| match arg {
Argument::Positional(Expression { expr, .. }) => match expr {
Expr::Keyword(.., expr) => {
let expr = expr.as_ref();
let Expression { expr, .. } = expr;
match expr {
Expr::Call(call_expr2) => call_expr2.decl_id == decl_id,
_ => false,
}
}
Expr::Call(call_expr2) => call_expr2.decl_id == decl_id,
_ => false,
},
_ => false,
})
}
_ => false,
})
});
block.recursive = Some(calls_itself);
block.signature = signature;
block.redirect_env = def_call == b"def-env";
} else {
error = error.or_else(|| {
Some(ParseError::InternalError(
"Predeclaration failed to add declaration".into(),
name_expr.span,
))
});
};
}
// It's OK if it returns None: The decl was already merged in previous parse pass.
working_set.merge_predecl(name.as_bytes());
(
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: call_span,
ty: Type::Any,
custom_completion: None,
}]),
error,
)
}
pub fn parse_extern(
working_set: &mut StateWorkingSet,
lite_command: &LiteCommand,
module_name: Option<&[u8]>,
expand_aliases_denylist: &[usize],
) -> (Pipeline, Option<ParseError>) {
let spans = &lite_command.parts;
let mut error = None;
let (usage, extra_usage) = working_set.build_usage(&lite_command.comments);
// Checking that the function is used with the correct name
// Maybe this is not necessary but it is a sanity check
let (name_span, split_id) =
if spans.len() > 1 && working_set.get_span_contents(spans[0]) == b"export" {
(spans[1], 2)
} else {
(spans[0], 1)
};
let extern_call = working_set.get_span_contents(name_span).to_vec();
if extern_call != b"extern" {
return (
garbage_pipeline(spans),
Some(ParseError::UnknownState(
"internal error: Wrong call name for extern function".into(),
span(spans),
)),
);
}
// Parsing the spans and checking that they match the register signature
// Using a parsed call makes more sense than checking for how many spans are in the call
// Also, by creating a call, it can be checked if it matches the declaration signature
let (call, call_span) = match working_set.find_decl(&extern_call, &Type::Any) {
None => {
return (
garbage_pipeline(spans),
Some(ParseError::UnknownState(
"internal error: def declaration not found".into(),
span(spans),
)),
)
}
Some(decl_id) => {
working_set.enter_scope();
let (command_spans, rest_spans) = spans.split_at(split_id);
let ParsedInternalCall {
call, error: err, ..
} = parse_internal_call(
working_set,
span(command_spans),
rest_spans,
decl_id,
expand_aliases_denylist,
);
working_set.exit_scope();
error = error.or(err);
let call_span = span(spans);
//let decl = working_set.get_decl(decl_id);
//let sig = decl.signature();
(call, call_span)
}
};
let name_expr = call.positional_nth(0);
let sig = call.positional_nth(1);
if let (Some(name_expr), Some(sig)) = (name_expr, sig) {
if let (Some(name), Some(mut signature)) = (&name_expr.as_string(), sig.as_signature()) {
if let Some(mod_name) = module_name {
if name.as_bytes() == mod_name {
let name_expr_span = name_expr.span;
return (
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: call_span,
ty: Type::Any,
custom_completion: None,
}]),
Some(ParseError::NamedAsModule(
"known external".to_string(),
name.clone(),
name_expr_span,
)),
);
}
}
if let Some(decl_id) = working_set.find_predecl(name.as_bytes()) {
let declaration = working_set.get_decl_mut(decl_id);
let external_name = if let Some(mod_name) = module_name {
if name.as_bytes() == b"main" {
String::from_utf8_lossy(mod_name).to_string()
} else {
name.clone()
}
} else {
name.clone()
};
signature.name = external_name.clone();
signature.usage = usage.clone();
signature.extra_usage = extra_usage.clone();
signature.allows_unknown_args = true;
let decl = KnownExternal {
name: external_name,
usage: [usage, extra_usage].join("\n"),
signature,
};
*declaration = Box::new(decl);
} else {
error = error.or_else(|| {
Some(ParseError::InternalError(
"Predeclaration failed to add declaration".into(),
spans[split_id],
))
});
};
}
if let Some(name) = name_expr.as_string() {
// It's OK if it returns None: The decl was already merged in previous parse pass.
working_set.merge_predecl(name.as_bytes());
} else {
error = error.or_else(|| {
Some(ParseError::UnknownState(
"Could not get string from string expression".into(),
name_expr.span,
))
});
}
}
(
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: call_span,
ty: Type::Any,
custom_completion: None,
}]),
error,
)
}
pub fn parse_alias(
working_set: &mut StateWorkingSet,
lite_command: &LiteCommand,
module_name: Option<&[u8]>,
expand_aliases_denylist: &[usize],
) -> (Pipeline, Option<ParseError>) {
let spans = &lite_command.parts;
let (name_span, split_id) =
if spans.len() > 1 && working_set.get_span_contents(spans[0]) == b"export" {
(spans[1], 2)
} else {
(spans[0], 1)
};
let name = working_set.get_span_contents(name_span);
if name != b"alias" {
return (
garbage_pipeline(spans),
Some(ParseError::InternalError(
"Alias statement unparsable".into(),
span(spans),
)),
);
}
if let Some((span, err)) = check_name(working_set, spans) {
return (Pipeline::from_vec(vec![garbage(*span)]), Some(err));
}
if let Some(decl_id) = working_set.find_decl(b"alias", &Type::Any) {
let (command_spans, rest_spans) = spans.split_at(split_id);
let ParsedInternalCall {
call: alias_call,
output,
..
} = parse_internal_call(
working_set,
span(command_spans),
rest_spans,
decl_id,
expand_aliases_denylist,
);
let has_help_flag = alias_call.has_flag("help");
let alias_pipeline = Pipeline::from_vec(vec![Expression {
expr: Expr::Call(alias_call),
span: span(spans),
ty: output,
custom_completion: None,
}]);
if has_help_flag {
return (alias_pipeline, None);
}
if spans.len() >= split_id + 3 {
let alias_name = working_set.get_span_contents(spans[split_id]);
let alias_name = if alias_name.starts_with(b"\"")
&& alias_name.ends_with(b"\"")
&& alias_name.len() > 1
{
alias_name[1..(alias_name.len() - 1)].to_vec()
} else {
alias_name.to_vec()
};
if let Some(mod_name) = module_name {
if alias_name == mod_name {
return (
alias_pipeline,
Some(ParseError::NamedAsModule(
"alias".to_string(),
String::from_utf8_lossy(&alias_name).to_string(),
spans[split_id],
)),
);
}
if &alias_name == b"main" {
return (
alias_pipeline,
Some(ParseError::ExportMainAliasNotAllowed(spans[split_id])),
);
}
}
let _equals = working_set.get_span_contents(spans[split_id + 1]);
let replacement_spans = &spans[(split_id + 2)..];
// Temporarily hide the alias itself to prevent recursion
let predecl_id = working_set
.delta
.last_scope_frame_mut()
.predecls
.remove(&alias_name);
let (expr, err) = parse_call(
working_set,
replacement_spans,
replacement_spans[0],
expand_aliases_denylist,
false, // TODO: Should this be set properly???
);
if let Some(id) = predecl_id {
working_set
.delta
.last_scope_frame_mut()
.predecls
.insert(alias_name.to_vec(), id);
}
if let Some(e) = err {
if let ParseError::MissingPositional(..) = e {
// ignore missing required positional
} else {
return (garbage_pipeline(replacement_spans), Some(e));
}
}
let (command, wrapped_call) = match expr {
Expression {
expr: Expr::Call(ref rhs_call),
..
} => {
let cmd = working_set.get_decl(rhs_call.decl_id);
if cmd.is_parser_keyword()
&& !ALIASABLE_PARSER_KEYWORDS.contains(&cmd.name().as_bytes())
{
return (
alias_pipeline,
Some(ParseError::CantAliasKeyword(
ALIASABLE_PARSER_KEYWORDS
.iter()
.map(|bytes| String::from_utf8_lossy(bytes).to_string())
.collect::<Vec<String>>()
.join(", "),
rhs_call.head,
)),
);
}
(Some(cmd.clone_box()), expr)
}
Expression {
expr: Expr::ExternalCall(..),
..
} => (None, expr),
_ => {
return (
alias_pipeline,
Some(ParseError::InternalError(
"Parsed call not a call".into(),
expr.span,
)),
)
}
};
if let Some(decl_id) = working_set.find_predecl(&alias_name) {
let alias_decl = working_set.get_decl_mut(decl_id);
let alias = Alias {
name: String::from_utf8_lossy(&alias_name).to_string(),
command,
wrapped_call,
};
*alias_decl = Box::new(alias);
} else {
return (
garbage_pipeline(spans),
Some(ParseError::InternalError(
"Predeclaration failed to add declaration".into(),
spans[split_id],
)),
);
}
// It's OK if it returns None: The decl was already merged in previous parse pass.
working_set.merge_predecl(&alias_name);
}
let err = if spans.len() < 4 {
Some(ParseError::IncorrectValue(
"Incomplete alias".into(),
span(&spans[..split_id]),
"incomplete alias".into(),
))
} else {
None
};
return (alias_pipeline, err);
}
(
garbage_pipeline(spans),
Some(ParseError::InternalError(
"Alias statement unparsable".into(),
span(spans),
)),
)
}
pub fn parse_old_alias(
working_set: &mut StateWorkingSet,
lite_command: &LiteCommand,
module_name: Option<&[u8]>,
expand_aliases_denylist: &[usize],
) -> (Pipeline, Option<ParseError>) {
let spans = &lite_command.parts;
// if the call is "alias", turn it into "print $nu.scope.aliases"
if spans.len() == 1 {
let head = Expression {
expr: Expr::Var(nu_protocol::NU_VARIABLE_ID),
span: Span::new(0, 0),
ty: Type::Any,
custom_completion: None,
};
let tail = vec![
PathMember::String {
val: "scope".to_string(),
span: Span::new(0, 0),
optional: false,
},
PathMember::String {
val: "aliases".to_string(),
span: Span::new(0, 0),
optional: false,
},
];
let expr = Expression {
ty: Type::Any,
expr: Expr::FullCellPath(Box::new(nu_protocol::ast::FullCellPath { head, tail })),
span: Span::new(0, 0),
custom_completion: None,
};
if let Some(decl_id) = working_set.find_decl(b"print", &Type::Any) {
let print_call = Expr::Call(Box::new(Call {
head: spans[0],
arguments: vec![Argument::Positional(expr)],
decl_id,
redirect_stdout: true,
redirect_stderr: false,
parser_info: HashMap::new(),
}));
return (
Pipeline::from_vec(vec![Expression {
expr: print_call,
span: spans[0],
ty: Type::Any,
custom_completion: None,
}]),
None,
);
}
return (Pipeline::from_vec(vec![expr]), None);
}
let (name_span, split_id) =
if spans.len() > 1 && working_set.get_span_contents(spans[0]) == b"export" {
(spans[1], 2)
} else {
(spans[0], 1)
};
let name = working_set.get_span_contents(name_span);
if name == b"old-alias" {
if let Some((span, err)) = check_name(working_set, spans) {
return (Pipeline::from_vec(vec![garbage(*span)]), Some(err));
}
if let Some(decl_id) = working_set.find_decl(b"alias", &Type::Any) {
let (command_spans, rest_spans) = spans.split_at(split_id);
let ParsedInternalCall { call, output, .. } = parse_internal_call(
working_set,
span(command_spans),
rest_spans,
decl_id,
expand_aliases_denylist,
);
if call.has_flag("help") {
return (
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: span(spans),
ty: output,
custom_completion: None,
}]),
None,
);
}
if spans.len() >= split_id + 3 {
let alias_name = working_set.get_span_contents(spans[split_id]);
let alias_name = if alias_name.starts_with(b"\"")
&& alias_name.ends_with(b"\"")
&& alias_name.len() > 1
{
alias_name[1..(alias_name.len() - 1)].to_vec()
} else {
alias_name.to_vec()
};
if let Some(mod_name) = module_name {
if alias_name == mod_name {
return (
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: span(spans),
ty: output,
custom_completion: None,
}]),
Some(ParseError::NamedAsModule(
"alias".to_string(),
String::from_utf8_lossy(&alias_name).to_string(),
spans[split_id],
)),
);
}
if &alias_name == b"main" {
return (
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: span(spans),
ty: output,
custom_completion: None,
}]),
Some(ParseError::ExportMainAliasNotAllowed(spans[split_id])),
);
}
}
let _equals = working_set.get_span_contents(spans[split_id + 1]);
let replacement = spans[(split_id + 2)..].to_vec();
let checked_name = String::from_utf8_lossy(&alias_name);
if checked_name.contains('#')
|| checked_name.contains('^')
|| checked_name.parse::<bytesize::ByteSize>().is_ok()
|| checked_name.parse::<f64>().is_ok()
{
return (
Pipeline::from_vec(vec![garbage(name_span)]),
Some(ParseError::AliasNotValid(name_span)),
);
}
working_set.add_alias(alias_name, replacement, lite_command.comments.clone());
}
let err = if spans.len() < 4 {
Some(ParseError::IncorrectValue(
"Incomplete alias".into(),
span(&spans[..split_id]),
"incomplete alias".into(),
))
} else {
None
};
return (
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: span(spans),
ty: Type::Any,
custom_completion: None,
}]),
err,
);
}
}
(
garbage_pipeline(spans),
Some(ParseError::InternalError(
"Alias statement unparsable".into(),
span(spans),
)),
)
}
// This one will trigger if `export` appears during eval, e.g., in a script
pub fn parse_export_in_block(
working_set: &mut StateWorkingSet,
lite_command: &LiteCommand,
expand_aliases_denylist: &[usize],
) -> (Pipeline, Option<ParseError>) {
let call_span = span(&lite_command.parts);
let full_name = if lite_command.parts.len() > 1 {
let sub = working_set.get_span_contents(lite_command.parts[1]);
match sub {
b"old-alias" | b"alias" | b"def" | b"def-env" | b"extern" | b"use" => {
[b"export ", sub].concat()
}
_ => b"export".to_vec(),
}
} else {
b"export".to_vec()
};
if let Some(decl_id) = working_set.find_decl(&full_name, &Type::Any) {
let ParsedInternalCall {
call,
error: mut err,
output,
..
} = parse_internal_call(
working_set,
if full_name == b"export" {
lite_command.parts[0]
} else {
span(&lite_command.parts[0..2])
},
if full_name == b"export" {
&lite_command.parts[1..]
} else {
&lite_command.parts[2..]
},
decl_id,
expand_aliases_denylist,
);
let decl = working_set.get_decl(decl_id);
err = check_call(call_span, &decl.signature(), &call).or(err);
if err.is_some() || call.has_flag("help") {
return (
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: call_span,
ty: output,
custom_completion: None,
}]),
err,
);
}
} else {
return (
garbage_pipeline(&lite_command.parts),
Some(ParseError::UnknownState(
format!(
"internal error: '{}' declaration not found",
String::from_utf8_lossy(&full_name)
),
span(&lite_command.parts),
)),
);
};
if &full_name == b"export" {
// export by itself is meaningless
return (
garbage_pipeline(&lite_command.parts),
Some(ParseError::UnexpectedKeyword(
"export".into(),
lite_command.parts[0],
)),
);
}
match full_name.as_slice() {
b"export old-alias" => {
parse_old_alias(working_set, lite_command, None, expand_aliases_denylist)
}
b"export alias" => parse_alias(working_set, lite_command, None, expand_aliases_denylist),
b"export def" | b"export def-env" => {
parse_def(working_set, lite_command, None, expand_aliases_denylist)
}
b"export use" => {
let (pipeline, _, err) =
parse_use(working_set, &lite_command.parts, expand_aliases_denylist);
(pipeline, err)
}
b"export extern" => parse_extern(working_set, lite_command, None, expand_aliases_denylist),
_ => (
garbage_pipeline(&lite_command.parts),
Some(ParseError::UnexpectedKeyword(
String::from_utf8_lossy(&full_name).to_string(),
lite_command.parts[0],
)),
),
}
}
// This one will trigger only in a module
pub fn parse_export_in_module(
working_set: &mut StateWorkingSet,
lite_command: &LiteCommand,
module_name: &[u8],
expand_aliases_denylist: &[usize],
) -> (Pipeline, Vec<Exportable>, Option<ParseError>) {
let spans = &lite_command.parts[..];
let mut error = None;
let export_span = if let Some(sp) = spans.get(0) {
if working_set.get_span_contents(*sp) != b"export" {
return (
garbage_pipeline(spans),
vec![],
Some(ParseError::UnknownState(
"expected export statement".into(),
span(spans),
)),
);
}
*sp
} else {
return (
garbage_pipeline(spans),
vec![],
Some(ParseError::UnknownState(
"got empty input for parsing export statement".into(),
span(spans),
)),
);
};
let export_decl_id = if let Some(id) = working_set.find_decl(b"export", &Type::Any) {
id
} else {
return (
garbage_pipeline(spans),
vec![],
Some(ParseError::InternalError(
"missing export command".into(),
export_span,
)),
);
};
let mut call = Box::new(Call {
head: spans[0],
decl_id: export_decl_id,
arguments: vec![],
redirect_stdout: true,
redirect_stderr: false,
parser_info: HashMap::new(),
});
let exportables = if let Some(kw_span) = spans.get(1) {
let kw_name = working_set.get_span_contents(*kw_span);
match kw_name {
b"def" => {
let lite_command = LiteCommand {
comments: lite_command.comments.clone(),
parts: spans[1..].to_vec(),
};
let (pipeline, err) = parse_def(
working_set,
&lite_command,
Some(module_name),
expand_aliases_denylist,
);
error = error.or(err);
let export_def_decl_id =
if let Some(id) = working_set.find_decl(b"export def", &Type::Any) {
id
} else {
return (
garbage_pipeline(spans),
vec![],
Some(ParseError::InternalError(
"missing 'export def' command".into(),
export_span,
)),
);
};
// Trying to warp the 'def' call into the 'export def' in a very clumsy way
if let Some(PipelineElement::Expression(
_,
Expression {
expr: Expr::Call(ref def_call),
..
},
)) = pipeline.elements.get(0)
{
call = def_call.clone();
call.head = span(&spans[0..=1]);
call.decl_id = export_def_decl_id;
} else {
error = error.or_else(|| {
Some(ParseError::InternalError(
"unexpected output from parsing a definition".into(),
span(&spans[1..]),
))
});
};
let mut result = vec![];
if let Some(decl_name_span) = spans.get(2) {
let decl_name = working_set.get_span_contents(*decl_name_span);
let decl_name = trim_quotes(decl_name);
if let Some(decl_id) = working_set.find_decl(decl_name, &Type::Any) {
result.push(Exportable::Decl {
name: decl_name.to_vec(),
id: decl_id,
});
} else {
error = error.or_else(|| {
Some(ParseError::InternalError(
"failed to find added declaration".into(),
span(&spans[1..]),
))
});
}
}
result
}
b"def-env" => {
let lite_command = LiteCommand {
comments: lite_command.comments.clone(),
parts: spans[1..].to_vec(),
};
let (pipeline, err) = parse_def(
working_set,
&lite_command,
Some(module_name),
expand_aliases_denylist,
);
error = error.or(err);
let export_def_decl_id =
if let Some(id) = working_set.find_decl(b"export def-env", &Type::Any) {
id
} else {
return (
garbage_pipeline(spans),
vec![],
Some(ParseError::InternalError(
"missing 'export def-env' command".into(),
export_span,
)),
);
};
// Trying to warp the 'def' call into the 'export def' in a very clumsy way
if let Some(PipelineElement::Expression(
_,
Expression {
expr: Expr::Call(ref def_call),
..
},
)) = pipeline.elements.get(0)
{
call = def_call.clone();
call.head = span(&spans[0..=1]);
call.decl_id = export_def_decl_id;
} else {
error = error.or_else(|| {
Some(ParseError::InternalError(
"unexpected output from parsing a definition".into(),
span(&spans[1..]),
))
});
};
let mut result = vec![];
let decl_name = match spans.get(2) {
Some(span) => working_set.get_span_contents(*span),
None => &[],
};
let decl_name = trim_quotes(decl_name);
if let Some(decl_id) = working_set.find_decl(decl_name, &Type::Any) {
result.push(Exportable::Decl {
name: decl_name.to_vec(),
id: decl_id,
});
} else {
error = error.or_else(|| {
Some(ParseError::InternalError(
"failed to find added declaration".into(),
span(&spans[1..]),
))
});
}
result
}
b"extern" => {
let lite_command = LiteCommand {
comments: lite_command.comments.clone(),
parts: spans[1..].to_vec(),
};
let (pipeline, err) = parse_extern(
working_set,
&lite_command,
Some(module_name),
expand_aliases_denylist,
);
error = error.or(err);
let export_def_decl_id =
if let Some(id) = working_set.find_decl(b"export extern", &Type::Any) {
id
} else {
return (
garbage_pipeline(spans),
vec![],
Some(ParseError::InternalError(
"missing 'export extern' command".into(),
export_span,
)),
);
};
// Trying to warp the 'def' call into the 'export def' in a very clumsy way
if let Some(PipelineElement::Expression(
_,
Expression {
expr: Expr::Call(ref def_call),
..
},
)) = pipeline.elements.get(0)
{
call = def_call.clone();
call.head = span(&spans[0..=1]);
call.decl_id = export_def_decl_id;
} else {
error = error.or_else(|| {
Some(ParseError::InternalError(
"unexpected output from parsing a definition".into(),
span(&spans[1..]),
))
});
};
let mut result = vec![];
let decl_name = match spans.get(2) {
Some(span) => working_set.get_span_contents(*span),
None => &[],
};
let decl_name = trim_quotes(decl_name);
if let Some(decl_id) = working_set.find_decl(decl_name, &Type::Any) {
result.push(Exportable::Decl {
name: decl_name.to_vec(),
id: decl_id,
});
} else {
error = error.or_else(|| {
Some(ParseError::InternalError(
"failed to find added declaration".into(),
span(&spans[1..]),
))
});
}
result
}
b"old-alias" => {
let lite_command = LiteCommand {
comments: lite_command.comments.clone(),
parts: spans[1..].to_vec(),
};
let (pipeline, err) = parse_old_alias(
working_set,
&lite_command,
Some(module_name),
expand_aliases_denylist,
);
error = error.or(err);
let export_alias_decl_id =
if let Some(id) = working_set.find_decl(b"export old-alias", &Type::Any) {
id
} else {
return (
garbage_pipeline(spans),
vec![],
Some(ParseError::InternalError(
"missing 'export old-alias' command".into(),
export_span,
)),
);
};
// Trying to warp the 'old-alias' call into the 'export old-alias' in a very clumsy way
if let Some(PipelineElement::Expression(
_,
Expression {
expr: Expr::Call(ref alias_call),
..
},
)) = pipeline.elements.get(0)
{
call = alias_call.clone();
call.head = span(&spans[0..=1]);
call.decl_id = export_alias_decl_id;
} else {
error = error.or_else(|| {
Some(ParseError::InternalError(
"unexpected output from parsing a definition".into(),
span(&spans[1..]),
))
});
};
let mut result = vec![];
let alias_name = match spans.get(2) {
Some(span) => working_set.get_span_contents(*span),
None => &[],
};
let alias_name = trim_quotes(alias_name);
if let Some(alias_id) = working_set.find_alias(alias_name) {
result.push(Exportable::Alias {
name: alias_name.to_vec(),
id: alias_id,
});
} else {
error = error.or_else(|| {
Some(ParseError::InternalError(
"failed to find added alias".into(),
span(&spans[1..]),
))
});
}
result
}
b"alias" => {
let lite_command = LiteCommand {
comments: lite_command.comments.clone(),
parts: spans[1..].to_vec(),
};
let (pipeline, err) = parse_alias(
working_set,
&lite_command,
Some(module_name),
expand_aliases_denylist,
);
error = error.or(err);
let export_alias_decl_id =
if let Some(id) = working_set.find_decl(b"export alias", &Type::Any) {
id
} else {
return (
garbage_pipeline(spans),
vec![],
Some(ParseError::InternalError(
"missing 'export alias' command".into(),
export_span,
)),
);
};
// Trying to warp the 'alias' call into the 'export alias' in a very clumsy way
if let Some(PipelineElement::Expression(
_,
Expression {
expr: Expr::Call(ref alias_call),
..
},
)) = pipeline.elements.get(0)
{
call = alias_call.clone();
call.head = span(&spans[0..=1]);
call.decl_id = export_alias_decl_id;
} else {
error = error.or_else(|| {
Some(ParseError::InternalError(
"unexpected output from parsing a definition".into(),
span(&spans[1..]),
))
});
};
let mut result = vec![];
let alias_name = match spans.get(2) {
Some(span) => working_set.get_span_contents(*span),
None => &[],
};
let alias_name = trim_quotes(alias_name);
if let Some(alias_id) = working_set.find_decl(alias_name, &Type::Any) {
result.push(Exportable::Decl {
name: alias_name.to_vec(),
id: alias_id,
});
} else {
error = error.or_else(|| {
Some(ParseError::InternalError(
"failed to find added alias".into(),
span(&spans[1..]),
))
});
}
result
}
b"use" => {
let lite_command = LiteCommand {
comments: lite_command.comments.clone(),
parts: spans[1..].to_vec(),
};
let (pipeline, exportables, err) =
parse_use(working_set, &lite_command.parts, expand_aliases_denylist);
error = error.or(err);
let export_use_decl_id =
if let Some(id) = working_set.find_decl(b"export use", &Type::Any) {
id
} else {
return (
garbage_pipeline(spans),
vec![],
Some(ParseError::InternalError(
"missing 'export use' command".into(),
export_span,
)),
);
};
// Trying to warp the 'use' call into the 'export use' in a very clumsy way
if let Some(PipelineElement::Expression(
_,
Expression {
expr: Expr::Call(ref use_call),
..
},
)) = pipeline.elements.get(0)
{
call = use_call.clone();
call.head = span(&spans[0..=1]);
call.decl_id = export_use_decl_id;
} else {
error = error.or_else(|| {
Some(ParseError::InternalError(
"unexpected output from parsing a definition".into(),
span(&spans[1..]),
))
});
};
exportables
}
_ => {
error = error.or_else(|| {
Some(ParseError::Expected(
// TODO: Fill in more keywords as they come
"def, def-env, alias, use, or env keyword".into(),
spans[1],
))
});
vec![]
}
}
} else {
error = error.or_else(|| {
Some(ParseError::MissingPositional(
"def, def-env, alias, or env keyword".into(), // TODO: keep filling more keywords as they come
Span::new(export_span.end, export_span.end),
"'def', `def-env`, `alias`, or 'env' keyword.".to_string(),
))
});
vec![]
};
(
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: span(spans),
ty: Type::Any,
custom_completion: None,
}]),
exportables,
error,
)
}
pub fn parse_export_env(
working_set: &mut StateWorkingSet,
spans: &[Span],
expand_aliases_denylist: &[usize],
) -> (Pipeline, Option<BlockId>, Option<ParseError>) {
if !spans.is_empty() && working_set.get_span_contents(spans[0]) != b"export-env" {
return (
garbage_pipeline(spans),
None,
Some(ParseError::UnknownState(
"internal error: Wrong call name for 'export-env' command".into(),
span(spans),
)),
);
}
if spans.len() < 2 {
return (
garbage_pipeline(spans),
None,
Some(ParseError::MissingPositional(
"block".into(),
span(spans),
"export-env <block>".into(),
)),
);
}
let call = match working_set.find_decl(b"export-env", &Type::Any) {
Some(decl_id) => {
let ParsedInternalCall {
call,
error: mut err,
output,
} = parse_internal_call(
working_set,
spans[0],
&[spans[1]],
decl_id,
expand_aliases_denylist,
);
let decl = working_set.get_decl(decl_id);
let call_span = span(spans);
err = check_call(call_span, &decl.signature(), &call).or(err);
if err.is_some() || call.has_flag("help") {
return (
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: call_span,
ty: output,
custom_completion: None,
}]),
None,
err,
);
}
call
}
None => {
return (
garbage_pipeline(spans),
None,
Some(ParseError::UnknownState(
"internal error: 'export-env' declaration not found".into(),
span(spans),
)),
)
}
};
let block_id = if let Some(block) = call.positional_nth(0) {
if let Some(block_id) = block.as_block() {
block_id
} else {
return (
garbage_pipeline(spans),
None,
Some(ParseError::UnknownState(
"internal error: 'export-env' block is not a block".into(),
block.span,
)),
);
}
} else {
return (
garbage_pipeline(spans),
None,
Some(ParseError::UnknownState(
"internal error: 'export-env' block is missing".into(),
span(spans),
)),
);
};
let pipeline = Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: span(spans),
ty: Type::Any,
custom_completion: None,
}]);
(pipeline, Some(block_id), None)
}
fn collect_first_comments(tokens: &[Token]) -> Vec<Span> {
let mut comments = vec![];
let mut tokens_iter = tokens.iter().peekable();
while let Some(token) = tokens_iter.next() {
match token.contents {
TokenContents::Comment => {
comments.push(token.span);
}
TokenContents::Eol => {
if let Some(Token {
contents: TokenContents::Eol,
..
}) = tokens_iter.peek()
{
if !comments.is_empty() {
break;
}
}
}
_ => {
comments.clear();
break;
}
}
}
comments
}
pub fn parse_module_block(
working_set: &mut StateWorkingSet,
span: Span,
module_name: &[u8],
expand_aliases_denylist: &[usize],
) -> (Block, Module, Vec<Span>, Option<ParseError>) {
let mut error = None;
working_set.enter_scope();
let source = working_set.get_span_contents(span);
let (output, err) = lex(source, span.start, &[], &[], false);
error = error.or(err);
let module_comments = collect_first_comments(&output);
let (output, err) = lite_parse(&output);
error = error.or(err);
for pipeline in &output.block {
if pipeline.commands.len() == 1 {
if let LiteElement::Command(_, command) = &pipeline.commands[0] {
parse_def_predecl(working_set, &command.parts, expand_aliases_denylist);
}
}
}
let mut module = Module::from_span(module_name.to_vec(), span);
let block: Block = output
.block
.iter()
.map(|pipeline| {
if pipeline.commands.len() == 1 {
match &pipeline.commands[0] {
LiteElement::Command(_, command) => {
let name = working_set.get_span_contents(command.parts[0]);
let (pipeline, err) = match name {
b"def" | b"def-env" => {
let (pipeline, err) = parse_def(
working_set,
command,
None, // using commands named as the module locally is OK
expand_aliases_denylist,
);
(pipeline, err)
}
b"extern" => {
let (pipeline, err) = parse_extern(
working_set,
command,
None,
expand_aliases_denylist,
);
(pipeline, err)
}
b"old-alias" => {
let (pipeline, err) = parse_old_alias(
working_set,
command,
None, // using aliases named as the module locally is OK
expand_aliases_denylist,
);
(pipeline, err)
}
b"alias" => {
let (pipeline, err) = parse_alias(
working_set,
command,
None, // using aliases named as the module locally is OK
expand_aliases_denylist,
);
(pipeline, err)
}
b"use" => {
let (pipeline, _, err) =
parse_use(working_set, &command.parts, expand_aliases_denylist);
(pipeline, err)
}
b"export" => {
let (pipe, exportables, err) = parse_export_in_module(
working_set,
command,
module_name,
expand_aliases_denylist,
);
if err.is_none() {
for exportable in exportables {
match exportable {
Exportable::Decl { name, id } => {
if &name == b"main" {
module.main = Some(id);
} else {
module.add_decl(name, id);
}
}
Exportable::Alias { name, id } => {
module.add_alias(name, id);
}
}
}
}
(pipe, err)
}
b"export-env" => {
let (pipe, maybe_env_block, err) = parse_export_env(
working_set,
&command.parts,
expand_aliases_denylist,
);
if let Some(block_id) = maybe_env_block {
module.add_env_block(block_id);
}
(pipe, err)
}
_ => (
garbage_pipeline(&command.parts),
Some(ParseError::ExpectedKeyword(
"def or export keyword".into(),
command.parts[0],
)),
),
};
if error.is_none() {
error = err;
}
pipeline
}
LiteElement::Redirection(_, _, command) => garbage_pipeline(&command.parts),
LiteElement::SeparateRedirection {
out: (_, command), ..
} => garbage_pipeline(&command.parts),
}
} else {
error = Some(ParseError::Expected("not a pipeline".into(), span));
garbage_pipeline(&[span])
}
})
.into();
working_set.exit_scope();
(block, module, module_comments, error)
}
pub fn parse_module(
working_set: &mut StateWorkingSet,
lite_command: &LiteCommand,
expand_aliases_denylist: &[usize],
) -> (Pipeline, Option<ParseError>) {
// TODO: Currently, module is closing over its parent scope (i.e., defs in the parent scope are
// visible and usable in this module's scope). We want to disable that for files.
let spans = &lite_command.parts;
let mut module_comments = lite_command.comments.clone();
let mut error = None;
let bytes = working_set.get_span_contents(spans[0]);
if bytes == b"module" && spans.len() >= 3 {
let (module_name_expr, err) = parse_string(working_set, spans[1], expand_aliases_denylist);
error = error.or(err);
let module_name = module_name_expr
.as_string()
.expect("internal error: module name is not a string");
let block_span = spans[2];
let block_bytes = working_set.get_span_contents(block_span);
let mut start = block_span.start;
let mut end = block_span.end;
if block_bytes.starts_with(b"{") {
start += 1;
} else {
return (
garbage_pipeline(spans),
Some(ParseError::Expected("block".into(), block_span)),
);
}
if block_bytes.ends_with(b"}") {
end -= 1;
} else {
error = error.or_else(|| Some(ParseError::Unclosed("}".into(), Span::new(end, end))));
}
let block_span = Span::new(start, end);
let (block, module, inner_comments, err) = parse_module_block(
working_set,
block_span,
module_name.as_bytes(),
expand_aliases_denylist,
);
error = error.or(err);
let block_id = working_set.add_block(block);
module_comments.extend(inner_comments);
let _ = working_set.add_module(&module_name, module, module_comments);
let block_expr = Expression {
expr: Expr::Block(block_id),
span: block_span,
ty: Type::Block,
custom_completion: None,
};
let module_decl_id = working_set
.find_decl(b"module", &Type::Any)
.expect("internal error: missing module command");
let call = Box::new(Call {
head: spans[0],
decl_id: module_decl_id,
arguments: vec![
Argument::Positional(module_name_expr),
Argument::Positional(block_expr),
],
redirect_stdout: true,
redirect_stderr: false,
parser_info: HashMap::new(),
});
(
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: span(spans),
ty: Type::Any,
custom_completion: None,
}]),
error,
)
} else {
(
garbage_pipeline(spans),
Some(ParseError::UnknownState(
"Expected structure: module <name> {}".into(),
span(spans),
)),
)
}
}
pub fn parse_use(
working_set: &mut StateWorkingSet,
spans: &[Span],
expand_aliases_denylist: &[usize],
) -> (Pipeline, Vec<Exportable>, Option<ParseError>) {
let (name_span, split_id) =
if spans.len() > 1 && working_set.get_span_contents(spans[0]) == b"export" {
(spans[1], 2)
} else {
(spans[0], 1)
};
let use_call = working_set.get_span_contents(name_span).to_vec();
if use_call != b"use" {
return (
garbage_pipeline(spans),
vec![],
Some(ParseError::UnknownState(
"internal error: Wrong call name for 'use' command".into(),
span(spans),
)),
);
}
if working_set.get_span_contents(name_span) != b"use" {
return (
garbage_pipeline(spans),
vec![],
Some(ParseError::UnknownState(
"internal error: Wrong call name for 'use' command".into(),
span(spans),
)),
);
}
let (call, call_span, args_spans) = match working_set.find_decl(b"use", &Type::Any) {
Some(decl_id) => {
let (command_spans, rest_spans) = spans.split_at(split_id);
let ParsedInternalCall {
call,
error: mut err,
output,
} = parse_internal_call(
working_set,
span(command_spans),
rest_spans,
decl_id,
expand_aliases_denylist,
);
let decl = working_set.get_decl(decl_id);
let call_span = span(spans);
err = check_call(call_span, &decl.signature(), &call).or(err);
if err.is_some() || call.has_flag("help") {
return (
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: call_span,
ty: output,
custom_completion: None,
}]),
vec![],
err,
);
}
(call, call_span, rest_spans)
}
None => {
return (
garbage_pipeline(spans),
vec![],
Some(ParseError::UnknownState(
"internal error: 'use' declaration not found".into(),
span(spans),
)),
)
}
};
let mut error = None;
let (import_pattern_expr, err) =
parse_import_pattern(working_set, args_spans, expand_aliases_denylist);
error = error.or(err);
let import_pattern = if let Expression {
expr: Expr::ImportPattern(import_pattern),
..
} = &import_pattern_expr
{
import_pattern.clone()
} else {
return (
garbage_pipeline(spans),
vec![],
Some(ParseError::UnknownState(
"internal error: Import pattern positional is not import pattern".into(),
import_pattern_expr.span,
)),
);
};
let cwd = working_set.get_cwd();
// TODO: Add checking for importing too long import patterns, e.g.:
// > use spam foo non existent names here do not throw error
let (import_pattern, module) = if let Some(module_id) = import_pattern.head.id {
(import_pattern, working_set.get_module(module_id).clone())
} else {
// It could be a file
// TODO: Do not close over when loading module from file?
let (module_filename, err) =
unescape_unquote_string(&import_pattern.head.name, import_pattern.head.span);
if err.is_none() {
if let Some(module_path) = find_in_dirs_with_id(
&module_filename,
working_set,
&cwd,
get_dirs_var_from_call(&call),
) {
if let Some(i) = working_set
.parsed_module_files
.iter()
.rposition(|p| p == &module_path)
{
let mut files: Vec<String> = working_set
.parsed_module_files
.split_off(i)
.iter()
.map(|p| p.to_string_lossy().to_string())
.collect();
files.push(module_path.to_string_lossy().to_string());
let msg = files.join("\nuses ");
return (
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: call_span,
ty: Type::Any,
custom_completion: None,
}]),
vec![],
Some(ParseError::CyclicalModuleImport(
msg,
import_pattern.head.span,
)),
);
}
let module_name = if let Some(stem) = module_path.file_stem() {
stem.to_string_lossy().to_string()
} else {
return (
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: call_span,
ty: Type::Any,
custom_completion: None,
}]),
vec![],
Some(ParseError::ModuleNotFound(import_pattern.head.span)),
);
};
if let Ok(contents) = std::fs::read(&module_path) {
let span_start = working_set.next_span_start();
working_set.add_file(module_filename, &contents);
let span_end = working_set.next_span_start();
// Change the currently parsed directory
let prev_currently_parsed_cwd = if let Some(parent) = module_path.parent() {
let prev = working_set.currently_parsed_cwd.clone();
working_set.currently_parsed_cwd = Some(parent.into());
prev
} else {
working_set.currently_parsed_cwd.clone()
};
// Add the file to the stack of parsed module files
working_set.parsed_module_files.push(module_path);
// Parse the module
let (block, module, module_comments, err) = parse_module_block(
working_set,
Span::new(span_start, span_end),
module_name.as_bytes(),
expand_aliases_denylist,
);
error = error.or(err);
// Remove the file from the stack of parsed module files
working_set.parsed_module_files.pop();
// Restore the currently parsed directory back
working_set.currently_parsed_cwd = prev_currently_parsed_cwd;
let _ = working_set.add_block(block);
let module_id =
working_set.add_module(&module_name, module.clone(), module_comments);
(
ImportPattern {
head: ImportPatternHead {
name: module_name.into(),
id: Some(module_id),
span: import_pattern.head.span,
},
members: import_pattern.members,
hidden: HashSet::new(),
},
module,
)
} else {
return (
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: call_span,
ty: Type::Any,
custom_completion: None,
}]),
vec![],
Some(ParseError::ModuleNotFound(import_pattern.head.span)),
);
}
} else {
return (
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: span(spans),
ty: Type::Any,
custom_completion: None,
}]),
vec![],
Some(ParseError::ModuleNotFound(import_pattern.head.span)),
);
}
} else {
return (
garbage_pipeline(spans),
vec![],
Some(ParseError::NonUtf8(import_pattern.head.span)),
);
}
};
let (decls_to_use, aliases_to_use) = if import_pattern.members.is_empty() {
(
module.decls_with_head(&import_pattern.head.name),
module.aliases_with_head(&import_pattern.head.name),
)
} else {
match &import_pattern.members[0] {
ImportPatternMember::Glob { .. } => (module.decls(), module.aliases()),
ImportPatternMember::Name { name, span } => {
let mut decl_output = vec![];
let mut alias_output = vec![];
if name == b"main" {
if let Some(id) = &module.main {
decl_output.push((import_pattern.head.name.clone(), *id));
} else {
error = error.or(Some(ParseError::ExportNotFound(*span)));
}
} else if let Some(id) = module.get_decl_id(name) {
decl_output.push((name.clone(), id));
} else if let Some(id) = module.get_alias_id(name) {
alias_output.push((name.clone(), id));
} else {
error = error.or(Some(ParseError::ExportNotFound(*span)));
}
(decl_output, alias_output)
}
ImportPatternMember::List { names } => {
let mut decl_output = vec![];
let mut alias_output = vec![];
for (name, span) in names {
if name == b"main" {
if let Some(id) = &module.main {
decl_output.push((import_pattern.head.name.clone(), *id));
} else {
error = error.or(Some(ParseError::ExportNotFound(*span)));
}
} else if let Some(id) = module.get_decl_id(name) {
decl_output.push((name.clone(), id));
} else if let Some(id) = module.get_alias_id(name) {
alias_output.push((name.clone(), id));
} else {
error = error.or(Some(ParseError::ExportNotFound(*span)));
break;
}
}
(decl_output, alias_output)
}
}
};
let exportables = decls_to_use
.iter()
.map(|(name, decl_id)| Exportable::Decl {
name: name.clone(),
id: *decl_id,
})
.chain(
aliases_to_use
.iter()
.map(|(name, alias_id)| Exportable::Alias {
name: name.clone(),
id: *alias_id,
}),
)
.collect();
// Extend the current scope with the module's exportables
working_set.use_decls(decls_to_use);
working_set.use_aliases(aliases_to_use);
// Create a new Use command call to pass the new import pattern
let import_pattern_expr = Expression {
expr: Expr::ImportPattern(import_pattern),
span: span(args_spans),
ty: Type::Any,
custom_completion: None,
};
let mut call = call;
call.set_parser_info("import_pattern".to_string(), import_pattern_expr);
(
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: span(spans),
ty: Type::Any,
custom_completion: None,
}]),
exportables,
error,
)
}
pub fn parse_hide(
working_set: &mut StateWorkingSet,
spans: &[Span],
expand_aliases_denylist: &[usize],
) -> (Pipeline, Option<ParseError>) {
if working_set.get_span_contents(spans[0]) != b"hide" {
return (
garbage_pipeline(spans),
Some(ParseError::UnknownState(
"internal error: Wrong call name for 'hide' command".into(),
span(spans),
)),
);
}
let (call, args_spans) = match working_set.find_decl(b"hide", &Type::Any) {
Some(decl_id) => {
let ParsedInternalCall {
call,
error: mut err,
output,
} = parse_internal_call(
working_set,
spans[0],
&spans[1..],
decl_id,
expand_aliases_denylist,
);
let decl = working_set.get_decl(decl_id);
let call_span = span(spans);
err = check_call(call_span, &decl.signature(), &call).or(err);
if err.is_some() || call.has_flag("help") {
return (
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: call_span,
ty: output,
custom_completion: None,
}]),
err,
);
}
(call, &spans[1..])
}
None => {
return (
garbage_pipeline(spans),
Some(ParseError::UnknownState(
"internal error: 'hide' declaration not found".into(),
span(spans),
)),
)
}
};
let mut error = None;
let (import_pattern_expr, err) =
parse_import_pattern(working_set, args_spans, expand_aliases_denylist);
error = error.or(err);
let import_pattern = if let Expression {
expr: Expr::ImportPattern(import_pattern),
..
} = &import_pattern_expr
{
import_pattern.clone()
} else {
return (
garbage_pipeline(spans),
Some(ParseError::UnknownState(
"internal error: Import pattern positional is not import pattern".into(),
import_pattern_expr.span,
)),
);
};
let bytes = working_set.get_span_contents(spans[0]);
if bytes == b"hide" && spans.len() >= 2 {
for span in spans[1..].iter() {
let (_, err) = parse_string(working_set, *span, expand_aliases_denylist);
error = error.or(err);
}
// module used only internally, not saved anywhere
let (is_module, module) = if let Some(module_id) =
working_set.find_module(&import_pattern.head.name)
{
(true, working_set.get_module(module_id).clone())
} else if import_pattern.members.is_empty() {
// The pattern head can be:
if let Some(id) = working_set.find_alias(&import_pattern.head.name) {
// an alias,
let mut module = Module::new(b"tmp".to_vec());
module.add_alias(import_pattern.head.name.clone(), id);
(false, module)
} else if let Some(id) = working_set.find_decl(&import_pattern.head.name, &Type::Any) {
// a custom command,
let mut module = Module::new(b"tmp".to_vec());
module.add_decl(import_pattern.head.name.clone(), id);
(false, module)
} else {
// , or it could be an env var (handled by the engine)
(false, Module::new(b"tmp".to_vec()))
}
} else {
return (
garbage_pipeline(spans),
Some(ParseError::ModuleNotFound(spans[1])),
);
};
// This kind of inverts the import pattern matching found in parse_use()
let (aliases_to_hide, decls_to_hide) = if import_pattern.members.is_empty() {
if is_module {
(
module.alias_names_with_head(&import_pattern.head.name),
module.decl_names_with_head(&import_pattern.head.name),
)
} else {
(module.alias_names(), module.decl_names())
}
} else {
match &import_pattern.members[0] {
ImportPatternMember::Glob { .. } => (module.alias_names(), module.decl_names()),
ImportPatternMember::Name { name, span } => {
let mut aliases = vec![];
let mut decls = vec![];
if name == b"main" {
if module.main.is_some() {
decls.push(import_pattern.head.name.clone());
} else {
error = error.or(Some(ParseError::ExportNotFound(*span)));
}
} else if let Some(item) =
module.alias_name_with_head(name, &import_pattern.head.name)
{
aliases.push(item);
} else if let Some(item) =
module.decl_name_with_head(name, &import_pattern.head.name)
{
decls.push(item);
} else {
error = error.or(Some(ParseError::ExportNotFound(*span)));
}
(aliases, decls)
}
ImportPatternMember::List { names } => {
let mut aliases = vec![];
let mut decls = vec![];
for (name, span) in names {
if name == b"main" {
if module.main.is_some() {
decls.push(import_pattern.head.name.clone());
} else {
error = error.or(Some(ParseError::ExportNotFound(*span)));
break;
}
} else if let Some(item) =
module.alias_name_with_head(name, &import_pattern.head.name)
{
aliases.push(item);
} else if let Some(item) =
module.decl_name_with_head(name, &import_pattern.head.name)
{
decls.push(item);
} else {
error = error.or(Some(ParseError::ExportNotFound(*span)));
break;
}
}
(aliases, decls)
}
}
};
let import_pattern = {
let aliases: HashSet<Vec<u8>> = aliases_to_hide.iter().cloned().collect();
let decls: HashSet<Vec<u8>> = decls_to_hide.iter().cloned().collect();
import_pattern.with_hidden(decls.union(&aliases).cloned().collect())
};
// TODO: `use spam; use spam foo; hide foo` will hide both `foo` and `spam foo` since
// they point to the same DeclId. Do we want to keep it that way?
working_set.hide_decls(&decls_to_hide);
working_set.hide_aliases(&aliases_to_hide);
// Create a new Use command call to pass the new import pattern
let import_pattern_expr = Expression {
expr: Expr::ImportPattern(import_pattern),
span: span(args_spans),
ty: Type::Any,
custom_completion: None,
};
let mut call = call;
call.set_parser_info("import_pattern".to_string(), import_pattern_expr);
(
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: span(spans),
ty: Type::Any,
custom_completion: None,
}]),
error,
)
} else {
(
garbage_pipeline(spans),
Some(ParseError::UnknownState(
"Expected structure: hide <name>".into(),
span(spans),
)),
)
}
}
pub fn parse_overlay_new(
working_set: &mut StateWorkingSet,
call: Box<Call>,
) -> (Pipeline, Option<ParseError>) {
let call_span = call.span();
let (overlay_name, _) = if let Some(expr) = call.positional_nth(0) {
match eval_constant(working_set, expr) {
Ok(val) => match value_as_string(val, expr.span) {
Ok(s) => (s, expr.span),
Err(err) => {
return (garbage_pipeline(&[call_span]), Some(err));
}
},
Err(err) => {
return (garbage_pipeline(&[call_span]), Some(err));
}
}
} else {
return (
garbage_pipeline(&[call_span]),
Some(ParseError::UnknownState(
"internal error: Missing required positional after call parsing".into(),
call_span,
)),
);
};
let pipeline = Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: call_span,
ty: Type::Any,
custom_completion: None,
}]);
let module_id = working_set.add_module(
&overlay_name,
Module::new(overlay_name.as_bytes().to_vec()),
vec![],
);
working_set.add_overlay(
overlay_name.as_bytes().to_vec(),
module_id,
vec![],
vec![],
false,
);
(pipeline, None)
}
pub fn parse_overlay_use(
working_set: &mut StateWorkingSet,
call: Box<Call>,
expand_aliases_denylist: &[usize],
) -> (Pipeline, Option<ParseError>) {
let call_span = call.span();
let (overlay_name, overlay_name_span) = if let Some(expr) = call.positional_nth(0) {
match eval_constant(working_set, expr) {
Ok(val) => match value_as_string(val, expr.span) {
Ok(s) => (s, expr.span),
Err(err) => {
return (garbage_pipeline(&[call_span]), Some(err));
}
},
Err(err) => {
return (garbage_pipeline(&[call_span]), Some(err));
}
}
} else {
return (
garbage_pipeline(&[call_span]),
Some(ParseError::UnknownState(
"internal error: Missing required positional after call parsing".into(),
call_span,
)),
);
};
let new_name = if let Some(kw_expression) = call.positional_nth(1) {
if let Some(new_name_expression) = kw_expression.as_keyword() {
match eval_constant(working_set, new_name_expression) {
Ok(val) => match value_as_string(val, new_name_expression.span) {
Ok(s) => Some(Spanned {
item: s,
span: new_name_expression.span,
}),
Err(err) => return (garbage_pipeline(&[call_span]), Some(err)),
},
Err(err) => return (garbage_pipeline(&[call_span]), Some(err)),
}
} else {
return (
garbage_pipeline(&[call_span]),
Some(ParseError::ExpectedKeyword(
"as keyword".to_string(),
kw_expression.span,
)),
);
}
} else {
None
};
let has_prefix = call.has_flag("prefix");
let do_reload = call.has_flag("reload");
let pipeline = Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call.clone()),
span: call_span,
ty: Type::Any,
custom_completion: None,
}]);
let cwd = working_set.get_cwd();
let mut error = None;
let (final_overlay_name, origin_module, origin_module_id, is_module_updated) = if let Some(
overlay_frame,
) =
working_set.find_overlay(overlay_name.as_bytes())
{
// Activate existing overlay
// First, check for errors
if has_prefix && !overlay_frame.prefixed {
return (
pipeline,
Some(ParseError::OverlayPrefixMismatch(
overlay_name,
"without".to_string(),
overlay_name_span,
)),
);
}
if !has_prefix && overlay_frame.prefixed {
return (
pipeline,
Some(ParseError::OverlayPrefixMismatch(
overlay_name,
"with".to_string(),
overlay_name_span,
)),
);
}
if let Some(new_name) = new_name {
if new_name.item != overlay_name {
return (
pipeline,
Some(ParseError::CantAddOverlayHelp(
format!("Cannot add overlay as '{}' because it already exists under the name '{}'", new_name.item, overlay_name),
new_name.span,
)),
);
}
}
let module_id = overlay_frame.origin;
if let Some(new_module_id) = working_set.find_module(overlay_name.as_bytes()) {
if !do_reload && (module_id == new_module_id) {
(
overlay_name,
Module::new(working_set.get_module(module_id).name.clone()),
module_id,
false,
)
} else {
// The origin module of an overlay changed => update it
(
overlay_name,
working_set.get_module(new_module_id).clone(),
new_module_id,
true,
)
}
} else {
let module_name = overlay_name.as_bytes().to_vec();
(overlay_name, Module::new(module_name), module_id, true)
}
} else {
// Create a new overlay from a module
if let Some(module_id) =
// the name is a module
working_set.find_module(overlay_name.as_bytes())
{
(
new_name.map(|spanned| spanned.item).unwrap_or(overlay_name),
working_set.get_module(module_id).clone(),
module_id,
true,
)
} else {
// try if the name is a file
if let Ok(module_filename) =
String::from_utf8(trim_quotes(overlay_name.as_bytes()).to_vec())
{
if let Some(module_path) = find_in_dirs_with_id(
&module_filename,
working_set,
&cwd,
get_dirs_var_from_call(&call),
) {
let overlay_name = if let Some(stem) = module_path.file_stem() {
stem.to_string_lossy().to_string()
} else {
return (
pipeline,
Some(ParseError::ModuleOrOverlayNotFound(overlay_name_span)),
);
};
if let Ok(contents) = std::fs::read(&module_path) {
let span_start = working_set.next_span_start();
working_set.add_file(module_filename, &contents);
let span_end = working_set.next_span_start();
// Change currently parsed directory
let prev_currently_parsed_cwd = if let Some(parent) = module_path.parent() {
let prev = working_set.currently_parsed_cwd.clone();
working_set.currently_parsed_cwd = Some(parent.into());
prev
} else {
working_set.currently_parsed_cwd.clone()
};
let (block, module, module_comments, err) = parse_module_block(
working_set,
Span::new(span_start, span_end),
overlay_name.as_bytes(),
expand_aliases_denylist,
);
error = error.or(err);
// Restore the currently parsed directory back
working_set.currently_parsed_cwd = prev_currently_parsed_cwd;
let _ = working_set.add_block(block);
let module_id =
working_set.add_module(&overlay_name, module.clone(), module_comments);
(
new_name.map(|spanned| spanned.item).unwrap_or(overlay_name),
module,
module_id,
true,
)
} else {
return (
pipeline,
Some(ParseError::ModuleOrOverlayNotFound(overlay_name_span)),
);
}
} else {
return (
pipeline,
Some(ParseError::ModuleOrOverlayNotFound(overlay_name_span)),
);
}
} else {
return (
garbage_pipeline(&[call_span]),
Some(ParseError::NonUtf8(overlay_name_span)),
);
}
}
};
let (decls_to_lay, aliases_to_lay) = if is_module_updated {
if has_prefix {
(
origin_module.decls_with_head(final_overlay_name.as_bytes()),
origin_module.aliases_with_head(final_overlay_name.as_bytes()),
)
} else {
(origin_module.decls(), origin_module.aliases())
}
} else {
(vec![], vec![])
};
working_set.add_overlay(
final_overlay_name.as_bytes().to_vec(),
origin_module_id,
decls_to_lay,
aliases_to_lay,
has_prefix,
);
// Change the call argument to include the Overlay expression with the module ID
let mut call = call;
call.set_parser_info(
"overlay_expr".to_string(),
Expression {
expr: Expr::Overlay(if is_module_updated {
Some(origin_module_id)
} else {
None
}),
span: overlay_name_span,
ty: Type::Any,
custom_completion: None,
},
);
let pipeline = Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: call_span,
ty: Type::Any,
custom_completion: None,
}]);
(pipeline, error)
}
pub fn parse_overlay_hide(
working_set: &mut StateWorkingSet,
call: Box<Call>,
) -> (Pipeline, Option<ParseError>) {
let call_span = call.span();
let (overlay_name, overlay_name_span) = if let Some(expr) = call.positional_nth(0) {
match eval_constant(working_set, expr) {
Ok(val) => match value_as_string(val, expr.span) {
Ok(s) => (s, expr.span),
Err(err) => {
return (garbage_pipeline(&[call_span]), Some(err));
}
},
Err(err) => {
return (garbage_pipeline(&[call_span]), Some(err));
}
}
} else {
(
String::from_utf8_lossy(working_set.last_overlay_name()).to_string(),
call_span,
)
};
let keep_custom = call.has_flag("keep-custom");
let pipeline = Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: call_span,
ty: Type::Any,
custom_completion: None,
}]);
if overlay_name == DEFAULT_OVERLAY_NAME {
return (
pipeline,
Some(ParseError::CantHideDefaultOverlay(
overlay_name,
overlay_name_span,
)),
);
}
if !working_set
.unique_overlay_names()
.contains(&overlay_name.as_bytes().to_vec())
{
return (
pipeline,
Some(ParseError::ActiveOverlayNotFound(overlay_name_span)),
);
}
if working_set.num_overlays() < 2 {
return (
pipeline,
Some(ParseError::CantRemoveLastOverlay(overlay_name_span)),
);
}
working_set.remove_overlay(overlay_name.as_bytes(), keep_custom);
(pipeline, None)
}
pub fn parse_let_or_const(
working_set: &mut StateWorkingSet,
spans: &[Span],
expand_aliases_denylist: &[usize],
) -> (Pipeline, Option<ParseError>) {
let name = working_set.get_span_contents(spans[0]);
if name == b"let" || name == b"const" {
let is_const = &name == b"const";
if let Some((span, err)) = check_name(working_set, spans) {
return (Pipeline::from_vec(vec![garbage(*span)]), Some(err));
}
if let Some(decl_id) =
working_set.find_decl(if is_const { b"const" } else { b"let" }, &Type::Any)
{
let cmd = working_set.get_decl(decl_id);
let call_signature = cmd.signature().call_signature();
if spans.len() >= 4 {
// This is a bit of by-hand parsing to get around the issue where we want to parse in the reverse order
// so that the var-id created by the variable isn't visible in the expression that init it
for span in spans.iter().enumerate() {
let item = working_set.get_span_contents(*span.1);
if item == b"=" && spans.len() > (span.0 + 1) {
let mut error = None;
let mut idx = span.0;
let (rvalue, err) = parse_multispan_value(
working_set,
spans,
&mut idx,
&SyntaxShape::Keyword(b"=".to_vec(), Box::new(SyntaxShape::Expression)),
expand_aliases_denylist,
);
error = error.or(err);
if idx < (spans.len() - 1) {
error = error.or(Some(ParseError::ExtraPositional(
call_signature,
spans[idx + 1],
)));
}
let mut idx = 0;
let (lvalue, err) = parse_var_with_opt_type(
working_set,
&spans[1..(span.0)],
&mut idx,
false,
);
error = error.or(err);
let var_name =
String::from_utf8_lossy(working_set.get_span_contents(lvalue.span))
.to_string();
if ["in", "nu", "env", "nothing"].contains(&var_name.as_str()) {
error = if is_const {
error.or(Some(ParseError::ConstBuiltinVar(var_name, lvalue.span)))
} else {
error.or(Some(ParseError::LetBuiltinVar(var_name, lvalue.span)))
};
}
let var_id = lvalue.as_var();
let rhs_type = rvalue.ty.clone();
if let Some(var_id) = var_id {
working_set.set_variable_type(var_id, rhs_type);
if is_const {
match eval_constant(working_set, &rvalue) {
Ok(val) => {
working_set.add_constant(var_id, val);
}
Err(err) => error = error.or(Some(err)),
}
}
}
let call = Box::new(Call {
decl_id,
head: spans[0],
arguments: vec![
Argument::Positional(lvalue),
Argument::Positional(rvalue),
],
redirect_stdout: true,
redirect_stderr: false,
parser_info: HashMap::new(),
});
return (
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: nu_protocol::span(spans),
ty: Type::Any,
custom_completion: None,
}]),
error,
);
}
}
}
let ParsedInternalCall {
call,
error: err,
output,
} = parse_internal_call(
working_set,
spans[0],
&spans[1..],
decl_id,
expand_aliases_denylist,
);
return (
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: nu_protocol::span(spans),
ty: output,
custom_completion: None,
}]),
err,
);
}
}
(
garbage_pipeline(spans),
Some(ParseError::UnknownState(
"internal error: let or const statement unparsable".into(),
span(spans),
)),
)
}
pub fn parse_mut(
working_set: &mut StateWorkingSet,
spans: &[Span],
expand_aliases_denylist: &[usize],
) -> (Pipeline, Option<ParseError>) {
let name = working_set.get_span_contents(spans[0]);
if name == b"mut" {
if let Some((span, err)) = check_name(working_set, spans) {
return (Pipeline::from_vec(vec![garbage(*span)]), Some(err));
}
if let Some(decl_id) = working_set.find_decl(b"mut", &Type::Any) {
let cmd = working_set.get_decl(decl_id);
let call_signature = cmd.signature().call_signature();
if spans.len() >= 4 {
// This is a bit of by-hand parsing to get around the issue where we want to parse in the reverse order
// so that the var-id created by the variable isn't visible in the expression that init it
for span in spans.iter().enumerate() {
let item = working_set.get_span_contents(*span.1);
if item == b"=" && spans.len() > (span.0 + 1) {
let mut error = None;
let mut idx = span.0;
let (rvalue, err) = parse_multispan_value(
working_set,
spans,
&mut idx,
&SyntaxShape::Keyword(b"=".to_vec(), Box::new(SyntaxShape::Expression)),
expand_aliases_denylist,
);
error = error.or(err);
if idx < (spans.len() - 1) {
error = error.or(Some(ParseError::ExtraPositional(
call_signature,
spans[idx + 1],
)));
}
let mut idx = 0;
let (lvalue, err) = parse_var_with_opt_type(
working_set,
&spans[1..(span.0)],
&mut idx,
true,
);
error = error.or(err);
let var_name =
String::from_utf8_lossy(working_set.get_span_contents(lvalue.span))
.to_string();
if ["in", "nu", "env", "nothing"].contains(&var_name.as_str()) {
error =
error.or(Some(ParseError::MutBuiltinVar(var_name, lvalue.span)));
}
let var_id = lvalue.as_var();
let rhs_type = rvalue.ty.clone();
if let Some(var_id) = var_id {
working_set.set_variable_type(var_id, rhs_type);
}
let call = Box::new(Call {
decl_id,
head: spans[0],
arguments: vec![
Argument::Positional(lvalue),
Argument::Positional(rvalue),
],
redirect_stdout: true,
redirect_stderr: false,
parser_info: HashMap::new(),
});
return (
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: nu_protocol::span(spans),
ty: Type::Any,
custom_completion: None,
}]),
error,
);
}
}
}
let ParsedInternalCall {
call,
error: err,
output,
} = parse_internal_call(
working_set,
spans[0],
&spans[1..],
decl_id,
expand_aliases_denylist,
);
return (
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: nu_protocol::span(spans),
ty: output,
custom_completion: None,
}]),
err,
);
}
}
(
garbage_pipeline(spans),
Some(ParseError::UnknownState(
"internal error: mut statement unparsable".into(),
span(spans),
)),
)
}
pub fn parse_source(
working_set: &mut StateWorkingSet,
spans: &[Span],
expand_aliases_denylist: &[usize],
) -> (Pipeline, Option<ParseError>) {
let mut error = None;
let name = working_set.get_span_contents(spans[0]);
if name == b"source" || name == b"source-env" {
let scoped = name == b"source-env";
if let Some(decl_id) = working_set.find_decl(name, &Type::Any) {
let cwd = working_set.get_cwd();
// 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,
error: err,
output,
} = parse_internal_call(
working_set,
spans[0],
&spans[1..],
decl_id,
expand_aliases_denylist,
);
error = error.or(err);
if error.is_some() || call.has_flag("help") {
return (
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: span(spans),
ty: output,
custom_completion: None,
}]),
error,
);
}
// Command and one file name
if spans.len() >= 2 {
let (expr, err) = parse_value(
working_set,
spans[1],
&SyntaxShape::Any,
expand_aliases_denylist,
);
error = error.or(err);
let val = match eval_constant(working_set, &expr) {
Ok(val) => val,
Err(err) => {
return (
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: span(&spans[1..]),
ty: Type::Any,
custom_completion: None,
}]),
Some(err),
);
}
};
let filename = match value_as_string(val, spans[1]) {
Ok(s) => s,
Err(err) => {
return (
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: span(&spans[1..]),
ty: Type::Any,
custom_completion: None,
}]),
Some(err),
);
}
};
if let Some(path) = find_in_dirs(&filename, working_set, &cwd, LIB_DIRS_VAR) {
if let Ok(contents) = std::fs::read(&path) {
// Change currently parsed directory
let prev_currently_parsed_cwd = if let Some(parent) = path.parent() {
let prev = working_set.currently_parsed_cwd.clone();
working_set.currently_parsed_cwd = Some(parent.into());
prev
} else {
working_set.currently_parsed_cwd.clone()
};
// This will load the defs from the file into the
// working set, if it was a successful parse.
let (block, err) = parse(
working_set,
path.file_name().and_then(|x| x.to_str()),
&contents,
scoped,
expand_aliases_denylist,
);
// Restore the currently parsed directory back
working_set.currently_parsed_cwd = prev_currently_parsed_cwd;
if err.is_some() {
// Unsuccessful parse of file
return (
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: span(&spans[1..]),
ty: Type::Any,
custom_completion: None,
}]),
// Return the file parse error
err,
);
} else {
// Save the block into the working set
let block_id = working_set.add_block(block);
let mut call_with_block = call;
// FIXME: Adding this expression to the positional creates a syntax highlighting error
// after writing `source example.nu`
call_with_block.set_parser_info(
"block_id".to_string(),
Expression {
expr: Expr::Int(block_id as i64),
span: spans[1],
ty: Type::Any,
custom_completion: None,
},
);
return (
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call_with_block),
span: span(spans),
ty: Type::Any,
custom_completion: None,
}]),
None,
);
}
}
} else {
error = error.or(Some(ParseError::SourcedFileNotFound(filename, spans[1])));
}
}
return (
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: span(spans),
ty: Type::Any,
custom_completion: None,
}]),
error,
);
}
}
(
garbage_pipeline(spans),
Some(ParseError::UnknownState(
"internal error: source statement unparsable".into(),
span(spans),
)),
)
}
pub fn parse_where_expr(
working_set: &mut StateWorkingSet,
spans: &[Span],
expand_aliases_denylist: &[usize],
) -> (Expression, Option<ParseError>) {
trace!("parsing: where");
if !spans.is_empty() && working_set.get_span_contents(spans[0]) != b"where" {
return (
garbage(span(spans)),
Some(ParseError::UnknownState(
"internal error: Wrong call name for 'where' command".into(),
span(spans),
)),
);
}
if spans.len() < 2 {
return (
garbage(span(spans)),
Some(ParseError::MissingPositional(
"row condition".into(),
span(spans),
"where <row_condition>".into(),
)),
);
}
let call = match working_set.find_decl(b"where", &Type::Any) {
Some(decl_id) => {
let ParsedInternalCall {
call,
error: mut err,
output,
} = parse_internal_call(
working_set,
spans[0],
&spans[1..],
decl_id,
expand_aliases_denylist,
);
let decl = working_set.get_decl(decl_id);
let call_span = span(spans);
err = check_call(call_span, &decl.signature(), &call).or(err);
if err.is_some() || call.has_flag("help") {
return (
Expression {
expr: Expr::Call(call),
span: call_span,
ty: output,
custom_completion: None,
},
err,
);
}
call
}
None => {
return (
garbage(span(spans)),
Some(ParseError::UnknownState(
"internal error: 'where' declaration not found".into(),
span(spans),
)),
)
}
};
(
Expression {
expr: Expr::Call(call),
span: span(spans),
ty: Type::Any,
custom_completion: None,
},
None,
)
}
pub fn parse_where(
working_set: &mut StateWorkingSet,
spans: &[Span],
expand_aliases_denylist: &[usize],
) -> (Pipeline, Option<ParseError>) {
let (expression, err) = parse_where_expr(working_set, spans, expand_aliases_denylist);
(Pipeline::from_vec(vec![expression]), err)
}
#[cfg(feature = "plugin")]
pub fn parse_register(
working_set: &mut StateWorkingSet,
spans: &[Span],
expand_aliases_denylist: &[usize],
) -> (Pipeline, Option<ParseError>) {
use nu_plugin::{get_signature, PluginDeclaration};
use nu_protocol::{engine::Stack, PluginSignature};
let cwd = working_set.get_cwd();
// Checking that the function is used with the correct name
// Maybe this is not necessary but it is a sanity check
if working_set.get_span_contents(spans[0]) != b"register" {
return (
garbage_pipeline(spans),
Some(ParseError::UnknownState(
"internal error: Wrong call name for parse plugin function".into(),
span(spans),
)),
);
}
// Parsing the spans and checking that they match the register signature
// Using a parsed call makes more sense than checking for how many spans are in the call
// Also, by creating a call, it can be checked if it matches the declaration signature
let (call, call_span) = match working_set.find_decl(b"register", &Type::Any) {
None => {
return (
garbage_pipeline(spans),
Some(ParseError::UnknownState(
"internal error: Register declaration not found".into(),
span(spans),
)),
)
}
Some(decl_id) => {
let ParsedInternalCall {
call,
error: mut err,
output,
} = parse_internal_call(
working_set,
spans[0],
&spans[1..],
decl_id,
expand_aliases_denylist,
);
let decl = working_set.get_decl(decl_id);
let call_span = span(spans);
err = check_call(call_span, &decl.signature(), &call).or(err);
if err.is_some() || call.has_flag("help") {
return (
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: call_span,
ty: output,
custom_completion: None,
}]),
err,
);
}
(call, call_span)
}
};
// Extracting the required arguments from the call and keeping them together in a tuple
// The ? operator is not used because the error has to be kept to be printed in the shell
// For that reason the values are kept in a result that will be passed at the end of this call
let arguments = call
.positional_nth(0)
.map(|expr| {
let name_expr = working_set.get_span_contents(expr.span);
let (name, err) = unescape_unquote_string(name_expr, expr.span);
if let Some(err) = err {
Err(err)
} else {
let path = if let Some(p) = find_in_dirs(&name, working_set, &cwd, PLUGIN_DIRS_VAR)
{
p
} else {
return Err(ParseError::RegisteredFileNotFound(name, expr.span));
};
if path.exists() & path.is_file() {
Ok(path)
} else {
Err(ParseError::RegisteredFileNotFound(
format!("{path:?}"),
expr.span,
))
}
}
})
.expect("required positional has being checked");
// Signature is an optional value from the call and will be used to decide if
// the plugin is called to get the signatures or to use the given signature
let signature = call.positional_nth(1).map(|expr| {
let signature = working_set.get_span_contents(expr.span);
serde_json::from_slice::<PluginSignature>(signature).map_err(|e| {
ParseError::LabeledError(
"Signature deserialization error".into(),
format!("unable to deserialize signature: {e}"),
spans[0],
)
})
});
// Shell is another optional value used as base to call shell to plugins
let shell = call.get_flag_expr("shell").map(|expr| {
let shell_expr = working_set.get_span_contents(expr.span);
String::from_utf8(shell_expr.to_vec())
.map_err(|_| ParseError::NonUtf8(expr.span))
.and_then(|name| {
canonicalize_with(&name, cwd)
.map_err(|_| ParseError::RegisteredFileNotFound(name, expr.span))
})
.and_then(|path| {
if path.exists() & path.is_file() {
Ok(path)
} else {
Err(ParseError::RegisteredFileNotFound(
format!("{path:?}"),
expr.span,
))
}
})
});
let shell = match shell {
None => None,
Some(path) => match path {
Ok(path) => Some(path),
Err(err) => {
return (
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: call_span,
ty: Type::Any,
custom_completion: None,
}]),
Some(err),
);
}
},
};
// We need the current environment variables for `python` based plugins
// Or we'll likely have a problem when a plugin is implemented in a virtual Python environment.
let stack = Stack::new();
let current_envs =
nu_engine::env::env_to_strings(working_set.permanent_state, &stack).unwrap_or_default();
let error = match signature {
Some(signature) => arguments.and_then(|path| {
// restrict plugin file name starts with `nu_plugin_`
let f_name = path
.file_name()
.map(|s| s.to_string_lossy().starts_with("nu_plugin_"));
if let Some(true) = f_name {
signature.map(|signature| {
let plugin_decl = PluginDeclaration::new(path, signature, shell);
working_set.add_decl(Box::new(plugin_decl));
working_set.mark_plugins_file_dirty();
})
} else {
Ok(())
}
}),
None => arguments.and_then(|path| {
// restrict plugin file name starts with `nu_plugin_`
let f_name = path
.file_name()
.map(|s| s.to_string_lossy().starts_with("nu_plugin_"));
if let Some(true) = f_name {
get_signature(path.as_path(), &shell, &current_envs)
.map_err(|err| {
ParseError::LabeledError(
"Error getting signatures".into(),
err.to_string(),
spans[0],
)
})
.map(|signatures| {
for signature in signatures {
// create plugin command declaration (need struct impl Command)
// store declaration in working set
let plugin_decl =
PluginDeclaration::new(path.clone(), signature, shell.clone());
working_set.add_decl(Box::new(plugin_decl));
}
working_set.mark_plugins_file_dirty();
})
} else {
Ok(())
}
}),
}
.err();
(
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(call),
span: call_span,
ty: Type::Nothing,
custom_completion: None,
}]),
error,
)
}
/// This helper function is used to find files during parsing
///
/// First, the actual current working directory is selected as
/// a) the directory of a file currently being parsed
/// b) current working directory (PWD)
///
/// Then, if the file is not found in the actual cwd, dirs_var is checked.
/// If dirs_var is an Expr::Var, then we look for a const with that VarId,
/// and if dirs_var is an Expr::String, then we look for an environment with that name.
/// If there is a relative path in dirs_var, it is assumed to be relative to the actual cwd
/// determined in the first step.
///
/// Always returns an absolute path
pub fn find_in_dirs_with_id(
filename: &str,
working_set: &StateWorkingSet,
cwd: &str,
dirs_var_id: Option<VarId>,
) -> Option<PathBuf> {
// Choose whether to use file-relative or PWD-relative path
let actual_cwd = if let Some(currently_parsed_cwd) = &working_set.currently_parsed_cwd {
currently_parsed_cwd.as_path()
} else {
Path::new(cwd)
};
if let Ok(p) = canonicalize_with(filename, actual_cwd) {
return Some(p);
}
let path = Path::new(filename);
if !path.is_relative() {
return None;
}
working_set
.find_constant(dirs_var_id?)?
.as_list()
.ok()?
.iter()
.map(|lib_dir| -> Option<PathBuf> {
let dir = lib_dir.as_path().ok()?;
let dir_abs = canonicalize_with(dir, actual_cwd).ok()?;
canonicalize_with(filename, dir_abs).ok()
})
.find(Option::is_some)
.flatten()
}
pub fn find_dirs_var(working_set: &StateWorkingSet, var_name: &str) -> Option<VarId> {
working_set
.find_variable(format!("${}", var_name).as_bytes())
.filter(|var_id| working_set.find_constant(*var_id).is_some())
}
pub fn find_in_dirs(
filename: &str,
working_set: &StateWorkingSet,
cwd: &str,
dirs_var_name: &str,
) -> Option<PathBuf> {
find_dirs_var(working_set, dirs_var_name)
.and_then(|var_id| find_in_dirs_with_id(filename, working_set, cwd, Some(var_id)))
.or_else(|| find_in_dirs_old(filename, working_set, cwd, dirs_var_name))
}
// TODO: remove (see #8310)
pub fn find_in_dirs_old(
filename: &str,
working_set: &StateWorkingSet,
cwd: &str,
dirs_env: &str,
) -> Option<PathBuf> {
// Choose whether to use file-relative or PWD-relative path
let actual_cwd = if let Some(currently_parsed_cwd) = &working_set.currently_parsed_cwd {
currently_parsed_cwd.as_path()
} else {
Path::new(cwd)
};
if let Ok(p) = canonicalize_with(filename, actual_cwd) {
Some(p)
} else {
let path = Path::new(filename);
if path.is_relative() {
if let Some(lib_dirs) = working_set.get_env_var(dirs_env) {
if let Ok(dirs) = lib_dirs.as_list() {
for lib_dir in dirs {
if let Ok(dir) = lib_dir.as_path() {
// make sure the dir is absolute path
if let Ok(dir_abs) = canonicalize_with(dir, actual_cwd) {
if let Ok(path) = canonicalize_with(filename, dir_abs) {
return Some(path);
}
}
}
}
None
} else {
None
}
} else {
None
}
} else {
None
}
}
}
Reference in New Issue View Git Blame Copy Permalink