language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-08-03 19:58:18 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Revert "Attempt a refactor, but run into lifetime issues"

Browse source 
This reverts commit 4a9b44aaaf.
This commit is contained in:
Richard Feldman 2022-10-30 07:22:32 -04:00
parent 4a9b44aaaf
commit 99f4d99771
No known key found for this signature in database
GPG key ID: F1F21AA5B1D9E43B
1 changed files with 61 additions and 97 deletions
Download patch file Download diff file Expand all files Collapse all files

158
crates/compiler/parse/src/expr.rs
View file

@ -925,65 +925,6 @@ pub fn parse_single_def<'a>(
}
}
pub fn join_ann_to_body<'a>(
arena: &'a Bump,
loc_pattern: &'a Loc<Pattern<'a>>,
loc_def_expr: &'a Loc<Expr<'a>>,
ann_pattern: &Loc<Pattern<'a>>,
ann_type: &Loc<TypeAnnotation<'a>>,
spaces_before_current: &'a [CommentOrNewline],
region: Region,
) -> (ValueDef<'a>, Region) {
// join this body with the preceding annotation
let value_def = ValueDef::AnnotatedBody {
ann_pattern: arena.alloc(*ann_pattern),
ann_type: arena.alloc(*ann_type),
comment: spaces_before_current
.first()
.and_then(CommentOrNewline::comment_str),
body_pattern: arena.alloc(loc_pattern),
body_expr: *arena.alloc(loc_def_expr),
};
(value_def, Region::span_across(&ann_pattern.region, &region))
}
pub fn join_alias_to_body<'a>(
arena: &'a Bump,
loc_pattern: &'a Loc<Pattern<'a>>,
loc_def_expr: &'a Loc<Expr<'a>>,
header: &'a TypeHeader<'a>,
ann_type: &'a Loc<TypeAnnotation<'a>>,
spaces_before_current: &'a [CommentOrNewline],
region: Region,
) -> (ValueDef<'a>, Region) {
// This is a case like
// UserId x : [UserId Int]
// UserId x = UserId 42
// We optimistically parsed the first line as an alias; we now turn it
// into an annotation.
let loc_name = arena.alloc(header.name.map(|x| Pattern::Tag(x)));
let ann_pattern = Pattern::Apply(loc_name, header.vars);
let vars_region = Region::across_all(header.vars.iter().map(|v| &v.region));
let region_ann_pattern = Region::span_across(&loc_name.region, &vars_region);
let loc_ann_pattern = Loc::at(region_ann_pattern, ann_pattern);
let value_def = ValueDef::AnnotatedBody {
ann_pattern: arena.alloc(loc_ann_pattern),
ann_type: arena.alloc(*ann_type),
comment: spaces_before_current
.first()
.and_then(CommentOrNewline::comment_str),
body_pattern: arena.alloc(loc_pattern),
body_expr: *arena.alloc(loc_def_expr),
};
(value_def, Region::span_across(&header.name.region, &region))
}
fn parse_defs_end<'a>(
_options: ExprParseOptions,
min_indent: u32,
@ -1008,64 +949,94 @@ fn parse_defs_end<'a>(
Either::Second(value_def) => {
// If we got a ValueDef::Body, check if a type annotation preceded it.
// If so, we may need to combine them into an AnnotatedBody.
let joined = match value_def {
match value_def {
ValueDef::Body(loc_pattern, loc_def_expr)
if spaces_before_current.len() <= 1 =>
{
let region =
Region::span_across(&loc_pattern.region, &loc_def_expr.region);
let comment = match spaces_before_current.get(0) {
Some(CommentOrNewline::LineComment(s)) => Some(*s),
Some(CommentOrNewline::DocComment(s)) => Some(*s),
_ => None,
};
match defs.last() {
Some(Err(ValueDef::Annotation(ann_pattern, ann_type))) => {
let (value_def, region) = join_ann_to_body(
arena,
loc_pattern,
loc_def_expr,
ann_pattern,
ann_type,
spaces_before_current,
region,
);
// join this body with the preceding annotation
let value_def = ValueDef::AnnotatedBody {
ann_pattern: arena.alloc(*ann_pattern),
ann_type: arena.alloc(*ann_type),
comment,
body_pattern: arena.alloc(loc_pattern),
body_expr: *arena.alloc(loc_def_expr),
};
let region =
Region::span_across(&ann_pattern.region, &region);
defs.replace_with_value_def(
defs.tags.len() - 1,
value_def,
region,
);
true
)
}
Some(Ok(TypeDef::Alias {
header,
ann: ann_type,
})) => {
let (value_def, region) = join_alias_to_body(
arena,
loc_pattern,
loc_def_expr,
header,
ann_type,
spaces_before_current,
region,
// This is a case like
// UserId x : [UserId Int]
// UserId x = UserId 42
// We optimistically parsed the first line as an alias; we now turn it
// into an annotation.
let loc_name =
arena.alloc(header.name.map(|x| Pattern::Tag(x)));
let ann_pattern = Pattern::Apply(loc_name, header.vars);
let vars_region = Region::across_all(
header.vars.iter().map(|v| &v.region),
);
let region_ann_pattern =
Region::span_across(&loc_name.region, &vars_region);
let loc_ann_pattern =
Loc::at(region_ann_pattern, ann_pattern);
let value_def = ValueDef::AnnotatedBody {
ann_pattern: arena.alloc(loc_ann_pattern),
ann_type: arena.alloc(*ann_type),
comment,
body_pattern: arena.alloc(loc_pattern),
body_expr: *arena.alloc(loc_def_expr),
};
let region =
Region::span_across(&header.name.region, &region);
defs.replace_with_value_def(
defs.tags.len() - 1,
value_def,
region,
);
true
)
}
_ => {
// the previous and current def can't be joined up
defs.push_value_def(
value_def,
region,
spaces_before_current,
&[],
);
}
_ => false,
}
}
_ => false,
};
if !joined {
// the previous and current def can't be joined up
defs.push_value_def(value_def, region, spaces_before_current, &[]);
_ => {
// the previous and current def can't be joined up
defs.push_value_def(value_def, region, spaces_before_current, &[]);
}
}
}
}
@ -1078,13 +1049,6 @@ fn parse_defs_end<'a>(
}
}
fn to_either<Ok, Err>(result: Result<Ok, Err>) -> Either<Ok, Err> {
match result {
Ok(ok) => Either::First(ok),
Err(err) => Either::Second(err),
}
}
pub struct SingleDef<'a> {
pub type_or_value: Either<TypeDef<'a>, ValueDef<'a>>,
pub region: Region,