Struct fe_driver::Db

pub struct Db { /* private fields */ }

Trait Implementations§

§

impl Database for Db

§

fn sweep_all(&self, strategy: SweepStrategy)

Iterates through all query storage and removes any values that have not been used since the last revision was created. The intended use-cycle is that you first execute all of your “main” queries; this will ensure that all query values they consume are marked as used. You then invoke this method to remove other values that were not needed for your main query results.
§

fn salsa_event(&self, event_fn: Event)

This function is invoked at key points in the salsa runtime. It permits the database to be customized and to inject logging or other custom behavior.
§

fn on_propagated_panic(&self) -> !

This function is invoked when a dependent query is being computed by the other thread, and that thread panics.
§

fn salsa_runtime(&self) -> &Runtime

Gives access to the underlying salsa runtime.
§

fn salsa_runtime_mut(&mut self) -> &mut Runtime

Gives access to the underlying salsa runtime.
§

impl Default for Db

§

fn default() -> Db

Returns the “default value” for a type. Read more
§

impl Upcast<dyn AnalyzerDb> for Db

§

fn upcast(&self) -> &(dyn AnalyzerDb + 'static)

§

impl Upcast<dyn MirDb> for Db

§

fn upcast(&self) -> &(dyn MirDb + 'static)

§

impl Upcast<dyn SourceDb> for Db

§

fn upcast(&self) -> &(dyn SourceDb + 'static)

§

impl UpcastMut<dyn AnalyzerDb> for Db

§

fn upcast_mut(&mut self) -> &mut (dyn AnalyzerDb + 'static)

§

impl UpcastMut<dyn MirDb> for Db

§

fn upcast_mut(&mut self) -> &mut (dyn MirDb + 'static)

§

impl UpcastMut<dyn SourceDb> for Db

§

fn upcast_mut(&mut self) -> &mut (dyn SourceDb + 'static)

Auto Trait Implementations§

§

impl RefUnwindSafe for Db

§

impl !Send for Db

§

impl !Sync for Db

§

impl Unpin for Db

§

impl UnwindSafe for Db

Blanket Implementations§

§

impl<DB> AnalyzerDb for DBwhere DB: SourceDb + Upcast<dyn SourceDb> + UpcastMut<dyn SourceDb> + Database + HasQueryGroup<AnalyzerDbStorage>,

§

fn intern_ingot(&self, key0: Rc<Ingot>) -> IngotId

§

fn lookup_intern_ingot(&self, key0: IngotId) -> Rc<Ingot>

§

fn intern_module(&self, key0: Rc<Module>) -> ModuleId

§

fn lookup_intern_module(&self, key0: ModuleId) -> Rc<Module>

§

fn intern_module_const(&self, key0: Rc<ModuleConstant>) -> ModuleConstantId

§

fn lookup_intern_module_const( &self, key0: ModuleConstantId ) -> Rc<ModuleConstant>

§

fn intern_struct(&self, key0: Rc<Struct>) -> StructId

§

fn lookup_intern_struct(&self, key0: StructId) -> Rc<Struct>

§

fn intern_struct_field(&self, key0: Rc<StructField>) -> StructFieldId

§

fn lookup_intern_struct_field(&self, key0: StructFieldId) -> Rc<StructField>

§

fn intern_enum(&self, key0: Rc<Enum>) -> EnumId

§

fn lookup_intern_enum(&self, key0: EnumId) -> Rc<Enum>

§

fn intern_attribute(&self, key0: Rc<Attribute>) -> AttributeId

§

fn lookup_intern_attribute(&self, key0: AttributeId) -> Rc<Attribute>

§

fn intern_enum_variant(&self, key0: Rc<EnumVariant>) -> EnumVariantId

§

fn lookup_intern_enum_variant(&self, key0: EnumVariantId) -> Rc<EnumVariant>

§

fn intern_trait(&self, key0: Rc<Trait>) -> TraitId

§

fn lookup_intern_trait(&self, key0: TraitId) -> Rc<Trait>

§

fn intern_impl(&self, key0: Rc<Impl>) -> ImplId

§

fn lookup_intern_impl(&self, key0: ImplId) -> Rc<Impl>

§

fn intern_type_alias(&self, key0: Rc<TypeAlias>) -> TypeAliasId

§

fn lookup_intern_type_alias(&self, key0: TypeAliasId) -> Rc<TypeAlias>

§

fn intern_contract(&self, key0: Rc<Contract>) -> ContractId

§

fn lookup_intern_contract(&self, key0: ContractId) -> Rc<Contract>

§

fn intern_contract_field(&self, key0: Rc<ContractField>) -> ContractFieldId

§

fn lookup_intern_contract_field( &self, key0: ContractFieldId ) -> Rc<ContractField>

§

fn intern_function_sig(&self, key0: Rc<FunctionSig>) -> FunctionSigId

§

fn lookup_intern_function_sig(&self, key0: FunctionSigId) -> Rc<FunctionSig>

§

fn intern_function(&self, key0: Rc<Function>) -> FunctionId

§

fn lookup_intern_function(&self, key0: FunctionId) -> Rc<Function>

§

fn intern_type(&self, key0: Type) -> TypeId

§

fn lookup_intern_type(&self, key0: TypeId) -> Type

§

fn ingot_files(&self, key0: IngotId) -> Rc<[SourceFileId]>

§

fn set_ingot_files(&mut self, key0: IngotId, value__: Rc<[SourceFileId]>)

Set the value of the ingot_files input. Read more
§

fn set_ingot_files_with_durability( &mut self, key0: IngotId, value__: Rc<[SourceFileId]>, durability__: Durability )

Set the value of the ingot_files input and promise that its value will never change again. Read more
§

fn ingot_external_ingots(&self, key0: IngotId) -> Rc<IndexMap<SmolStr, IngotId>>

§

fn set_ingot_external_ingots( &mut self, key0: IngotId, value__: Rc<IndexMap<SmolStr, IngotId>> )

Set the value of the ingot_external_ingots input. Read more
§

fn set_ingot_external_ingots_with_durability( &mut self, key0: IngotId, value__: Rc<IndexMap<SmolStr, IngotId>>, durability__: Durability )

Set the value of the ingot_external_ingots input and promise that its value will never change again. Read more
§

fn root_ingot(&self) -> IngotId

§

fn set_root_ingot(&mut self, value__: IngotId)

Set the value of the root_ingot input. Read more
§

fn set_root_ingot_with_durability( &mut self, value__: IngotId, durability__: Durability )

Set the value of the root_ingot input and promise that its value will never change again. Read more
§

fn ingot_modules(&self, key0: IngotId) -> Rc<[ModuleId]>

§

fn ingot_root_module(&self, key0: IngotId) -> Option<ModuleId>

§

fn module_file_path(&self, key0: ModuleId) -> SmolStr

§

fn module_parse(&self, key0: ModuleId) -> Analysis<Rc<Module>>

§

fn module_is_incomplete(&self, key0: ModuleId) -> bool

§

fn module_all_items(&self, key0: ModuleId) -> Rc<[Item]>

§

fn module_all_impls(&self, key0: ModuleId) -> Analysis<Rc<[ImplId]>>

§

fn module_item_map( &self, key0: ModuleId ) -> Analysis<Rc<IndexMap<SmolStr, Item>>>

§

fn module_impl_map( &self, key0: ModuleId ) -> Analysis<Rc<IndexMap<(TraitId, TypeId), ImplId>>>

§

fn module_contracts(&self, key0: ModuleId) -> Rc<[ContractId]>

§

fn module_structs(&self, key0: ModuleId) -> Rc<[StructId]>

§

fn module_constants(&self, key0: ModuleId) -> Rc<Vec<ModuleConstantId>>

§

fn module_used_item_map( &self, key0: ModuleId ) -> Analysis<Rc<IndexMap<SmolStr, (Span, Item)>>>

§

fn module_parent_module(&self, key0: ModuleId) -> Option<ModuleId>

§

fn module_submodules(&self, key0: ModuleId) -> Rc<[ModuleId]>

§

fn module_tests(&self, key0: ModuleId) -> Vec<FunctionId>

§

fn module_constant_type( &self, key0: ModuleConstantId ) -> Analysis<Result<TypeId, TypeError>>

§

fn module_constant_value( &self, key0: ModuleConstantId ) -> Analysis<Result<Constant, ConstEvalError>>

§

fn contract_all_functions(&self, key0: ContractId) -> Rc<[FunctionId]>

§

fn contract_function_map( &self, key0: ContractId ) -> Analysis<Rc<IndexMap<SmolStr, FunctionId>>>

§

fn contract_public_function_map( &self, key0: ContractId ) -> Rc<IndexMap<SmolStr, FunctionId>>

§

fn contract_init_function( &self, key0: ContractId ) -> Analysis<Option<FunctionId>>

§

fn contract_call_function( &self, key0: ContractId ) -> Analysis<Option<FunctionId>>

§

fn contract_all_fields(&self, key0: ContractId) -> Rc<[ContractFieldId]>

§

fn contract_field_map( &self, key0: ContractId ) -> Analysis<Rc<IndexMap<SmolStr, ContractFieldId>>>

§

fn contract_field_type( &self, key0: ContractFieldId ) -> Analysis<Result<TypeId, TypeError>>

§

fn contract_dependency_graph(&self, key0: ContractId) -> DepGraphWrapper

§

fn contract_runtime_dependency_graph(&self, key0: ContractId) -> DepGraphWrapper

§

fn function_signature( &self, key0: FunctionSigId ) -> Analysis<Rc<FunctionSignature>>

§

fn function_body(&self, key0: FunctionId) -> Analysis<Rc<FunctionBody>>

§

fn function_dependency_graph(&self, key0: FunctionId) -> DepGraphWrapper

§

fn struct_all_fields(&self, key0: StructId) -> Rc<[StructFieldId]>

§

fn struct_field_map( &self, key0: StructId ) -> Analysis<Rc<IndexMap<SmolStr, StructFieldId>>>

§

fn struct_field_type( &self, key0: StructFieldId ) -> Analysis<Result<TypeId, TypeError>>

§

fn struct_all_functions(&self, key0: StructId) -> Rc<[FunctionId]>

§

fn struct_function_map( &self, key0: StructId ) -> Analysis<Rc<IndexMap<SmolStr, FunctionId>>>

§

fn struct_dependency_graph(&self, key0: StructId) -> Analysis<DepGraphWrapper>

§

fn enum_all_variants(&self, key0: EnumId) -> Rc<[EnumVariantId]>

§

fn enum_variant_map( &self, key0: EnumId ) -> Analysis<Rc<IndexMap<SmolStr, EnumVariantId>>>

§

fn enum_all_functions(&self, key0: EnumId) -> Rc<[FunctionId]>

§

fn enum_function_map( &self, key0: EnumId ) -> Analysis<Rc<IndexMap<SmolStr, FunctionId>>>

§

fn enum_dependency_graph(&self, key0: EnumId) -> Analysis<DepGraphWrapper>

§

fn enum_variant_kind( &self, key0: EnumVariantId ) -> Analysis<Result<EnumVariantKind, TypeError>>

§

fn trait_all_functions(&self, key0: TraitId) -> Rc<[FunctionSigId]>

§

fn trait_function_map( &self, key0: TraitId ) -> Analysis<Rc<IndexMap<SmolStr, FunctionSigId>>>

§

fn trait_is_implemented_for(&self, key0: TraitId, key1: TypeId) -> bool

§

fn impl_all_functions(&self, key0: ImplId) -> Rc<[FunctionId]>

§

fn impl_function_map( &self, key0: ImplId ) -> Analysis<Rc<IndexMap<SmolStr, FunctionId>>>

§

fn all_impls(&self, key0: TypeId) -> Rc<[ImplId]>

§

fn impl_for(&self, key0: TypeId, key1: TraitId) -> Option<ImplId>

§

fn function_sigs(&self, key0: TypeId, key1: SmolStr) -> Rc<[FunctionSigId]>

§

fn type_alias_type( &self, key0: TypeAliasId ) -> Analysis<Result<TypeId, TypeError>>

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<DB> CodegenDb for DBwhere DB: MirDb + Upcast<dyn MirDb> + UpcastMut<dyn MirDb> + Database + HasQueryGroup<CodegenDbStorage>,

§

fn codegen_legalized_signature(&self, key0: FunctionId) -> Rc<FunctionSignature>

§

fn codegen_legalized_body(&self, key0: FunctionId) -> Rc<FunctionBody>

§

fn codegen_function_symbol_name(&self, key0: FunctionId) -> Rc<String>

§

fn codegen_legalized_type(&self, key0: TypeId) -> TypeId

§

fn codegen_abi_type(&self, key0: TypeId) -> AbiType

§

fn codegen_abi_function(&self, key0: FunctionId) -> AbiFunction

§

fn codegen_abi_event(&self, key0: TypeId) -> AbiEvent

§

fn codegen_abi_contract(&self, key0: ContractId) -> AbiContract

§

fn codegen_abi_module_events(&self, key0: ModuleId) -> Vec<AbiEvent>

§

fn codegen_abi_type_maximum_size(&self, key0: TypeId) -> usize

§

fn codegen_abi_type_minimum_size(&self, key0: TypeId) -> usize

§

fn codegen_abi_function_argument_maximum_size(&self, key0: FunctionId) -> usize

§

fn codegen_abi_function_return_maximum_size(&self, key0: FunctionId) -> usize

§

fn codegen_contract_symbol_name(&self, key0: ContractId) -> Rc<String>

§

fn codegen_contract_deployer_symbol_name(&self, key0: ContractId) -> Rc<String>

§

fn codegen_constant_string_symbol_name(&self, key0: String) -> Rc<String>

source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

§

impl<DB> MirDb for DBwhere DB: AnalyzerDb + Upcast<dyn AnalyzerDb> + UpcastMut<dyn AnalyzerDb> + Database + HasQueryGroup<MirDbStorage>,

§

fn mir_intern_const(&self, key0: Rc<Constant>) -> ConstantId

§

fn lookup_mir_intern_const(&self, key0: ConstantId) -> Rc<Constant>

§

fn mir_intern_type(&self, key0: Rc<Type>) -> TypeId

§

fn lookup_mir_intern_type(&self, key0: TypeId) -> Rc<Type>

§

fn mir_intern_function(&self, key0: Rc<FunctionSignature>) -> FunctionId

§

fn lookup_mir_intern_function(&self, key0: FunctionId) -> Rc<FunctionSignature>

§

fn mir_lower_module_all_functions(&self, key0: ModuleId) -> Rc<Vec<FunctionId>>

§

fn mir_lower_contract_all_functions( &self, key0: ContractId ) -> Rc<Vec<FunctionId>>

§

fn mir_lower_struct_all_functions(&self, key0: StructId) -> Rc<Vec<FunctionId>>

§

fn mir_lower_enum_all_functions(&self, key0: EnumId) -> Rc<Vec<FunctionId>>

§

fn mir_lowered_type(&self, key0: TypeId) -> TypeId

§

fn mir_lowered_constant(&self, key0: ModuleConstantId) -> ConstantId

§

fn mir_lowered_func_signature(&self, key0: FunctionId) -> FunctionId

§

fn mir_lowered_monomorphized_func_signature( &self, key0: FunctionId, key1: BTreeMap<SmolStr, TypeId> ) -> FunctionId

§

fn mir_lowered_pseudo_monomorphized_func_signature( &self, key0: FunctionId ) -> FunctionId

§

fn mir_lowered_func_body(&self, key0: FunctionId) -> Rc<FunctionBody>

source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<DB> SourceDb for DBwhere DB: Database + HasQueryGroup<SourceDbStorage>,

§

fn intern_file(&self, key0: File) -> SourceFileId

§

fn lookup_intern_file(&self, key0: SourceFileId) -> File

§

fn file_content(&self, key0: SourceFileId) -> Rc<str>

Set with `fn set_file_content(&mut self, file: SourceFileId, content: Rc)
§

fn set_file_content(&mut self, key0: SourceFileId, value__: Rc<str>)

Set the value of the file_content input. Read more
§

fn set_file_content_with_durability( &mut self, key0: SourceFileId, value__: Rc<str>, durability__: Durability )

Set the value of the file_content input and promise that its value will never change again. Read more
§

fn file_line_starts(&self, key0: SourceFileId) -> Rc<[usize]>

§

fn file_name(&self, key0: SourceFileId) -> SmolStr

source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<V, T> VZip<V> for Twhere V: MultiLane<T>,

§

fn vzip(self) -> V