Enum valkyrie_ast::ImportState

pub enum ImportState {
    Explicit,
    Implicit,
    Duplicate,
    Ambiguous,
}

The resolve result of import

• function, constant, structure, interfaces, type share a namespace
• derive and macro share a namespace
• If a macro is an implicit macro, it occupies the namespace of the function

namespace a {
    class A;
    class B;
    class C;
    class D;
}

namespace b {
    class A;
    class B;
    class C;
}

using a.*;
using b.*;
using a.{A, B};
using b.B;

Script Mode

In script mode, adjusting the import statement orders at the same level does not affect the final result.

• You cannot explicitly import two objects with the same name, it is a compile-time error

• You cannot implicitly import two objects with the same name, this is a compile-time warning

• Extensions cannot be implicitly imported

• A: a::A (explicit)

• B: null (duplicate, error, not available)

• C: null (ambiguous, waring, not available)

• D: a::D (implicit)

Interactive Mode

In repl mode, imports always available.

• later implicit imports will override earlier implicit imports

• later explicit imports will override earlier explicit imports

• A: a::A (explicit)

• B: b::B (explicit)

• C: b::C (implicit)

• D: a::D (implicit)

Variants

Explicit

Available by explicit import

Implicit

Available by implicit import

Duplicate

Unavailable due to duplicate import

Ambiguous

Unavailable due to ambiguous import

Trait Implementations

impl Clone for ImportState

fn clone(&self) -> ImportState

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ImportState

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for ImportState

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ImportState

fn eq(&self, other: &ImportState) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for ImportState

impl Eq for ImportState

impl StructuralPartialEq for ImportState