nightly doesn't show the line number for some error

[bbigras-]

nightly-x86_64-unknown-linux-gnu (default)
rustc 1.28.0-nightly (524ad9b 2018-05-29)

Here's an error without a line number:

error[E0559]: variant `ldap::LdapError::NotInGroup` has no field named `name`
  |
  = note: available fields are: `group_name`
error: aborting due to previous error
For more information about this error, try `rustc --explain E0559`.
error: Could not compile `some_project`.

[GuillaumeGomez]

I'll take a look.

[GuillaumeGomez]

I was able to get the error and I have the expected lines:

fn main() {
    enum Mouth {Foo{x: i32}, Bar};

    let x = Mouth::Foo {y: 0};
}

Can you provide a small code sample with this issue please?

[bbigras-]

It might have something to do with formatting. The following code causes the problem for me but the problem goes away if I format the code using cargo fmt.

deps

[dependencies]
failure = "0.1"
futures-await = "0.1"
ldap3 = "0.6"
tokio-core = "0.1"

code

#![feature(proc_macro, generators)]

extern crate futures_await as futures;
extern crate ldap3;
extern crate tokio_core;

#[macro_use]
extern crate failure;

use tokio_core::reactor::Handle;
use ldap3::{LdapConnAsync, Scope};
use futures::prelude::*;
use failure::Error;

use std::io::Write;

#[derive(Fail)]
enum LdapError {
    #[fail(display = "InvalidCreds: {}", name)]
    InvalidCreds { name: String },

    #[fail(display = "NotInGroup: {}", group_name)]
    NotInGroup { group_name: String },
}

#[async]
fn test_user_has_access(handle: Handle) -> Result<(), Error> {
    let r = LdapConnAsync::new("ldap://localhost:2389", &handle)?
        .map_err(|e| {
            let e2: Error = e.into();
            e2
        })
        .and_then(move |ldap| {
            ldap.simple_bind("bind_user", "bind_pass")
                .map_err(Into::into)
                .and_then(move |ldap2| {
                    let j = if ldap2.rc == 49 {
                        Err(LdapError::InvalidCreds { name: "some_user".to_string() }.into())
                    } else {
                        Ok(())
                    };

                    j.into_future().and_then(|()| {
                        ldap.search("something", Scope::Subtree, "something", vec![])
                            .map_err(Into::into)
                    })
                })
        });

    return Err(LdapError::NotInGroup {
        name: "test".to_string(),
    }.into());
}

fn main() {}

[GuillaumeGomez]

Ok, I think the problem comes from async/await.

cc @rust-lang/compiler

[estebank]

That output seems consistent with a lack of spans or finding DUMMY_SP in the diagnostic. This can happen when the code is in a separate crate, but the primary span should always be pointing at local code...

[eddyb]

@estebank It might be caused, in this case, by macro expansion.

[estebank]

@eddyb that sounds likely.

[Mark-Simulacrum]

I suspect this is somewhat "unfixable" -- proc macros sometimes just lose spans if they make no effort to preserve them. As such, I'm going to close; if a minimal example can be shown to have a similar error with just macro_rules we can probably reopen.

[estebank]

I don't entirely agree, but we already have #51635 covering related remediations so closing this should be ok.