Trait cairo_lang_semantic::db::SemanticGroup

pub trait SemanticGroup: Database + HasQueryGroup<SemanticDatabase> + DefsGroup + Upcast<dyn DefsGroup> + ParserGroup + Upcast<dyn FilesGroup> + AsFilesGroupMut + Elongate {
    // Required methods
    fn intern_function(&self, key0: FunctionLongId) -> FunctionId;
    fn lookup_intern_function(&self, key0: FunctionId) -> FunctionLongId;
    fn intern_concrete_function_with_body(
        &self,
        key0: ConcreteFunctionWithBody
    ) -> ConcreteFunctionWithBodyId;
    fn lookup_intern_concrete_function_with_body(
        &self,
        key0: ConcreteFunctionWithBodyId
    ) -> ConcreteFunctionWithBody;
    fn intern_concrete_struct(
        &self,
        key0: ConcreteStructLongId
    ) -> ConcreteStructId;
    fn lookup_intern_concrete_struct(
        &self,
        key0: ConcreteStructId
    ) -> ConcreteStructLongId;
    fn intern_concrete_enum(&self, key0: ConcreteEnumLongId) -> ConcreteEnumId;
    fn lookup_intern_concrete_enum(
        &self,
        key0: ConcreteEnumId
    ) -> ConcreteEnumLongId;
    fn intern_concrete_extern_type(
        &self,
        key0: ConcreteExternTypeLongId
    ) -> ConcreteExternTypeId;
    fn lookup_intern_concrete_extern_type(
        &self,
        key0: ConcreteExternTypeId
    ) -> ConcreteExternTypeLongId;
    fn intern_concrete_trait(
        &self,
        key0: ConcreteTraitLongId
    ) -> ConcreteTraitId;
    fn lookup_intern_concrete_trait(
        &self,
        key0: ConcreteTraitId
    ) -> ConcreteTraitLongId;
    fn intern_concrete_trait_function(
        &self,
        key0: ConcreteTraitGenericFunctionLongId
    ) -> ConcreteTraitGenericFunctionId;
    fn lookup_intern_concrete_trait_function(
        &self,
        key0: ConcreteTraitGenericFunctionId
    ) -> ConcreteTraitGenericFunctionLongId;
    fn intern_concrete_impl(&self, key0: ConcreteImplLongId) -> ConcreteImplId;
    fn lookup_intern_concrete_impl(
        &self,
        key0: ConcreteImplId
    ) -> ConcreteImplLongId;
    fn intern_type(&self, key0: TypeLongId) -> TypeId;
    fn lookup_intern_type(&self, key0: TypeId) -> TypeLongId;
    fn intern_literal(&self, key0: LiteralLongId) -> LiteralId;
    fn lookup_intern_literal(&self, key0: LiteralId) -> LiteralLongId;
    fn intern_impl_var(&self, key0: ImplVar) -> ImplVarId;
    fn lookup_intern_impl_var(&self, key0: ImplVarId) -> ImplVar;
    fn priv_constant_semantic_data(
        &self,
        key0: ConstantId
    ) -> Maybe<ConstantData>;
    fn constant_semantic_diagnostics(
        &self,
        key0: ConstantId
    ) -> Diagnostics<SemanticDiagnostic>;
    fn constant_semantic_data(&self, key0: ConstantId) -> Maybe<Constant>;
    fn constant_resolver_data(
        &self,
        key0: ConstantId
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_use_semantic_data(&self, key0: UseId) -> Maybe<UseData>;
    fn use_semantic_diagnostics(
        &self,
        key0: UseId
    ) -> Diagnostics<SemanticDiagnostic>;
    fn use_resolver_data(&self, key0: UseId) -> Maybe<Arc<ResolverData>>;
    fn priv_module_semantic_data(
        &self,
        key0: ModuleId
    ) -> Maybe<Arc<ModuleSemanticData>>;
    fn module_scope(&self, key0: ModuleId) -> Maybe<Arc<Scope>>;
    fn module_item_by_name(
        &self,
        key0: ModuleId,
        key1: SmolStr
    ) -> Maybe<Option<ModuleItemId>>;
    fn module_attributes(&self, key0: ModuleId) -> Maybe<Vec<Attribute>>;
    fn priv_struct_declaration_data(
        &self,
        key0: StructId
    ) -> Maybe<StructDeclarationData>;
    fn struct_declaration_diagnostics(
        &self,
        key0: StructId
    ) -> Diagnostics<SemanticDiagnostic>;
    fn struct_attributes(&self, key0: StructId) -> Maybe<Vec<Attribute>>;
    fn struct_generic_params(&self, key0: StructId) -> Maybe<Vec<GenericParam>>;
    fn struct_generic_params_data(
        &self,
        key0: StructId
    ) -> Maybe<GenericParamsData>;
    fn struct_declaration_resolver_data(
        &self,
        key0: StructId
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_struct_definition_data(
        &self,
        key0: StructId
    ) -> Maybe<StructDefinitionData>;
    fn struct_definition_diagnostics(
        &self,
        key0: StructId
    ) -> Diagnostics<SemanticDiagnostic>;
    fn struct_members(
        &self,
        key0: StructId
    ) -> Maybe<OrderedHashMap<SmolStr, Member>>;
    fn struct_definition_resolver_data(
        &self,
        key0: StructId
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_enum_declaration_data(
        &self,
        key0: EnumId
    ) -> Maybe<EnumDeclarationData>;
    fn enum_declaration_diagnostics(
        &self,
        key0: EnumId
    ) -> Diagnostics<SemanticDiagnostic>;
    fn enum_generic_params(&self, key0: EnumId) -> Maybe<Vec<GenericParam>>;
    fn enum_generic_params_data(&self, key0: EnumId) -> Maybe<GenericParamsData>;
    fn enum_attributes(&self, key0: EnumId) -> Maybe<Vec<Attribute>>;
    fn enum_declaration_resolver_data(
        &self,
        key0: EnumId
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_enum_definition_data(
        &self,
        key0: EnumId
    ) -> Maybe<EnumDefinitionData>;
    fn enum_definition_diagnostics(
        &self,
        key0: EnumId
    ) -> Diagnostics<SemanticDiagnostic>;
    fn enum_variants(
        &self,
        key0: EnumId
    ) -> Maybe<OrderedHashMap<SmolStr, VariantId>>;
    fn variant_semantic(&self, key0: EnumId, key1: VariantId) -> Maybe<Variant>;
    fn enum_definition_resolver_data(
        &self,
        key0: EnumId
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_type_alias_semantic_data(
        &self,
        key0: TypeAliasId
    ) -> Maybe<TypeAliasData>;
    fn type_alias_semantic_diagnostics(
        &self,
        key0: TypeAliasId
    ) -> Diagnostics<SemanticDiagnostic>;
    fn type_alias_resolved_type(&self, key0: TypeAliasId) -> Maybe<TypeId>;
    fn type_alias_generic_params(
        &self,
        key0: TypeAliasId
    ) -> Maybe<Vec<GenericParam>>;
    fn type_alias_generic_params_data(
        &self,
        key0: TypeAliasId
    ) -> Maybe<GenericParamsData>;
    fn type_alias_resolver_data(
        &self,
        key0: TypeAliasId
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_impl_alias_semantic_data(
        &self,
        key0: ImplAliasId
    ) -> Maybe<ImplAliasData>;
    fn impl_alias_semantic_diagnostics(
        &self,
        key0: ImplAliasId
    ) -> Diagnostics<SemanticDiagnostic>;
    fn impl_alias_resolved_impl(&self, key0: ImplAliasId) -> Maybe<ImplId>;
    fn impl_alias_generic_params(
        &self,
        key0: ImplAliasId
    ) -> Maybe<Vec<GenericParam>>;
    fn impl_alias_generic_params_data(
        &self,
        key0: ImplAliasId
    ) -> Maybe<GenericParamsData>;
    fn impl_alias_resolver_data(
        &self,
        key0: ImplAliasId
    ) -> Maybe<Arc<ResolverData>>;
    fn trait_semantic_declaration_diagnostics(
        &self,
        key0: TraitId
    ) -> Diagnostics<SemanticDiagnostic>;
    fn trait_generic_params(&self, key0: TraitId) -> Maybe<Vec<GenericParam>>;
    fn trait_generic_params_data(
        &self,
        key0: TraitId
    ) -> Maybe<GenericParamsData>;
    fn trait_attributes(&self, key0: TraitId) -> Maybe<Vec<Attribute>>;
    fn trait_function_asts(
        &self,
        key0: TraitId
    ) -> Maybe<OrderedHashMap<TraitFunctionId, TraitItemFunction>>;
    fn trait_resolver_data(&self, key0: TraitId) -> Maybe<Arc<ResolverData>>;
    fn priv_trait_semantic_declaration_data(
        &self,
        key0: TraitId
    ) -> Maybe<TraitDeclarationData>;
    fn trait_semantic_definition_diagnostics(
        &self,
        key0: TraitId
    ) -> Diagnostics<SemanticDiagnostic>;
    fn trait_functions(
        &self,
        key0: TraitId
    ) -> Maybe<OrderedHashMap<SmolStr, TraitFunctionId>>;
    fn trait_function_by_name(
        &self,
        key0: TraitId,
        key1: SmolStr
    ) -> Maybe<Option<TraitFunctionId>>;
    fn priv_trait_semantic_definition_data(
        &self,
        key0: TraitId
    ) -> Maybe<TraitDefinitionData>;
    fn trait_function_declaration_diagnostics(
        &self,
        key0: TraitFunctionId
    ) -> Diagnostics<SemanticDiagnostic>;
    fn trait_function_signature(
        &self,
        key0: TraitFunctionId
    ) -> Maybe<Signature>;
    fn trait_function_generic_params(
        &self,
        key0: TraitFunctionId
    ) -> Maybe<Vec<GenericParam>>;
    fn trait_function_generic_params_data(
        &self,
        key0: TraitFunctionId
    ) -> Maybe<GenericParamsData>;
    fn trait_function_attributes(
        &self,
        key0: TraitFunctionId
    ) -> Maybe<Vec<Attribute>>;
    fn trait_function_resolver_data(
        &self,
        key0: TraitFunctionId
    ) -> Maybe<Arc<ResolverData>>;
    fn trait_function_declaration_inline_config(
        &self,
        key0: TraitFunctionId
    ) -> Maybe<InlineConfiguration>;
    fn trait_function_declaration_implicit_precedence(
        &self,
        key0: TraitFunctionId
    ) -> Maybe<ImplicitPrecedence>;
    fn trait_function_declaration_implicits(
        &self,
        key0: TraitFunctionId
    ) -> Maybe<Vec<TypeId>>;
    fn priv_trait_function_declaration_data(
        &self,
        key0: TraitFunctionId
    ) -> Maybe<FunctionDeclarationData>;
    fn trait_function_body_diagnostics(
        &self,
        key0: TraitFunctionId
    ) -> Diagnostics<SemanticDiagnostic>;
    fn trait_function_body(
        &self,
        key0: TraitFunctionId
    ) -> Maybe<Option<Arc<FunctionBody>>>;
    fn priv_trait_function_body_data(
        &self,
        key0: TraitFunctionId
    ) -> Maybe<Option<FunctionBodyData>>;
    fn concrete_trait_function_generic_params(
        &self,
        key0: ConcreteTraitGenericFunctionId
    ) -> Maybe<Vec<GenericParam>>;
    fn concrete_trait_function_signature(
        &self,
        key0: ConcreteTraitGenericFunctionId
    ) -> Maybe<Signature>;
    fn module_impl_ids_for_trait_filter(
        &self,
        key0: ModuleId,
        key1: TraitFilter
    ) -> Maybe<Vec<UninferredImpl>>;
    fn canonic_trait_solutions(
        &self,
        key0: CanonicalTrait,
        key1: ImplLookupContext
    ) -> InferenceResult<SolutionSet<CanonicalImpl>>;
    fn impl_semantic_declaration_diagnostics(
        &self,
        key0: ImplDefId
    ) -> Diagnostics<SemanticDiagnostic>;
    fn impl_def_functions_asts(
        &self,
        key0: ImplDefId
    ) -> Maybe<OrderedHashMap<ImplFunctionId, FunctionWithBody>>;
    fn impl_def_generic_params_data(
        &self,
        key0: ImplDefId
    ) -> Maybe<GenericParamsData>;
    fn impl_def_generic_params(
        &self,
        key0: ImplDefId
    ) -> Maybe<Vec<GenericParam>>;
    fn impl_def_resolver_data(
        &self,
        key0: ImplDefId
    ) -> Maybe<Arc<ResolverData>>;
    fn impl_def_concrete_trait(&self, key0: ImplDefId) -> Maybe<ConcreteTraitId>;
    fn impl_def_attributes(&self, key0: ImplDefId) -> Maybe<Vec<Attribute>>;
    fn impl_concrete_trait(&self, key0: ImplId) -> Maybe<ConcreteTraitId>;
    fn impl_def_trait(&self, key0: ImplDefId) -> Maybe<TraitId>;
    fn priv_impl_declaration_data(
        &self,
        key0: ImplDefId
    ) -> Maybe<ImplDeclarationData>;
    fn impl_semantic_definition_diagnostics(
        &self,
        key0: ImplDefId
    ) -> Diagnostics<SemanticDiagnostic>;
    fn impl_functions(
        &self,
        key0: ImplDefId
    ) -> Maybe<OrderedHashMap<SmolStr, ImplFunctionId>>;
    fn impl_function_by_trait_function(
        &self,
        key0: ImplDefId,
        key1: TraitFunctionId
    ) -> Maybe<Option<ImplFunctionId>>;
    fn priv_impl_definition_data(
        &self,
        key0: ImplDefId
    ) -> Maybe<ImplDefinitionData>;
    fn impl_function_declaration_diagnostics(
        &self,
        key0: ImplFunctionId
    ) -> Diagnostics<SemanticDiagnostic>;
    fn impl_function_signature(&self, key0: ImplFunctionId) -> Maybe<Signature>;
    fn impl_function_generic_params(
        &self,
        key0: ImplFunctionId
    ) -> Maybe<Vec<GenericParam>>;
    fn impl_function_generic_params_data(
        &self,
        key0: ImplFunctionId
    ) -> Maybe<GenericParamsData>;
    fn impl_function_attributes(
        &self,
        key0: ImplFunctionId
    ) -> Maybe<Vec<Attribute>>;
    fn impl_function_resolver_data(
        &self,
        key0: ImplFunctionId
    ) -> Maybe<Arc<ResolverData>>;
    fn impl_function_declaration_inline_config(
        &self,
        key0: ImplFunctionId
    ) -> Maybe<InlineConfiguration>;
    fn impl_function_declaration_implicit_precedence(
        &self,
        key0: ImplFunctionId
    ) -> Maybe<ImplicitPrecedence>;
    fn impl_function_declaration_implicits(
        &self,
        key0: ImplFunctionId
    ) -> Maybe<Vec<TypeId>>;
    fn impl_function_trait_function(
        &self,
        key0: ImplFunctionId
    ) -> Maybe<TraitFunctionId>;
    fn priv_impl_function_declaration_data(
        &self,
        key0: ImplFunctionId
    ) -> Maybe<ImplFunctionDeclarationData>;
    fn impl_function_body_diagnostics(
        &self,
        key0: ImplFunctionId
    ) -> Diagnostics<SemanticDiagnostic>;
    fn impl_function_body(
        &self,
        key0: ImplFunctionId
    ) -> Maybe<Arc<FunctionBody>>;
    fn impl_function_body_resolver_data(
        &self,
        key0: ImplFunctionId
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_impl_function_body_data(
        &self,
        key0: ImplFunctionId
    ) -> Maybe<FunctionBodyData>;
    fn free_function_declaration_diagnostics(
        &self,
        key0: FreeFunctionId
    ) -> Diagnostics<SemanticDiagnostic>;
    fn free_function_signature(&self, key0: FreeFunctionId) -> Maybe<Signature>;
    fn free_function_declaration_implicits(
        &self,
        key0: FreeFunctionId
    ) -> Maybe<Vec<TypeId>>;
    fn free_function_declaration_implicit_precedence(
        &self,
        key0: FreeFunctionId
    ) -> Maybe<ImplicitPrecedence>;
    fn free_function_generic_params(
        &self,
        key0: FreeFunctionId
    ) -> Maybe<Vec<GenericParam>>;
    fn free_function_generic_params_data(
        &self,
        key0: FreeFunctionId
    ) -> Maybe<GenericParamsData>;
    fn free_function_declaration_resolver_data(
        &self,
        key0: FreeFunctionId
    ) -> Maybe<Arc<ResolverData>>;
    fn free_function_declaration_inline_config(
        &self,
        key0: FreeFunctionId
    ) -> Maybe<InlineConfiguration>;
    fn priv_free_function_declaration_data(
        &self,
        key0: FreeFunctionId
    ) -> Maybe<FunctionDeclarationData>;
    fn free_function_body_diagnostics(
        &self,
        key0: FreeFunctionId
    ) -> Diagnostics<SemanticDiagnostic>;
    fn free_function_body_resolver_data(
        &self,
        key0: FreeFunctionId
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_free_function_body_data(
        &self,
        key0: FreeFunctionId
    ) -> Maybe<FunctionBodyData>;
    fn function_declaration_diagnostics(
        &self,
        key0: FunctionWithBodyId
    ) -> Diagnostics<SemanticDiagnostic>;
    fn function_declaration_inline_config(
        &self,
        key0: FunctionWithBodyId
    ) -> Maybe<InlineConfiguration>;
    fn function_declaration_implicit_precedence(
        &self,
        key0: FunctionWithBodyId
    ) -> Maybe<ImplicitPrecedence>;
    fn function_with_body_signature(
        &self,
        key0: FunctionWithBodyId
    ) -> Maybe<Signature>;
    fn function_with_body_generic_params(
        &self,
        key0: FunctionWithBodyId
    ) -> Maybe<Vec<GenericParam>>;
    fn function_with_body_attributes(
        &self,
        key0: FunctionWithBodyId
    ) -> Maybe<Vec<Attribute>>;
    fn function_body_diagnostics(
        &self,
        key0: FunctionWithBodyId
    ) -> Diagnostics<SemanticDiagnostic>;
    fn function_body_expr(&self, key0: FunctionWithBodyId) -> Maybe<ExprId>;
    fn function_body(
        &self,
        key0: FunctionWithBodyId
    ) -> Maybe<Arc<FunctionBody>>;
    fn priv_extern_function_declaration_data(
        &self,
        key0: ExternFunctionId
    ) -> Maybe<FunctionDeclarationData>;
    fn extern_function_declaration_inline_config(
        &self,
        key0: ExternFunctionId
    ) -> Maybe<InlineConfiguration>;
    fn extern_function_declaration_diagnostics(
        &self,
        key0: ExternFunctionId
    ) -> Diagnostics<SemanticDiagnostic>;
    fn extern_function_signature(
        &self,
        key0: ExternFunctionId
    ) -> Maybe<Signature>;
    fn extern_function_declaration_generic_params(
        &self,
        key0: ExternFunctionId
    ) -> Maybe<Vec<GenericParam>>;
    fn extern_function_declaration_generic_params_data(
        &self,
        key0: ExternFunctionId
    ) -> Maybe<GenericParamsData>;
    fn extern_function_declaration_implicits(
        &self,
        key0: ExternFunctionId
    ) -> Maybe<Vec<TypeId>>;
    fn extern_function_declaration_refs(
        &self,
        key0: ExternFunctionId
    ) -> Maybe<Vec<Parameter>>;
    fn extern_function_declaration_resolver_data(
        &self,
        key0: ExternFunctionId
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_extern_type_declaration_data(
        &self,
        key0: ExternTypeId
    ) -> Maybe<ExternTypeDeclarationData>;
    fn extern_type_declaration_diagnostics(
        &self,
        key0: ExternTypeId
    ) -> Diagnostics<SemanticDiagnostic>;
    fn extern_type_declaration_generic_params(
        &self,
        key0: ExternTypeId
    ) -> Maybe<Vec<GenericParam>>;
    fn extern_type_declaration_generic_params_data(
        &self,
        key0: ExternTypeId
    ) -> Maybe<GenericParamsData>;
    fn function_title_signature(
        &self,
        key0: FunctionTitleId
    ) -> Maybe<Signature>;
    fn function_title_generic_params(
        &self,
        key0: FunctionTitleId
    ) -> Maybe<Vec<GenericParam>>;
    fn concrete_function_signature(&self, key0: FunctionId) -> Maybe<Signature>;
    fn generic_type_generic_params(
        &self,
        key0: GenericTypeId
    ) -> Maybe<Vec<GenericParam>>;
    fn generic_param_data(
        &self,
        key0: GenericParamId
    ) -> Maybe<GenericParamData>;
    fn generic_param_semantic(
        &self,
        key0: GenericParamId
    ) -> Maybe<GenericParam>;
    fn generic_param_diagnostics(
        &self,
        key0: GenericParamId
    ) -> Diagnostics<SemanticDiagnostic>;
    fn generic_param_resolver_data(
        &self,
        key0: GenericParamId
    ) -> Maybe<Arc<ResolverData>>;
    fn generic_impl_param_trait(&self, key0: GenericParamId) -> Maybe<TraitId>;
    fn type_info(
        &self,
        key0: ImplLookupContext,
        key1: TypeId
    ) -> Maybe<TypeInfo>;
    fn expr_semantic(&self, key0: FunctionWithBodyId, key1: ExprId) -> Expr;
    fn statement_semantic(
        &self,
        key0: FunctionWithBodyId,
        key1: StatementId
    ) -> Statement;
    fn lookup_resolved_generic_item_by_ptr(
        &self,
        key0: LookupItemId,
        key1: TerminalIdentifierPtr
    ) -> Option<ResolvedGenericItem>;
    fn lookup_resolved_concrete_item_by_ptr(
        &self,
        key0: LookupItemId,
        key1: TerminalIdentifierPtr
    ) -> Option<ResolvedConcreteItem>;
    fn module_semantic_diagnostics(
        &self,
        key0: ModuleId
    ) -> Maybe<Diagnostics<SemanticDiagnostic>>;
    fn file_semantic_diagnostics(
        &self,
        key0: FileId
    ) -> Maybe<Diagnostics<SemanticDiagnostic>>;
    fn core_crate(&self) -> CrateId;
    fn core_module(&self) -> ModuleId;
    fn core_felt252_ty(&self) -> TypeId;
    fn semantic_plugins(&self) -> Vec<Arc<dyn SemanticPlugin>>;
    fn set_semantic_plugins(&mut self, value__: Vec<Arc<dyn SemanticPlugin>>);
    fn set_semantic_plugins_with_durability(
        &mut self,
        value__: Vec<Arc<dyn SemanticPlugin>>,
        durability__: Durability
    );
    fn methods_in_module(
        &self,
        key0: ModuleId,
        key1: TypeFilter
    ) -> Vec<TraitFunctionId>;
    fn methods_in_crate(
        &self,
        key0: CrateId,
        key1: TypeFilter
    ) -> Vec<TraitFunctionId>;
}

Required Methods

fn intern_function(&self, key0: FunctionLongId) -> FunctionId

fn lookup_intern_function(&self, key0: FunctionId) -> FunctionLongId

fn intern_concrete_function_with_body( &self, key0: ConcreteFunctionWithBody ) -> ConcreteFunctionWithBodyId

fn lookup_intern_concrete_function_with_body( &self, key0: ConcreteFunctionWithBodyId ) -> ConcreteFunctionWithBody

fn intern_concrete_struct(&self, key0: ConcreteStructLongId) -> ConcreteStructId

fn lookup_intern_concrete_struct( &self, key0: ConcreteStructId ) -> ConcreteStructLongId

fn intern_concrete_enum(&self, key0: ConcreteEnumLongId) -> ConcreteEnumId

fn lookup_intern_concrete_enum( &self, key0: ConcreteEnumId ) -> ConcreteEnumLongId

fn intern_concrete_extern_type( &self, key0: ConcreteExternTypeLongId ) -> ConcreteExternTypeId

fn lookup_intern_concrete_extern_type( &self, key0: ConcreteExternTypeId ) -> ConcreteExternTypeLongId

fn intern_concrete_trait(&self, key0: ConcreteTraitLongId) -> ConcreteTraitId

fn lookup_intern_concrete_trait( &self, key0: ConcreteTraitId ) -> ConcreteTraitLongId

fn intern_concrete_trait_function( &self, key0: ConcreteTraitGenericFunctionLongId ) -> ConcreteTraitGenericFunctionId

fn lookup_intern_concrete_trait_function( &self, key0: ConcreteTraitGenericFunctionId ) -> ConcreteTraitGenericFunctionLongId

fn intern_concrete_impl(&self, key0: ConcreteImplLongId) -> ConcreteImplId

fn lookup_intern_concrete_impl( &self, key0: ConcreteImplId ) -> ConcreteImplLongId

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

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

fn intern_literal(&self, key0: LiteralLongId) -> LiteralId

fn lookup_intern_literal(&self, key0: LiteralId) -> LiteralLongId

fn intern_impl_var(&self, key0: ImplVar) -> ImplVarId

fn lookup_intern_impl_var(&self, key0: ImplVarId) -> ImplVar

fn priv_constant_semantic_data(&self, key0: ConstantId) -> Maybe<ConstantData>

Private query to compute data about a constant definition.

fn constant_semantic_diagnostics( &self, key0: ConstantId ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic diagnostics of a constant definition.

fn constant_semantic_data(&self, key0: ConstantId) -> Maybe<Constant>

Returns the semantic data of a constant definition.

fn constant_resolver_data(&self, key0: ConstantId) -> Maybe<Arc<ResolverData>>

fn priv_use_semantic_data(&self, key0: UseId) -> Maybe<UseData>

Private query to compute data about a use.

fn use_semantic_diagnostics( &self, key0: UseId ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic diagnostics of a use.

fn use_resolver_data(&self, key0: UseId) -> Maybe<Arc<ResolverData>>

fn priv_module_semantic_data( &self, key0: ModuleId ) -> Maybe<Arc<ModuleSemanticData>>

Private query to compute data about the module.

fn module_scope(&self, key0: ModuleId) -> Maybe<Arc<Scope>>

Returns the scope of a module. See Scope.

fn module_item_by_name( &self, key0: ModuleId, key1: SmolStr ) -> Maybe<Option<ModuleItemId>>

Returns Maybe::Err if the module was not properly resolved. Returns [Maybe::Ok(Option::None)] if the item does not exist.

fn module_attributes(&self, key0: ModuleId) -> Maybe<Vec<Attribute>>

Returns the attributes of a module.

fn priv_struct_declaration_data( &self, key0: StructId ) -> Maybe<StructDeclarationData>

Private query to compute data about a struct declaration.

fn struct_declaration_diagnostics( &self, key0: StructId ) -> Diagnostics<SemanticDiagnostic>

Returns the declaration diagnostics of a struct.

fn struct_attributes(&self, key0: StructId) -> Maybe<Vec<Attribute>>

Returns the attributes of a struct.

fn struct_generic_params(&self, key0: StructId) -> Maybe<Vec<GenericParam>>

Returns the generic parameters of an enum.

fn struct_generic_params_data(&self, key0: StructId) -> Maybe<GenericParamsData>

Returns the generic parameters data of an enum.

fn struct_declaration_resolver_data( &self, key0: StructId ) -> Maybe<Arc<ResolverData>>

Returns the resolution resolved_items of a struct declaration.

fn priv_struct_definition_data( &self, key0: StructId ) -> Maybe<StructDefinitionData>

Private query to compute data about a struct definition.

fn struct_definition_diagnostics( &self, key0: StructId ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic diagnostics of a struct definition.

fn struct_members( &self, key0: StructId ) -> Maybe<OrderedHashMap<SmolStr, Member>>

Returns the members of a struct.

fn struct_definition_resolver_data( &self, key0: StructId ) -> Maybe<Arc<ResolverData>>

Returns the resolution resolved_items of a struct definition.

fn priv_enum_declaration_data(&self, key0: EnumId) -> Maybe<EnumDeclarationData>

Private query to compute data about an enum declaration.

fn enum_declaration_diagnostics( &self, key0: EnumId ) -> Diagnostics<SemanticDiagnostic>

Returns the diagnostics of an enum declaration.

fn enum_generic_params(&self, key0: EnumId) -> Maybe<Vec<GenericParam>>

Returns the generic parameters of an enum.

fn enum_generic_params_data(&self, key0: EnumId) -> Maybe<GenericParamsData>

Returns the generic parameters data of an enum.

fn enum_attributes(&self, key0: EnumId) -> Maybe<Vec<Attribute>>

Returns the attributes attached to an enum.

fn enum_declaration_resolver_data( &self, key0: EnumId ) -> Maybe<Arc<ResolverData>>

Returns the resolution resolved_items of an enum declaration.

fn priv_enum_definition_data(&self, key0: EnumId) -> Maybe<EnumDefinitionData>

Private query to compute data about an enum definition.

fn enum_definition_diagnostics( &self, key0: EnumId ) -> Diagnostics<SemanticDiagnostic>

Returns the definition diagnostics of an enum definition.

fn enum_variants( &self, key0: EnumId ) -> Maybe<OrderedHashMap<SmolStr, VariantId>>

Returns the members of an enum.

fn variant_semantic(&self, key0: EnumId, key1: VariantId) -> Maybe<Variant>

Returns the semantic model of a variant.

fn enum_definition_resolver_data( &self, key0: EnumId ) -> Maybe<Arc<ResolverData>>

Returns the resolution resolved_items of an enum definition.

fn priv_type_alias_semantic_data( &self, key0: TypeAliasId ) -> Maybe<TypeAliasData>

Private query to compute data about a type alias.

fn type_alias_semantic_diagnostics( &self, key0: TypeAliasId ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic diagnostics of a type alias.

fn type_alias_resolved_type(&self, key0: TypeAliasId) -> Maybe<TypeId>

Returns the resolved type of a type alias.

fn type_alias_generic_params( &self, key0: TypeAliasId ) -> Maybe<Vec<GenericParam>>

Returns the generic parameters of a type alias.

fn type_alias_generic_params_data( &self, key0: TypeAliasId ) -> Maybe<GenericParamsData>

Returns the generic parameters data of a type alias.

fn type_alias_resolver_data( &self, key0: TypeAliasId ) -> Maybe<Arc<ResolverData>>

Returns the resolution resolved_items of a type alias.

fn priv_impl_alias_semantic_data( &self, key0: ImplAliasId ) -> Maybe<ImplAliasData>

Private query to compute data about a type alias.

fn impl_alias_semantic_diagnostics( &self, key0: ImplAliasId ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic diagnostics of a type alias.

fn impl_alias_resolved_impl(&self, key0: ImplAliasId) -> Maybe<ImplId>

Returns the resolved type of a type alias.

fn impl_alias_generic_params( &self, key0: ImplAliasId ) -> Maybe<Vec<GenericParam>>

Returns the generic parameters of a type alias.

fn impl_alias_generic_params_data( &self, key0: ImplAliasId ) -> Maybe<GenericParamsData>

Returns the generic parameters data of a type alias.

fn impl_alias_resolver_data( &self, key0: ImplAliasId ) -> Maybe<Arc<ResolverData>>

Returns the resolution resolved_items of a type alias.

fn trait_semantic_declaration_diagnostics( &self, key0: TraitId ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic declaration diagnostics of a trait.

fn trait_generic_params(&self, key0: TraitId) -> Maybe<Vec<GenericParam>>

Returns the generic parameters of a trait.

fn trait_generic_params_data(&self, key0: TraitId) -> Maybe<GenericParamsData>

Returns the generic parameters data of a trait.

fn trait_attributes(&self, key0: TraitId) -> Maybe<Vec<Attribute>>

Returns the attributes of a trait.

fn trait_function_asts( &self, key0: TraitId ) -> Maybe<OrderedHashMap<TraitFunctionId, TraitItemFunction>>

Returns the asts of the functions of a trait.

fn trait_resolver_data(&self, key0: TraitId) -> Maybe<Arc<ResolverData>>

Returns the resolution resolved_items of a trait.

fn priv_trait_semantic_declaration_data( &self, key0: TraitId ) -> Maybe<TraitDeclarationData>

Private query to compute declaration data about a trait.

fn trait_semantic_definition_diagnostics( &self, key0: TraitId ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic definition diagnostics of a trait.

fn trait_functions( &self, key0: TraitId ) -> Maybe<OrderedHashMap<SmolStr, TraitFunctionId>>

Returns the functions of a trait.

fn trait_function_by_name( &self, key0: TraitId, key1: SmolStr ) -> Maybe<Option<TraitFunctionId>>

Returns the function with the given name of the given trait, if exists.

fn priv_trait_semantic_definition_data( &self, key0: TraitId ) -> Maybe<TraitDefinitionData>

Private query to compute definition data about a trait.

fn trait_function_declaration_diagnostics( &self, key0: TraitFunctionId ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic diagnostics of a trait function.

fn trait_function_signature(&self, key0: TraitFunctionId) -> Maybe<Signature>

Returns the signature of a trait function.

fn trait_function_generic_params( &self, key0: TraitFunctionId ) -> Maybe<Vec<GenericParam>>

Returns the generic params of a trait function.

fn trait_function_generic_params_data( &self, key0: TraitFunctionId ) -> Maybe<GenericParamsData>

Returns the generic params data of a trait function.

fn trait_function_attributes( &self, key0: TraitFunctionId ) -> Maybe<Vec<Attribute>>

Returns the attributes of a trait function.

fn trait_function_resolver_data( &self, key0: TraitFunctionId ) -> Maybe<Arc<ResolverData>>

Returns the resolution resolved_items of a trait function.

fn trait_function_declaration_inline_config( &self, key0: TraitFunctionId ) -> Maybe<InlineConfiguration>

Returns the inline configuration of a trait function’s declaration.

fn trait_function_declaration_implicit_precedence( &self, key0: TraitFunctionId ) -> Maybe<ImplicitPrecedence>

Returns the implicits precedence of a trait function.

fn trait_function_declaration_implicits( &self, key0: TraitFunctionId ) -> Maybe<Vec<TypeId>>

Returns the explicit implicits of a signature of a trait function.

fn priv_trait_function_declaration_data( &self, key0: TraitFunctionId ) -> Maybe<FunctionDeclarationData>

Private query to compute data about a trait function declaration.

fn trait_function_body_diagnostics( &self, key0: TraitFunctionId ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic diagnostics of a trait function definition (declaration + body).

fn trait_function_body( &self, key0: TraitFunctionId ) -> Maybe<Option<Arc<FunctionBody>>>

Returns the body of a trait function, if any.

fn priv_trait_function_body_data( &self, key0: TraitFunctionId ) -> Maybe<Option<FunctionBodyData>>

Private query to compute data about a trait function definition (declaration + body)

fn concrete_trait_function_generic_params( &self, key0: ConcreteTraitGenericFunctionId ) -> Maybe<Vec<GenericParam>>

Returns the generic params of a concrete trait function.

fn concrete_trait_function_signature( &self, key0: ConcreteTraitGenericFunctionId ) -> Maybe<Signature>

Returns the signature of a concrete trait function.

fn module_impl_ids_for_trait_filter( &self, key0: ModuleId, key1: TraitFilter ) -> Maybe<Vec<UninferredImpl>>

Returns candidate ImplDefIds for a specific trait lookup constraint.

fn canonic_trait_solutions( &self, key0: CanonicalTrait, key1: ImplLookupContext ) -> InferenceResult<SolutionSet<CanonicalImpl>>

fn impl_semantic_declaration_diagnostics( &self, key0: ImplDefId ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic declaration diagnostics of an impl.

fn impl_def_functions_asts( &self, key0: ImplDefId ) -> Maybe<OrderedHashMap<ImplFunctionId, FunctionWithBody>>

Returns asts of the functions of an impl.

fn impl_def_generic_params_data( &self, key0: ImplDefId ) -> Maybe<GenericParamsData>

Returns the generic parameters data of an impl.

fn impl_def_generic_params(&self, key0: ImplDefId) -> Maybe<Vec<GenericParam>>

Returns the generic parameters of an impl.

fn impl_def_resolver_data(&self, key0: ImplDefId) -> Maybe<Arc<ResolverData>>

Returns the resolution resolved_items of an impl.

fn impl_def_concrete_trait(&self, key0: ImplDefId) -> Maybe<ConcreteTraitId>

Returns the concrete trait that is implemented by the impl.

fn impl_def_attributes(&self, key0: ImplDefId) -> Maybe<Vec<Attribute>>

Returns the attributes attached to the impl.

fn impl_concrete_trait(&self, key0: ImplId) -> Maybe<ConcreteTraitId>

Returns the concrete trait that is implemented by the concrete impl.

fn impl_def_trait(&self, key0: ImplDefId) -> Maybe<TraitId>

Returns the trait that is implemented by the impl.

fn priv_impl_declaration_data( &self, key0: ImplDefId ) -> Maybe<ImplDeclarationData>

Private query to compute declaration data about an impl.

fn impl_semantic_definition_diagnostics( &self, key0: ImplDefId ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic definition diagnostics of an impl.

fn impl_functions( &self, key0: ImplDefId ) -> Maybe<OrderedHashMap<SmolStr, ImplFunctionId>>

Returns the functions in the impl.

fn impl_function_by_trait_function( &self, key0: ImplDefId, key1: TraitFunctionId ) -> Maybe<Option<ImplFunctionId>>

Returns the impl function that matches the given trait function, if exists. Note that a function that doesn’t exist in the impl doesn’t necessarily indicate an error, as, e.g., a trait function that has a default implementation doesn’t have to be implemented in the impl.

fn priv_impl_definition_data( &self, key0: ImplDefId ) -> Maybe<ImplDefinitionData>

Private query to compute definition data about an impl.

fn impl_function_declaration_diagnostics( &self, key0: ImplFunctionId ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic diagnostics of an impl function’s declaration (signature).

fn impl_function_signature(&self, key0: ImplFunctionId) -> Maybe<Signature>

Returns the signature of an impl function.

fn impl_function_generic_params( &self, key0: ImplFunctionId ) -> Maybe<Vec<GenericParam>>

Returns the generic params of an impl function.

fn impl_function_generic_params_data( &self, key0: ImplFunctionId ) -> Maybe<GenericParamsData>

Returns the generic params data of an impl function.

fn impl_function_attributes( &self, key0: ImplFunctionId ) -> Maybe<Vec<Attribute>>

Returns the attributes of an impl function.

fn impl_function_resolver_data( &self, key0: ImplFunctionId ) -> Maybe<Arc<ResolverData>>

Returns the resolution resolved_items of an impl function’s declaration.

fn impl_function_declaration_inline_config( &self, key0: ImplFunctionId ) -> Maybe<InlineConfiguration>

Returns the inline configuration of an impl function’s declaration.

fn impl_function_declaration_implicit_precedence( &self, key0: ImplFunctionId ) -> Maybe<ImplicitPrecedence>

Returns the implicits precedence of an impl function.

fn impl_function_declaration_implicits( &self, key0: ImplFunctionId ) -> Maybe<Vec<TypeId>>

Returns the explicit implicits of a signature of an impl function.

fn impl_function_trait_function( &self, key0: ImplFunctionId ) -> Maybe<TraitFunctionId>

Returns the trait function of an impl function.

fn priv_impl_function_declaration_data( &self, key0: ImplFunctionId ) -> Maybe<ImplFunctionDeclarationData>

Private query to compute data about an impl function declaration.

fn impl_function_body_diagnostics( &self, key0: ImplFunctionId ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic diagnostics of an impl function definition (declaration + body).

fn impl_function_body(&self, key0: ImplFunctionId) -> Maybe<Arc<FunctionBody>>

Returns the definition of an impl function.

fn impl_function_body_resolver_data( &self, key0: ImplFunctionId ) -> Maybe<Arc<ResolverData>>

Returns the resolution resolved_items of an impl function’s definition.

fn priv_impl_function_body_data( &self, key0: ImplFunctionId ) -> Maybe<FunctionBodyData>

Private query to compute data about an impl function definition (declaration + body)

fn free_function_declaration_diagnostics( &self, key0: FreeFunctionId ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic diagnostics of a free function’s declaration (signature).

fn free_function_signature(&self, key0: FreeFunctionId) -> Maybe<Signature>

Returns the signature of a free function.

fn free_function_declaration_implicits( &self, key0: FreeFunctionId ) -> Maybe<Vec<TypeId>>

Returns the explicit implicits of a signature of a free function.

fn free_function_declaration_implicit_precedence( &self, key0: FreeFunctionId ) -> Maybe<ImplicitPrecedence>

Returns the implicits precedence of a free function.

fn free_function_generic_params( &self, key0: FreeFunctionId ) -> Maybe<Vec<GenericParam>>

Returns the generic params of a free function.

fn free_function_generic_params_data( &self, key0: FreeFunctionId ) -> Maybe<GenericParamsData>

Returns the generic params data of a free function.

fn free_function_declaration_resolver_data( &self, key0: FreeFunctionId ) -> Maybe<Arc<ResolverData>>

Returns the resolution resolved_items of a free function’s declaration.

fn free_function_declaration_inline_config( &self, key0: FreeFunctionId ) -> Maybe<InlineConfiguration>

Returns the inline configuration of a free function’s declaration.

fn priv_free_function_declaration_data( &self, key0: FreeFunctionId ) -> Maybe<FunctionDeclarationData>

Private query to compute data about a free function declaration - its signature excluding its body.

fn free_function_body_diagnostics( &self, key0: FreeFunctionId ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic diagnostics of a free function’s body.

fn free_function_body_resolver_data( &self, key0: FreeFunctionId ) -> Maybe<Arc<ResolverData>>

Returns the resolution resolved_items of a free function’s body.

fn priv_free_function_body_data( &self, key0: FreeFunctionId ) -> Maybe<FunctionBodyData>

Private query to compute data about a free function’s body.

fn function_declaration_diagnostics( &self, key0: FunctionWithBodyId ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic diagnostics of a declaration (signature) of a function with a body.

fn function_declaration_inline_config( &self, key0: FunctionWithBodyId ) -> Maybe<InlineConfiguration>

Returns the inline configuration of a declaration (signature) of a function with a body.

fn function_declaration_implicit_precedence( &self, key0: FunctionWithBodyId ) -> Maybe<ImplicitPrecedence>

Returns the implicit order of a declaration (signature) of a function with a body.

fn function_with_body_signature( &self, key0: FunctionWithBodyId ) -> Maybe<Signature>

Returns the signature of a function with a body.

fn function_with_body_generic_params( &self, key0: FunctionWithBodyId ) -> Maybe<Vec<GenericParam>>

Returns all the available generic params inside a function body.

fn function_with_body_attributes( &self, key0: FunctionWithBodyId ) -> Maybe<Vec<Attribute>>

Returns the attributes of a function with a body.

fn function_body_diagnostics( &self, key0: FunctionWithBodyId ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic diagnostics of a body of a function (with a body).

fn function_body_expr(&self, key0: FunctionWithBodyId) -> Maybe<ExprId>

Returns the body expr of a function (with a body).

fn function_body(&self, key0: FunctionWithBodyId) -> Maybe<Arc<FunctionBody>>

Returns the body of a function (with a body).

fn priv_extern_function_declaration_data( &self, key0: ExternFunctionId ) -> Maybe<FunctionDeclarationData>

Private query to compute data about an extern function declaration. An extern function has no body, and thus only has a declaration.

fn extern_function_declaration_inline_config( &self, key0: ExternFunctionId ) -> Maybe<InlineConfiguration>

Returns the inline configuration of an extern function’s declaration.

fn extern_function_declaration_diagnostics( &self, key0: ExternFunctionId ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic diagnostics of an extern function declaration. An extern function has no body, and thus only has a declaration.

fn extern_function_signature(&self, key0: ExternFunctionId) -> Maybe<Signature>

Returns the signature of an extern function.

fn extern_function_declaration_generic_params( &self, key0: ExternFunctionId ) -> Maybe<Vec<GenericParam>>

Returns the generic params of an extern function.

fn extern_function_declaration_generic_params_data( &self, key0: ExternFunctionId ) -> Maybe<GenericParamsData>

Returns the generic params data of an extern function.

fn extern_function_declaration_implicits( &self, key0: ExternFunctionId ) -> Maybe<Vec<TypeId>>

Returns the explicit implicits of an extern function declaration.

fn extern_function_declaration_refs( &self, key0: ExternFunctionId ) -> Maybe<Vec<Parameter>>

Returns the ref parameters of an extern function declaration.

fn extern_function_declaration_resolver_data( &self, key0: ExternFunctionId ) -> Maybe<Arc<ResolverData>>

Returns the resolution resolved_items of an extern function.

fn priv_extern_type_declaration_data( &self, key0: ExternTypeId ) -> Maybe<ExternTypeDeclarationData>

Private query to compute data about an extern type declaration. An extern type has no body, and thus only has a declaration.

fn extern_type_declaration_diagnostics( &self, key0: ExternTypeId ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic diagnostics of an extern type declaration. An extern type has no body, and thus only has a declaration.

fn extern_type_declaration_generic_params( &self, key0: ExternTypeId ) -> Maybe<Vec<GenericParam>>

Returns the generic params of an extern type.

fn extern_type_declaration_generic_params_data( &self, key0: ExternTypeId ) -> Maybe<GenericParamsData>

Returns the generic params data of an extern type.

fn function_title_signature(&self, key0: FunctionTitleId) -> Maybe<Signature>

Returns the signature of the given FunctionTitleId. This include free functions, extern functions, etc…

fn function_title_generic_params( &self, key0: FunctionTitleId ) -> Maybe<Vec<GenericParam>>

Returns the generic parameters of the given FunctionTitleId. This include free functions, extern functions, etc…

fn concrete_function_signature(&self, key0: FunctionId) -> Maybe<Signature>

Returns the signature of a concrete function. This include free functions, extern functions, etc…

fn generic_type_generic_params( &self, key0: GenericTypeId ) -> Maybe<Vec<GenericParam>>

Returns the generic params of a generic type.

fn generic_param_data(&self, key0: GenericParamId) -> Maybe<GenericParamData>

Query to compute data about a generic param.

fn generic_param_semantic(&self, key0: GenericParamId) -> Maybe<GenericParam>

Returns the semantic data of a generic param.

fn generic_param_diagnostics( &self, key0: GenericParamId ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic diagnostics of a generic param.

fn generic_param_resolver_data( &self, key0: GenericParamId ) -> Maybe<Arc<ResolverData>>

Returns the resolver data of a generic param.

fn generic_impl_param_trait(&self, key0: GenericParamId) -> Maybe<TraitId>

Returns the trait a generic param impl should implement.

fn type_info(&self, key0: ImplLookupContext, key1: TypeId) -> Maybe<TypeInfo>

Returns the generic_type of a generic function. This include free types, extern types, etc…

fn expr_semantic(&self, key0: FunctionWithBodyId, key1: ExprId) -> Expr

Assumes function and expression are present.

fn statement_semantic( &self, key0: FunctionWithBodyId, key1: StatementId ) -> Statement

Assumes function and statement are valid.

fn lookup_resolved_generic_item_by_ptr( &self, key0: LookupItemId, key1: TerminalIdentifierPtr ) -> Option<ResolvedGenericItem>

fn lookup_resolved_concrete_item_by_ptr( &self, key0: LookupItemId, key1: TerminalIdentifierPtr ) -> Option<ResolvedConcreteItem>

fn module_semantic_diagnostics( &self, key0: ModuleId ) -> Maybe<Diagnostics<SemanticDiagnostic>>

Aggregates module level semantic diagnostics.

fn file_semantic_diagnostics( &self, key0: FileId ) -> Maybe<Diagnostics<SemanticDiagnostic>>

Aggregates file level semantic diagnostics.

fn core_crate(&self) -> CrateId

fn core_module(&self) -> ModuleId

fn core_felt252_ty(&self) -> TypeId

fn semantic_plugins(&self) -> Vec<Arc<dyn SemanticPlugin>>

fn set_semantic_plugins(&mut self, value__: Vec<Arc<dyn SemanticPlugin>>)

Set the value of the semantic_plugins input.

See semantic_plugins for details.

Note: Setting values will trigger cancellation of any ongoing queries; this method blocks until those queries have been cancelled.

fn set_semantic_plugins_with_durability( &mut self, value__: Vec<Arc<dyn SemanticPlugin>>, durability__: Durability )

Set the value of the semantic_plugins input and promise that its value will never change again.

See semantic_plugins for details.

Note: Setting values will trigger cancellation of any ongoing queries; this method blocks until those queries have been cancelled.

fn methods_in_module( &self, key0: ModuleId, key1: TypeFilter ) -> Vec<TraitFunctionId>

Returns all methods in a module that match the given type filter.

fn methods_in_crate( &self, key0: CrateId, key1: TypeFilter ) -> Vec<TraitFunctionId>

Returns all methods in a crate that match the given type filter.

Trait Implementations

impl DebugWithDb<dyn SemanticGroup> for ConcreteFunction

fn fmt( &self, f: &mut Formatter<'_>, db: &(dyn SemanticGroup + 'static) ) -> Result

fn debug<'me, 'db>(&'me self, db: &'me Db) -> DebugWith<'me, Db>where Self: Sized + 'me,

fn into_debug<'me, 'db>(self, db: &'me Db) -> DebugWith<'me, Db>where Self: Sized + 'me,

impl DebugWithDb<dyn SemanticGroup> for ConcreteFunctionWithBody

fn fmt( &self, f: &mut Formatter<'_>, db: &(dyn SemanticGroup + 'static) ) -> Result

fn debug<'me, 'db>(&'me self, db: &'me Db) -> DebugWith<'me, Db>where Self: Sized + 'me,

fn into_debug<'me, 'db>(self, db: &'me Db) -> DebugWith<'me, Db>where Self: Sized + 'me,

impl DebugWithDb<dyn SemanticGroup> for ConcreteImplLongId

fn fmt( &self, f: &mut Formatter<'_>, db: &(dyn SemanticGroup + 'static) ) -> Result

fn debug<'me, 'db>(&'me self, db: &'me Db) -> DebugWith<'me, Db>where Self: Sized + 'me,

fn into_debug<'me, 'db>(self, db: &'me Db) -> DebugWith<'me, Db>where Self: Sized + 'me,

impl DebugWithDb<dyn SemanticGroup> for ConcreteStructLongId

fn fmt( &self, f: &mut Formatter<'_>, db: &(dyn SemanticGroup + 'static) ) -> Result

fn debug<'me, 'db>(&'me self, db: &'me Db) -> DebugWith<'me, Db>where Self: Sized + 'me,

fn into_debug<'me, 'db>(self, db: &'me Db) -> DebugWith<'me, Db>where Self: Sized + 'me,

impl DebugWithDb<dyn SemanticGroup> for ConcreteTraitLongId

fn fmt( &self, f: &mut Formatter<'_>, db: &(dyn SemanticGroup + 'static) ) -> Result

fn debug<'me, 'db>(&'me self, db: &'me Db) -> DebugWith<'me, Db>where Self: Sized + 'me,

fn into_debug<'me, 'db>(self, db: &'me Db) -> DebugWith<'me, Db>where Self: Sized + 'me,

impl DebugWithDb<dyn SemanticGroup> for ConcreteTypeId

fn fmt( &self, f: &mut Formatter<'_>, db: &(dyn SemanticGroup + 'static) ) -> Result

fn debug<'me, 'db>(&'me self, db: &'me Db) -> DebugWith<'me, Db>where Self: Sized + 'me,

fn into_debug<'me, 'db>(self, db: &'me Db) -> DebugWith<'me, Db>where Self: Sized + 'me,

impl DebugWithDb<dyn SemanticGroup> for FunctionLongId

fn fmt( &self, f: &mut Formatter<'_>, db: &(dyn SemanticGroup + 'static) ) -> Result

fn debug<'me, 'db>(&'me self, db: &'me Db) -> DebugWith<'me, Db>where Self: Sized + 'me,

fn into_debug<'me, 'db>(self, db: &'me Db) -> DebugWith<'me, Db>where Self: Sized + 'me,

impl DebugWithDb<dyn SemanticGroup> for GenericArgumentId

fn fmt( &self, f: &mut Formatter<'_>, db: &(dyn SemanticGroup + 'static) ) -> Result

fn debug<'me, 'db>(&'me self, db: &'me Db) -> DebugWith<'me, Db>where Self: Sized + 'me,

fn into_debug<'me, 'db>(self, db: &'me Db) -> DebugWith<'me, Db>where Self: Sized + 'me,

impl DebugWithDb<dyn SemanticGroup> for GenericParam

fn fmt( &self, f: &mut Formatter<'_>, db: &(dyn SemanticGroup + 'static) ) -> Result

fn debug<'me, 'db>(&'me self, db: &'me Db) -> DebugWith<'me, Db>where Self: Sized + 'me,

fn into_debug<'me, 'db>(self, db: &'me Db) -> DebugWith<'me, Db>where Self: Sized + 'me,

impl DebugWithDb<dyn SemanticGroup> for ImplId

fn fmt( &self, f: &mut Formatter<'_>, db: &(dyn SemanticGroup + 'static) ) -> Result

fn debug<'me, 'db>(&'me self, db: &'me Db) -> DebugWith<'me, Db>where Self: Sized + 'me,

fn into_debug<'me, 'db>(self, db: &'me Db) -> DebugWith<'me, Db>where Self: Sized + 'me,

impl DebugWithDb<dyn SemanticGroup> for TypeLongId

fn fmt( &self, f: &mut Formatter<'_>, db: &(dyn SemanticGroup + 'static) ) -> Result

fn debug<'me, 'db>(&'me self, db: &'me Db) -> DebugWith<'me, Db>where Self: Sized + 'me,

fn into_debug<'me, 'db>(self, db: &'me Db) -> DebugWith<'me, Db>where Self: Sized + 'me,

impl DebugWithDb<dyn SemanticGroup> for UninferredImpl

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

fn debug<'me, 'db>(&'me self, db: &'me Db) -> DebugWith<'me, Db>where Self: Sized + 'me,

fn into_debug<'me, 'db>(self, db: &'me Db) -> DebugWith<'me, Db>where Self: Sized + 'me,

impl<'a> HasDb<&'a dyn SemanticGroup> for Inference<'a>

fn get_db(&self) -> &'a dyn SemanticGroup

impl<'a> HasDb<&'a dyn SemanticGroup> for SubstitutionRewriter<'a>

fn get_db(&self) -> &'a dyn SemanticGroup

impl<'a> Upcast<dyn SemanticGroup> for ExprFormatter<'a>

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

Implementors

impl<DB> SemanticGroup for DBwhere DB: DefsGroup + Upcast<dyn DefsGroup> + ParserGroup + Upcast<dyn FilesGroup> + AsFilesGroupMut + Elongate + Database + HasQueryGroup<SemanticDatabase>,