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

Update from PR comments

Browse source
This commit is contained in:
Sam Mohr 2024-07-07 18:33:20 -07:00
parent f415017c90
commit fe1b6d71fc
No known key found for this signature in database
GPG key ID: EA41D161A3C1BC99
17 changed files with 377 additions and 176 deletions
Download patch file Download diff file Expand all files Collapse all files

32
crates/compiler/parse/src/ast.rs
View file

@ -449,7 +449,7 @@ pub enum Expr<'a> {
/// foo: Task.getData Foo,
/// bar: Task.getData Bar,
/// }
NewRecordBuilder {
RecordBuilder {
mapper: &'a Loc<Expr<'a>>,
fields: Collection<'a, Loc<AssignedField<'a, Expr<'a>>>>,
},
@ -517,9 +517,9 @@ pub enum Expr<'a> {
PrecedenceConflict(&'a PrecedenceConflict<'a>),
MultipleOldRecordBuilders(&'a Loc<Expr<'a>>),
UnappliedOldRecordBuilder(&'a Loc<Expr<'a>>),
EmptyNewRecordBuilder(&'a Loc<Expr<'a>>),
SingleFieldNewRecordBuilder(&'a Loc<Expr<'a>>),
OptionalFieldInNewRecordBuilder(&'a Loc<&'a str>, &'a Loc<Expr<'a>>),
EmptyRecordBuilder(&'a Loc<Expr<'a>>),
SingleFieldRecordBuilder(&'a Loc<Expr<'a>>),
OptionalFieldInRecordBuilder(&'a Loc<&'a str>, &'a Loc<Expr<'a>>),
}
impl Expr<'_> {
@ -635,7 +635,7 @@ pub fn is_expr_suffixed(expr: &Expr) -> bool {
Expr::OldRecordBuilder(items) => items
.iter()
.any(|rbf| is_record_builder_field_suffixed(&rbf.value)),
Expr::NewRecordBuilder { mapper: _, fields } => fields
Expr::RecordBuilder { mapper: _, fields } => fields
.iter()
.any(|field| is_assigned_value_suffixed(&field.value)),
Expr::Underscore(_) => false,
@ -659,9 +659,9 @@ pub fn is_expr_suffixed(expr: &Expr) -> bool {
Expr::PrecedenceConflict(_) => false,
Expr::MultipleOldRecordBuilders(_) => false,
Expr::UnappliedOldRecordBuilder(_) => false,
Expr::EmptyNewRecordBuilder(_) => false,
Expr::SingleFieldNewRecordBuilder(_) => false,
Expr::OptionalFieldInNewRecordBuilder(_, _) => false,
Expr::EmptyRecordBuilder(_) => false,
Expr::SingleFieldRecordBuilder(_) => false,
Expr::OptionalFieldInRecordBuilder(_, _) => false,
}
}
@ -924,7 +924,7 @@ impl<'a, 'b> RecursiveValueDefIter<'a, 'b> {
}
}
}
NewRecordBuilder {
RecordBuilder {
mapper: map2,
fields,
} => {
@ -998,9 +998,9 @@ impl<'a, 'b> RecursiveValueDefIter<'a, 'b> {
MultipleOldRecordBuilders(loc_expr)
| UnappliedOldRecordBuilder(loc_expr)
| EmptyNewRecordBuilder(loc_expr)
| SingleFieldNewRecordBuilder(loc_expr)
| OptionalFieldInNewRecordBuilder(_, loc_expr) => expr_stack.push(&loc_expr.value),
| EmptyRecordBuilder(loc_expr)
| SingleFieldRecordBuilder(loc_expr)
| OptionalFieldInRecordBuilder(_, loc_expr) => expr_stack.push(&loc_expr.value),
Float(_)
| Num(_)
@ -2437,7 +2437,7 @@ impl<'a> Malformed for Expr<'a> {
Tuple(items) => items.is_malformed(),
OldRecordBuilder(items) => items.is_malformed(),
NewRecordBuilder { mapper: map2, fields } => map2.is_malformed() || fields.is_malformed(),
RecordBuilder { mapper: map2, fields } => map2.is_malformed() || fields.is_malformed(),
Closure(args, body) => args.iter().any(|arg| arg.is_malformed()) || body.is_malformed(),
Defs(defs, body) => defs.is_malformed() || body.is_malformed(),
@ -2461,9 +2461,9 @@ impl<'a> Malformed for Expr<'a> {
PrecedenceConflict(_) |
MultipleOldRecordBuilders(_) |
UnappliedOldRecordBuilder(_) |
EmptyNewRecordBuilder(_) |
SingleFieldNewRecordBuilder(_) |
OptionalFieldInNewRecordBuilder(_, _) => true,
EmptyRecordBuilder(_) |
SingleFieldRecordBuilder(_) |
OptionalFieldInRecordBuilder(_, _) => true,
}
}
}

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

@ -998,13 +998,13 @@ fn import_params<'a>() -> impl Parser<'a, ModuleImportParams<'a>, EImportParams<
|arena, state, _, (before, record): (_, RecordHelp<'a>)| {
if let Some(prefix) = record.prefix {
match prefix {
RecordHelpPrefix::Update(update) => {
(update, RecordHelpPrefix::Update) => {
return Err((
MadeProgress,
EImportParams::RecordUpdateFound(update.region),
))
}
RecordHelpPrefix::Mapper(mapper) => {
(mapper, RecordHelpPrefix::Mapper) => {
return Err((
MadeProgress,
EImportParams::RecordBuilderFound(mapper.region),
@ -2381,7 +2381,7 @@ fn expr_to_pattern_help<'a>(arena: &'a Bump, expr: &Expr<'a>) -> Result<Pattern<
| Expr::SpaceAfter(..)
| Expr::ParensAround(..)
| Expr::OldRecordBuilder(..)
| Expr::NewRecordBuilder { .. } => unreachable!(),
| Expr::RecordBuilder { .. } => unreachable!(),
Expr::Record(fields) => {
let patterns = fields.map_items_result(arena, |loc_assigned_field| {
@ -2430,9 +2430,9 @@ fn expr_to_pattern_help<'a>(arena: &'a Bump, expr: &Expr<'a>) -> Result<Pattern<
| Expr::PrecedenceConflict { .. }
| Expr::MultipleOldRecordBuilders { .. }
| Expr::UnappliedOldRecordBuilder { .. }
| Expr::EmptyNewRecordBuilder(_)
| Expr::SingleFieldNewRecordBuilder(_)
| Expr::OptionalFieldInNewRecordBuilder(_, _)
| Expr::EmptyRecordBuilder(_)
| Expr::SingleFieldRecordBuilder(_)
| Expr::OptionalFieldInRecordBuilder(_, _)
| Expr::RecordUpdate { .. }
| Expr::UnaryOp(_, _)
| Expr::TaskAwaitBang(..)
@ -3241,27 +3241,20 @@ fn record_field_expr<'a>() -> impl Parser<'a, RecordFieldExpr<'a>, ERecord<'a>>
)
}
fn record_updateable_identifier<'a>() -> impl Parser<'a, Expr<'a>, ERecord<'a>> {
fn record_prefix_identifier<'a>() -> impl Parser<'a, Expr<'a>, ERecord<'a>> {
specialize_err(
|_, pos| ERecord::Updateable(pos),
|_, pos| ERecord::Prefix(pos),
map_with_arena(parse_ident, ident_to_expr),
)
}
fn record_builder_mapper_identifier<'a>() -> impl Parser<'a, Expr<'a>, ERecord<'a>> {
specialize_err(
|_, pos| ERecord::BuilderMapper(pos),
map_with_arena(parse_ident, ident_to_expr),
)
}
enum RecordHelpPrefix<'a> {
Update(Loc<Expr<'a>>),
Mapper(Loc<Expr<'a>>),
enum RecordHelpPrefix {
Update,
Mapper,
}
struct RecordHelp<'a> {
prefix: Option<RecordHelpPrefix<'a>>,
prefix: Option<(Loc<Expr<'a>>, RecordHelpPrefix)>,
fields: Collection<'a, Loc<RecordField<'a>>>,
}
@ -3271,28 +3264,25 @@ fn record_help<'a>() -> impl Parser<'a, RecordHelp<'a>, ERecord<'a>> {
reset_min_indent(record!(RecordHelp {
// You can optionally have an identifier followed by an '&' to
// make this a record update, e.g. { Foo.user & username: "blah" }.
prefix: optional(map_with_arena(
either(
backtrackable(skip_second(
spaces_around(
// We wrap the ident in an Expr here,
// so that we have a Spaceable value to work with,
// and then in canonicalization verify that it's an Expr::Var
// (and not e.g. an `Expr::Access`) and extract its string.
loc(record_updateable_identifier()),
),
byte(b'&', ERecord::Ampersand)
)),
backtrackable(skip_second(
spaces_around(loc(record_builder_mapper_identifier()),),
two_bytes(b'<', b'-', ERecord::Arrow),
)),
prefix: optional(backtrackable(and(
spaces_around(
// We wrap the ident in an Expr here,
// so that we have a Spaceable value to work with,
// and then in canonicalization verify that it's an Expr::Var
// (and not e.g. an `Expr::Access`) and extract its string.
loc(record_prefix_identifier()),
),
|_arena, output| match output {
Either::First(update) => RecordHelpPrefix::Update(update),
Either::Second(mapper) => RecordHelpPrefix::Mapper(mapper),
}
)),
map_with_arena(
either(
byte(b'&', ERecord::Ampersand),
two_bytes(b'<', b'-', ERecord::Arrow),
),
|_arena, output| match output {
Either::First(()) => RecordHelpPrefix::Update,
Either::Second(()) => RecordHelpPrefix::Mapper,
}
)
))),
fields: collection_inner(
loc(record_field()),
byte(b',', ERecord::End),
@ -3312,10 +3302,10 @@ fn record_literal_help<'a>() -> impl Parser<'a, Expr<'a>, EExpr<'a>> {
),
move |arena, state, _, (record, accessors)| {
let expr_result = match record.prefix {
Some(RecordHelpPrefix::Update(update)) => {
Some((update, RecordHelpPrefix::Update)) => {
record_update_help(arena, update, record.fields)
}
Some(RecordHelpPrefix::Mapper(mapper)) => {
Some((mapper, RecordHelpPrefix::Mapper)) => {
new_record_builder_help(arena, mapper, record.fields)
}
None => {
@ -3384,7 +3374,7 @@ fn new_record_builder_help<'a>(
}
});
result.map(|fields| Expr::NewRecordBuilder {
result.map(|fields| Expr::RecordBuilder {
mapper: &*arena.alloc(mapper),
fields,
})

9
crates/compiler/parse/src/parser.rs
View file

@ -422,8 +422,7 @@ pub enum ERecord<'a> {
End(Position),
Open(Position),
Updateable(Position),
BuilderMapper(Position),
Prefix(Position),
Field(Position),
Colon(Position),
QuestionMark(Position),
@ -739,8 +738,7 @@ pub enum ETypeAbilityImpl<'a> {
Space(BadInputError, Position),
Updateable(Position),
BuilderMapper(Position),
Prefix(Position),
QuestionMark(Position),
Ampersand(Position),
Expr(&'a EExpr<'a>, Position),
@ -757,8 +755,7 @@ impl<'a> From<ERecord<'a>> for ETypeAbilityImpl<'a> {
ERecord::Colon(p) => ETypeAbilityImpl::Colon(p),
ERecord::Arrow(p) => ETypeAbilityImpl::Arrow(p),
ERecord::Space(s, p) => ETypeAbilityImpl::Space(s, p),
ERecord::Updateable(p) => ETypeAbilityImpl::Updateable(p),
ERecord::BuilderMapper(p) => ETypeAbilityImpl::BuilderMapper(p),
ERecord::Prefix(p) => ETypeAbilityImpl::Prefix(p),
ERecord::QuestionMark(p) => ETypeAbilityImpl::QuestionMark(p),
ERecord::Ampersand(p) => ETypeAbilityImpl::Ampersand(p),
ERecord::Expr(e, p) => ETypeAbilityImpl::Expr(e, p),