Ability to refer to a path relative to the current scope in use declarations

[crumblingstatue]

(Note that this is not about the ability to refer to the current module, which is already possible with use self::foo.)

Rust allows declaring modules, enums, and extern crates in most places where items can be declared, including block scopes inside functions.
One use of this is bringing an extern crate into scope inside a conditional branch:

fn show_message(message: &str) {
    if (inside_a_gui_context) {
        extern crate messagebox;
        // Import trait Messagebox
        use messagebox::Messagebox; // Doesn't work
        ...
    } else {
        println!("{}", message);
    }
}

The problem is that there is no way to refer to items declared this way in use declarations, as paths in use declarations are absolute.

It feels inconsistent being able to declare items like this, but not being able to refer to them in use declarations, and might surprise some users. It did surprise me.

While referring to the items inside can be done by using their full relative path (e.g. do_something_with(messagebox::foo)), there is no way to import traits, so the user has to move the module/crate up to a scope where it can be referred from in use declarations.

One way this could be resolved is to give users a way to refer to a relative path in use declarations.

Options include:

• Using a keyword , e.g. use relative::messagebox::Messagebox, although I'm not sure reserving a new keyword this late in the alpha is desirable.
• Using _, as in use _::messagebox::Messagebox, but I'm not sure if _ could otherwise refer to a valid path. It's also not as descriptive as a keyword, but still better than nothing.

The general ability to use relative paths in use declarations might also bring ergonomic benefits in other cases too.

Any thoughts on this issue?

[blaenk]

Not sure I understand the issue. I think @eddyb has the best understanding of this area.

[Kimundi]

Another option would be to change the existing use self::messagebox::MessageBox semantic to refer to all items currently in scope, which would include the items inside a block if the use is written inside the block.

[ticki]

This seems like it should enter FCP.

[ticki]

If not outright considered a bug.

[lambda-fairy]

I think I've run into this issue with Maud.

I'd like to write a function-like proc macro that expands to the following expression (where $expr and $output are arguments to the macro):

{
    extern crate maud;
    use maud::Render;
    $expr.render_to($output);
}

But because of this issue, the use statement fails to compile.

I could call the trait method directly (maud::Render::render_to($expr, $output)) but then I lose autoref.

I ended up working around this issue using a forwarding trait + blanket impl:

{
    extern crate maud;
    trait RenderWrapper: maud::Render {
        fn __render_to(&self, output: &mut String) {
            maud::Render::render_to(self, output);
        }
    }
    impl<T: maud::Render> RenderWrapper for T {}
    $expr.__render_to($output);
}

but this feels kind of icky.