Struct Scope 

pub struct Scope<'scope, 'db> {
    span: Span<'db>,
    chain: ScopeChain<'scope, 'db>,
}

Name resolution scope, used when converting types/function-bodies etc into symbols.

Fields

span: Span<'db>

chain: ScopeChain<'scope, 'db>

Implementations

impl<'scope, 'db> Scope<'scope, 'db>

pub(crate) fn new(db: &'db dyn Db, span: Span<'db>) -> Self

A base scope containing only the primitive names.

pub(crate) fn with_link<'scope1>( self, link: impl Into<ScopeChainKind<'scope1, 'db>>, ) -> Scope<'scope1, 'db>

where 'scope: 'scope1,

Extend this scope with another link in the name resolution chain

pub fn span(&self) -> Span<'db>

fn with_prelude( self, db: &'db dyn Db, span: Span<'db>, crate_source: Krate, ) -> Self

Extend this scope with the prelude from a crate. Crates can define a module named prelude.

pub fn push_link(&mut self, kind: impl Into<ScopeChainKind<'scope, 'db>>)

Extend this scope with another link in the name resolution chain

pub fn aggregate(&self) -> Option<SymAggregate<'db>>

Return the innermost class in scope (if any).

pub(crate) fn resolve_name( &self, db: &'db dyn Db, id: Identifier<'db>, span: Span<'db>, ) -> Errors<NameResolution<'db>>

Resolve identifier id (found at span) in the scope. Reports errors if nothing is found and returns Err(Reported).

pub fn generic_sym_in_scope( &self, db: &'db dyn Db, sym: SymVariable<'db>, ) -> bool

True if sym is in scope.

pub fn into_bound_value<B>(self, db: &'db dyn Db, value: B::LeafTerm) -> B

where B: BoundTerm<'db>,

Given a value of type T that was resolved against this scope, creates a bound version like Binder<T> or Binder<Binder<T>> where all variables defined in scope are contained in these binders.

Each inner binding level in the output binds the symbols from one binding level in the scope. The outermost binding level in the output then binds all remaining symbols.

Example: Given a scope that has three levels like

• Class binding [A, B]
• Function binding [C, D]
• Local variables binding [x, y]

if we produce a Binder<'db, Binder<'db, T>>, then the result would be

• an outer Binder<Binder<T>> binds [A, B, C, D] that contains…
  • an inner Binder<T> binding [x, y] that contains…
    • the T value referencing A, B, C, D, x, and y

Panics

If the target type B requires more binding levels than are present in scope.

pub fn all_binders(&self) -> Vec<Vec<SymVariable<'db>>>

Convert self into a vec-of-vecs containing the bound generic symbols in outermost-to-innermost order. e.g. if you have class[type A] { fn foo[type B]() }, this will return [[A], [B]].

Trait Implementations

impl<'scope, 'db> Clone for Scope<'scope, 'db>

fn clone(&self) -> Scope<'scope, 'db>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'scope, 'db> Debug for Scope<'scope, 'db>

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

Formats the value using the given formatter.

impl<'scope, 'db> PartialEq for Scope<'scope, 'db>

fn eq(&self, other: &Scope<'scope, 'db>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'scope, 'db> Eq for Scope<'scope, 'db>

impl<'scope, 'db> StructuralPartialEq for Scope<'scope, 'db>