holm/nushell
1
1
Fork 0
forked from extern/nushell
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #243 from kubouch/module-files

Browse Source 
Loading modules from files
This commit is contained in:
JT 2021-11-01 11:08:03 +13:00 committed by GitHub
commit 3176f60b5b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 330 additions and 232 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
crates/nu-command/src/core_commands/use_.rs
View File

@ -15,7 +15,7 @@ impl Command for Use {
}
fn signature(&self) -> nu_protocol::Signature {
Signature::build("use").required("pattern", SyntaxShape::String, "import pattern")
Signature::build("use").rest("pattern", SyntaxShape::String, "import pattern parts")
}
fn run(

8
crates/nu-parser/src/errors.rs
View File

@ -93,9 +93,9 @@ pub enum ParseError {
)]
UnknownCommand(#[label = "unknown command"] Span),
#[error("Non-UTF8 code.")]
#[error("Non-UTF8 string.")]
#[diagnostic(code(nu::parser::non_utf8), url(docsrs))]
NonUtf8(#[label = "non-UTF8 code"] Span),
NonUtf8(#[label = "non-UTF8 string"] Span),
#[error("The `{0}` command doesn't have flag `{1}`.")]
#[diagnostic(code(nu::parser::unknown_flag), url(docsrs))]
@ -171,6 +171,10 @@ pub enum ParseError {
#[diagnostic(code(nu::parser::missing_import_pattern), url(docsrs))]
MissingImportPattern(#[label = "needs an import pattern"] Span),
#[error("Wrong import pattern structure.")]
#[diagnostic(code(nu::parser::missing_import_pattern), url(docsrs))]
WrongImportPattern(#[label = "invalid import pattern structure"] Span),
#[error("Module export not found.")]
#[diagnostic(code(nu::parser::export_not_found), url(docsrs))]
ExportNotFound(#[label = "could not find imports"] Span),

293
crates/nu-parser/src/parse_keywords.rs
View File

@ -1,5 +1,5 @@
use nu_protocol::{
ast::{Block, Call, Expr, Expression, ImportPatternMember, Pipeline, Statement},
ast::{Block, Call, Expr, Expression, ImportPattern, ImportPatternMember, Pipeline, Statement},
engine::StateWorkingSet,
span, DeclId, Span, SyntaxShape, Type,
};
@ -218,8 +218,6 @@ pub fn parse_alias(
let replacement = spans[3..].to_vec();
//println!("{:?} {:?}", alias_name, replacement);
working_set.add_alias(alias_name, replacement);
}
@ -309,6 +307,88 @@ pub fn parse_export(
}
}
pub fn parse_module_block(
working_set: &mut StateWorkingSet,
span: Span,
) -> (Block, 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, &[], &[]);
error = error.or(err);
let (output, err) = lite_parse(&output);
error = error.or(err);
for pipeline in &output.block {
if pipeline.commands.len() == 1 {
parse_def_predecl(working_set, &pipeline.commands[0].parts);
}
}
let mut exports: Vec<(Vec<u8>, DeclId)> = vec![];
let block: Block = output
.block
.iter()
.map(|pipeline| {
if pipeline.commands.len() == 1 {
// this one here is doing parse_statement() equivalent
// let (stmt, err) = parse_statement(working_set, &pipeline.commands[0].parts);
let name = working_set.get_span_contents(pipeline.commands[0].parts[0]);
let (stmt, err) = match name {
b"def" => {
let (stmt, err) = parse_def(working_set, &pipeline.commands[0].parts);
(stmt, err)
}
b"export" => {
let (stmt, err) = parse_export(working_set, &pipeline.commands[0].parts);
if err.is_none() {
let decl_name =
// parts[2] is safe since it's checked in parse_export already
working_set.get_span_contents(pipeline.commands[0].parts[2]);
let decl_id = working_set
.find_decl(decl_name)
.expect("internal error: failed to find added declaration");
exports.push((decl_name.into(), decl_id));
}
(stmt, err)
}
_ => (
garbage_statement(&pipeline.commands[0].parts),
Some(ParseError::Expected(
"def or export keyword".into(),
pipeline.commands[0].parts[0],
)),
),
};
if error.is_none() {
error = err;
}
stmt
} else {
error = Some(ParseError::Expected("not a pipeline".into(), span));
garbage_statement(&[span])
}
})
.into();
working_set.exit_scope();
(block.with_exports(exports), error)
}
pub fn parse_module(
working_set: &mut StateWorkingSet,
spans: &[Span],
@ -359,91 +439,9 @@ pub fn parse_module(
let block_span = Span { start, end };
let source = working_set.get_span_contents(block_span);
let (output, err) = lex(source, start, &[], &[]);
let (block, err) = parse_module_block(working_set, block_span);
error = error.or(err);
working_set.enter_scope();
// Do we need block parameters?
let (output, err) = lite_parse(&output);
error = error.or(err);
// We probably don't need $it
// we're doing parse_block() equivalent
// let (mut output, err) = parse_block(working_set, &output, false);
for pipeline in &output.block {
if pipeline.commands.len() == 1 {
parse_def_predecl(working_set, &pipeline.commands[0].parts);
}
}
let mut exports: Vec<(Vec<u8>, DeclId)> = vec![];
let block: Block = output
.block
.iter()
.map(|pipeline| {
if pipeline.commands.len() == 1 {
// this one here is doing parse_statement() equivalent
// let (stmt, err) = parse_statement(working_set, &pipeline.commands[0].parts);
let name = working_set.get_span_contents(pipeline.commands[0].parts[0]);
let (stmt, err) = match name {
// TODO: Here we can add other stuff that's allowed for modules
b"def" => {
let (stmt, err) = parse_def(working_set, &pipeline.commands[0].parts);
(stmt, err)
}
b"export" => {
let (stmt, err) =
parse_export(working_set, &pipeline.commands[0].parts);
if err.is_none() {
let decl_name =
// parts[2] is safe since it's checked in parse_def already
working_set.get_span_contents(pipeline.commands[0].parts[2]);
let decl_id = working_set
.find_decl(decl_name)
.expect("internal error: failed to find added declaration");
exports.push((decl_name.into(), decl_id));
}
(stmt, err)
}
_ => (
garbage_statement(&pipeline.commands[0].parts),
Some(ParseError::Expected(
// TODO: Fill in more keywords as they come
"def or export keyword".into(),
pipeline.commands[0].parts[0],
)),
),
};
if error.is_none() {
error = err;
}
stmt
} else {
error = Some(ParseError::Expected("not a pipeline".into(), block_span));
garbage_statement(spans)
}
})
.into();
let block = block.with_exports(exports);
working_set.exit_scope();
let block_id = working_set.add_module(&module_name, block);
let block_expr = Expression {
@ -492,27 +490,76 @@ pub fn parse_use(
let bytes = working_set.get_span_contents(spans[0]);
if bytes == b"use" && spans.len() >= 2 {
let (module_name_expr, err) = parse_string(working_set, spans[1]);
let mut import_pattern_exprs: Vec<Expression> = vec![];
for span in spans[1..].iter() {
let (expr, err) = parse_string(working_set, *span);
import_pattern_exprs.push(expr);
error = error.or(err);
}
// 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, err) = parse_import_pattern(working_set, &spans[1..]);
error = error.or(err);
let (import_pattern, err) = parse_import_pattern(working_set, spans[1]);
error = error.or(err);
let (import_pattern, exports) =
if let Some(block_id) = working_set.find_module(&import_pattern.head) {
(
import_pattern,
working_set.get_block(block_id).exports.clone(),
)
} else {
// TODO: Do not close over when loading module from file
// It could be a file
if let Ok(module_filename) = String::from_utf8(import_pattern.head) {
let module_path = Path::new(&module_filename);
let module_name = if let Some(stem) = module_path.file_stem() {
stem.to_string_lossy().to_string()
} else {
return (
garbage_statement(spans),
Some(ParseError::ModuleNotFound(spans[1])),
);
};
let exports = if let Some(block_id) = working_set.find_module(&import_pattern.head) {
working_set.get_block(block_id).exports.clone()
} else {
return (
garbage_statement(spans),
Some(ParseError::ModuleNotFound(spans[1])),
);
};
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();
let (block, err) =
parse_module_block(working_set, Span::new(span_start, span_end));
error = error.or(err);
let block_id = working_set.add_module(&module_name, block);
(
ImportPattern {
head: module_name.into(),
members: import_pattern.members,
},
working_set.get_block(block_id).exports.clone(),
)
} else {
return (
garbage_statement(spans),
Some(ParseError::ModuleNotFound(spans[1])),
);
}
} else {
return (
garbage_statement(spans),
Some(ParseError::NonUtf8(spans[1])),
);
}
};
let exports = if import_pattern.members.is_empty() {
exports
.into_iter()
.map(|(name, id)| {
let mut new_name = import_pattern.head.to_vec();
new_name.push(b'.');
new_name.push(b' ');
new_name.extend(&name);
(new_name, id)
})
@ -562,7 +609,7 @@ pub fn parse_use(
let call = Box::new(Call {
head: spans[0],
decl_id: use_decl_id,
positional: vec![module_name_expr],
positional: import_pattern_exprs,
named: vec![],
});
@ -597,20 +644,23 @@ pub fn parse_hide(
let (name_expr, err) = parse_string(working_set, spans[1]);
error = error.or(err);
let (import_pattern, err) = parse_import_pattern(working_set, spans[1]);
let (import_pattern, err) = parse_import_pattern(working_set, &spans[1..]);
error = error.or(err);
let exported_names: Vec<Vec<u8>> =
let (is_module, exported_names): (bool, Vec<Vec<u8>>) =
if let Some(block_id) = working_set.find_module(&import_pattern.head) {
working_set
.get_block(block_id)
.exports
.iter()
.map(|(name, _)| name.clone())
.collect()
(
true,
working_set
.get_block(block_id)
.exports
.iter()
.map(|(name, _)| name.clone())
.collect(),
)
} else if import_pattern.members.is_empty() {
// The pattern head can be e.g. a function name, not just a module
vec![import_pattern.head.clone()]
(false, vec![import_pattern.head.clone()])
} else {
return (
garbage_statement(spans),
@ -620,14 +670,26 @@ pub fn parse_hide(
// This kind of inverts the import pattern matching found in parse_use()
let names_to_hide = if import_pattern.members.is_empty() {
exported_names
if is_module {
exported_names
.into_iter()
.map(|name| {
let mut new_name = import_pattern.head.to_vec();
new_name.push(b' ');
new_name.extend(&name);
new_name
})
.collect()
} else {
exported_names
}
} else {
match &import_pattern.members[0] {
ImportPatternMember::Glob { .. } => exported_names
.into_iter()
.map(|name| {
let mut new_name = import_pattern.head.to_vec();
new_name.push(b'.');
new_name.push(b' ');
new_name.extend(&name);
new_name
})
@ -638,7 +700,7 @@ pub fn parse_hide(
.filter(|n| n == name)
.map(|n| {
let mut new_name = import_pattern.head.to_vec();
new_name.push(b'.');
new_name.push(b' ');
new_name.extend(&n);
new_name
})
@ -659,7 +721,7 @@ pub fn parse_hide(
.filter_map(|n| if n == name { Some(n.clone()) } else { None })
.map(|n| {
let mut new_name = import_pattern.head.to_vec();
new_name.push(b'.');
new_name.push(b' ');
new_name.extend(n);
new_name
})
@ -678,6 +740,8 @@ pub fn parse_hide(
};
for name in names_to_hide {
// 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?
if working_set.hide_decl(&name).is_none() {
error = error.or_else(|| Some(ParseError::UnknownCommand(spans[1])));
}
@ -833,6 +897,11 @@ pub fn parse_source(
);
}
}
} else {
return (
garbage_statement(spans),
Some(ParseError::NonUtf8(spans[1])),
);
}
}
return (

211
crates/nu-parser/src/parser.rs
View File

@ -39,6 +39,26 @@ fn is_identifier_byte(b: u8) -> bool {
b != b'.' && b != b'[' && b != b'(' && b != b'{'
}
fn is_math_expression_byte(b: u8) -> bool {
b == b'0'
|| b == b'1'
|| b == b'2'
|| b == b'3'
|| b == b'4'
|| b == b'5'
|| b == b'6'
|| b == b'7'
|| b == b'8'
|| b == b'9'
|| b == b'('
|| b == b'{'
|| b == b'['
|| b == b'$'
|| b == b'"'
|| b == b'\''
|| b == b'-'
}
fn is_identifier(bytes: &[u8]) -> bool {
bytes.iter().all(|x| is_identifier_byte(*x))
}
@ -595,7 +615,16 @@ pub fn parse_call(
spans: &[Span],
expand_aliases: bool,
) -> (Expression, Option<ParseError>) {
// assume spans.len() > 0?
if spans.is_empty() {
return (
garbage(Span::unknown()),
Some(ParseError::UnknownState(
"Encountered command with zero spans".into(),
span(spans),
)),
);
}
let mut pos = 0;
let mut shorthand = vec![];
@ -613,104 +642,82 @@ pub fn parse_call(
if pos == spans.len() {
return (
Expression::garbage(span(spans)),
garbage(span(spans)),
Some(ParseError::UnknownCommand(spans[0])),
);
}
let name = working_set.get_span_contents(spans[pos]);
let cmd_start = pos;
let mut name_spans = vec![];
if expand_aliases {
if let Some(expansion) = working_set.find_alias(name) {
let orig_span = spans[pos];
//let mut spans = spans.to_vec();
let mut new_spans: Vec<Span> = vec![];
new_spans.extend(&spans[0..pos]);
new_spans.extend(expansion);
if spans.len() > pos {
new_spans.extend(&spans[(pos + 1)..]);
}
for word_span in spans[cmd_start..].iter() {
// Find the longest group of words that could form a command
let bytes = working_set.get_span_contents(*word_span);
let (result, err) = parse_expression(working_set, &new_spans, false);
if is_math_expression_byte(bytes[0]) {
break;
}
let expression = match result {
Expression {
expr: Expr::Call(mut call),
span,
ty,
custom_completion: None,
} => {
call.head = orig_span;
name_spans.push(*word_span);
let name = working_set.get_span_contents(span(&name_spans));
if expand_aliases {
// If the word is an alias, expand it and re-parse the expression
if let Some(expansion) = working_set.find_alias(name) {
let orig_span = spans[pos];
let mut new_spans: Vec<Span> = vec![];
new_spans.extend(&spans[0..pos]);
new_spans.extend(expansion);
if spans.len() > pos {
new_spans.extend(&spans[(pos + 1)..]);
}
let (result, err) = parse_expression(working_set, &new_spans, false);
let expression = match result {
Expression {
expr: Expr::Call(call),
expr: Expr::Call(mut call),
span,
ty,
custom_completion: None,
}
}
x => x,
};
return (expression, err);
}
}
pos += 1;
if let Some(mut decl_id) = working_set.find_decl(name) {
let mut name = name.to_vec();
while pos < spans.len() {
// look to see if it's a subcommand
let mut new_name = name.to_vec();
new_name.push(b' ');
new_name.extend(working_set.get_span_contents(spans[pos]));
if expand_aliases {
if let Some(expansion) = working_set.find_alias(&new_name) {
let orig_span = span(&spans[cmd_start..pos + 1]);
//let mut spans = spans.to_vec();
let mut new_spans: Vec<Span> = vec![];
new_spans.extend(&spans[0..cmd_start]);
new_spans.extend(expansion);
if spans.len() > pos {
new_spans.extend(&spans[(pos + 1)..]);
}
let (result, err) = parse_expression(working_set, &new_spans, false);
let expression = match result {
} => {
call.head = orig_span;
Expression {
expr: Expr::Call(mut call),
expr: Expr::Call(call),
span,
ty,
custom_completion: None,
} => {
call.head = orig_span;
Expression {
expr: Expr::Call(call),
span,
ty,
custom_completion: None,
}
}
x => x,
};
}
x => x,
};
return (expression, err);
}
return (expression, err);
}
if let Some(did) = working_set.find_decl(&new_name) {
decl_id = did;
} else {
break;
}
name = new_name;
pos += 1;
}
pos += 1;
}
let name = working_set.get_span_contents(span(&name_spans));
let mut maybe_decl_id = working_set.find_decl(name);
while maybe_decl_id.is_none() {
// Find the longest command match
if name_spans.len() <= 1 {
// Keep the first word even if it does not match -- could be external command
break;
}
name_spans.pop();
pos -= 1;
let name = working_set.get_span_contents(span(&name_spans));
maybe_decl_id = working_set.find_decl(name);
}
if let Some(decl_id) = maybe_decl_id {
// Before the internal parsing we check if there is no let or alias declarations
// that are missing their name, e.g.: let = 1 or alias = 2
if spans.len() > 1 {
@ -718,7 +725,7 @@ pub fn parse_call(
if test_equal == [b'='] {
return (
garbage(Span::new(0, 0)),
garbage(Span::unknown()),
Some(ParseError::UnknownState(
"Incomplete statement".into(),
span(spans),
@ -728,8 +735,12 @@ pub fn parse_call(
}
// parse internal command
let (call, _, err) =
parse_internal_call(working_set, span(&spans[0..pos]), &spans[pos..], decl_id);
let (call, _, err) = parse_internal_call(
working_set,
span(&spans[cmd_start..pos]),
&spans[pos..],
decl_id,
);
(
Expression {
expr: Expr::Call(call),
@ -748,6 +759,8 @@ pub fn parse_call(
return (range_expr, range_err);
}
}
// Otherwise, try external command
parse_external_call(working_set, spans)
}
}
@ -1703,40 +1716,36 @@ pub fn parse_type(_working_set: &StateWorkingSet, bytes: &[u8]) -> Type {
pub fn parse_import_pattern(
working_set: &mut StateWorkingSet,
span: Span,
spans: &[Span],
) -> (ImportPattern, Option<ParseError>) {
let source = working_set.get_span_contents(span);
let mut error = None;
let (tokens, err) = lex(source, span.start, &[], &[b'.']);
error = error.or(err);
if tokens.is_empty() {
let head = if let Some(head_span) = spans.get(0) {
working_set.get_span_contents(*head_span).to_vec()
} else {
return (
ImportPattern {
head: vec![],
members: vec![],
},
Some(ParseError::MissingImportPattern(span)),
Some(ParseError::WrongImportPattern(span(spans))),
);
}
};
let head = working_set.get_span_contents(tokens[0].span).to_vec();
if let Some(tail) = tokens.get(2) {
if let Some(tail_span) = spans.get(1) {
// FIXME: expand this to handle deeper imports once we support module imports
let tail_span = tail.span;
let tail = working_set.get_span_contents(tail.span);
let tail = working_set.get_span_contents(*tail_span);
if tail == b"*" {
(
ImportPattern {
head,
members: vec![ImportPatternMember::Glob { span: tail_span }],
members: vec![ImportPatternMember::Glob { span: *tail_span }],
},
error,
)
} else if tail.starts_with(b"[") {
let (result, err) = parse_list_expression(working_set, tail_span, &SyntaxShape::String);
let (result, err) =
parse_list_expression(working_set, *tail_span, &SyntaxShape::String);
error = error.or(err);
let mut output = vec![];
@ -1773,7 +1782,7 @@ pub fn parse_import_pattern(
head,
members: vec![ImportPatternMember::Name {
name: tail.to_vec(),
span: tail_span,
span: *tail_span,
}],
},
error,
@ -2945,10 +2954,10 @@ pub fn parse_expression(
) -> (Expression, Option<ParseError>) {
let bytes = working_set.get_span_contents(spans[0]);
match bytes[0] {
b'0' | b'1' | b'2' | b'3' | b'4' | b'5' | b'6' | b'7' | b'8' | b'9' | b'(' | b'{'
| b'[' | b'$' | b'"' | b'\'' | b'-' => parse_math_expression(working_set, spans, None),
_ => parse_call(working_set, spans, expand_aliases),
if is_math_expression_byte(bytes[0]) {
parse_math_expression(working_set, spans, None)
} else {
parse_call(working_set, spans, expand_aliases)
}
}

4
crates/nu-protocol/src/engine/engine_state.rs
View File

@ -506,7 +506,7 @@ impl<'a> StateWorkingSet<'a> {
let permanent_span_start = self.permanent_state.next_span_start();
if let Some((_, _, last)) = self.delta.file_contents.last() {
permanent_span_start + *last
*last
} else {
permanent_span_start
}
@ -566,7 +566,7 @@ impl<'a> StateWorkingSet<'a> {
if permanent_end <= span.start {
for (contents, start, finish) in &self.delta.file_contents {
if (span.start >= *start) && (span.end <= *finish) {
return &contents[(span.start - permanent_end)..(span.end - permanent_end)];
return &contents[(span.start - start)..(span.end - start)];
}
}
} else {

44
src/tests.rs
View File

@ -247,6 +247,14 @@ fn alias_2() -> TestResult {
)
}
#[test]
fn alias_2_multi_word() -> TestResult {
run_test(
r#"def "foo bar" [$x $y] { $x + $y + 10 }; alias f = foo bar 33; f 100"#,
"143",
)
}
#[test]
fn block_param1() -> TestResult {
run_test("[3] | each { $it + 10 } | get 0", "13")
@ -389,7 +397,7 @@ fn better_block_types() -> TestResult {
#[test]
fn module_imports_1() -> TestResult {
run_test(
r#"module foo { export def a [] { 1 }; def b [] { 2 } }; use foo; foo.a"#,
r#"module foo { export def a [] { 1 }; def b [] { 2 } }; use foo; foo a"#,
"1",
)
}
@ -397,7 +405,7 @@ fn module_imports_1() -> TestResult {
#[test]
fn module_imports_2() -> TestResult {
run_test(
r#"module foo { export def a [] { 1 }; def b [] { 2 } }; use foo.a; a"#,
r#"module foo { export def a [] { 1 }; def b [] { 2 } }; use foo a; a"#,
"1",
)
}
@ -405,7 +413,7 @@ fn module_imports_2() -> TestResult {
#[test]
fn module_imports_3() -> TestResult {
run_test(
r#"module foo { export def a [] { 1 }; export def b [] { 2 } }; use foo.*; b"#,
r#"module foo { export def a [] { 1 }; export def b [] { 2 } }; use foo *; b"#,
"2",
)
}
@ -413,7 +421,7 @@ fn module_imports_3() -> TestResult {
#[test]
fn module_imports_4() -> TestResult {
fail_test(
r#"module foo { export def a [] { 1 }; export def b [] { 2 } }; use foo.c"#,
r#"module foo { export def a [] { 1 }; export def b [] { 2 } }; use foo c"#,
"not find import",
)
}
@ -421,7 +429,7 @@ fn module_imports_4() -> TestResult {
#[test]
fn module_imports_5() -> TestResult {
run_test(
r#"module foo { export def a [] { 1 }; def b [] { 2 }; export def c [] { 3 } }; use foo.[a, c]; c"#,
r#"module foo { export def a [] { 1 }; def b [] { 2 }; export def c [] { 3 } }; use foo [a, c]; c"#,
"3",
)
}
@ -429,7 +437,7 @@ fn module_imports_5() -> TestResult {
#[test]
fn module_import_uses_internal_command() -> TestResult {
run_test(
r#"module foo { def b [] { 2 }; export def a [] { b } }; use foo; foo.a"#,
r#"module foo { def b [] { 2 }; export def a [] { b } }; use foo; foo a"#,
"2",
)
}
@ -491,7 +499,7 @@ fn hide_twice_not_allowed() -> TestResult {
#[test]
fn hides_import_1() -> TestResult {
fail_test(
r#"module spam { export def foo [] { "foo" } }; use spam; hide spam.foo; foo"#,
r#"module spam { export def foo [] { "foo" } }; use spam; hide spam foo; foo"#,
not_found_msg(),
)
}
@ -499,7 +507,7 @@ fn hides_import_1() -> TestResult {
#[test]
fn hides_import_2() -> TestResult {
fail_test(
r#"module spam { export def foo [] { "foo" } }; use spam; hide spam.*; foo"#,
r#"module spam { export def foo [] { "foo" } }; use spam; hide spam *; foo"#,
not_found_msg(),
)
}
@ -507,7 +515,7 @@ fn hides_import_2() -> TestResult {
#[test]
fn hides_import_3() -> TestResult {
fail_test(
r#"module spam { export def foo [] { "foo" } }; use spam; hide spam.[foo]; foo"#,
r#"module spam { export def foo [] { "foo" } }; use spam; hide spam [foo]; foo"#,
not_found_msg(),
)
}
@ -515,7 +523,7 @@ fn hides_import_3() -> TestResult {
#[test]
fn hides_import_4() -> TestResult {
fail_test(
r#"module spam { export def foo [] { "foo" } }; use spam.foo; hide foo; foo"#,
r#"module spam { export def foo [] { "foo" } }; use spam foo; hide foo; foo"#,
not_found_msg(),
)
}
@ -523,7 +531,15 @@ fn hides_import_4() -> TestResult {
#[test]
fn hides_import_5() -> TestResult {
fail_test(
r#"module spam { export def foo [] { "foo" } }; use spam.*; hide foo; foo"#,
r#"module spam { export def foo [] { "foo" } }; use spam *; hide foo; foo"#,
not_found_msg(),
)
}
#[test]
fn hides_import_6() -> TestResult {
fail_test(
r#"module spam { export def foo [] { "foo" } }; use spam; hide spam; foo"#,
not_found_msg(),
)
}
@ -539,7 +555,7 @@ fn def_twice_should_fail() -> TestResult {
#[test]
fn use_import_after_hide() -> TestResult {
run_test(
r#"module spam { export def foo [] { "foo" } }; use spam.foo; hide foo; use spam.foo; foo"#,
r#"module spam { export def foo [] { "foo" } }; use spam foo; hide foo; use spam foo; foo"#,
"foo",
)
}
@ -547,7 +563,7 @@ fn use_import_after_hide() -> TestResult {
#[test]
fn hide_shadowed_decl() -> TestResult {
run_test(
r#"module spam { export def foo [] { "bar" } }; def foo [] { "foo" }; do { use spam.foo; hide foo; foo }"#,
r#"module spam { export def foo [] { "bar" } }; def foo [] { "foo" }; do { use spam foo; hide foo; foo }"#,
"foo",
)
}
@ -555,7 +571,7 @@ fn hide_shadowed_decl() -> TestResult {
#[test]
fn hides_all_decls_within_scope() -> TestResult {
fail_test(
r#"module spam { export def foo [] { "bar" } }; def foo [] { "foo" }; use spam.foo; hide foo; foo"#,
r#"module spam { export def foo [] { "bar" } }; def foo [] { "foo" }; use spam foo; hide foo; foo"#,
not_found_msg(),
)
}