Skip to main content

Env

Trait Env 

Source
pub trait Env {
    // Provided methods
    fn root(&self, name: Name) -> Option<Export> { ... }
    fn prelude(&self, name: Name, ns: Namespace) -> Option<Export> { ... }
    fn member(
        &self,
        container: Res,
        name: Name,
        ns: Namespace,
    ) -> Option<Export> { ... }
    fn for_each_member(
        &self,
        container: Res,
        f: &mut dyn FnMut(Name, Namespace, Export),
    ) { ... }
    fn for_each_root(&self, f: &mut dyn FnMut(Name)) { ... }
    fn for_each_prelude(&self, f: &mut dyn FnMut(Name, Namespace)) { ... }
}
Expand description

The host’s side of resolution: everything outside the program.

Every method has a default that knows nothing, so a host implements only what its language has. Lookups are by exact Name (symbol and hygiene mark). The resolver calls each method a bounded number of times per path segment, and the enumeration methods only for glob imports from outside the program and for did-you-mean suggestions.

§Examples

use hir_lang::{Name, Prim, Res};
use resolve_lang::{DefKind, Env, Export, Namespace};

/// Primitive types only: `int` is `i64`.
struct Prims { int: Name }

impl Env for Prims {
    fn prelude(&self, name: Name, ns: Namespace) -> Option<Export> {
        (name == self.int && ns == Namespace::Type)
            .then(|| Export::new(Res::Prim(Prim::I64), DefKind::Prim))
    }
}

Provided Methods§

Source

fn root(&self, name: Name) -> Option<Export>

A name visible as the first segment of a path in every unit, after every lexical scope: another package, a precompiled unit, an extern module. Usually a DefKind::Module or DefKind::Extern.

Source

fn prelude(&self, name: Name, ns: Namespace) -> Option<Export>

The prelude: names visible everywhere, after lexical scopes and roots (builtins, primitive type names).

Source

fn member(&self, container: Res, name: Name, ns: Namespace) -> Option<Export>

A member of a container the program does not define: a module or class of another package, an extern module. container is the resolution the path reached so far.

Source

fn for_each_member( &self, container: Res, f: &mut dyn FnMut(Name, Namespace, Export), )

Calls f for every member of an outside container, for glob imports and suggestions.

Source

fn for_each_root(&self, f: &mut dyn FnMut(Name))

Calls f for every root name, for suggestions.

Source

fn for_each_prelude(&self, f: &mut dyn FnMut(Name, Namespace))

Calls f for every prelude name, for suggestions.

Dyn Compatibility§

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors§