language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-09-29 14:54:47 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7

fix top level def

Browse source
This commit is contained in:
Folkert 2021-02-02 16:24:21 +01:00
parent 851f472167
commit e83cb0d027
6 changed files with 31 additions and 28 deletions
Download patch file Download diff file Expand all files Collapse all files

2
compiler/parse/src/blankspace.rs
View file

@ -280,7 +280,7 @@ pub fn spaces_exactly<'a>(spaces_expected: u16) -> impl Parser<'a, ()> {
Err(FailReason::BadUtf8) => {
// If we hit an invalid UTF-8 character, bail out immediately.
let progress = Progress::from_bool(spaces_seen != 0);
let progress = Progress::progress_when(spaces_seen != 0);
return state.fail(progress, FailReason::BadUtf8);
}
Err(_) => {

8
compiler/parse/src/ident.rs
View file

@ -121,7 +121,7 @@ pub fn parse_ident<'a>(
}
}
Err(reason) => {
let progress = Progress::from_bool(state.bytes.len() == start_bytes_len);
let progress = Progress::from_lengths(start_bytes_len, state.bytes.len());
return state.fail(progress, reason);
}
}
@ -130,7 +130,7 @@ pub fn parse_ident<'a>(
}
}
Err(reason) => {
let progress = Progress::from_bool(state.bytes.len() == start_bytes_len);
let progress = Progress::from_lengths(start_bytes_len, state.bytes.len());
return state.fail(progress, reason);
}
}
@ -195,7 +195,7 @@ pub fn parse_ident<'a>(
state = state.advance_without_indenting(bytes_parsed)?;
}
Err(reason) => {
let progress = Progress::from_bool(state.bytes.len() == start_bytes_len);
let progress = Progress::from_lengths(start_bytes_len, state.bytes.len());
return state.fail(progress, reason);
}
}
@ -267,7 +267,7 @@ pub fn parse_ident<'a>(
}
};
let progress = Progress::from_bool(state.bytes.len() != start_bytes_len);
let progress = Progress::from_lengths(start_bytes_len, state.bytes.len());
debug_assert_eq!(progress, Progress::MadeProgress,);
Ok((Progress::MadeProgress, (answer, None), state))
}

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

@ -99,12 +99,12 @@ pub fn parse_package_part<'a>(arena: &'a Bump, mut state: State<'a>) -> ParseRes
state = state.advance_without_indenting(bytes_parsed)?;
} else {
let progress = Progress::from_bool(!part_buf.is_empty());
let progress = Progress::progress_when(!part_buf.is_empty());
return Ok((progress, part_buf.into_bump_str(), state));
}
}
Err(reason) => {
let progress = Progress::from_bool(!part_buf.is_empty());
let progress = Progress::progress_when(!part_buf.is_empty());
return state.fail(progress, reason);
}
}
@ -299,7 +299,7 @@ pub fn platform_header<'a>() -> impl Parser<'a, PlatformHeader<'a>> {
pub fn module_defs<'a>() -> impl Parser<'a, Vec<'a, Located<Def<'a>>>> {
move |a: &'a Bump, s: State<'a>| {
// this parses just the defs
let defs = zero_or_more!(space0_around(loc(def(0)), 0));
let defs = zero_or_more!(space0_around(loc(debug!(def(0))), 0));
// let result = skip_second!(defs, end_of_file()).parse(a, s);
let result = defs.parse(a, s);

4
compiler/parse/src/parser.rs
View file

@ -239,10 +239,10 @@ impl Progress {
Self::from_consumed(before - after)
}
pub fn from_consumed(chars_consumed: usize) -> Self {
Self::from_bool(chars_consumed != 0)
Self::progress_when(chars_consumed != 0)
}
pub fn from_bool(made_progress: bool) -> Self {
pub fn progress_when(made_progress: bool) -> Self {
if made_progress {
Progress::MadeProgress
} else {

37
compiler/parse/src/type_annotation.rs
View file

@ -53,12 +53,12 @@ pub fn term<'a>(min_indent: u16) -> impl Parser<'a, Located<TypeAnnotation<'a>>>
map_with_arena!(
and!(
one_of!(
// loc_wildcard(),
// loc_parenthetical_type(min_indent),
// loc!(record_type(min_indent)),
// loc!(tag_union!(min_indent)),
|a, s| dbg!(loc!(applied_type(min_indent)).parse(a, s)),
|a, s| dbg!(loc!(parse_type_variable).parse(a, s))
loc_wildcard(),
loc_parenthetical_type(min_indent),
loc!(record_type(min_indent)),
loc!(tag_union!(min_indent)),
loc!(applied_type(min_indent)),
loc!(parse_type_variable)
),
|a, s| {
dbg!("term state", &s);
@ -220,6 +220,7 @@ fn applied_type<'a>(min_indent: u16) -> impl Parser<'a, TypeAnnotation<'a>> {
}
fn expression<'a>(min_indent: u16) -> impl Parser<'a, Located<TypeAnnotation<'a>>> {
dbg!("parsing type ig");
use crate::blankspace::space0;
move |arena, state: State<'a>| {
let (p1, first, state) = space0_before(term(min_indent), min_indent).parse(arena, state)?;
@ -293,7 +294,7 @@ fn parse_concrete_type<'a>(
let mut part_buf = String::new_in(arena); // The current "part" (parts are dot-separated.)
let mut parts: Vec<&'a str> = Vec::new_in(arena);
let start_bytes_remaining = state.bytes.len();
let start_bytes_len = state.bytes.len();
// Qualified types must start with a capitalized letter.
match peek_utf8_char(&state) {
@ -353,9 +354,9 @@ fn parse_concrete_type<'a>(
state = state.advance_without_indenting(bytes_parsed)?;
}
Err(reason) => {
let made_progress = state.bytes.len() != start_bytes_remaining;
let progress = Progress::from_lengths(start_bytes_len, state.bytes.len());
return state.fail(Progress::from_bool(made_progress), reason);
return state.fail(progress, reason);
}
}
}
@ -383,8 +384,8 @@ fn parse_concrete_type<'a>(
&[],
);
let made_progress = state.bytes.len() != start_bytes_remaining;
Ok((Progress::from_bool(made_progress), answer, state))
let progress = Progress::from_lengths(start_bytes_len, state.bytes.len());
Ok((progress, answer, state))
}
fn parse_type_variable<'a>(
@ -393,7 +394,7 @@ fn parse_type_variable<'a>(
) -> ParseResult<'a, TypeAnnotation<'a>> {
let mut buf = String::new_in(arena);
let start_bytes_remaining = state.bytes.len();
let start_bytes_len = state.bytes.len();
match peek_utf8_char(&state) {
Ok((first_letter, bytes_parsed)) => {
@ -407,8 +408,8 @@ fn parse_type_variable<'a>(
state = state.advance_without_indenting(bytes_parsed)?;
}
Err(reason) => {
let made_progress = state.bytes.len() != start_bytes_remaining;
return state.fail(Progress::from_bool(made_progress), reason);
let progress = Progress::from_lengths(start_bytes_len, state.bytes.len());
return state.fail(progress, reason);
}
}
@ -429,16 +430,16 @@ fn parse_type_variable<'a>(
state = state.advance_without_indenting(bytes_parsed)?;
}
Err(reason) => {
let made_progress = state.bytes.len() != start_bytes_remaining;
return state.fail(Progress::from_bool(made_progress), reason);
let progress = Progress::from_lengths(start_bytes_len, state.bytes.len());
return state.fail(progress, reason);
}
}
}
let answer = TypeAnnotation::BoundVariable(buf.into_bump_str());
let made_progress = state.bytes.len() != start_bytes_remaining;
Ok((Progress::from_bool(made_progress), answer, state))
let progress = Progress::from_lengths(start_bytes_len, state.bytes.len());
Ok((progress, answer, state))
}
fn malformed<'a>(