global_allocator can not not be defined inside module

[rkapl]

When trying define a global allocator inside a module, you get a weird error message: [E0432]: unresolved import super. The global_allocator is expanded to code containing use super::<varname> but I don't know why rustc fails to resolve that in this case. Happens with both inline and file modules.

Looks like the module that is created by expanding global_allocator thinks its parent is the root crate despite being in the breaks module.

Example:

#![feature(global_allocator, allocator_api)]                                                                                                                                                                       
                                                                                                                                                                                                                   
struct TAlloc;                                                                                                                                                                                                     
                                                                                                                                                                                                                   
unsafe impl<'a> std::heap::Alloc for &'a TAlloc{                                                                                                                                                                   
    unsafe fn alloc(&mut self, _layout: std::heap::Layout) -> std::result::Result<*mut u8, std::heap::AllocErr> {                                                                                                  
        return Err(std::heap::AllocErr::Unsupported{details: "Stub allocator"});                                                                                                                                   
    }                                                                                                                                                                                                              
    unsafe fn dealloc(&mut self, _ptr: *mut u8, _layout: std::heap::Layout) {                                                                                                                                      
    }                                                                                                                                                                                                              
}                                                                                                                                                                                                                  
                                                                                                                                                                                                                   
mod breaks{                                                                                                                                                                                                        
    #[global_allocator]                                                                                                                                                                                            
    static ALLOCATOR: ::TAlloc = ::TAlloc;                                                                                                                                                                         
}                                                                                                                                                                                                                  
                                                                                                                                                                                                                   
pub fn main() {                                                                                                                                                                                                    
}

causes:

error[E0432]: unresolved import `super`
  --> alloc.rs:15:5
   |
15 |     static ALLOCATOR: ::TAlloc = ::TAlloc;
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `ALLOCATOR` in the root

[mattico]

I looked into this a bit, writing some notes here so I don't forget what I found.

The problem is here:

rust/src/librustc_allocator/expand.rs

Lines 94 to 97 in 0e6f4cf

	let super_path = f.cx.path(f.span, vec![
	Ident::from_str("super"),
	f.global,
	]);

The Path for the allocator is hard-coded to be super::<allocator name>. We need to instead get a proper Path for f.global.

There may be a function hidden in the compiler somewhere that can help get a Path for an Item. If there isn't we could keep a Vec<Mod> as we traverse modules and convert that to a Path if we find an allocator definition.

[mattico]

Another option is to generate stub impls of the global alloc functions in the AST but then fill them out later when there's more information available.

[whitequark]

To add to this, this is also broken:

pub fn main() {
    #[global_allocator]
    static ALLOCATOR: ::TAlloc = ::TAlloc;
}

[mark-i-m]

playground example: https://play.rust-lang.org/?gist=db5d76e6c9da2e3e08de7592862e7ff3&version=nightly

[mark-i-m]

Started working on this... It's very WIP at the moment, though. If anyone has feedback, let me know.