language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-09-28 14:24:45 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

don't leak implementation details

Browse source
This commit is contained in:
Folkert 2021-03-09 23:20:31 +01:00
parent bd61a03ae0
commit 91271d0308
5 changed files with 42 additions and 55 deletions
Download patch file Download diff file Expand all files Collapse all files

24
compiler/load/src/file.rs
View file

@ -2305,7 +2305,7 @@ fn load_pkg_config<'a>(
let parse_start = SystemTime::now(); let parse_start = SystemTime::now();
let bytes = arena.alloc(bytes_vec); let bytes = arena.alloc(bytes_vec);
let parse_state = parser::State::new_in(arena, bytes); let parse_state = parser::State::new_in(arena, bytes);
let parsed = roc_parse::module::header().parse(&arena, parse_state); let parsed = roc_parse::module::parse_header(&arena, parse_state);
let parse_header_duration = parse_start.elapsed().unwrap(); let parse_header_duration = parse_start.elapsed().unwrap();
// Insert the first entries for this module's timings // Insert the first entries for this module's timings
@ -2319,19 +2319,19 @@ fn load_pkg_config<'a>(
effect_module_timing.parse_header = parse_header_duration; effect_module_timing.parse_header = parse_header_duration;
match parsed { match parsed {
Ok((_, ast::Module::Interface { header }, _parse_state)) => { Ok((ast::Module::Interface { header }, _parse_state)) => {
Err(LoadingProblem::UnexpectedHeader(format!( Err(LoadingProblem::UnexpectedHeader(format!(
"expected platform/package module, got Interface with header\n{:?}", "expected platform/package module, got Interface with header\n{:?}",
header header
))) )))
} }
Ok((_, ast::Module::App { header }, _parse_state)) => { Ok((ast::Module::App { header }, _parse_state)) => {
Err(LoadingProblem::UnexpectedHeader(format!( Err(LoadingProblem::UnexpectedHeader(format!(
"expected platform/package module, got App with header\n{:?}", "expected platform/package module, got App with header\n{:?}",
header header
))) )))
} }
Ok((_, ast::Module::Platform { header }, parser_state)) => { Ok((ast::Module::Platform { header }, parser_state)) => {
// make a Pkg-Config module that ultimately exposes `main` to the host // make a Pkg-Config module that ultimately exposes `main` to the host
let pkg_config_module_msg = fabricate_pkg_config_module( let pkg_config_module_msg = fabricate_pkg_config_module(
arena, arena,
@ -2359,8 +2359,8 @@ fn load_pkg_config<'a>(
Ok(Msg::Many(vec![effects_module_msg, pkg_config_module_msg])) Ok(Msg::Many(vec![effects_module_msg, pkg_config_module_msg]))
} }
Err((_, fail, _)) => Err(LoadingProblem::ParsingFailed( Err(fail) => Err(LoadingProblem::ParsingFailed(
fail.into_parse_problem(filename, bytes), SyntaxError::Header(fail).into_parse_problem(filename, bytes),
)), )),
} }
} }
@ -2475,7 +2475,7 @@ fn parse_header<'a>(
) -> Result<(ModuleId, Msg<'a>), LoadingProblem<'a>> { ) -> Result<(ModuleId, Msg<'a>), LoadingProblem<'a>> {
let parse_start = SystemTime::now(); let parse_start = SystemTime::now();
let parse_state = parser::State::new_in(arena, src_bytes); let parse_state = parser::State::new_in(arena, src_bytes);
let parsed = roc_parse::module::header().parse(&arena, parse_state); let parsed = roc_parse::module::parse_header(&arena, parse_state);
let parse_header_duration = parse_start.elapsed().unwrap(); let parse_header_duration = parse_start.elapsed().unwrap();
// Insert the first entries for this module's timings // Insert the first entries for this module's timings
@ -2485,7 +2485,7 @@ fn parse_header<'a>(
module_timing.parse_header = parse_header_duration; module_timing.parse_header = parse_header_duration;
match parsed { match parsed {
Ok((_, ast::Module::Interface { header }, parse_state)) => { Ok((ast::Module::Interface { header }, parse_state)) => {
let header_src = unsafe { let header_src = unsafe {
let chomped = src_bytes.len() - parse_state.bytes.len(); let chomped = src_bytes.len() - parse_state.bytes.len();
std::str::from_utf8_unchecked(&src_bytes[..chomped]) std::str::from_utf8_unchecked(&src_bytes[..chomped])
@ -2514,7 +2514,7 @@ fn parse_header<'a>(
module_timing, module_timing,
)) ))
} }
Ok((_, ast::Module::App { header }, parse_state)) => { Ok((ast::Module::App { header }, parse_state)) => {
let mut pkg_config_dir = filename.clone(); let mut pkg_config_dir = filename.clone();
pkg_config_dir.pop(); pkg_config_dir.pop();
@ -2623,7 +2623,7 @@ fn parse_header<'a>(
}, },
} }
} }
Ok((_, ast::Module::Platform { header }, _parse_state)) => Ok(fabricate_effects_module( Ok((ast::Module::Platform { header }, _parse_state)) => Ok(fabricate_effects_module(
arena, arena,
&"", &"",
module_ids, module_ids,
@ -2632,8 +2632,8 @@ fn parse_header<'a>(
header, header,
module_timing, module_timing,
)), )),
Err((_, fail, _)) => Err(LoadingProblem::ParsingFailed( Err(fail) => Err(LoadingProblem::ParsingFailed(
fail.into_parse_problem(filename, src_bytes), SyntaxError::Header(fail).into_parse_problem(filename, src_bytes),
)), )),
} }
} }

12
compiler/parse/src/module.rs
View file

@ -16,11 +16,17 @@ use crate::type_annotation;
use bumpalo::collections::Vec; use bumpalo::collections::Vec;
use roc_region::all::Located; use roc_region::all::Located;
pub fn header<'a>() -> impl Parser<'a, Module<'a>, SyntaxError<'a>> { pub fn parse_header<'a>(
specialize(|e, _, _| SyntaxError::Header(e), header_help()) arena: &'a bumpalo::Bump,
state: State<'a>,
) -> Result<(Module<'a>, State<'a>), EHeader<'a>> {
match header().parse(arena, state) {
Ok((_, module, state)) => Ok((module, state)),
Err((_, fail, _)) => Err(fail),
}
} }
fn header_help<'a>() -> impl Parser<'a, Module<'a>, EHeader<'a>> { fn header<'a>() -> impl Parser<'a, Module<'a>, EHeader<'a>> {
use crate::parser::keyword_e; use crate::parser::keyword_e;
one_of![ one_of![

14
compiler/parse/src/test_helpers.rs
View file

@ -1,7 +1,7 @@
use crate::ast; use crate::ast;
use crate::blankspace::space0_before; use crate::blankspace::space0_before;
use crate::expr::expr; use crate::expr::expr;
use crate::module::{header, module_defs}; use crate::module::module_defs;
use crate::parser::{loc, Parser, State, SyntaxError}; use crate::parser::{loc, Parser, State, SyntaxError};
use bumpalo::collections::Vec; use bumpalo::collections::Vec;
use bumpalo::Bump; use bumpalo::Bump;
@ -14,18 +14,6 @@ pub fn parse_expr_with<'a>(
parse_loc_with(arena, input).map(|loc_expr| loc_expr.value) parse_loc_with(arena, input).map(|loc_expr| loc_expr.value)
} }
pub fn parse_header_with<'a>(
arena: &'a Bump,
input: &'a str,
) -> Result<ast::Module<'a>, SyntaxError<'a>> {
let state = State::new_in(arena, input.trim().as_bytes());
let answer = header().parse(arena, state);
answer
.map(|(_, loc_expr, _)| loc_expr)
.map_err(|(_, fail, _)| fail)
}
#[allow(dead_code)] #[allow(dead_code)]
pub fn parse_defs_with<'a>( pub fn parse_defs_with<'a>(
arena: &'a Bump, arena: &'a Bump,

41
compiler/parse/tests/test_parse.rs
View file

@ -2433,9 +2433,8 @@ mod test_parse {
app "test-app" packages {} imports [] provides [] to blah app "test-app" packages {} imports [] provides [] to blah
"# "#
); );
let actual = roc_parse::module::header() let actual = roc_parse::module::parse_header(&arena, State::new_in(&arena, src.as_bytes()))
.parse(&arena, State::new_in(&arena, src.as_bytes())) .map(|tuple| tuple.0);
.map(|tuple| tuple.1);
assert_eq!(Ok(expected), actual); assert_eq!(Ok(expected), actual);
} }
@ -2474,9 +2473,8 @@ mod test_parse {
"# "#
); );
let actual = roc_parse::module::header() let actual = roc_parse::module::parse_header(&arena, State::new_in(&arena, src.as_bytes()))
.parse(&arena, State::new_in(&arena, src.as_bytes())) .map(|tuple| tuple.0);
.map(|tuple| tuple.1);
assert_eq!(Ok(expected), actual); assert_eq!(Ok(expected), actual);
} }
@ -2530,9 +2528,8 @@ mod test_parse {
"# "#
); );
let actual = roc_parse::module::header() let actual = roc_parse::module::parse_header(&arena, State::new_in(&arena, src.as_bytes()))
.parse(&arena, State::new_in(&arena, src.as_bytes())) .map(|tuple| tuple.0);
.map(|tuple| tuple.1);
assert_eq!(Ok(expected), actual); assert_eq!(Ok(expected), actual);
} }
@ -2576,9 +2573,8 @@ mod test_parse {
let expected = roc_parse::ast::Module::Platform { header }; let expected = roc_parse::ast::Module::Platform { header };
let src = "platform rtfeldman/blah requires {} exposes [] packages {} imports [] provides [] effects fx.Blah {}"; let src = "platform rtfeldman/blah requires {} exposes [] packages {} imports [] provides [] effects fx.Blah {}";
let actual = roc_parse::module::header() let actual = roc_parse::module::parse_header(&arena, State::new_in(&arena, src.as_bytes()))
.parse(&arena, State::new_in(&arena, src.as_bytes())) .map(|tuple| tuple.0);
.map(|tuple| tuple.1);
assert_eq!(Ok(expected), actual); assert_eq!(Ok(expected), actual);
} }
@ -2646,9 +2642,8 @@ mod test_parse {
effects fx.Effect {} effects fx.Effect {}
"# "#
); );
let actual = roc_parse::module::header() let actual = roc_parse::module::parse_header(&arena, State::new_in(&arena, src.as_bytes()))
.parse(&arena, State::new_in(&arena, src.as_bytes())) .map(|tuple| tuple.0);
.map(|tuple| tuple.1);
assert_eq!(Ok(expected), actual); assert_eq!(Ok(expected), actual);
} }
@ -2678,9 +2673,8 @@ mod test_parse {
interface Foo exposes [] imports [] interface Foo exposes [] imports []
"# "#
); );
let actual = roc_parse::module::header() let actual = roc_parse::module::parse_header(&arena, State::new_in(&arena, src.as_bytes()))
.parse(&arena, State::new_in(&arena, src.as_bytes())) .map(|tuple| tuple.0);
.map(|tuple| tuple.1);
assert_eq!(Ok(expected), actual); assert_eq!(Ok(expected), actual);
} }
@ -2710,9 +2704,8 @@ mod test_parse {
interface Foo.Bar.Baz exposes [] imports [] interface Foo.Bar.Baz exposes [] imports []
"# "#
); );
let actual = roc_parse::module::header() let actual = roc_parse::module::parse_header(&arena, State::new_in(&arena, src.as_bytes()))
.parse(&arena, State::new_in(&arena, src.as_bytes())) .map(|tuple| tuple.0);
.map(|tuple| tuple.1);
assert_eq!(Ok(expected), actual); assert_eq!(Ok(expected), actual);
} }
@ -2818,7 +2811,7 @@ mod test_parse {
let actual = module_defs() let actual = module_defs()
.parse(&arena, State::new_in(&arena, src.as_bytes())) .parse(&arena, State::new_in(&arena, src.as_bytes()))
.map(|tuple| tuple.1); .map(|tuple| tuple.0);
assert!(actual.is_ok()); assert!(actual.is_ok());
} }
@ -2840,7 +2833,7 @@ mod test_parse {
let actual = module_defs() let actual = module_defs()
.parse(&arena, State::new_in(&arena, src.as_bytes())) .parse(&arena, State::new_in(&arena, src.as_bytes()))
.map(|tuple| tuple.1); .map(|tuple| tuple.0);
assert!(actual.is_ok()); assert!(actual.is_ok());
} }
@ -2861,7 +2854,7 @@ mod test_parse {
let actual = module_defs() let actual = module_defs()
.parse(&arena, State::new_in(&arena, src.as_bytes())) .parse(&arena, State::new_in(&arena, src.as_bytes()))
.map(|tuple| tuple.1); .map(|tuple| tuple.0);
dbg!(&actual); dbg!(&actual);

6
editor/src/lang/roc_file.rs
View file

@ -37,10 +37,10 @@ impl<'a> File<'a> {
let allocation = arena.alloc(bytes); let allocation = arena.alloc(bytes);
let module_parse_state = parser::State::new_in(arena, allocation); let module_parse_state = parser::State::new_in(arena, allocation);
let parsed_module = roc_parse::module::header().parse(&arena, module_parse_state); let parsed_module = roc_parse::module::parse_header(&arena, module_parse_state);
match parsed_module { match parsed_module {
Ok((_, module, state)) => { Ok((module, state)) => {
let parsed_defs = module_defs().parse(&arena, state); let parsed_defs = module_defs().parse(&arena, state);
match parsed_defs { match parsed_defs {
@ -52,7 +52,7 @@ impl<'a> File<'a> {
Err((_, error, _)) => Err(ReadError::ParseDefs(error)), Err((_, error, _)) => Err(ReadError::ParseDefs(error)),
} }
} }
Err((_, error, _)) => Err(ReadError::ParseHeader(error)), Err(error) => Err(ReadError::ParseHeader(SyntaxError::Header(error))),
} }
} }