Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Work in progress

Name resolution

Name resolution is the process of tying paths and other identifiers to the declarations of those entities. Names are segregated into different namespaces, allowing entities in different namespaces to share the same name without conflict. Each name is valid within a scope, or a region of source text where that name may be referenced. Access to a name may be restricted based on its visibility.

Name resolution is split into three stages throughout the compilation process. The first stage, expansion-time resolution, resolves all use declarations and macro invocations. The second stage, primary resolution, resolves all names that have not yet been resolved and that do not depend on type information to resolve. The last stage, type-relative resolution, resolves the remaining names once type information is available.

Note

Expansion-time resolution is also known as early resolution. Primary resolution is also known as late resolution.

General

The rules within this section apply to all stages of name resolution.

Scopes

Note

This is a placeholder for future expansion about resolution of names within various scopes.

Expansion-time name resolution

Expansion-time name resolution is the stage of name resolution necessary to complete macro expansion and fully generate a crate’s AST. This stage requires the resolution of macro invocations and use declarations. Resolving use declarations is required for macro invocations that resolve via path-based scope. Resolving macro invocations is required in order to expand them.

After expansion-time name resolution, the AST must not contain any unexpanded macro invocations. Every macro invocation resolves to a valid definition that exists in the final AST or in an external crate.

#![allow(unused)]
fn main() {
m!(); // ERROR: Cannot find macro `m` in this scope.
}

The resolution of names must be stable. After expansion, names in the fully expanded AST must resolve to the same definition regardless of the order in which macros are expanded and imports are resolved.

All name resolution candidates selected during macro expansion are considered speculative. Once the crate has been fully expanded, all speculative import resolutions are validated to ensure that macro expansion did not introduce any new ambiguities.

Note

Due to the iterative nature of macro expansion, this causes so-called time traveling ambiguities, such as when a macro or glob import introduces an item that is ambiguous with its own base path.

fn main() {}
macro_rules! f {
    () => {
        mod m {
            pub(crate) use f;
        }
    }
}
f!();

const _: () = {
    // Initially, we speculatively resolve `m` to the module in
    // the crate root.
    //
    // Expansion of `f` introduces a second `m` module inside this
    // body.
    //
    // Expansion-time resolution finalizes resolutions by re-
    // resolving all imports and macro invocations, sees the
    // introduced ambiguity and reports it as an error.
    m::f!(); // ERROR: `m` is ambiguous.
};

Imports

All use declarations are fully resolved during this stage of resolution. Type-relative paths cannot be resolved at this stage and will produce an error.

#![allow(unused)]
fn main() {
mod m {
    pub const C: () = ();
    pub enum E { V }
    pub type A = E;
    impl E {
        pub const C: () = ();
    }
}

// Valid imports resolved at expansion-time:
use m::C; // OK.
use m::E; // OK.
use m::A; // OK.
use m::E::V; // OK.

// Valid expressions resolved during type-relative resolution:
let _ = m::A::V; // OK.
let _ = m::E::C; // OK.
}
#![allow(unused)]
fn main() {
mod m {
    pub const C: () = ();
    pub enum E { V }
    pub type A = E;
    impl E {
        pub const C: () = ();
    }
}
// Invalid type-relative imports that can't resolve at expansion-time:
use m::E::C; // ERROR: Unresolved import `m::E::C`.
use m::A::V; // ERROR: Unresolved import `m::A::V`.
}

Names introduced via use declarations in an outer scope are shadowed by candidates in the same namespace with the same name from an inner scope except where otherwise restricted by name resolution ambiguities.

#![allow(unused)]
fn main() {
pub mod m1 {
    pub mod ambig {
        pub const C: u8 = 1;
    }
}

pub mod m2 {
    pub mod ambig {
        pub const C: u8 = 2;
    }
}

// This introduces the name `ambig` in the outer scope.
use m1::ambig;
fn f() {
    // This shadows `ambig` in the inner scope.
    use m2::ambig;
    // The inner candidate is selected here
    // as the resolution of `ambig`.
    use ambig::C;
    const { assert!(C == 2) };
}
}

Shadowing of names introduced via use declarations within a single scope is permitted in the following situations:

Ambiguities

There are certain situations during expansion-time resolution where there are multiple macro definitions, use declarations, or modules an import or macro invocation’s name could refer to where the compiler cannot consistently determine which candidate should shadow the other. Shadowing cannot be permitted in these situations and the compiler instead emits ambiguity errors.

Names may not be resolved through ambiguous glob imports. Glob imports are allowed to import conflicting names in the same namespace as long as the name is not used. Names with conflicting candidates from ambiguous glob imports may still be shadowed by non-glob imports and used without producing an error. The errors occur at time of use, not time of import.

For example:

#![allow(unused)]
fn main() {
mod m1 {
    pub struct Ambig;
}

mod m2 {
    pub struct Ambig;
}

// OK: This brings conficting names into scope and namespace
// but they have not been used yet.
use m1::*;
use m2::*;

fn ambiguous_use() {
    let x = Ambig; // ERROR: `Ambig` is ambiguous.
}
}
#![allow(unused)]
fn main() {
mod m1 {
    pub struct Ambig;
}

mod m2 {
    pub struct Ambig;
}

use m1::*;
use m2::*; // OK: No name conflict.
fn ambiguous_shadow() {
    // This is permitted, since resolution is not through the ambiguous globs.
    struct Ambig;
    let x = Ambig;
}
}

Multiple glob imports are allowed to import the same name, and that name is allowed to be used if the imports are of the same item (following re-exports). The visibility of the name is the maximum visibility of the imports.

mod m1 {
    pub struct Ambig;
}

mod m2 {
    // This re-exports the same `Ambig` item through a second module.
    pub use super::m1::Ambig;
}

// These both import the same `Ambig`.
//
// The visibility of `Ambig` is `pub` because that is the
// maximum visibility between these two `use` declarations.
mod m3 {
    pub use super::m1::*;
    use super::m2::*;
}

fn main() {
    // `Ambig` can be used through the m3
    // globs and still has `pub` visibility.
    let _ = m3::Ambig;
}

Names in imports and macro invocations may not be resolved through glob imports when there is another candidate available in an outer scope.

#![allow(unused)]
fn main() {
mod glob {
    pub mod ambig {
        pub struct Name;
    }
}

// Outer `ambig` candidate.
pub mod ambig {
    pub struct Name;
}

const _: () = {
    // Cannot resolve `ambig` through this glob
    // because of the outer `ambig` candidate above.
    use glob::*;
    use ambig::Name; // ERROR: `ambig` is ambiguous.
};
}
#![allow(unused)]
fn main() {
use m::f as ambig;
pub mod m {
    macro_rules! f {
        () => {};
    }
    pub(crate) use f;
}
pub mod glob {
    macro_rules! f {
        () => {};
    }
    pub(crate) use f as ambig;
}

const _: () = {
    use glob::*;
    ambig!(); // ERROR: `ambig` is ambiguous.
};
}

Note

These ambiguity errors are specific to expansion-time resolution. Having multiple candidates available for a given name during later stages of resolution is not considered an error. So long as none of the imports themselves are ambiguous, there will always be a single unambiguous closest resolution.

#![allow(unused)]
fn main() {
mod glob {
    pub const AMBIG: bool = true;
}

mod outer {
    pub const AMBIG: bool = false;
}

use outer::AMBIG;

pub fn f() {
    use glob::*;
    assert!(AMBIG);
    //      ^--- This `AMBIG` is resolved during primary resolution.
}
}

Names may not be resolved through ambiguous macro re-exports. Macro re-exports are ambiguous when they would shadow a textual macro candidate for the same name in an outer scope.

#![allow(unused)]
fn main() {
// Textual macro candidate.
macro_rules! ambig {
    () => {}
}

// Path-based macro candidate.
macro_rules! path_based {
    () => {}
}

pub fn f() {
    // This re-export of the `path_based` macro definition
    // as `ambig` may not shadow the `ambig` macro definition
    // which is resolved via textual macro scope.
    use path_based as ambig;
    ambig!(); // ERROR: `ambig` is ambiguous.
}
}

Note

This restriction is needed due to implementation details in the compiler, specifically the current scope visitation logic and the complexity of supporting this behavior. This ambiguity error may be removed in the future.

Macros

Macros are resolved by iterating through the available scopes to find the available candidates. Macros are split into two sub-namespaces, one for function-like macros, and the other for attributes and derives. Resolution candidates from the incorrect sub-namespace are ignored.

The available scope kinds are visited in the following order. Each of these scope kinds represent one or more scopes.

Note

The compiler will attempt to resolve derive helpers that are used before their associated macro introduces them into scope. This scope is visited after the scope for resolving derive helper candidates that are correctly in scope. This behavior is slated for removal.

For more info see derive helper scope.

Note

This visitation order may change in the future, such as interleaving the visitation of textual and path-based scope candidates based on their lexical scopes.

2018 Edition differences

Starting in edition 2018 the #[macro_use] prelude is not visited when #[no_implicit_prelude] is present.

Derive helper scopes are not visited when resolving derive macros in the parent scope (starting scope).

The names cfg and cfg_attr are reserved in the macro attribute sub-namespace.

Ambiguities

Names may not be resolved through ambiguous candidates inside of macro expansions. Candidates inside of macro expansions are ambiguous when they would shadow a candidate for the same name from outside of the first candidate’s macro expansion and the invocation of the name being resolved is also from outside of the first candidate’s macro expansion.

#![allow(unused)]
fn main() {
macro_rules! define_ambig {
    () => {
        macro_rules! ambig {
            () => {}
        }
    }
}

// Introduce outer candidate definition for `ambig` macro invocation.
macro_rules! ambig {
    () => {}
}

// Introduce a second candidate definition for `ambig` inside of a macro
// expansion.
define_ambig!();

// The definition of `ambig` from the second invocation
// of `define_ambig` is the innermost canadidate.
//
// The definition of `ambig` from the first invocation of `define_ambig`
// is the second candidate.
//
// The compiler checks that the first candidate is inside of a macro
// expansion, that the second candidate is not from within the same
// macro expansion, and that the name being resolved is not from
// within the same macro expansion.
ambig!(); // ERROR: `ambig` is ambiguous.
}

The reverse is not considered ambiguous.

#![allow(unused)]
fn main() {
macro_rules! define_ambig {
    () => {
        macro_rules! ambig {
            () => {}
        }
    }
}
// Swap order of definitions.
define_ambig!();
macro_rules! ambig {
    () => {}
}
// The innermost candidate is now less expanded so it may shadow more
// the macro expanded definition above it.
ambig!();
}

Nor is it ambiguous if the invocation being resolved is within the innermost candidate’s expansion.

#![allow(unused)]
fn main() {
macro_rules! ambig {
    () => {}
}

macro_rules! define_and_invoke_ambig {
    () => {
        // Define innermost candidate.
        macro_rules! ambig {
            () => {}
        }

        // Invocation of `ambig` is in the same expansion as the
        // innermost candidate.
        ambig!(); // OK
    }
}

define_and_invoke_ambig!();
}

It doesn’t matter if both definitions come from invocations of the same macro, the outermost candidate is still considered “less expanded” because it is not within the expansion containing the innermost candidate’s definition.

#![allow(unused)]
fn main() {
macro_rules! define_ambig {
    () => {
        macro_rules! ambig {
            () => {}
        }
    }
}
define_ambig!();
define_ambig!();
ambig!(); // ERROR: `ambig` is ambiguous.
}

This also applies to imports, so long as the innermost candidate for the invocation of name is from within a macro expansion.

#![allow(unused)]
fn main() {
macro_rules! define_ambig {
    () => {
        mod ambig {
            pub struct Name;
        }
    }
}

mod ambig {
    pub struct Name;
}

const _: () = {
    // Introduce innermost candidate for
    // `ambig` mod in this macro expansion.
    define_ambig!();
    use ambig::Name; // ERROR: `ambig` is ambiguous.
};
}

User defined attributes or derive macros may not shadow builtin non-macro attributes (e.g. inline).

// with-helper/src/lib.rs
use proc_macro::TokenStream;
#[proc_macro_derive(WithHelperAttr, attributes(non_exhaustive))]
//                                             ^------------- user attr candidate
...
pub fn derive_with_helper_attr(_item: TokenStream) -> TokenStream {
    TokenStream::new()
}
// src/lib.rs
#[derive(with_helper::WithHelperAttr)]
#[non_exhaustive] // ERROR: `non_exhaustive` is ambiguous.
struct S;

Note

This applies regardless of the name the builtin attribute is a candidate for:

// with-helper/src/lib.rs
use proc_macro::TokenStream;

#[proc_macro_derive(WithHelperAttr, attributes(helper))]
//                                             ^----- user attr candidate
...
pub fn derive_with_helper_attr(_item: TokenStream) -> TokenStream {
    TokenStream::new()
}
// src/lib.rs
use inline as helper;
//            ^----- builtin attr candidate via re-export

#[derive(with_helper::WithHelperAttr)]
#[helper] // ERROR: `helper` is ambiguous.
struct S;

Primary name resolution

Note

This is a placeholder for future expansion about primary name resolution.

Type-relative resolution

Note

This is a placeholder for future expansion about type-dependent resolution.