Struct MapEnv 

pub struct MapEnv { /* private fields */ }

A ready-made in-memory Env: roots, a prelude, and members of outside containers, each registered once.

Lookups are O(log n); enumeration is in name order, so suggestions are deterministic.

Examples

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

let mut names = Interner::new();
let int = Name::new(names.intern("int"));
let env = MapEnv::new().with_prelude(int, Namespace::Type, Export::new(Res::Prim(Prim::I64), DefKind::Prim));
assert_eq!(env.prelude(int, Namespace::Type).map(|e| e.res), Some(Res::Prim(Prim::I64)));
assert!(env.prelude(int, Namespace::Value).is_none());

Implementations

impl MapEnv

pub fn new() -> Self

An empty environment.

Examples

use resolve_lang::MapEnv;

let _env = MapEnv::new();

pub fn with_root(self, name: Name, export: Export) -> Self

Adds a root name (replacing an earlier one of the same name).

Examples

use hir_lang::{Name, Res};
use intern_lang::Interner;
use resolve_lang::{DefKind, Env, Export, MapEnv};

let mut names = Interner::new();
let std = names.intern("std");
let env = MapEnv::new().with_root(Name::new(std), Export::new(Res::Extern(std), DefKind::Extern));
assert!(env.root(Name::new(std)).is_some());

pub fn with_prelude(self, name: Name, ns: Namespace, export: Export) -> Self

Adds a prelude name in one namespace.

Examples

use hir_lang::{Name, Res};
use intern_lang::Interner;
use resolve_lang::{DefKind, Env, Export, MapEnv, Namespace};

let mut names = Interner::new();
let print = names.intern("print");
let env = MapEnv::new().with_prelude(Name::new(print), Namespace::Value, Export::new(Res::Extern(print), DefKind::Extern));
assert!(env.prelude(Name::new(print), Namespace::Value).is_some());

pub fn with_member( self, container: Res, name: Name, ns: Namespace, export: Export, ) -> Self

Adds a member of an outside container (a Res::Def or Res::Extern; other resolutions are ignored).

Examples

use hir_lang::{Name, Res};
use intern_lang::Interner;
use resolve_lang::{DefKind, Env, Export, MapEnv, Namespace};

let mut names = Interner::new();
let (os, path) = (names.intern("os"), names.intern("path"));
let env = MapEnv::new().with_member(Res::Extern(os), Name::new(path), Namespace::Module, Export::new(Res::Extern(path), DefKind::Extern));
assert!(env.member(Res::Extern(os), Name::new(path), Namespace::Module).is_some());

Trait Implementations

impl Clone for MapEnv

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MapEnv

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

Formats the value using the given formatter.

impl Default for MapEnv

fn default() -> Self

Returns the “default value” for a type.

impl Env for MapEnv

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.

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

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

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.

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.

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

Calls f for every root name, for suggestions.

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

Calls f for every prelude name, for suggestions.