Struct corpus_database::tables::Loader

pub struct Loader { /* fields omitted */ }

Implementations

impl Loader

pub fn new(database_root: PathBuf) -> Self

pub fn load_def_path_span(&self) -> Ref<'_, Vec<(DefPath, Span)>>

pub fn store_def_path_span(&self, facts: Vec<(DefPath, Span)>)

pub fn load_build_crate_types(&self) -> Ref<'_, Vec<(Build, InternedString)>>

pub fn store_build_crate_types(&self, facts: Vec<(Build, InternedString)>)

pub fn load_root_modules(&self) -> Ref<'_, Vec<(Build, Module)>>

pub fn store_root_modules(&self, facts: Vec<(Build, Module)>)

pub fn load_submodules(
    &self
) -> Ref<'_, Vec<(DefPath, Module, Module, Name, Visibility, Abi)>>

pub fn store_submodules(
    &self,
    facts: Vec<(DefPath, Module, Module, Name, Visibility, Abi)>
)

pub fn load_function_definitions(
    &self
) -> Ref<'_, Vec<(Item, DefPath, Module, Visibility, Unsafety, Abi, Type)>>

pub fn store_function_definitions(
    &self,
    facts: Vec<(Item, DefPath, Module, Visibility, Unsafety, Abi, Type)>
)

pub fn load_function_parameter_types(
    &self
) -> Ref<'_, Vec<(Item, FnParamIndex, Type)>>

pub fn store_function_parameter_types(
    &self,
    facts: Vec<(Item, FnParamIndex, Type)>
)

pub fn load_function_unsafe_use(&self) -> Ref<'_, Vec<(DefPath, bool)>>

pub fn store_function_unsafe_use(&self, facts: Vec<(DefPath, bool)>)

pub fn load_function_unsafe_reasons(
    &self
) -> Ref<'_, Vec<(DefPath, u32, InternedString)>>

pub fn store_function_unsafe_reasons(
    &self,
    facts: Vec<(DefPath, u32, InternedString)>
)

pub fn load_static_definitions(
    &self
) -> Ref<'_, Vec<(DefPath, Item, Module, Name, Visibility, Mutability)>>

pub fn store_static_definitions(
    &self,
    facts: Vec<(DefPath, Item, Module, Name, Visibility, Mutability)>
)

pub fn load_impl_definitions(
    &self
) -> Ref<'_, Vec<(DefPath, Item, Module, Name, Visibility, Unsafety, ImplPolarity, Defaultness, Constness, Type)>>

pub fn store_impl_definitions(
    &self,
    facts: Vec<(DefPath, Item, Module, Name, Visibility, Unsafety, ImplPolarity, Defaultness, Constness, Type)>
)

pub fn load_trait_impls(&self) -> Ref<'_, Vec<(Item, Type, DefPath)>>

pub fn store_trait_impls(&self, facts: Vec<(Item, Type, DefPath)>)

pub fn load_global_asm_blocks(
    &self
) -> Ref<'_, Vec<(DefPath, Item, Module, Name, Visibility)>>

pub fn store_global_asm_blocks(
    &self,
    facts: Vec<(DefPath, Item, Module, Name, Visibility)>
)

pub fn load_items(
    &self
) -> Ref<'_, Vec<(DefPath, Item, Module, Name, Visibility)>>

pub fn store_items(&self, facts: Vec<(DefPath, Item, Module, Name, Visibility)>)

pub fn load_mir_cfgs(&self) -> Ref<'_, Vec<(Item, DefPath, Scope)>>

pub fn store_mir_cfgs(&self, facts: Vec<(Item, DefPath, Scope)>)

pub fn load_subscopes(
    &self
) -> Ref<'_, Vec<(Scope, Scope, ScopeSafety, BlockCheckMode, u32, Span)>>

pub fn store_subscopes(
    &self,
    facts: Vec<(Scope, Scope, ScopeSafety, BlockCheckMode, u32, Span)>
)

pub fn load_spans(
    &self
) -> Ref<'_, Vec<(Span, Span, SpanExpansionKind, InternedString, SpanFileName, u16, u16)>>

pub fn store_spans(
    &self,
    facts: Vec<(Span, Span, SpanExpansionKind, InternedString, SpanFileName, u16, u16)>
)

pub fn load_macro_expansions(
    &self
) -> Ref<'_, Vec<(Span, InternedString, SpanFileName, u16, u16)>>

pub fn store_macro_expansions(
    &self,
    facts: Vec<(Span, InternedString, SpanFileName, u16, u16)>
)

pub fn load_crate_cfgs(
    &self
) -> Ref<'_, Vec<(Build, CrateCfgKey, CrateCfgValue)>>

pub fn store_crate_cfgs(&self, facts: Vec<(Build, CrateCfgKey, CrateCfgValue)>)

pub fn load_crate_authors(&self) -> Ref<'_, Vec<(Build, InternedString)>>

pub fn store_crate_authors(&self, facts: Vec<(Build, InternedString)>)

pub fn load_crate_keywords(&self) -> Ref<'_, Vec<(Build, InternedString)>>

pub fn store_crate_keywords(&self, facts: Vec<(Build, InternedString)>)

pub fn load_crate_categories(&self) -> Ref<'_, Vec<(Build, InternedString)>>

pub fn store_crate_categories(&self, facts: Vec<(Build, InternedString)>)

pub fn load_type_defs(
    &self
) -> Ref<'_, Vec<(Item, Type, DefPath, InternedString, Visibility, TyDefKind)>>

pub fn store_type_defs(
    &self,
    facts: Vec<(Item, Type, DefPath, InternedString, Visibility, TyDefKind)>
)

pub fn load_types(&self) -> Ref<'_, Vec<(Type, TyKind)>>

pub fn store_types(&self, facts: Vec<(Type, TyKind)>)

pub fn load_types_primitive(&self) -> Ref<'_, Vec<(Type, TyPrimitive)>>

pub fn store_types_primitive(&self, facts: Vec<(Type, TyPrimitive)>)

pub fn load_types_adt_def(
    &self
) -> Ref<'_, Vec<(Type, DefPath, AdtKind, bool, bool)>>

pub fn store_types_adt_def(
    &self,
    facts: Vec<(Type, DefPath, AdtKind, bool, bool)>
)

pub fn load_types_adt_variant(
    &self
) -> Ref<'_, Vec<(Type, AdtVariantIndex, DefPath, InternedString)>>

pub fn store_types_adt_variant(
    &self,
    facts: Vec<(Type, AdtVariantIndex, DefPath, InternedString)>
)

pub fn load_types_adt_field(
    &self
) -> Ref<'_, Vec<(Field, Type, AdtVariantIndex, DefPath, InternedString, TyVisibility, Type)>>

pub fn store_types_adt_field(
    &self,
    facts: Vec<(Field, Type, AdtVariantIndex, DefPath, InternedString, TyVisibility, Type)>
)

pub fn load_types_adt_field_visible_in(&self) -> Ref<'_, Vec<(Field, DefPath)>>

pub fn store_types_adt_field_visible_in(&self, facts: Vec<(Field, DefPath)>)

pub fn load_types_foreign(&self) -> Ref<'_, Vec<(Type, DefPath)>>

pub fn store_types_foreign(&self, facts: Vec<(Type, DefPath)>)

pub fn load_types_array(&self) -> Ref<'_, Vec<(Type, Type)>>

pub fn store_types_array(&self, facts: Vec<(Type, Type)>)

pub fn load_types_slice(&self) -> Ref<'_, Vec<(Type, Type)>>

pub fn store_types_slice(&self, facts: Vec<(Type, Type)>)

pub fn load_types_raw_ptr(&self) -> Ref<'_, Vec<(Type, Type, Mutability)>>

pub fn store_types_raw_ptr(&self, facts: Vec<(Type, Type, Mutability)>)

pub fn load_types_ref(&self) -> Ref<'_, Vec<(Type, Type, Mutability)>>

pub fn store_types_ref(&self, facts: Vec<(Type, Type, Mutability)>)

pub fn load_types_fn_def(&self) -> Ref<'_, Vec<(Type, DefPath)>>

pub fn store_types_fn_def(&self, facts: Vec<(Type, DefPath)>)

pub fn load_types_fn_ptr(&self) -> Ref<'_, Vec<(Type,)>>

pub fn store_types_fn_ptr(&self, facts: Vec<(Type,)>)

pub fn load_types_dynamic(&self) -> Ref<'_, Vec<(Type,)>>

pub fn store_types_dynamic(&self, facts: Vec<(Type,)>)

pub fn load_types_dynamic_trait(&self) -> Ref<'_, Vec<(Type, DefPath, bool)>>

pub fn store_types_dynamic_trait(&self, facts: Vec<(Type, DefPath, bool)>)

pub fn load_types_closure(&self) -> Ref<'_, Vec<(Type, DefPath)>>

pub fn store_types_closure(&self, facts: Vec<(Type, DefPath)>)

pub fn load_types_generator(&self) -> Ref<'_, Vec<(Type, DefPath)>>

pub fn store_types_generator(&self, facts: Vec<(Type, DefPath)>)

pub fn load_types_generator_witness(&self) -> Ref<'_, Vec<(Type,)>>

pub fn store_types_generator_witness(&self, facts: Vec<(Type,)>)

pub fn load_types_tuple(&self) -> Ref<'_, Vec<(Type,)>>

pub fn store_types_tuple(&self, facts: Vec<(Type,)>)

pub fn load_types_tuple_element(
    &self
) -> Ref<'_, Vec<(Type, TupleFieldIndex, Type)>>

pub fn store_types_tuple_element(
    &self,
    facts: Vec<(Type, TupleFieldIndex, Type)>
)

pub fn load_types_projection(&self) -> Ref<'_, Vec<(Type, DefPath, DefPath)>>

pub fn store_types_projection(&self, facts: Vec<(Type, DefPath, DefPath)>)

pub fn load_types_opaque(&self) -> Ref<'_, Vec<(Type, DefPath)>>

pub fn store_types_opaque(&self, facts: Vec<(Type, DefPath)>)

pub fn load_types_param(&self) -> Ref<'_, Vec<(Type, u32, InternedString)>>

pub fn store_types_param(&self, facts: Vec<(Type, u32, InternedString)>)

pub fn load_traits(
    &self
) -> Ref<'_, Vec<(Item, DefPath, InternedString, Visibility, bool, bool, Unsafety)>>

pub fn store_traits(
    &self,
    facts: Vec<(Item, DefPath, InternedString, Visibility, bool, bool, Unsafety)>
)

pub fn load_trait_items(&self) -> Ref<'_, Vec<(Item, DefPath, Defaultness)>>

pub fn store_trait_items(&self, facts: Vec<(Item, DefPath, Defaultness)>)

pub fn load_basic_blocks(
    &self
) -> Ref<'_, Vec<(BasicBlock, DefPath, BasicBlockKind)>>

pub fn store_basic_blocks(
    &self,
    facts: Vec<(BasicBlock, DefPath, BasicBlockKind)>
)

pub fn load_statements(
    &self
) -> Ref<'_, Vec<(Statement, BasicBlock, StatementIndex, StatementKind, Scope)>>

pub fn store_statements(
    &self,
    facts: Vec<(Statement, BasicBlock, StatementIndex, StatementKind, Scope)>
)

pub fn load_statements_assign_use(
    &self
) -> Ref<'_, Vec<(Statement, Type, Operand)>>

pub fn store_statements_assign_use(
    &self,
    facts: Vec<(Statement, Type, Operand)>
)

pub fn load_statements_assign_thead_local_ref(
    &self
) -> Ref<'_, Vec<(Statement, Type, DefPath)>>

pub fn store_statements_assign_thead_local_ref(
    &self,
    facts: Vec<(Statement, Type, DefPath)>
)

pub fn load_statements_assign_repeat(
    &self
) -> Ref<'_, Vec<(Statement, Type, Operand, u64)>>

pub fn store_statements_assign_repeat(
    &self,
    facts: Vec<(Statement, Type, Operand, u64)>
)

pub fn load_statements_assign_ref(
    &self
) -> Ref<'_, Vec<(Statement, Type, Type, BorrowKind)>>

pub fn store_statements_assign_ref(
    &self,
    facts: Vec<(Statement, Type, Type, BorrowKind)>
)

pub fn load_statements_assign_address(
    &self
) -> Ref<'_, Vec<(Statement, Type, Type, Mutability)>>

pub fn store_statements_assign_address(
    &self,
    facts: Vec<(Statement, Type, Type, Mutability)>
)

pub fn load_statements_assign_len(
    &self
) -> Ref<'_, Vec<(Statement, Type, Type)>>

pub fn store_statements_assign_len(&self, facts: Vec<(Statement, Type, Type)>)

pub fn load_statements_assign_cast(
    &self
) -> Ref<'_, Vec<(Statement, Type, CastKind, Operand, Type)>>

pub fn store_statements_assign_cast(
    &self,
    facts: Vec<(Statement, Type, CastKind, Operand, Type)>
)

pub fn load_statements_assign_binary_op(
    &self
) -> Ref<'_, Vec<(Statement, Type, BinOp, Operand, Operand)>>

pub fn store_statements_assign_binary_op(
    &self,
    facts: Vec<(Statement, Type, BinOp, Operand, Operand)>
)

pub fn load_statements_assign_checked_binary_op(
    &self
) -> Ref<'_, Vec<(Statement, Type, BinOp, Operand, Operand)>>

pub fn store_statements_assign_checked_binary_op(
    &self,
    facts: Vec<(Statement, Type, BinOp, Operand, Operand)>
)

pub fn load_statements_assign_nullary_op(
    &self
) -> Ref<'_, Vec<(Statement, Type, NullOp, Type)>>

pub fn store_statements_assign_nullary_op(
    &self,
    facts: Vec<(Statement, Type, NullOp, Type)>
)

pub fn load_statements_assign_unary_op(
    &self
) -> Ref<'_, Vec<(Statement, Type, UnOp, Operand)>>

pub fn store_statements_assign_unary_op(
    &self,
    facts: Vec<(Statement, Type, UnOp, Operand)>
)

pub fn load_statements_assign_discriminant(
    &self
) -> Ref<'_, Vec<(Statement, Type, Type)>>

pub fn store_statements_assign_discriminant(
    &self,
    facts: Vec<(Statement, Type, Type)>
)

pub fn load_statements_assign_aggregate(
    &self
) -> Ref<'_, Vec<(Statement, Type, AggregateKind)>>

pub fn store_statements_assign_aggregate(
    &self,
    facts: Vec<(Statement, Type, AggregateKind)>
)

pub fn load_statements_assign_aggregate_operands(
    &self
) -> Ref<'_, Vec<(Statement, OperandIndex, Operand)>>

pub fn store_statements_assign_aggregate_operands(
    &self,
    facts: Vec<(Statement, OperandIndex, Operand)>
)

pub fn load_statements_inline_asm_inputs(
    &self
) -> Ref<'_, Vec<(Statement, Operand)>>

pub fn store_statements_inline_asm_inputs(
    &self,
    facts: Vec<(Statement, Operand)>
)

pub fn load_statements_inline_asm_outputs(
    &self
) -> Ref<'_, Vec<(Statement, Type)>>

pub fn store_statements_inline_asm_outputs(&self, facts: Vec<(Statement, Type)>)

pub fn load_operands(&self) -> Ref<'_, Vec<(Operand, OperandKind, Type)>>

pub fn store_operands(&self, facts: Vec<(Operand, OperandKind, Type)>)

pub fn load_terminators(
    &self
) -> Ref<'_, Vec<(BasicBlock, TerminatorKind, Scope)>>

pub fn store_terminators(&self, facts: Vec<(BasicBlock, TerminatorKind, Scope)>)

pub fn load_terminators_goto(&self) -> Ref<'_, Vec<(BasicBlock, BasicBlock)>>

pub fn store_terminators_goto(&self, facts: Vec<(BasicBlock, BasicBlock)>)

pub fn load_terminators_switch_int(
    &self
) -> Ref<'_, Vec<(BasicBlock, Operand, Type)>>

pub fn store_terminators_switch_int(
    &self,
    facts: Vec<(BasicBlock, Operand, Type)>
)

pub fn load_terminators_switch_int_targets(
    &self
) -> Ref<'_, Vec<(BasicBlock, u128, BasicBlock)>>

pub fn store_terminators_switch_int_targets(
    &self,
    facts: Vec<(BasicBlock, u128, BasicBlock)>
)

pub fn load_terminators_drop(
    &self
) -> Ref<'_, Vec<(BasicBlock, Type, BasicBlock, BasicBlock)>>

pub fn store_terminators_drop(
    &self,
    facts: Vec<(BasicBlock, Type, BasicBlock, BasicBlock)>
)

pub fn load_terminators_drop_and_replace(
    &self
) -> Ref<'_, Vec<(BasicBlock, Type, Operand, BasicBlock, BasicBlock)>>

pub fn store_terminators_drop_and_replace(
    &self,
    facts: Vec<(BasicBlock, Type, Operand, BasicBlock, BasicBlock)>
)

pub fn load_terminators_call(
    &self
) -> Ref<'_, Vec<(BasicBlock, FunctionCall, Operand, Unsafety, Abi, Type, BasicBlock, BasicBlock, Span)>>

pub fn store_terminators_call(
    &self,
    facts: Vec<(BasicBlock, FunctionCall, Operand, Unsafety, Abi, Type, BasicBlock, BasicBlock, Span)>
)

pub fn load_terminators_call_arg(
    &self
) -> Ref<'_, Vec<(FunctionCall, CallArgIndex, Operand)>>

pub fn store_terminators_call_arg(
    &self,
    facts: Vec<(FunctionCall, CallArgIndex, Operand)>
)

pub fn load_terminators_call_const_target(
    &self
) -> Ref<'_, Vec<(FunctionCall, DefPath)>>

pub fn store_terminators_call_const_target(
    &self,
    facts: Vec<(FunctionCall, DefPath)>
)

pub fn load_terminators_call_const_target_self(
    &self
) -> Ref<'_, Vec<(FunctionCall, Type)>>

pub fn store_terminators_call_const_target_self(
    &self,
    facts: Vec<(FunctionCall, Type)>
)

pub fn load_terminators_assert(
    &self
) -> Ref<'_, Vec<(BasicBlock, Operand, bool, BasicBlock, BasicBlock)>>

pub fn store_terminators_assert(
    &self,
    facts: Vec<(BasicBlock, Operand, bool, BasicBlock, BasicBlock)>
)

pub fn load_terminators_yield(
    &self
) -> Ref<'_, Vec<(BasicBlock, Operand, BasicBlock, BasicBlock)>>

pub fn store_terminators_yield(
    &self,
    facts: Vec<(BasicBlock, Operand, BasicBlock, BasicBlock)>
)

pub fn load_terminators_false_edges(
    &self
) -> Ref<'_, Vec<(BasicBlock, BasicBlock, BasicBlock)>>

pub fn store_terminators_false_edges(
    &self,
    facts: Vec<(BasicBlock, BasicBlock, BasicBlock)>
)

pub fn load_terminators_false_unwind(
    &self
) -> Ref<'_, Vec<(BasicBlock, BasicBlock, BasicBlock)>>

pub fn store_terminators_false_unwind(
    &self,
    facts: Vec<(BasicBlock, BasicBlock, BasicBlock)>
)

pub fn load_terminators_inline_asm(&self) -> Ref<'_, Vec<(BasicBlock,)>>

pub fn store_terminators_inline_asm(&self, facts: Vec<(BasicBlock,)>)

pub fn load_selected_builds(
    &self
) -> Ref<'_, Vec<(Build, Package, PackageVersion, Krate, CrateHash, Edition)>>

pub fn store_selected_builds(
    &self,
    facts: Vec<(Build, Package, PackageVersion, Krate, CrateHash, Edition)>
)

pub fn load_build_script_builds(
    &self
) -> Ref<'_, Vec<(Build, Package, PackageVersion, Krate, CrateHash, Edition)>>

pub fn store_build_script_builds(
    &self,
    facts: Vec<(Build, Package, PackageVersion, Krate, CrateHash, Edition)>
)

pub fn load_selected_modules(&self) -> Ref<'_, Vec<(Build, Module)>>

pub fn store_selected_modules(&self, facts: Vec<(Build, Module)>)

pub fn load_selected_mir_cfgs(
    &self
) -> Ref<'_, Vec<(Build, Item, DefPath, Scope)>>

pub fn store_selected_mir_cfgs(&self, facts: Vec<(Build, Item, DefPath, Scope)>)

pub fn load_selected_scopes(
    &self
) -> Ref<'_, Vec<(Build, DefPath, Scope, Scope, ScopeSafety, u32, BlockCheckMode, Span)>>

pub fn store_selected_scopes(
    &self,
    facts: Vec<(Build, DefPath, Scope, Scope, ScopeSafety, u32, BlockCheckMode, Span)>
)

pub fn load_selected_type_defs(
    &self
) -> Ref<'_, Vec<(Build, Item, Type, DefPath, InternedString, Visibility, TyKind, TyDefKind)>>

pub fn store_selected_type_defs(
    &self,
    facts: Vec<(Build, Item, Type, DefPath, InternedString, Visibility, TyKind, TyDefKind)>
)

pub fn load_selected_adts(
    &self
) -> Ref<'_, Vec<(Build, Item, Type, DefPath, DefPath, InternedString, Visibility, TyKind, TyDefKind, AdtKind, bool, bool)>>

pub fn store_selected_adts(
    &self,
    facts: Vec<(Build, Item, Type, DefPath, DefPath, InternedString, Visibility, TyKind, TyDefKind, AdtKind, bool, bool)>
)

pub fn load_selected_adt_field_types(
    &self
) -> Ref<'_, Vec<(Build, Item, Type, AdtVariantIndex, DefPath, DefPath, DefPath, InternedString, Visibility, TyKind, TyDefKind, AdtKind, bool, bool, InternedString, TyVisibility, Type, TyKind)>>

pub fn store_selected_adt_field_types(
    &self,
    facts: Vec<(Build, Item, Type, AdtVariantIndex, DefPath, DefPath, DefPath, InternedString, Visibility, TyKind, TyDefKind, AdtKind, bool, bool, InternedString, TyVisibility, Type, TyKind)>
)

pub fn load_types_unsafe_cell(&self) -> Ref<'_, Vec<(Type, DefPath)>>

pub fn store_types_unsafe_cell(&self, facts: Vec<(Type, DefPath)>)

pub fn load_types_union(&self) -> Ref<'_, Vec<(Type, DefPath)>>

pub fn store_types_union(&self, facts: Vec<(Type, DefPath)>)

pub fn load_unsafe_types(&self) -> Ref<'_, Vec<(Type,)>>

pub fn store_unsafe_types(&self, facts: Vec<(Type,)>)

pub fn load_safe_wrapper_types(&self) -> Ref<'_, Vec<(Type,)>>

pub fn store_safe_wrapper_types(&self, facts: Vec<(Type,)>)

pub fn load_unsafe_blocks(
    &self
) -> Ref<'_, Vec<(Build, DefPath, Scope, SpanExpansionKind, BlockCheckMode, Span)>>

pub fn store_unsafe_blocks(
    &self,
    facts: Vec<(Build, DefPath, Scope, SpanExpansionKind, BlockCheckMode, Span)>
)

pub fn load_functions_unsafe_blocks(
    &self
) -> Ref<'_, Vec<(Build, Item, Scope, SpanExpansionKind, BlockCheckMode)>>

pub fn store_functions_unsafe_blocks(
    &self,
    facts: Vec<(Build, Item, Scope, SpanExpansionKind, BlockCheckMode)>
)

pub fn load_selected_function_definitions(
    &self
) -> Ref<'_, Vec<(Build, Item, DefPath, Module, Visibility, Unsafety, Abi, Type, bool)>>

pub fn store_selected_function_definitions(
    &self,
    facts: Vec<(Build, Item, DefPath, Module, Visibility, Unsafety, Abi, Type, bool)>
)

pub fn load_unsafe_statements(
    &self
) -> Ref<'_, Vec<(Build, Statement, BasicBlock, StatementIndex, StatementKind, Scope, BlockCheckMode)>>

pub fn store_unsafe_statements(
    &self,
    facts: Vec<(Build, Statement, BasicBlock, StatementIndex, StatementKind, Scope, BlockCheckMode)>
)

pub fn load_unsafe_terminators(
    &self
) -> Ref<'_, Vec<(Build, BasicBlock, TerminatorKind, Scope, BlockCheckMode)>>

pub fn store_unsafe_terminators(
    &self,
    facts: Vec<(Build, BasicBlock, TerminatorKind, Scope, BlockCheckMode)>
)

pub fn load_unsafe_block_calls(
    &self
) -> Ref<'_, Vec<(Build, BasicBlock, Scope, BlockCheckMode, FunctionCall, Unsafety, Abi, Type)>>

pub fn store_unsafe_block_calls(
    &self,
    facts: Vec<(Build, BasicBlock, Scope, BlockCheckMode, FunctionCall, Unsafety, Abi, Type)>
)

pub fn load_unsafe_block_calls_known_target(
    &self
) -> Ref<'_, Vec<(Build, BasicBlock, Scope, Span, BlockCheckMode, FunctionCall, DefPath, Unsafety, Abi, Type)>>

pub fn store_unsafe_block_calls_known_target(
    &self,
    facts: Vec<(Build, BasicBlock, Scope, Span, BlockCheckMode, FunctionCall, DefPath, Unsafety, Abi, Type)>
)

pub fn load_unsafe_block_call_counts(
    &self
) -> Ref<'_, Vec<(Build, Scope, BlockCheckMode, u16)>>

pub fn store_unsafe_block_call_counts(
    &self,
    facts: Vec<(Build, Scope, BlockCheckMode, u16)>
)

pub fn load_unsafe_block_no_calls(
    &self
) -> Ref<'_, Vec<(Build, DefPath, Scope, SpanExpansionKind, BlockCheckMode, Span)>>

pub fn store_unsafe_block_no_calls(
    &self,
    facts: Vec<(Build, DefPath, Scope, SpanExpansionKind, BlockCheckMode, Span)>
)

pub fn load_adts_with_unsafe_cell_fields(
    &self
) -> Ref<'_, Vec<(Type, DefPath, AdtKind, bool, InternedString, TyVisibility, Type, TyKind, DefPath)>>

pub fn store_adts_with_unsafe_cell_fields(
    &self,
    facts: Vec<(Type, DefPath, AdtKind, bool, InternedString, TyVisibility, Type, TyKind, DefPath)>
)

pub fn load_selected_function_sizes(
    &self
) -> Ref<'_, Vec<(Build, Item, DefPath, Visibility, Unsafety, Abi, bool, u64, u64, u64)>>

pub fn store_selected_function_sizes(
    &self,
    facts: Vec<(Build, Item, DefPath, Visibility, Unsafety, Abi, bool, u64, u64, u64)>
)

pub fn load_selected_build_sizes(&self) -> Ref<'_, Vec<(Build, u64, u64, u64)>>

pub fn store_selected_build_sizes(&self, facts: Vec<(Build, u64, u64, u64)>)

pub fn load_strings(&self) -> Ref<'_, InterningTable<InternedString, String>>

pub fn load_strings_as_vec(&self) -> Vec<(InternedString, String)>

pub fn load_package_names(
    &self
) -> Ref<'_, InterningTable<Package, InternedString>>

pub fn load_package_names_as_vec(&self) -> Vec<(Package, InternedString)>

pub fn load_package_versions(
    &self
) -> Ref<'_, InterningTable<PackageVersion, InternedString>>

pub fn load_package_versions_as_vec(
    &self
) -> Vec<(PackageVersion, InternedString)>

pub fn load_crate_names(&self) -> Ref<'_, InterningTable<Krate, InternedString>>

pub fn load_crate_names_as_vec(&self) -> Vec<(Krate, InternedString)>

pub fn load_editions(&self) -> Ref<'_, InterningTable<Edition, InternedString>>

pub fn load_editions_as_vec(&self) -> Vec<(Edition, InternedString)>

pub fn load_names(&self) -> Ref<'_, InterningTable<Name, InternedString>>

pub fn load_names_as_vec(&self) -> Vec<(Name, InternedString)>

pub fn load_relative_def_paths(
    &self
) -> Ref<'_, InterningTable<RelativeDefId, InternedString>>

pub fn load_relative_def_paths_as_vec(
    &self
) -> Vec<(RelativeDefId, InternedString)>

pub fn load_summary_keys(
    &self
) -> Ref<'_, InterningTable<SummaryId, InternedString>>

pub fn load_summary_keys_as_vec(&self) -> Vec<(SummaryId, InternedString)>

pub fn load_abis(&self) -> Ref<'_, InterningTable<Abi, InternedString>>

pub fn load_abis_as_vec(&self) -> Vec<(Abi, InternedString)>

pub fn load_def_paths(
    &self
) -> Ref<'_, InterningTable<DefPath, (Krate, CrateHash, RelativeDefId, DefPathHash, SummaryId)>>

pub fn load_def_paths_as_vec(
    &self
) -> Vec<(DefPath, Krate, CrateHash, RelativeDefId, DefPathHash, SummaryId)>

pub fn load_builds(
    &self
) -> Ref<'_, InterningTable<Build, (Package, PackageVersion, Krate, CrateHash, Edition)>>

pub fn load_builds_as_vec(
    &self
) -> Vec<(Build, Package, PackageVersion, Krate, CrateHash, Edition)>

pub fn load_span_file_names(
    &self
) -> Ref<'_, InterningTable<SpanFileName, InternedString>>

pub fn load_span_file_names_as_vec(&self) -> Vec<(SpanFileName, InternedString)>

pub fn load_crate_cfg_keys(
    &self
) -> Ref<'_, InterningTable<CrateCfgKey, InternedString>>

pub fn load_crate_cfg_keys_as_vec(&self) -> Vec<(CrateCfgKey, InternedString)>

pub fn load_crate_cfg_values(
    &self
) -> Ref<'_, InterningTable<CrateCfgValue, InternedString>>

pub fn load_crate_cfg_values_as_vec(
    &self
) -> Vec<(CrateCfgValue, InternedString)>

pub fn load_type_kinds(&self) -> Ref<'_, InterningTable<TyKind, InternedString>>

pub fn load_type_kinds_as_vec(&self) -> Vec<(TyKind, InternedString)>

pub fn load_statement_kinds(
    &self
) -> Ref<'_, InterningTable<StatementKind, InternedString>>

pub fn load_statement_kinds_as_vec(
    &self
) -> Vec<(StatementKind, InternedString)>

pub fn load_binary_op_kind(
    &self
) -> Ref<'_, InterningTable<BinOp, InternedString>>

pub fn load_binary_op_kind_as_vec(&self) -> Vec<(BinOp, InternedString)>

pub fn load_nullary_op_kind(
    &self
) -> Ref<'_, InterningTable<NullOp, InternedString>>

pub fn load_nullary_op_kind_as_vec(&self) -> Vec<(NullOp, InternedString)>

pub fn load_unary_op_kind(
    &self
) -> Ref<'_, InterningTable<UnOp, InternedString>>

pub fn load_unary_op_kind_as_vec(&self) -> Vec<(UnOp, InternedString)>

pub fn load_terminator_kinds(
    &self
) -> Ref<'_, InterningTable<TerminatorKind, InternedString>>

pub fn load_terminator_kinds_as_vec(
    &self
) -> Vec<(TerminatorKind, InternedString)>

Trait Implementations

impl Default for Loader

fn default() -> Loader

Returns the “default value” for a type.