Struct Compiler 

pub struct Compiler { /* private fields */ }

Implementations

impl Compiler

pub fn new(options: CompilerOptions) -> Self

pub fn source(&self) -> &Source

pub fn options(&self) -> &CompilerOptions

pub fn set_source(&mut self, source: Source)

pub fn scope_stack(&self) -> Vec<ScopeId>

pub fn syntax_map(&self) -> &SyntaxMap

pub fn add_syntax(&mut self, kind: SyntaxItemKind, span: TextRange)

pub fn add_syntax_for_source( &mut self, kind: SyntaxItemKind, span: TextRange, source_kind: SourceKind, )

pub fn take_diagnostics(&mut self) -> Vec<Diagnostic>

pub fn builtins(&self) -> &Builtins

pub fn diagnostic(&mut self, node: &impl GetTextRange, kind: DiagnosticKind)

pub fn diagnostic_name(&mut self, name: &Name, kind: DiagnosticKind)

pub fn diagnostic_at(&mut self, srcloc: SrcLoc, kind: DiagnosticKind)

pub fn srcloc(&self, node: &impl GetTextRange) -> SrcLoc

pub fn local_name(&self, token: &SyntaxToken) -> Name

pub fn extend_diagnostics(&mut self, diagnostics: Vec<Diagnostic>)

pub fn alloc_child_scope(&mut self) -> ScopeId

pub fn push_scope(&mut self, scope: ScopeId, start: TextSize)

pub fn pop_scope(&mut self, end: TextSize)

pub fn last_scope(&self) -> &Scope

pub fn last_scope_mut(&mut self) -> &mut Scope

pub fn last_scope_id(&self) -> ScopeId

pub fn push_module(&mut self, module: SymbolId)

pub fn pop_module(&mut self)

pub fn parent_module_stack(&self) -> &[SymbolId]

pub fn resolve_symbol_in( &self, scope: ScopeId, name: &str, ) -> Option<(SymbolId, Option<ImportId>)>

pub fn resolve_type_in( &self, scope: ScopeId, name: &str, ) -> Option<(TypeId, Option<ImportId>)>

pub fn type_name(&mut self, ty: TypeId) -> String

pub fn type_name_in(&mut self, scope: ScopeId, ty: TypeId) -> String

pub fn symbol_name(&self, symbol: SymbolId) -> String

pub fn symbol_type(&self, symbol: SymbolId) -> TypeId

pub fn symbol_type_in(&self, scope: ScopeId, symbol: SymbolId) -> TypeId

pub fn push_mappings( &mut self, mappings: HashMap<SymbolId, HashMap<Vec<TypePath>, TypeId>>, start: TextSize, ) -> usize

pub fn mapping_checkpoint(&self) -> usize

pub fn revert_mappings(&mut self, index: usize, end: TextSize)

pub fn is_assignable(&mut self, from: TypeId, to: TypeId) -> bool

pub fn is_castable(&mut self, from: TypeId, to: TypeId) -> bool

pub fn assign_type( &mut self, node: &impl GetTextRange, from: TypeId, to: TypeId, )

pub fn cast_type(&mut self, node: &impl GetTextRange, from: TypeId, to: TypeId)

pub fn guard_type( &mut self, node: &impl GetTextRange, from: TypeId, to: TypeId, ) -> Constraint

pub fn check_condition(&mut self, node: &impl GetTextRange, ty: TypeId)

pub fn infer_type( &mut self, node: &impl GetTextRange, from: TypeId, to: TypeId, infer: &mut HashMap<TypeId, Vec<TypeId>>, )

pub fn insert_default_field(&mut self, ty: TypeId, name: String, value: Value)

pub fn default_field(&self, ty: TypeId, name: &str) -> Option<Value>

pub fn push_declaration(&mut self, declaration: Declaration)

pub fn pop_declaration(&mut self)

pub fn reference(&mut self, reference: Declaration, import: Option<ImportId>)

pub fn declaration_span(&mut self, declaration: Declaration, span: TextRange)

pub fn reference_span(&mut self, reference: Declaration, span: TextRange)

pub fn is_unresolved(&mut self, ty: TypeId) -> bool

Methods from Deref<Target = Database>

pub fn alloc_hir(&mut self, hir: Hir) -> Id<Hir>

pub fn hir(&self, id: Id<Hir>) -> &Hir

pub fn hir_mut(&mut self, id: Id<Hir>) -> &mut Hir

pub fn alloc_scope(&mut self, scope: Scope) -> Id<Scope>

pub fn scope(&self, id: Id<Scope>) -> &Scope

pub fn scope_mut(&mut self, id: Id<Scope>) -> &mut Scope

pub fn alloc_import(&mut self, import: Import) -> Id<Import>

pub fn import(&self, id: Id<Import>) -> &Import

pub fn import_mut(&mut self, id: Id<Import>) -> &mut Import

pub fn alloc_symbol(&mut self, symbol: Symbol) -> Id<Symbol>

pub fn symbol(&self, id: Id<Symbol>) -> &Symbol

pub fn symbol_mut(&mut self, id: Id<Symbol>) -> &mut Symbol

pub fn module(&self, id: Id<Symbol>) -> &ModuleSymbol

pub fn module_mut(&mut self, id: Id<Symbol>) -> &mut ModuleSymbol

pub fn alloc_type(&mut self, ty: Type) -> Id<Type>

pub fn ty(&self, id: Id<Type>) -> &Type

pub fn ty_mut(&mut self, id: Id<Type>) -> &mut Type

pub fn types(&self) -> &Arena<Type>

pub fn types_mut(&mut self) -> &mut Arena<Type>

pub fn add_relevant_declaration(&mut self, declaration: Declaration)

pub fn relevant_declarations(&self) -> impl Iterator<Item = Declaration>

pub fn add_reference(&mut self, outer: Declaration, inner: Declaration)

pub fn add_declaration(&mut self, outer: Declaration, inner: Declaration)

pub fn reference_parents(&self, declaration: Declaration) -> Vec<Declaration>

pub fn declaration_parents(&self, declaration: Declaration) -> Vec<Declaration>

pub fn add_relevant_import(&mut self, import: Id<Import>)

pub fn relevant_imports(&self) -> impl Iterator<Item = Id<Import>>

pub fn add_import_reference( &mut self, import: Id<Import>, declaration: Declaration, )

pub fn import_references(&self, import: Id<Import>) -> Vec<Declaration>

pub fn add_test(&mut self, test: Test)

pub fn tests(&self) -> impl Iterator<Item = &Test>

pub fn debug_symbol(&self, id: Id<Symbol>) -> String

pub fn debug_hir(&self, id: Id<Hir>) -> String

Trait Implementations

impl Clone for Compiler

fn clone(&self) -> Compiler

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Compiler

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

Formats the value using the given formatter.

impl Deref for Compiler

type Target = Database

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for Compiler

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.