Struct gluon::import::Import

pub struct Import<I = DefaultImporter> {
    pub paths: RwLock<Vec<PathBuf>>,
    pub importer: I,
    pub compiler: Mutex<CompilerDatabase>,
}

Macro which rewrites occurances of import! "filename" to a load of that file if it is not already loaded and then a global access to the loaded module

Fields

paths: RwLock<Vec<PathBuf>>

importer: I

compiler: Mutex<CompilerDatabase>

Implementations

impl<I> Import<I>

pub fn new(importer: I) -> Import<I>

Creates a new import macro

pub fn add_path<P: Into<PathBuf>>(&self, path: P)

Adds a path to the list of paths which the importer uses to find files

pub fn set_paths(&self, paths: Vec<PathBuf>)

pub fn modules( &self, compiler: &mut ModuleCompiler<'_, '_> ) -> Vec<Cow<'static, str>>

pub fn database_mut(self: Arc<Self>, thread: RootedThread) -> DatabaseMut

where I: Importer,

pub fn snapshot(&self, thread: RootedThread) -> Snapshot<CompilerDatabase>

pub fn fork( &mut self, forker: ForkState, thread: RootedThread ) -> Snapshot<CompilerDatabase>

Trait Implementations

impl<I> Macro for Import<I>

where I: Importer,

fn get_capability_impl( &self, thread: &Thread, arc_self: &Arc<dyn Macro>, id: TypeId ) -> Option<Box<dyn Any>>

fn expand<'r, 'a: 'r, 'b: 'r, 'c: 'r, 'ast: 'r>( &self, macros: &'b mut MacroExpander<'a>, _symbols: &'c mut Symbols, _arena: &'b mut OwnedArena<'ast, Symbol>, args: &'b mut [SpannedExpr<'ast, Symbol>] ) -> MacroFuture<'r, 'ast>

Creating a symbol in symbols will put it in the same scope as the code surrounding the expansion. If you want to create a unique symbol then call Symbol::from or create a new Symbols table

fn get_capability<T>( &self, thread: &Thread, arc_self: &Arc<dyn Macro> ) -> Option<T>

where Self: Sized, T: Any,

impl<I> Trace for Import<I>

unsafe fn root(&mut self)

unsafe fn unroot(&mut self)

fn trace(&self, _gc: &mut Gc)