Struct Resolver 

pub struct Resolver<'e> { /* private fields */ }

Resolves one unit (Tier 2): a policy, an environment, a budget.

Examples

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

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));

// const N: int = 1
let mut b = Builder::new();
let ty_path = b.name_path(int, hir_lang::Ns::Type);
let ty = b.ty(hir_lang::Ty::Path(ty_path));
let one = b.int(1);
let n = b.item(hir_lang::Item::new(Some(Name::new(names.intern("N"))), hir_lang::ItemKind::Const { ty: Some(ty), value: Some(one) }));
let root = b.module(None, &[n]);

let res = Resolver::new(Policy::kraken()).with_env(&env).resolve(b.finish(root)?, &names)?;
assert!(res.is_clean());
assert_eq!(res.units()[0].hir().path(ty_path).res, Res::Prim(Prim::I64));

Implementations

impl Resolver<'static>

pub fn new(policy: Policy) -> Self

A resolver with policy, no environment, and the default budget.

Examples

use resolve_lang::{Policy, Resolver};

let _r = Resolver::new(Policy::python());

impl Resolver<'_>

pub fn with_env(self, env: &dyn Env) -> Resolver<'_>

Uses env for names outside the unit.

Examples

use resolve_lang::{MapEnv, Policy, Resolver};

let env = MapEnv::new();
let _r = Resolver::new(Policy::new()).with_env(&env);

pub fn with_budget(self, budget: Budget) -> Self

Sets the budget.

Examples

use resolve_lang::{Budget, Policy, Resolver};

let _r = Resolver::new(Policy::new()).with_budget(Budget::unlimited());

pub fn resolve<L: Lookup>( self, hir: Hir, names: &L, ) -> Result<Resolution, ResolveError>

Resolves hir.

Errors

ResolveError::BudgetExceeded if the unit exceeds the budget.

Examples

use hir_lang::Builder;
use intern_lang::Interner;
use resolve_lang::{Policy, Resolver};

let mut b = Builder::new();
let root = b.module(None, &[]);
let res = Resolver::new(Policy::php()).resolve(b.finish(root)?, &Interner::new())?;
assert!(res.is_clean());

Trait Implementations

impl<'e> Clone for Resolver<'e>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'e> Copy for Resolver<'e>

impl Debug for Resolver<'_>

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

Formats the value using the given formatter.