Functions that encode the semantic code for looking up symbols.

Code Map

//! Functions that encode the semantic code for looking up symbols.
module volt.semantic.lookup;


//! Look up an identifier in a scope and its parent scopes. Returns the
//! store or null if no match was found.
fn lookup(lp: LanguagePass, _scope: ir.Scope, loc: const(Location), name: string) ir.Store { }
//! Look up a QualifiedName chain, the first identifier is looked up
//! globaly, and the result is treated as a scope to lookup the next one
//! should there be more identifiers.
fn lookup(lp: LanguagePass, _scope: ir.Scope, qn: ir.QualifiedName) ir.Store { }
//! Look up an identifier in the given scope only. Doesn't check parent
//! scopes, parent classes, imports, or anywhere else but the given scope.
fn lookupInGivenScopeOnly(lp: LanguagePass, _scope: ir.Scope, loc: const(Location), name: string) ir.Store { }
//! Look up an identifier in this scope, in parent scopes (in the case of
//! classes), and in any imports for this scope.
fn lookupAsThisScope(lp: LanguagePass, _scope: ir.Scope, loc: const(Location), name: string, current: ir.Scope) ir.Store { }
//! Lookup in this scope and parent class scopes, if any.
fn lookupOnlyThisScopeAndClassParents(lp: LanguagePass, _scope: ir.Scope, loc: const(Location), name: string) ir.Store { }
//! Lookup up as identifier in this scope, and any public imports.
fn lookupAsImportScope(lp: LanguagePass, _scope: ir.Scope, loc: const(Location), name: string) ir.Store { }
//! Lookup an identifier in multiple scopes, as import scopes.
fn lookupAsImportScopes(lp: LanguagePass, scopes: ir.Scope[], loc: const(Location), name: string) ir.Store { }
//! This function is used to retrive cached versions of helper functions.
fn lookupFunction(lp: LanguagePass, _scope: ir.Scope, loc: const(Location), name: string) ir.Function { }
//! Helper functions that looksup a type and throws compiler errors if it
//! is not found or the found identifier is not a type.
fn lookupType(lp: LanguagePass, _scope: ir.Scope, id: ir.QualifiedName) ir.Type { }
fn lookupType(lp: LanguagePass, _scope: ir.Scope, id: ir.QualifiedName, store: ir.Store) ir.Type { }
//! Resolves a store making sure the node it points to is resolved, the
//! function returns the store that a alias is pointing to. Not the alias
//! itself.
fn ensureResolved(lp: LanguagePass, s: ir.Store) ir.Store { }
//! Get the module in the bottom of the given _scope chain.
fn getModuleFromScope(loc: const(Location), _scope: ir.Scope) ir.Module { }
//! Return the first class scope and the class going down the chain of
//! containing scopes (_scope.parent field).
fn getFirstClass(_scope: ir.Scope, outScope: ir.Scope, outClass: ir.Class) bool { }

            The function pointed to by the store.

            The type pointed to by the store.

            The scope of store type or the scope itself.