roc-lang/roc
1
1
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2024-09-11 18:58:24 +03:00
Code Issues Packages Projects Releases Wiki Activity

Update tests

Browse Source
This commit is contained in:
Richard Feldman 2023-03-26 10:17:36 -04:00
parent ae906ca7b3
commit 21e14589b0
No known key found for this signature in database
GPG Key ID: F1F21AA5B1D9E43B
3 changed files with 105 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
crates/repl_expect/src/lib.rs
View File

@ -666,10 +666,16 @@ mod test {
When it failed, these variables had these values:
a : [Err Str, Ok Str]
a : [
Err Str,
Ok Str,
]
a = Ok "Astra mortemque praestare gradatim"
b : [Err Str, Ok Str]
b : [
Err Str,
Ok Str,
]
b = Err "Profundum et fundamentum"
"#
),

43
crates/reporting/src/error/type.rs
View File

@ -3571,7 +3571,8 @@ fn diff_tag_union<'b>(
// We've removed all the tags that they had in common, so the remaining entries in tags2
// are ones that appear on the right only.
let tags_in_right_only = tags2;
let any_tags_in_common =
!same_tags_different_payloads.is_empty() || same_tags_same_payloads > 0;
let both = same_tags_different_payloads
.into_iter()
.map(to_overlap_docs);
@ -3623,17 +3624,38 @@ fn diff_tag_union<'b>(
tags_diff.right_able.extend(diff.right_able);
}
let mut left_tags_omitted = same_tags_same_payloads;
let mut right_tags_omitted = same_tags_same_payloads;
let left_tags_omitted;
let right_tags_omitted;
if !all_tags_shared {
if !any_tags_in_common {
// If they have no tags in common, we shouldn't omit any tags,
// because that would result in an unhelpful diff of
// […] on one side and another […] on the other side!
left_tags_omitted = 0;
right_tags_omitted = 0;
for (tag, tag_doc, args, able) in left {
tags_diff.left.push((tag, tag_doc, args));
tags_diff.left_able.extend(able);
}
for (tag, tag_doc, args, able) in right {
tags_diff.right.push((tag, tag_doc, args));
tags_diff.right_able.extend(able);
}
tags_diff.status.merge(Status::Different(Vec::new()));
} else if !all_tags_shared {
// If either tag union is open, omit the tags in the other. In other words,
// if one tag union is a pattern match which has _ ->, don't list the tags
// which fall under that catch-all pattern because they won't be helpful.
// By omitting them, we'll only show the tags that are actually matched.
if ext2_is_open {
left_tags_omitted += left.len();
left_tags_omitted = same_tags_same_payloads + left.len();
} else {
left_tags_omitted = same_tags_same_payloads;
for (tag, tag_doc, args, able) in left {
tags_diff.left.push((tag, tag_doc, args));
tags_diff.left_able.extend(able);
@ -3641,8 +3663,10 @@ fn diff_tag_union<'b>(
}
if ext1_is_open {
right_tags_omitted += right.len();
right_tags_omitted = same_tags_same_payloads + right.len();
} else {
right_tags_omitted = same_tags_same_payloads;
for (tag, tag_doc, args, able) in right {
tags_diff.right.push((tag, tag_doc, args));
tags_diff.right_able.extend(able);
@ -3650,6 +3674,9 @@ fn diff_tag_union<'b>(
}
tags_diff.status.merge(Status::Different(Vec::new()));
} else {
left_tags_omitted = same_tags_same_payloads;
right_tags_omitted = same_tags_same_payloads;
}
tags_diff.left.sort_by(|a, b| a.0.cmp(&b.0));
@ -4056,8 +4083,8 @@ mod report_text {
alloc.text("[]")
} else {
alloc
.text("[ ")
.append(alloc.ellipsis().append(alloc.text(" ]")))
.text("[")
.append(alloc.ellipsis().append(alloc.text("]")))
}
.append(ext_doc)
} else if entries.len() == 1 {

89
crates/reporting/tests/test_reporting.rs
View File

@ -1461,7 +1461,10 @@ mod test_reporting {
But `f` needs its 1st argument to be:
[Green, Red]
[
Green,
Red,
]
Tip: Seems like a tag typo. Maybe `Blue` should be `Red`?
@ -1495,7 +1498,10 @@ mod test_reporting {
But `f` needs its 1st argument to be:
[Green Str, Red (Int *)]
[
Green Str,
Red (Int *),
]
Tip: Seems like a tag typo. Maybe `Blue` should be `Red`?
@ -2528,11 +2534,11 @@ mod test_reporting {
This `a` value is a:
[A]
[…]
But the type annotation on `f` says it should be:
[A, B]
[B, …]
Tip: Looks like a closed tag union does not have the `B` tag.
@ -2562,11 +2568,15 @@ mod test_reporting {
This `a` value is a:
[A]
[…]
But the type annotation on `f` says it should be:
[A, B, C]
[
B,
C,
…
]
Tip: Looks like a closed tag union does not have the `B` and `C` tags.
@ -2631,11 +2641,11 @@ mod test_reporting {
This `x` value is a:
[Left {}, Right Str]
[Right Str, …]
But you are trying to use it as:
[Left *]
[…]
Tip: Looks like a closed tag union does not have the `Right` tag.
@ -3380,7 +3390,13 @@ mod test_reporting {
This `Cons` tag application has the type:
[Cons {} [Cons Str [Cons {} a, Nil]b as a, Nil]b, Nil]b
[
Cons {} [
Cons Str [Cons {} a, Nil]b as a,
Nil,
]b,
Nil,
]b
But the type annotation on `x` says it should be:
@ -3417,8 +3433,20 @@ mod test_reporting {
This `ACons` tag application has the type:
[ACons (Int Signed64) [BCons (Int Signed64) [ACons Str [BCons I64 [ACons I64 (BList I64 I64),
ANil]b as ∞, BNil]c, ANil]b, BNil]c, ANil]b
[
ACons (Int Signed64) [
BCons (Int Signed64) [
ACons Str [
BCons I64 [ACons I64 (BList I64 I64),
ANil]b as ∞,
BNil,
]c,
ANil,
]b,
BNil,
]c,
ANil,
]b
But the type annotation on `x` says it should be:
@ -7946,11 +7974,11 @@ In roc, functions are always written as a lambda, like{}
This `v` value is a:
F [A, B, C]
F [C, …]
But the branch patterns have type:
F [A, B]
F […]
The branches must be cases of the `when` condition's type!
@ -8976,26 +9004,30 @@ In roc, functions are always written as a lambda, like{}
foo
"#
),
@r#"
── TYPE MISMATCH ───────────────────────────────────────── /code/proj/Main.roc ─
@r###"
── TYPE MISMATCH ───────────────────────────────────────── /code/proj/Main.roc ─
The branches of this `when` expression don't match the condition:
The branches of this `when` expression don't match the condition:
6│> when bool is
7│ True -> "true"
8│ False -> "false"
9│ Wat -> "surprise!"
6│> when bool is
7│ True -> "true"
8│ False -> "false"
9│ Wat -> "surprise!"
This `bool` value is a:
This `bool` value is a:
Bool
Bool
But the branch patterns have type:
But the branch patterns have type:
[False, True, Wat]
[
False,
True,
Wat,
]
The branches must be cases of the `when` condition's type!
"#
The branches must be cases of the `when` condition's type!
"###
);
// from https://github.com/roc-lang/roc/commit/1372737f5e53ee5bb96d7e1b9593985e5537023a
@ -12119,7 +12151,10 @@ I recommend using camelCase. It's the standard style in Roc code!
The `when` condition is a list of type:
List [A, B]
List [
A,
B,
]
But the branch patterns have type: