Multi-line errors #19870

mdinger · 2014-12-15T09:15:14Z

Updated 1/12/2014

I updated the multi-line testcase to current but didn't modify the others. The spew code was broke by the matches! macro no longer working and I'm not interested in fixing the testcase.

I additionally added one testcase below.

Errors will in general look similar to below if the error is either mismatched types or a few other types. The rest are ignored.

Extra testcase:

pub trait Foo {
    type A;
    fn boo(&self) -> <Self as Foo>::A;
}

struct Bar;

impl Foo for i32 {
    type A = u32;
    fn boo(&self) -> u32 {
        42
    }
}

fn foo1<I: Foo<A=Bar>>(x: I) {
    let _: Bar = x.boo();
}

fn foo2<I: Foo>(x: I) {
    let _: Bar = x.boo();
}


pub fn baz(x: &Foo<A=Bar>) {
    let _: Bar = x.boo();
}


pub fn main() {
    let a = 42i32;
    foo1(a);
    baz(&a);
}

Multi-line output:

$ ./rustc test3.rs
test3.rs:20:18: 20:25 error: mismatched types:
 expected `Bar`,
    found `<I as Foo>::A`
(expected struct `Bar`,
    found associated type)
test3.rs:20     let _: Bar = x.boo();
                             ^~~~~~~
test3.rs:31:5: 31:9 error: type mismatch resolving `<i32 as Foo>::A == Bar`:
 expected u32,
    found struct `Bar`
test3.rs:31     foo1(a);
                ^~~~
test3.rs:31:5: 31:9 note: required by `foo1`
test3.rs:31     foo1(a);
                ^~~~
test3.rs:32:9: 32:11 error: type mismatch resolving `<i32 as Foo>::A == Bar`:
 expected u32,
    found struct `Bar`
test3.rs:32     baz(&a);
                    ^~
test3.rs:32:9: 32:11 note: required for the cast to the object type `Foo`
test3.rs:32     baz(&a);
                    ^~
error: aborting due to 3 previous errors

This is a continuation of #19203 which I apparently broke by force pushing after it was closed. I'm attempting to add multi-line errors where they are largely beneficial - to help differentiate different types in compiler messages. As before, this is still a simple fix.

Testcase:

struct S;

fn test() -> Option<i32> {
    let s: S;

    s
}

fn test2() -> Option<i32> {
    Ok(7) // Should be Some(7)
}

impl Iterator for S {
    type Item = i32;
    fn next(&mut self) -> Result<i32, i32> { Ok(7) }
}

fn main(){ 
    test();
    test2();

}

Single-line playpen errors:

<anon>:6:5: 6:6 error: mismatched types: expected `core::option::Option<int>`, found `S` (expected enum core::option::Option, found struct S)
<anon>:6     s
             ^
<anon>:10:5: 10:10 error: mismatched types: expected `core::option::Option<int>`, found `core::result::Result<_, _>` (expected enum core::option::Option, found enum core::result::Result)
<anon>:10     Ok(7) // Should be Some(7)
              ^~~~~
<anon>:14:5: 14:55 error: method `next` has an incompatible type for trait: expected enum core::option::Option, found enum core::result::Result [E0053]
<anon>:14     fn next(&mut self) -> Result<uint, uint> { Ok(7) }
              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to 3 previous errors
playpen: application terminated with error code 101

Multi-line errors:

$ ./rustc test.rs
test.rs:6:5: 6:6 error: mismatched types:
 expected `core::option::Option<i32>`,
    found `S`
(expected enum `core::option::Option`,
    found struct `S`)
test.rs:6     s
              ^
test.rs:10:5: 10:10 error: mismatched types:
 expected `core::option::Option<i32>`,
    found `core::result::Result<_, _>`
(expected enum `core::option::Option`,
    found enum `core::result::Result`)
test.rs:10     Ok(7) // Should be Some(7)
               ^~~~~
test.rs:15:5: 15:53 error: method `next` has an incompatible type for trait: expected enum `core::option::Option`, found enum `core::result::Result` [E0053]
test.rs:15     fn next(&mut self) -> Result<i32, i32> { Ok(7) }
               ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to 3 previous errors

Positive notes

Vim worked fine with it: Align error messages for easier comparing #19203 (comment)
make check didn't find any errors
Fixed backtick placement suggested by @p1start at Align error messages for easier comparing #19203 (comment)

Negative notes

Didn't check Emacs support but also wasn't provided a testcase...
Needs to be tested with macro errors but I don't have a good testcase yet
I would like to move the E[0053] earlier (see Collect errors which would be better as multiline errors #19464 (comment)) but I don't know how
It might be better to indent the types slightly like so (but I don't know how):

test.rs:6:5: 6:6 error: mismatched types:
          expected `core::option::Option<int>`,
             found `S`
         (expected enum `core::option::Option`,
             found struct `S`)
test.rs:6     s

Deep whitespace indentation may be a bad idea because early wrapping will cause misalignment between lines

Other

I thought that compiler flags or something else (environment variables maybe) might be required because of comments against it but now that seems too much of a burden for users and for too little gain.
There was concern that it will make large quantities of errors difficult to distinguish but I don't find that an issue. They both look awful and multi-line errors makes the types easier to understand.

Single lined spew:

$ rustc test2.rs 
test2.rs:161:9: 170:10 error: method `next` has an incompatible type for trait: expected enum core::option::Option, found enum core::result::Result [E0053]
test2.rs:161         fn next(&mut self) -> Result<&'a str, int> {
test2.rs:162             self.curr = self.next;
test2.rs:163             
test2.rs:164             if let (Some(open), Some(close)) = Parens::find_parens(self.all, self.next) {
test2.rs:165                 self.next = if self.all.char_at(self.next) == '(' { close }
test2.rs:166                 else { open }
             ...
test2.rs:164:21: 164:31 error: mismatched types: expected `core::result::Result<uint, int>`, found `core::option::Option<_>` (expected enum core::result::Result, found enum core::option::Option)
test2.rs:164             if let (Some(open), Some(close)) = Parens::find_parens(self.all, self.next) {
                                 ^~~~~~~~~~
test2.rs:164:33: 164:44 error: mismatched types: expected `core::result::Result<uint, int>`, found `core::option::Option<_>` (expected enum core::result::Result, found enum core::option::Option)
test2.rs:164             if let (Some(open), Some(close)) = Parens::find_parens(self.all, self.next) {
                                             ^~~~~~~~~~~
test2.rs:169:40: 169:76 error: mismatched types: expected `core::result::Result<&'a str, int>`, found `core::option::Option<&str>` (expected enum core::result::Result, found enum core::option::Option)
test2.rs:169             if self.curr != self.len { Some(self.all[self.curr..self.next]) } else { None }
                                                    ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test2.rs:169:86: 169:90 error: mismatched types: expected `core::result::Result<&'a str, int>`, found `core::option::Option<_>` (expected enum core::result::Result, found enum core::option::Option)
test2.rs:169             if self.curr != self.len { Some(self.all[self.curr..self.next]) } else { None }
                                                                                                  ^~~~
test2.rs:205:14: 205:18 error: mismatched types: expected `core::result::Result<uint, int>`, found `core::option::Option<uint>` (expected enum core::result::Result, found enum core::option::Option)
test2.rs:205             (open, close)
                          ^~~~
test2.rs:205:20: 205:25 error: mismatched types: expected `core::result::Result<uint, int>`, found `core::option::Option<uint>` (expected enum core::result::Result, found enum core::option::Option)
test2.rs:205             (open, close)
                                ^~~~~
test2.rs:210:21: 210:31 error: mismatched types: expected `core::result::Result<uint, int>`, found `core::option::Option<_>` (expected enum core::result::Result, found enum core::option::Option)
test2.rs:210             if let (Some(open), _) = Parens::find_parens(self.all, 0) {
                                 ^~~~~~~~~~
test2.rs:210:13: 212:28 error: mismatched types: expected `core::option::Option<&'a int>`, found `core::option::Option<&str>` (expected int, found str)
test2.rs:210             if let (Some(open), _) = Parens::find_parens(self.all, 0) {
test2.rs:211                 Some(self.all[0..open])
test2.rs:212             } else { None }
test2.rs:299:48: 299:58 error: mismatched types: expected `Box<translate::Entity>`, found `collections::vec::Vec<_>` (expected box, found struct collections::vec::Vec)
test2.rs:299         pub fn new() -> Entity { Entity::Group(Vec::new()) }
                                                            ^~~~~~~~~~
test2.rs:359:51: 359:58 error: type `&mut Box<translate::Entity>` does not implement any method in scope named `push`
test2.rs:359                 Entity::Group(ref mut vec) => vec.push(e),
                                                               ^~~~~~~
test2.rs:366:51: 366:85 error: type `&mut Box<translate::Entity>` does not implement any method in scope named `push`
test2.rs:366                 Entity::Group(ref mut vec) => vec.push(Entity::Inner(s.to_string())),
                                                               ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to 12 previous errors

Multi-line spew:

$ ./rustc test2.rs 
test2.rs:161:9: 170:10 error: method `next` has an incompatible type for trait:
 expected enum `core::option::Option`,
    found enum `core::result::Result` [E0053]
test2.rs:161         fn next(&mut self) -> Result<&'a str, int> {
test2.rs:162             self.curr = self.next;
test2.rs:163             
test2.rs:164             if let (Some(open), Some(close)) = Parens::find_parens(self.all, self.next) {
test2.rs:165                 self.next = if self.all.char_at(self.next) == '(' { close }
test2.rs:166                 else { open }
             ...
test2.rs:164:21: 164:31 error: mismatched types:
 expected `core::result::Result<uint, int>`,
    found `core::option::Option<_>`
(expected enum `core::result::Result`,
    found enum `core::option::Option`)
test2.rs:164             if let (Some(open), Some(close)) = Parens::find_parens(self.all, self.next) {
                                 ^~~~~~~~~~
test2.rs:164:33: 164:44 error: mismatched types:
 expected `core::result::Result<uint, int>`,
    found `core::option::Option<_>`
(expected enum `core::result::Result`,
    found enum `core::option::Option`)
test2.rs:164             if let (Some(open), Some(close)) = Parens::find_parens(self.all, self.next) {
                                             ^~~~~~~~~~~
test2.rs:169:40: 169:76 error: mismatched types:
 expected `core::result::Result<&'a str, int>`,
    found `core::option::Option<&str>`
(expected enum `core::result::Result`,
    found enum `core::option::Option`)
test2.rs:169             if self.curr != self.len { Some(self.all[self.curr..self.next]) } else { None }
                                                    ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test2.rs:169:86: 169:90 error: mismatched types:
 expected `core::result::Result<&'a str, int>`,
    found `core::option::Option<_>`
(expected enum `core::result::Result`,
    found enum `core::option::Option`)
test2.rs:169             if self.curr != self.len { Some(self.all[self.curr..self.next]) } else { None }
                                                                                                  ^~~~
test2.rs:205:14: 205:18 error: mismatched types:
 expected `core::result::Result<uint, int>`,
    found `core::option::Option<uint>`
(expected enum `core::result::Result`,
    found enum `core::option::Option`)
test2.rs:205             (open, close)
                          ^~~~
test2.rs:205:20: 205:25 error: mismatched types:
 expected `core::result::Result<uint, int>`,
    found `core::option::Option<uint>`
(expected enum `core::result::Result`,
    found enum `core::option::Option`)
test2.rs:205             (open, close)
                                ^~~~~
test2.rs:210:21: 210:31 error: mismatched types:
 expected `core::result::Result<uint, int>`,
    found `core::option::Option<_>`
(expected enum `core::result::Result`,
    found enum `core::option::Option`)
test2.rs:210             if let (Some(open), _) = Parens::find_parens(self.all, 0) {
                                 ^~~~~~~~~~
test2.rs:210:13: 212:28 error: mismatched types:
 expected `core::option::Option<&'a int>`,
    found `core::option::Option<&str>`
(expected int,
    found str)
test2.rs:210             if let (Some(open), _) = Parens::find_parens(self.all, 0) {
test2.rs:211                 Some(self.all[0..open])
test2.rs:212             } else { None }
test2.rs:229:57: 229:96 error: the trait `core::ops::Fn<(char,), bool>` is not implemented for the type `|char| -> bool`
test2.rs:229                                              .map(|s| s.trim_chars(|c: char| c.is_whitespace()))
                                                                     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test2.rs:238:46: 239:75 error: type `core::str::CharSplits<'_, |char| -> bool>` does not implement any method in scope named `filter_map`
test2.rs:238                                             .filter_map(|s| if !s.is_empty() { Some(s.trim_chars('\'')) }
test2.rs:239                                                             else { None })
test2.rs:237:46: 237:91 error: the trait `core::ops::Fn<(char,), bool>` is not implemented for the type `|char| -> bool`
test2.rs:237                 let vec: Vec<&str> = value[].split(|c: char| matches!(c, '(' | ')' | ','))
                                                          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test2.rs:238:65: 238:77 error: the type of this value must be known in this context
test2.rs:238                                             .filter_map(|s| if !s.is_empty() { Some(s.trim_chars('\'')) }
                                                                             ^~~~~~~~~~~~
test2.rs:299:48: 299:58 error: mismatched types:
 expected `Box<translate::Entity>`,
    found `collections::vec::Vec<_>`
(expected box,
    found struct `collections::vec::Vec`)
test2.rs:299         pub fn new() -> Entity { Entity::Group(Vec::new()) }
                                                            ^~~~~~~~~~
test2.rs:321:36: 322:65 error: type `core::str::CharSplits<'_, |char| -> bool>` does not implement any method in scope named `filter_map`
test2.rs:321                                   .filter_map(|s| if !s.is_empty() { Some(s.trim_chars('\'')) }
test2.rs:322                                                   else { None })
test2.rs:320:36: 320:81 error: the trait `core::ops::Fn<(char,), bool>` is not implemented for the type `|char| -> bool`
test2.rs:320             let vec: Vec<&str> = s.split(|c: char| matches!(c, '(' | ')' | ','))
                                                ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
test2.rs:321:55: 321:67 error: the type of this value must be known in this context
test2.rs:321                                   .filter_map(|s| if !s.is_empty() { Some(s.trim_chars('\'')) }
                                                                   ^~~~~~~~~~~~
test2.rs:359:51: 359:58 error: type `&mut Box<translate::Entity>` does not implement any method in scope named `push`
test2.rs:359                 Entity::Group(ref mut vec) => vec.push(e),
                                                               ^~~~~~~
test2.rs:366:51: 366:85 error: type `&mut Box<translate::Entity>` does not implement any method in scope named `push`
test2.rs:366                 Entity::Group(ref mut vec) => vec.push(Entity::Inner(s.to_string())),
                                                               ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to 24 previous errors

Closes #18946 #19464
cc @P1start @jakub- @tomjakubowski @kballard @chris-morgan

blaenk · 2014-12-16T01:55:16Z

We seriously need this in some form by 1.0. I absolutely love Rust but the error messages it vomits are completely nasty and I always find myself having to copy them into vim to manually line them up, which is very frustrating when I know that it can do this work itself, like GHC does with Haskell type errors. I can't imagine how much more frustrating it would be to a newcomer. This issue is compounded given the current type landscape where parameterized types explode in length (e.g. the various kinds of iterators).

The primary target for compiler output should be humans. We shouldn't be bending over backwards to appease editors; we can create functionality on the side for them if need be, similar to git's porcelain flags:

Give the output in an easy-to-parse format for scripts. This is similar to the short output, but will remain stable across git versions and regardless of user configuration.

Gankra · 2015-01-02T16:59:53Z

Needs a rebase, and a reviewer. @mdinger do you know anyone who should review this?

emberian · 2015-01-02T17:02:17Z

This looks great! r=me with a rebase.

mdinger · 2015-01-03T05:56:47Z

Rebased though I did modify some of the comments. I ran make check and it failed but I kinda think it's supposed to because only compile-fail failed. That compile-fail is confusing.

ftxqxd · 2015-01-03T06:06:21Z

If compile-fail failed, then it didn't pass the test suite. compile-fail is only supposed to fail at compiling in a particular way. If it failed and printed out a test failure message, then you normally need to update the tests that failed. However, in this case, you’ll need to dig around in src/compiletest/runtest.rs to add support for testing multi-line error messages, as I mentioned in the previous PR.

mdinger · 2015-01-03T06:11:52Z

Yeah, I remember checking it before and it worked. I'll look into it.

mdinger · 2015-01-05T22:15:13Z

Rebased and passes make check. This is much bigger than before.

I also rechecked vim support and it still seems fine.

mdinger · 2015-01-06T03:07:30Z

r? @cmr

Let me know if this looks okay or not. I know it needs a rebase but I'd like to wait until I've heard back about it before I do. I think this will create a lot of merge conflicts and I don't want to continually rebase.

emberian · 2015-01-06T03:25:20Z

So, the code looks good, but I'll leave the final r+ to @nikomatsakis or @nick29581, possibly after the alpha, since we're micromanaging the queue pretty hard already...

mdinger · 2015-01-06T03:49:29Z

Sounds good. Just let me know when to rebase so you can land it.

nrc · 2015-01-06T04:02:01Z

src/librustc_typeck/check/mod.rs

                                 format!("structure constructor specifies a \
                                         structure of type `{}`, but this \
-                                         structure has type `{}`: {}",
+                                         structure has type `{}`:\n {}",


this looks like an odd place for a newline

I think I was trying to fix this error type. It was probably printing out like this beforehand:

// Before error: structure constructor specifies a structure of type: expected f32, found int // After error: structure constructor specifies a structure of type expected f32, found int

I was trying to force all expected, found patterns to be multi-line for consistency (except for a few which were easier to control).

I don't see how that lines up with error message in the code - where is the "but this structure has type" and where do the expected/found come from?

Ah, I didn't have to give the entire error. Just a substring of the error because the regex is only looking for a match. That error is really long and I thought it might hit the make check parsing width limit. So I trimmed it. The full script is here at playpen. The main part of the error which I pasted below:

<anon>:8:14: 8:20 error: structure constructor specifies a structure of type `Point<f32>`, but this structure has type `Point<int>`: expected f32, found int <anon>:8 let pt = PointF {

Oh, I see! Thanks for the explanation!

Yeah, but it's not obvious. A better, more thorough way would be much nicer.

nrc · 2015-01-06T04:04:14Z

Nice! I'm not sure about the approach though, it seems fragile and a recipe for inconsistent line breaks. Could we leave the error messges as they are and insert linebreaks by scanning for the expected and found substrings?. That would make it easier to customise error messages too.

Also +1 on not landing till after the alpha release.

mdinger · 2015-01-06T04:32:33Z

While I agree that would be good, I don't know where to do the search/scanning. The myriad ways errors get printed out are very confusing. I could possibly do it but I'd need tips on where I need to look.

nrc · 2015-01-06T04:49:58Z

In the end they should all go through Session::span_err or Session::err, I think. Certainly all the compiler ones. The libsyntax ones might go somewhere else, but there is probably either a common callee, or you could just ignore libsyntax errors to start with.

mdinger · 2015-01-06T05:16:39Z

src/librustc_typeck/check/mod.rs

+                          token::get_name(trait_m.name),
+                          ty_err);
+            } else {
+                span_err!(tcx.sess, impl_m_span, E0053,


This throws a warning I think because E0053 was duplicated into this branch. Not sure how to avoid it.

mdinger · 2015-01-06T06:42:24Z

I'll try and look into those

mdinger · 2015-01-09T03:15:39Z

It needs a rebase but it passes the testsuite again. It is more methodical now about enabling the multi-line errors.

mdinger · 2015-01-10T18:26:10Z

Rebased. This passed make check except for tidy which I fixed before rebase. Just waiting for a complete retest on tip.

r? @nick29581

mdinger · 2015-01-10T20:17:10Z

Passes make check.

mdinger · 2015-01-10T20:19:04Z

A quick review would be awesome because this needs a rebase with most compile-fail modifications.

nrc · 2015-01-11T23:01:11Z

src/librustc/session/mod.rs

+        let first  = Regex::new(r"[( ]expected").unwrap();
+        let second = Regex::new(r" found").unwrap();
+        let third  = Regex::new(
+            r"\((values differ|lifetime|cyclic type of infinite size)").unwrap();


nit: prefer to line break after the = rather than after the (. And/or break the string.

You want this trimmed? Raw strings have no escapes and breaking them can give surprising results when applied with a regex. Using non-raw strings also can give surprising results.

Technically I could do this but I decided against it because it makes it much less obvious what you're trying to do.

let s = r"\((values differ|lifetime|cyclic type of infinite size)"; // could also be let v = vec![r"\((values differ", r"lifetime", r"cyclic type of infinite size)"].connect("|");

let third = Regex::new(r"\((values differ|lifetime|cyclic type of infinite size)").unwrap();

nrc · 2015-01-11T23:06:33Z

src/librustc/session/mod.rs

+                            second.find_iter(msg)) {
+            // A `(` may be preceded by a space and it should be trimmed
+            new_msg = new_msg +
+                      msg.slice(beg, pos1.0).trim_right() + // prefix


prefer [] slicing notation to slice

I had that but it stopped working yesterday. I swapped to .slice() to get it working again.

should be working again now, sorry about the churn

nrc · 2015-01-11T23:12:59Z

Looks great! Just to confirm, the error output looks the same as for the previous version? r=me with the minor comments fixed.

mdinger · 2015-01-11T23:55:11Z

I'll recheck with the changes and repost the output at the top.

blaenk · 2015-01-12T02:57:20Z

I'm very glad this is going through, thanks a ton @mdinger

Just a quick question though, is there any reason this isn't using the regex! macro so that it compiles at compile-time? Not a big deal, but seems like it'd be useful in many of these patterns.

mdinger · 2015-01-12T03:01:14Z

I'm not sure. I think I tried to use it but it didn't compile and the other examples of regex I found didn't use the macro. So I just went ahead and used the regular.

blaenk · 2015-01-12T03:08:29Z

Did you see this? The advantage is that the regex gets compiled at compile time, so it's faster and if there are any issues you can get a compile-time error.

Anyways it's not a big deal, just thought I'd bring it up.

mdinger · 2015-01-12T03:17:57Z

Yeah, I know. I just wasn't sure how to integrate it into the compiler (the compiler doesn't use cargo you know). It'd be an easy PR later too if someone knows how to add it.

mdinger · 2015-01-12T07:54:16Z

@nick29581 Updated the summary a little. The errors will look basically the same. The only real difference is that now, it is done systematically which allows manually opting in/out as desired.

nrc · 2015-01-12T08:10:30Z

LGTM. Am I right to think that there is no way to turn off multi-line errors? Could you file a follow up issue for that please. Ping me for r+ when it's ready and rebased.

mdinger · 2015-01-12T08:21:51Z

@nick29581 rebased

mdinger · 2015-01-12T08:22:06Z

r? @nick29581

mdinger · 2015-01-12T08:28:55Z

Passed make check. Fixed all your nits. Removed a few tests I modified when the originals worked (I probably modified them originally but then they didn't need multi-line treatment and I never backed them out).

I don't think there's a way to turn off the multi-line error checking thing. It's either every line or none. It depends though, it seems to ignore Note type. Maybe warnings too. You have to be very explicit now.

It's still only substring matches though so you don't need the entire message. I just copied them from the terminal though generally so they're pretty exact.

mdinger · 2015-01-12T08:40:55Z

@nick29581 Thanks for the review!
@P1start Thanks for pointing me to those compile-fail tests. I would've never noticed.

@tomjakubowski

#### Updated 1/12/2014 I updated the multi-line testcase to current but didn't modify the others. The spew code was broke by the `matches!` macro no longer working and I'm not interested in fixing the testcase. I additionally added one testcase below. Errors will in general look similar to below if the error is either `mismatched types` or a few other types. The rest are ignored. --- #### Extra testcase: ```rust pub trait Foo { type A; fn boo(&self) -> <Self as Foo>::A; } struct Bar; impl Foo for i32 { type A = u32; fn boo(&self) -> u32 { 42 } } fn foo1<I: Foo<A=Bar>>(x: I) { let _: Bar = x.boo(); } fn foo2<I: Foo>(x: I) { let _: Bar = x.boo(); } pub fn baz(x: &Foo<A=Bar>) { let _: Bar = x.boo(); } pub fn main() { let a = 42i32; foo1(a); baz(&a); } ``` #### Multi-line output: ```cmd $ ./rustc test3.rs test3.rs:20:18: 20:25 error: mismatched types: expected `Bar`, found `<I as Foo>::A` (expected struct `Bar`, found associated type) test3.rs:20 let _: Bar = x.boo(); ^~~~~~~ test3.rs:31:5: 31:9 error: type mismatch resolving `<i32 as Foo>::A == Bar`: expected u32, found struct `Bar` test3.rs:31 foo1(a); ^~~~ test3.rs:31:5: 31:9 note: required by `foo1` test3.rs:31 foo1(a); ^~~~ test3.rs:32:9: 32:11 error: type mismatch resolving `<i32 as Foo>::A == Bar`: expected u32, found struct `Bar` test3.rs:32 baz(&a); ^~ test3.rs:32:9: 32:11 note: required for the cast to the object type `Foo` test3.rs:32 baz(&a); ^~ error: aborting due to 3 previous errors ``` --- This is a continuation of #19203 which I apparently broke by force pushing after it was closed. I'm attempting to add multi-line errors where they are largely beneficial - to help differentiate different types in compiler messages. As before, this is still a simple fix. #### Testcase: ```rust struct S; fn test() -> Option<i32> { let s: S; s } fn test2() -> Option<i32> { Ok(7) // Should be Some(7) } impl Iterator for S { type Item = i32; fn next(&mut self) -> Result<i32, i32> { Ok(7) } } fn main(){ test(); test2(); } ``` --- #### Single-line playpen errors: ```cmd <anon>:6:5: 6:6 error: mismatched types: expected `core::option::Option<int>`, found `S` (expected enum core::option::Option, found struct S) <anon>:6 s ^ <anon>:10:5: 10:10 error: mismatched types: expected `core::option::Option<int>`, found `core::result::Result<_, _>` (expected enum core::option::Option, found enum core::result::Result) <anon>:10 Ok(7) // Should be Some(7) ^~~~~ <anon>:14:5: 14:55 error: method `next` has an incompatible type for trait: expected enum core::option::Option, found enum core::result::Result [E0053] <anon>:14 fn next(&mut self) -> Result<uint, uint> { Ok(7) } ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ error: aborting due to 3 previous errors playpen: application terminated with error code 101 ``` --- #### Multi-line errors: ```cmd $ ./rustc test.rs test.rs:6:5: 6:6 error: mismatched types: expected `core::option::Option<i32>`, found `S` (expected enum `core::option::Option`, found struct `S`) test.rs:6 s ^ test.rs:10:5: 10:10 error: mismatched types: expected `core::option::Option<i32>`, found `core::result::Result<_, _>` (expected enum `core::option::Option`, found enum `core::result::Result`) test.rs:10 Ok(7) // Should be Some(7) ^~~~~ test.rs:15:5: 15:53 error: method `next` has an incompatible type for trait: expected enum `core::option::Option`, found enum `core::result::Result` [E0053] test.rs:15 fn next(&mut self) -> Result<i32, i32> { Ok(7) } ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ error: aborting due to 3 previous errors ``` --- #### Positive notes * Vim worked fine with it: #19203 (comment) * `make check` didn't find any errors * Fixed *backtick* placement suggested by @p1start at #19203 (comment) #### Negative notes * Didn't check Emacs support but also wasn't provided a testcase... * Needs to be tested with macro errors but I don't have a good testcase yet * I would like to move the `E[0053]` earlier (see #19464 (comment)) but I don't know how * It might be better to indent the types slightly like so (but I don't know how): ```cmd test.rs:6:5: 6:6 error: mismatched types: expected `core::option::Option<int>`, found `S` (expected enum `core::option::Option`, found struct `S`) test.rs:6 s ``` * Deep whitespace indentation may be a bad idea because early wrapping will cause misalignment between lines #### Other * I thought that compiler flags or something else (environment variables maybe) might be required because of comments against it but now that seems too much of a burden for users and for too little gain. * There was concern that it will make large quantities of errors difficult to distinguish but I don't find that an issue. They both look awful and multi-line errors makes the types easier to understand. --- #### Single lined spew: ```cmd $ rustc test2.rs test2.rs:161:9: 170:10 error: method `next` has an incompatible type for trait: expected enum core::option::Option, found enum core::result::Result [E0053] test2.rs:161 fn next(&mut self) -> Result<&'a str, int> { test2.rs:162 self.curr = self.next; test2.rs:163 test2.rs:164 if let (Some(open), Some(close)) = Parens::find_parens(self.all, self.next) { test2.rs:165 self.next = if self.all.char_at(self.next) == '(' { close } test2.rs:166 else { open } ... test2.rs:164:21: 164:31 error: mismatched types: expected `core::result::Result<uint, int>`, found `core::option::Option<_>` (expected enum core::result::Result, found enum core::option::Option) test2.rs:164 if let (Some(open), Some(close)) = Parens::find_parens(self.all, self.next) { ^~~~~~~~~~ test2.rs:164:33: 164:44 error: mismatched types: expected `core::result::Result<uint, int>`, found `core::option::Option<_>` (expected enum core::result::Result, found enum core::option::Option) test2.rs:164 if let (Some(open), Some(close)) = Parens::find_parens(self.all, self.next) { ^~~~~~~~~~~ test2.rs:169:40: 169:76 error: mismatched types: expected `core::result::Result<&'a str, int>`, found `core::option::Option<&str>` (expected enum core::result::Result, found enum core::option::Option) test2.rs:169 if self.curr != self.len { Some(self.all[self.curr..self.next]) } else { None } ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ test2.rs:169:86: 169:90 error: mismatched types: expected `core::result::Result<&'a str, int>`, found `core::option::Option<_>` (expected enum core::result::Result, found enum core::option::Option) test2.rs:169 if self.curr != self.len { Some(self.all[self.curr..self.next]) } else { None } ^~~~ test2.rs:205:14: 205:18 error: mismatched types: expected `core::result::Result<uint, int>`, found `core::option::Option<uint>` (expected enum core::result::Result, found enum core::option::Option) test2.rs:205 (open, close) ^~~~ test2.rs:205:20: 205:25 error: mismatched types: expected `core::result::Result<uint, int>`, found `core::option::Option<uint>` (expected enum core::result::Result, found enum core::option::Option) test2.rs:205 (open, close) ^~~~~ test2.rs:210:21: 210:31 error: mismatched types: expected `core::result::Result<uint, int>`, found `core::option::Option<_>` (expected enum core::result::Result, found enum core::option::Option) test2.rs:210 if let (Some(open), _) = Parens::find_parens(self.all, 0) { ^~~~~~~~~~ test2.rs:210:13: 212:28 error: mismatched types: expected `core::option::Option<&'a int>`, found `core::option::Option<&str>` (expected int, found str) test2.rs:210 if let (Some(open), _) = Parens::find_parens(self.all, 0) { test2.rs:211 Some(self.all[0..open]) test2.rs:212 } else { None } test2.rs:299:48: 299:58 error: mismatched types: expected `Box<translate::Entity>`, found `collections::vec::Vec<_>` (expected box, found struct collections::vec::Vec) test2.rs:299 pub fn new() -> Entity { Entity::Group(Vec::new()) } ^~~~~~~~~~ test2.rs:359:51: 359:58 error: type `&mut Box<translate::Entity>` does not implement any method in scope named `push` test2.rs:359 Entity::Group(ref mut vec) => vec.push(e), ^~~~~~~ test2.rs:366:51: 366:85 error: type `&mut Box<translate::Entity>` does not implement any method in scope named `push` test2.rs:366 Entity::Group(ref mut vec) => vec.push(Entity::Inner(s.to_string())), ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ error: aborting due to 12 previous errors ``` --- #### Multi-line spew: ```cmd $ ./rustc test2.rs test2.rs:161:9: 170:10 error: method `next` has an incompatible type for trait: expected enum `core::option::Option`, found enum `core::result::Result` [E0053] test2.rs:161 fn next(&mut self) -> Result<&'a str, int> { test2.rs:162 self.curr = self.next; test2.rs:163 test2.rs:164 if let (Some(open), Some(close)) = Parens::find_parens(self.all, self.next) { test2.rs:165 self.next = if self.all.char_at(self.next) == '(' { close } test2.rs:166 else { open } ... test2.rs:164:21: 164:31 error: mismatched types: expected `core::result::Result<uint, int>`, found `core::option::Option<_>` (expected enum `core::result::Result`, found enum `core::option::Option`) test2.rs:164 if let (Some(open), Some(close)) = Parens::find_parens(self.all, self.next) { ^~~~~~~~~~ test2.rs:164:33: 164:44 error: mismatched types: expected `core::result::Result<uint, int>`, found `core::option::Option<_>` (expected enum `core::result::Result`, found enum `core::option::Option`) test2.rs:164 if let (Some(open), Some(close)) = Parens::find_parens(self.all, self.next) { ^~~~~~~~~~~ test2.rs:169:40: 169:76 error: mismatched types: expected `core::result::Result<&'a str, int>`, found `core::option::Option<&str>` (expected enum `core::result::Result`, found enum `core::option::Option`) test2.rs:169 if self.curr != self.len { Some(self.all[self.curr..self.next]) } else { None } ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ test2.rs:169:86: 169:90 error: mismatched types: expected `core::result::Result<&'a str, int>`, found `core::option::Option<_>` (expected enum `core::result::Result`, found enum `core::option::Option`) test2.rs:169 if self.curr != self.len { Some(self.all[self.curr..self.next]) } else { None } ^~~~ test2.rs:205:14: 205:18 error: mismatched types: expected `core::result::Result<uint, int>`, found `core::option::Option<uint>` (expected enum `core::result::Result`, found enum `core::option::Option`) test2.rs:205 (open, close) ^~~~ test2.rs:205:20: 205:25 error: mismatched types: expected `core::result::Result<uint, int>`, found `core::option::Option<uint>` (expected enum `core::result::Result`, found enum `core::option::Option`) test2.rs:205 (open, close) ^~~~~ test2.rs:210:21: 210:31 error: mismatched types: expected `core::result::Result<uint, int>`, found `core::option::Option<_>` (expected enum `core::result::Result`, found enum `core::option::Option`) test2.rs:210 if let (Some(open), _) = Parens::find_parens(self.all, 0) { ^~~~~~~~~~ test2.rs:210:13: 212:28 error: mismatched types: expected `core::option::Option<&'a int>`, found `core::option::Option<&str>` (expected int, found str) test2.rs:210 if let (Some(open), _) = Parens::find_parens(self.all, 0) { test2.rs:211 Some(self.all[0..open]) test2.rs:212 } else { None } test2.rs:229:57: 229:96 error: the trait `core::ops::Fn<(char,), bool>` is not implemented for the type `|char| -> bool` test2.rs:229 .map(|s| s.trim_chars(|c: char| c.is_whitespace())) ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ test2.rs:238:46: 239:75 error: type `core::str::CharSplits<'_, |char| -> bool>` does not implement any method in scope named `filter_map` test2.rs:238 .filter_map(|s| if !s.is_empty() { Some(s.trim_chars('\'')) } test2.rs:239 else { None }) test2.rs:237:46: 237:91 error: the trait `core::ops::Fn<(char,), bool>` is not implemented for the type `|char| -> bool` test2.rs:237 let vec: Vec<&str> = value[].split(|c: char| matches!(c, '(' | ')' | ',')) ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ test2.rs:238:65: 238:77 error: the type of this value must be known in this context test2.rs:238 .filter_map(|s| if !s.is_empty() { Some(s.trim_chars('\'')) } ^~~~~~~~~~~~ test2.rs:299:48: 299:58 error: mismatched types: expected `Box<translate::Entity>`, found `collections::vec::Vec<_>` (expected box, found struct `collections::vec::Vec`) test2.rs:299 pub fn new() -> Entity { Entity::Group(Vec::new()) } ^~~~~~~~~~ test2.rs:321:36: 322:65 error: type `core::str::CharSplits<'_, |char| -> bool>` does not implement any method in scope named `filter_map` test2.rs:321 .filter_map(|s| if !s.is_empty() { Some(s.trim_chars('\'')) } test2.rs:322 else { None }) test2.rs:320:36: 320:81 error: the trait `core::ops::Fn<(char,), bool>` is not implemented for the type `|char| -> bool` test2.rs:320 let vec: Vec<&str> = s.split(|c: char| matches!(c, '(' | ')' | ',')) ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ test2.rs:321:55: 321:67 error: the type of this value must be known in this context test2.rs:321 .filter_map(|s| if !s.is_empty() { Some(s.trim_chars('\'')) } ^~~~~~~~~~~~ test2.rs:359:51: 359:58 error: type `&mut Box<translate::Entity>` does not implement any method in scope named `push` test2.rs:359 Entity::Group(ref mut vec) => vec.push(e), ^~~~~~~ test2.rs:366:51: 366:85 error: type `&mut Box<translate::Entity>` does not implement any method in scope named `push` test2.rs:366 Entity::Group(ref mut vec) => vec.push(Entity::Inner(s.to_string())), ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ error: aborting due to 24 previous errors ``` Closes #18946 #19464 cc @P1start @jakub- @tomjakubowski @kballard @chris-morgan

mdinger force-pushed the align_error branch from 40b4d90 to a0f6bf6 Compare January 3, 2015 05:49

mdinger force-pushed the align_error branch from a0f6bf6 to 6c6c320 Compare January 5, 2015 22:12

mdinger force-pushed the align_error branch from 6c6c320 to 072ef4e Compare January 6, 2015 02:26

rust-highfive assigned emberian Jan 6, 2015

nrc reviewed Jan 6, 2015
View reviewed changes

mdinger reviewed Jan 6, 2015
View reviewed changes

mdinger force-pushed the align_error branch 2 times, most recently from 5263eba to 84ce667 Compare January 9, 2015 03:10

mdinger force-pushed the align_error branch from 84ce667 to fb85490 Compare January 10, 2015 18:19

nrc reviewed Jan 11, 2015
View reviewed changes

mdinger added 3 commits January 12, 2015 01:34

Backtick nits

24ace16

Implement multi-line errors

5616b92

Fix testsuite errors

7b82a93

nrc assigned nrc and unassigned emberian Jan 12, 2015

mdinger force-pushed the align_error branch from fb85490 to 7b82a93 Compare January 12, 2015 08:20

mdinger mentioned this pull request Jan 12, 2015

Testsuite compile-fail error checking requires you to be very explicit #20987

Closed

bors merged commit 7b82a93 into rust-lang:master Jan 12, 2015

mdinger deleted the align_error branch January 12, 2015 15:17

This was referenced Jan 13, 2015

Collect errors which would be better as multiline errors #19464

Closed

extend multi-line errors to "method * has incompatible type for trait" #21332

Closed

cuviper mentioned this pull request Feb 28, 2016

ICE when attempting to split error message that contains " found" before "expected" into lines #31173

Closed

greenfork mentioned this pull request Jun 24, 2021

stage2: Add "tilde pointing" to errors for multi-character offenses ziglang/zig#9201

Closed

Multi-line errors #19870

Multi-line errors #19870

Conversation

mdinger commented Dec 15, 2014

Updated 1/12/2014

Extra testcase:

Multi-line output:

Testcase:

Single-line playpen errors:

Multi-line errors:

Positive notes

Negative notes

Other

Single lined spew:

Multi-line spew:

blaenk commented Dec 16, 2014

Gankra commented Jan 2, 2015

emberian commented Jan 2, 2015

mdinger commented Jan 3, 2015

ftxqxd commented Jan 3, 2015

mdinger commented Jan 3, 2015

mdinger commented Jan 5, 2015

mdinger commented Jan 6, 2015

emberian commented Jan 6, 2015

mdinger commented Jan 6, 2015

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

nrc commented Jan 6, 2015

mdinger commented Jan 6, 2015

nrc commented Jan 6, 2015

Choose a reason for hiding this comment

mdinger commented Jan 6, 2015

mdinger commented Jan 9, 2015

mdinger commented Jan 10, 2015

mdinger commented Jan 10, 2015

mdinger commented Jan 10, 2015

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

nrc commented Jan 11, 2015

mdinger commented Jan 11, 2015

blaenk commented Jan 12, 2015

mdinger commented Jan 12, 2015

blaenk commented Jan 12, 2015

mdinger commented Jan 12, 2015

mdinger commented Jan 12, 2015

nrc commented Jan 12, 2015

mdinger commented Jan 12, 2015

mdinger commented Jan 12, 2015

mdinger commented Jan 12, 2015

mdinger commented Jan 12, 2015