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

more cleanup

Browse source
This commit is contained in:
Folkert 2021-03-01 19:04:57 +01:00
parent 7c3a14c370
commit 663ffdeb88
2 changed files with 53 additions and 53 deletions
Download patch file Download diff file Expand all files Collapse all files

101
compiler/parse/src/expr.rs
View file

@ -1,15 +1,15 @@
use crate::ast::{AssignedField, CommentOrNewline, Def, Expr, Pattern, Spaceable, TypeAnnotation}; use crate::ast::{AssignedField, CommentOrNewline, Def, Expr, Pattern, Spaceable, TypeAnnotation};
use crate::blankspace::{ use crate::blankspace::{
line_comment, space0, space0_after_e, space0_around_ee, space0_before, space0_before_e, line_comment, space0_after_e, space0_around_ee, space0_before_e, space0_e, space1_e,
space0_e, space1_e, spaces_exactly_e, spaces_exactly_e,
}; };
use crate::ident::{ident, lowercase_ident, Ident}; use crate::ident::{ident, lowercase_ident, Ident};
use crate::keyword; use crate::keyword;
use crate::parser::{ use crate::parser::{
self, allocated, and_then_with_indent_level, ascii_char, ascii_string, backtrackable, map, self, allocated, and_then_with_indent_level, ascii_char, backtrackable, map, newline_char,
newline_char, optional, sep_by1, sep_by1_e, specialize, specialize_ref, then, trailing_sep_by0, optional, sep_by1, sep_by1_e, specialize, specialize_ref, then, trailing_sep_by0, word1, word2,
word1, word2, EExpr, EInParens, ELambda, EPattern, ERecord, EString, Either, If, List, Number, EExpr, EInParens, ELambda, EPattern, ERecord, EString, Either, If, List, Number, ParseResult,
ParseResult, Parser, State, SyntaxError, Type, When, Parser, State, SyntaxError, Type, When,
}; };
use crate::pattern::loc_closure_param; use crate::pattern::loc_closure_param;
use crate::type_annotation; use crate::type_annotation;
@ -489,6 +489,13 @@ pub fn expr_to_pattern<'a>(
arena: &'a Bump, arena: &'a Bump,
expr: &Expr<'a>, expr: &Expr<'a>,
) -> Result<Pattern<'a>, SyntaxError<'a>> { ) -> Result<Pattern<'a>, SyntaxError<'a>> {
match expr_to_pattern_help(arena, expr) {
Ok(good) => Ok(good),
Err(_bad) => Err(SyntaxError::InvalidPattern),
}
}
fn expr_to_pattern_help<'a>(arena: &'a Bump, expr: &Expr<'a>) -> Result<Pattern<'a>, EPattern<'a>> {
match expr { match expr {
Expr::Var { module_name, ident } => { Expr::Var { module_name, ident } => {
if module_name.is_empty() { if module_name.is_empty() {
@ -501,14 +508,14 @@ pub fn expr_to_pattern<'a>(
Expr::PrivateTag(value) => Ok(Pattern::PrivateTag(value)), Expr::PrivateTag(value) => Ok(Pattern::PrivateTag(value)),
Expr::Apply(loc_val, loc_args, _) => { Expr::Apply(loc_val, loc_args, _) => {
let region = loc_val.region; let region = loc_val.region;
let value = expr_to_pattern(arena, &loc_val.value)?; let value = expr_to_pattern_help(arena, &loc_val.value)?;
let val_pattern = arena.alloc(Located { region, value }); let val_pattern = arena.alloc(Located { region, value });
let mut arg_patterns = Vec::with_capacity_in(loc_args.len(), arena); let mut arg_patterns = Vec::with_capacity_in(loc_args.len(), arena);
for loc_arg in loc_args.iter() { for loc_arg in loc_args.iter() {
let region = loc_arg.region; let region = loc_arg.region;
let value = expr_to_pattern(arena, &loc_arg.value)?; let value = expr_to_pattern_help(arena, &loc_arg.value)?;
arg_patterns.push(Located { region, value }); arg_patterns.push(Located { region, value });
} }
@ -519,15 +526,17 @@ pub fn expr_to_pattern<'a>(
} }
Expr::SpaceBefore(sub_expr, spaces) => Ok(Pattern::SpaceBefore( Expr::SpaceBefore(sub_expr, spaces) => Ok(Pattern::SpaceBefore(
arena.alloc(expr_to_pattern(arena, sub_expr)?), arena.alloc(expr_to_pattern_help(arena, sub_expr)?),
spaces, spaces,
)), )),
Expr::SpaceAfter(sub_expr, spaces) => Ok(Pattern::SpaceAfter( Expr::SpaceAfter(sub_expr, spaces) => Ok(Pattern::SpaceAfter(
arena.alloc(expr_to_pattern(arena, sub_expr)?), arena.alloc(expr_to_pattern_help(arena, sub_expr)?),
spaces, spaces,
)), )),
Expr::ParensAround(sub_expr) | Expr::Nested(sub_expr) => expr_to_pattern(arena, sub_expr), Expr::ParensAround(sub_expr) | Expr::Nested(sub_expr) => {
expr_to_pattern_help(arena, sub_expr)
}
Expr::Record { Expr::Record {
fields, fields,
@ -538,7 +547,7 @@ pub fn expr_to_pattern<'a>(
for loc_assigned_field in fields.iter() { for loc_assigned_field in fields.iter() {
let region = loc_assigned_field.region; let region = loc_assigned_field.region;
let value = assigned_expr_field_to_pattern(arena, &loc_assigned_field.value)?; let value = assigned_expr_field_to_pattern_help(arena, &loc_assigned_field.value)?;
loc_patterns.push(Located { region, value }); loc_patterns.push(Located { region, value });
} }
@ -571,7 +580,10 @@ pub fn expr_to_pattern<'a>(
| Expr::Record { | Expr::Record {
update: Some(_), .. update: Some(_), ..
} }
| Expr::UnaryOp(_, _) => Err(SyntaxError::InvalidPattern), | Expr::UnaryOp(_, _) => {
// TODO nonsense region
Err(EPattern::Start(0, 0))
}
Expr::Str(string) => Ok(Pattern::StrLiteral(string.clone())), Expr::Str(string) => Ok(Pattern::StrLiteral(string.clone())),
Expr::MalformedIdent(string, _problem) => Ok(Pattern::Malformed(string)), Expr::MalformedIdent(string, _problem) => Ok(Pattern::Malformed(string)),
@ -579,7 +591,7 @@ pub fn expr_to_pattern<'a>(
} }
/// use for expressions like { x: a + b } /// use for expressions like { x: a + b }
pub fn assigned_expr_field_to_pattern<'a>( fn assigned_expr_field_to_pattern<'a>(
arena: &'a Bump, arena: &'a Bump,
assigned_field: &AssignedField<'a, Expr<'a>>, assigned_field: &AssignedField<'a, Expr<'a>>,
) -> Result<Pattern<'a>, SyntaxError<'a>> { ) -> Result<Pattern<'a>, SyntaxError<'a>> {
@ -627,68 +639,51 @@ pub fn assigned_expr_field_to_pattern<'a>(
}) })
} }
/// Used for patterns like { x: Just _ } fn assigned_expr_field_to_pattern_help<'a>(
pub fn assigned_pattern_field_to_pattern<'a>(
arena: &'a Bump, arena: &'a Bump,
assigned_field: &AssignedField<'a, Expr<'a>>, assigned_field: &AssignedField<'a, Expr<'a>>,
backup_region: Region, ) -> Result<Pattern<'a>, EPattern<'a>> {
) -> Result<Located<Pattern<'a>>, SyntaxError<'a>> {
// the assigned fields always store spaces, but this slice is often empty // the assigned fields always store spaces, but this slice is often empty
Ok(match assigned_field { Ok(match assigned_field {
AssignedField::RequiredValue(name, spaces, value) => { AssignedField::RequiredValue(name, spaces, value) => {
let pattern = expr_to_pattern(arena, &value.value)?; let pattern = expr_to_pattern_help(arena, &value.value)?;
let region = Region::span_across(&value.region, &value.region);
let result = arena.alloc(Located { let result = arena.alloc(Located {
region: value.region, region: value.region,
value: pattern, value: pattern,
}); });
if spaces.is_empty() { if spaces.is_empty() {
Located::at(region, Pattern::RequiredField(name.value, result)) Pattern::RequiredField(name.value, result)
} else { } else {
Located::at( Pattern::SpaceAfter(
region, arena.alloc(Pattern::RequiredField(name.value, result)),
Pattern::SpaceAfter( spaces,
arena.alloc(Pattern::RequiredField(name.value, result)),
spaces,
),
) )
} }
} }
AssignedField::OptionalValue(name, spaces, value) => { AssignedField::OptionalValue(name, spaces, value) => {
let pattern = value.value.clone();
let region = Region::span_across(&value.region, &value.region);
let result = arena.alloc(Located { let result = arena.alloc(Located {
region: value.region, region: value.region,
value: pattern, value: value.value.clone(),
}); });
if spaces.is_empty() { if spaces.is_empty() {
Located::at(region, Pattern::OptionalField(name.value, result)) Pattern::OptionalField(name.value, result)
} else { } else {
Located::at( Pattern::SpaceAfter(
region, arena.alloc(Pattern::OptionalField(name.value, result)),
Pattern::SpaceAfter( spaces,
arena.alloc(Pattern::OptionalField(name.value, result)),
spaces,
),
) )
} }
} }
AssignedField::LabelOnly(name) => Located::at(name.region, Pattern::Identifier(name.value)), AssignedField::LabelOnly(name) => Pattern::Identifier(name.value),
AssignedField::SpaceBefore(nested, spaces) => { AssignedField::SpaceBefore(nested, spaces) => Pattern::SpaceBefore(
let can_nested = assigned_pattern_field_to_pattern(arena, nested, backup_region)?; arena.alloc(assigned_expr_field_to_pattern_help(arena, nested)?),
Located::at( spaces,
can_nested.region, ),
Pattern::SpaceBefore(arena.alloc(can_nested.value), spaces), AssignedField::SpaceAfter(nested, spaces) => Pattern::SpaceAfter(
) arena.alloc(assigned_expr_field_to_pattern_help(arena, nested)?),
} spaces,
AssignedField::SpaceAfter(nested, spaces) => { ),
let can_nested = assigned_pattern_field_to_pattern(arena, nested, backup_region)?; AssignedField::Malformed(string) => Pattern::Malformed(string),
Located::at(
can_nested.region,
Pattern::SpaceAfter(arena.alloc(can_nested.value), spaces),
)
}
AssignedField::Malformed(string) => Located::at(backup_region, Pattern::Malformed(string)),
}) })
} }

5
editor/src/lang/pattern.rs
View file

@ -409,6 +409,11 @@ pub fn to_pattern2<'a>(
malformed_pattern(env, problem, region) malformed_pattern(env, problem, region)
} }
MalformedIdent(_str, bad_ident) => {
let problem = MalformedPatternProblem::BadIdent(*bad_ident);
malformed_pattern(env, problem, region)
}
SpaceBefore(sub_pattern, _) | SpaceAfter(sub_pattern, _) | Nested(sub_pattern) => { SpaceBefore(sub_pattern, _) | SpaceAfter(sub_pattern, _) | Nested(sub_pattern) => {
return to_pattern2(env, scope, pattern_type, sub_pattern, region) return to_pattern2(env, scope, pattern_type, sub_pattern, region)
} }