Trait SemanticGroup

pub trait SemanticGroup:
    Database
    + HasQueryGroup<SemanticDatabase>
    + DefsGroup
    + Upcast<dyn DefsGroup>
    + Upcast<dyn ParserGroup>
    + Upcast<dyn FilesGroup>
    + AsFilesGroupMut
    + Elongate {
    // Required methods
    fn intern_function(&self, id: FunctionLongId) -> FunctionId;
    fn lookup_intern_function(&self, key: FunctionId) -> FunctionLongId;
    fn intern_concrete_function_with_body(
        &self,
        id: ConcreteFunctionWithBody,
    ) -> ConcreteFunctionWithBodyId;
    fn lookup_intern_concrete_function_with_body(
        &self,
        key: ConcreteFunctionWithBodyId,
    ) -> ConcreteFunctionWithBody;
    fn intern_concrete_struct(
        &self,
        id: ConcreteStructLongId,
    ) -> ConcreteStructId;
    fn lookup_intern_concrete_struct(
        &self,
        key: ConcreteStructId,
    ) -> ConcreteStructLongId;
    fn intern_concrete_enum(&self, id: ConcreteEnumLongId) -> ConcreteEnumId;
    fn lookup_intern_concrete_enum(
        &self,
        key: ConcreteEnumId,
    ) -> ConcreteEnumLongId;
    fn intern_concrete_extern_type(
        &self,
        id: ConcreteExternTypeLongId,
    ) -> ConcreteExternTypeId;
    fn lookup_intern_concrete_extern_type(
        &self,
        key: ConcreteExternTypeId,
    ) -> ConcreteExternTypeLongId;
    fn intern_concrete_trait(&self, id: ConcreteTraitLongId) -> ConcreteTraitId;
    fn lookup_intern_concrete_trait(
        &self,
        key: ConcreteTraitId,
    ) -> ConcreteTraitLongId;
    fn intern_concrete_trait_function(
        &self,
        id: ConcreteTraitGenericFunctionLongId,
    ) -> ConcreteTraitGenericFunctionId;
    fn lookup_intern_concrete_trait_function(
        &self,
        key: ConcreteTraitGenericFunctionId,
    ) -> ConcreteTraitGenericFunctionLongId;
    fn intern_concrete_trait_type(
        &self,
        id: ConcreteTraitTypeLongId,
    ) -> ConcreteTraitTypeId;
    fn lookup_intern_concrete_trait_type(
        &self,
        key: ConcreteTraitTypeId,
    ) -> ConcreteTraitTypeLongId;
    fn intern_concrete_trait_constant(
        &self,
        id: ConcreteTraitConstantLongId,
    ) -> ConcreteTraitConstantId;
    fn lookup_intern_concrete_trait_constant(
        &self,
        key: ConcreteTraitConstantId,
    ) -> ConcreteTraitConstantLongId;
    fn intern_concrete_impl(&self, id: ConcreteImplLongId) -> ConcreteImplId;
    fn lookup_intern_concrete_impl(
        &self,
        key: ConcreteImplId,
    ) -> ConcreteImplLongId;
    fn intern_concrete_trait_impl(
        &self,
        id: ConcreteTraitImplLongId,
    ) -> ConcreteTraitImplId;
    fn lookup_intern_concrete_trait_impl(
        &self,
        key: ConcreteTraitImplId,
    ) -> ConcreteTraitImplLongId;
    fn intern_type(&self, id: TypeLongId) -> TypeId;
    fn lookup_intern_type(&self, key: TypeId) -> TypeLongId;
    fn intern_const_value(&self, id: ConstValue) -> ConstValueId;
    fn lookup_intern_const_value(&self, key: ConstValueId) -> ConstValue;
    fn intern_impl(&self, id: ImplLongId) -> ImplId;
    fn lookup_intern_impl(&self, key: ImplId) -> ImplLongId;
    fn intern_impl_var(&self, id: ImplVar) -> ImplVarId;
    fn lookup_intern_impl_var(&self, key: ImplVarId) -> ImplVar;
    fn intern_generated_impl(&self, id: GeneratedImplLongId) -> GeneratedImplId;
    fn lookup_intern_generated_impl(
        &self,
        key: GeneratedImplId,
    ) -> GeneratedImplLongId;
    fn intern_uninferred_generated_impl(
        &self,
        id: UninferredGeneratedImplLongId,
    ) -> UninferredGeneratedImplId;
    fn lookup_intern_uninferred_generated_impl(
        &self,
        key: UninferredGeneratedImplId,
    ) -> UninferredGeneratedImplLongId;
    fn priv_constant_semantic_data(
        &self,
        const_id: ConstantId,
        in_cycle: bool,
    ) -> Maybe<ConstantData>;
    fn constant_semantic_diagnostics(
        &self,
        const_id: ConstantId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn constant_semantic_data(&self, use_id: ConstantId) -> Maybe<Constant>;
    fn constant_resolver_data(
        &self,
        use_id: ConstantId,
    ) -> Maybe<Arc<ResolverData>>;
    fn constant_const_value(&self, const_id: ConstantId) -> Maybe<ConstValueId>;
    fn constant_const_type(&self, const_id: ConstantId) -> Maybe<TypeId>;
    fn priv_use_semantic_data(&self, use_id: UseId) -> Maybe<UseData>;
    fn use_semantic_diagnostics(
        &self,
        use_id: UseId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn use_resolver_data(&self, use_id: UseId) -> Maybe<Arc<ResolverData>>;
    fn priv_global_use_semantic_data(
        &self,
        global_use_id: GlobalUseId,
    ) -> Maybe<UseGlobalData>;
    fn priv_global_use_imported_module(
        &self,
        global_use_id: GlobalUseId,
    ) -> Maybe<ModuleId>;
    fn global_use_semantic_diagnostics(
        &self,
        global_use_id: GlobalUseId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn priv_module_use_star_modules(
        &self,
        module_id: ModuleId,
    ) -> Arc<ImportedModules>;
    fn priv_module_semantic_data(
        &self,
        module_id: ModuleId,
    ) -> Maybe<Arc<ModuleSemanticData>>;
    fn module_item_by_name(
        &self,
        module_id: ModuleId,
        name: SmolStr,
    ) -> Maybe<Option<ModuleItemId>>;
    fn module_item_info_by_name(
        &self,
        module_id: ModuleId,
        name: SmolStr,
    ) -> Maybe<Option<ModuleItemInfo>>;
    fn module_all_used_items(
        &self,
        module_id: ModuleId,
    ) -> Maybe<Arc<OrderedHashSet<LookupItemId>>>;
    fn module_attributes(&self, module_id: ModuleId) -> Maybe<Vec<Attribute>>;
    fn module_usable_trait_ids(
        &self,
        module_id: ModuleId,
    ) -> Maybe<Arc<OrderedHashMap<TraitId, LookupItemId>>>;
    fn priv_struct_declaration_data(
        &self,
        struct_id: StructId,
    ) -> Maybe<StructDeclarationData>;
    fn struct_declaration_diagnostics(
        &self,
        struct_id: StructId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn struct_attributes(&self, struct_id: StructId) -> Maybe<Vec<Attribute>>;
    fn struct_generic_params(
        &self,
        struct_id: StructId,
    ) -> Maybe<Vec<GenericParam>>;
    fn struct_generic_params_data(
        &self,
        struct_id: StructId,
    ) -> Maybe<GenericParamsData>;
    fn struct_declaration_resolver_data(
        &self,
        structure_id: StructId,
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_struct_definition_data(
        &self,
        struct_id: StructId,
    ) -> Maybe<StructDefinitionData>;
    fn struct_definition_diagnostics(
        &self,
        struct_id: StructId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn struct_members(
        &self,
        struct_id: StructId,
    ) -> Maybe<Arc<OrderedHashMap<SmolStr, Member>>>;
    fn struct_definition_resolver_data(
        &self,
        structure_id: StructId,
    ) -> Maybe<Arc<ResolverData>>;
    fn concrete_struct_members(
        &self,
        concrete_struct_id: ConcreteStructId,
    ) -> Maybe<Arc<OrderedHashMap<SmolStr, Member>>>;
    fn priv_enum_declaration_data(
        &self,
        enum_id: EnumId,
    ) -> Maybe<EnumDeclarationData>;
    fn enum_declaration_diagnostics(
        &self,
        enum_id: EnumId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn enum_generic_params(&self, enum_id: EnumId) -> Maybe<Vec<GenericParam>>;
    fn enum_generic_params_data(
        &self,
        enum_id: EnumId,
    ) -> Maybe<GenericParamsData>;
    fn enum_attributes(&self, enum_id: EnumId) -> Maybe<Vec<Attribute>>;
    fn enum_declaration_resolver_data(
        &self,
        enum_id: EnumId,
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_enum_definition_data(
        &self,
        enum_id: EnumId,
    ) -> Maybe<EnumDefinitionData>;
    fn enum_definition_diagnostics(
        &self,
        enum_id: EnumId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn enum_variants(
        &self,
        enum_id: EnumId,
    ) -> Maybe<OrderedHashMap<SmolStr, VariantId>>;
    fn variant_semantic(
        &self,
        enum_id: EnumId,
        variant_id: VariantId,
    ) -> Maybe<Variant>;
    fn enum_definition_resolver_data(
        &self,
        enum_id: EnumId,
    ) -> Maybe<Arc<ResolverData>>;
    fn module_type_alias_semantic_diagnostics(
        &self,
        module_type_alias_id: ModuleTypeAliasId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn module_type_alias_resolved_type(
        &self,
        module_type_alias_id: ModuleTypeAliasId,
    ) -> Maybe<TypeId>;
    fn module_type_alias_generic_params(
        &self,
        enum_id: ModuleTypeAliasId,
    ) -> Maybe<Vec<GenericParam>>;
    fn module_type_alias_resolver_data(
        &self,
        module_type_alias_id: ModuleTypeAliasId,
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_module_type_alias_generic_params_data(
        &self,
        enum_id: ModuleTypeAliasId,
    ) -> Maybe<GenericParamsData>;
    fn priv_module_type_alias_semantic_data(
        &self,
        module_type_alias_id: ModuleTypeAliasId,
        in_cycle: bool,
    ) -> Maybe<ModuleTypeAliasData>;
    fn impl_alias_impl_def(
        &self,
        impl_alias_id: ImplAliasId,
    ) -> Maybe<ImplDefId>;
    fn priv_impl_alias_semantic_data(
        &self,
        impl_alias_id: ImplAliasId,
        in_cycle: bool,
    ) -> Maybe<ImplAliasData>;
    fn impl_alias_semantic_diagnostics(
        &self,
        impl_alias_id: ImplAliasId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn impl_alias_resolved_impl(
        &self,
        impl_alias_id: ImplAliasId,
    ) -> Maybe<ImplId>;
    fn impl_alias_generic_params(
        &self,
        impl_alias_id: ImplAliasId,
    ) -> Maybe<Vec<GenericParam>>;
    fn impl_alias_generic_params_data(
        &self,
        impl_alias_id: ImplAliasId,
    ) -> Maybe<GenericParamsData>;
    fn impl_alias_resolver_data(
        &self,
        impl_alias_id: ImplAliasId,
    ) -> Maybe<Arc<ResolverData>>;
    fn impl_alias_attributes(
        &self,
        impl_def_id: ImplAliasId,
    ) -> Maybe<Vec<Attribute>>;
    fn trait_semantic_declaration_diagnostics(
        &self,
        trait_id: TraitId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn trait_generic_params(
        &self,
        trait_id: TraitId,
    ) -> Maybe<Vec<GenericParam>>;
    fn trait_generic_params_data(
        &self,
        trait_id: TraitId,
        in_cycle: bool,
    ) -> Maybe<GenericParamsData>;
    fn trait_attributes(&self, trait_id: TraitId) -> Maybe<Vec<Attribute>>;
    fn trait_resolver_data(&self, trait_id: TraitId) -> Maybe<Arc<ResolverData>>;
    fn priv_trait_declaration_data(
        &self,
        trait_id: TraitId,
    ) -> Maybe<TraitDeclarationData>;
    fn trait_semantic_definition_diagnostics(
        &self,
        trait_id: TraitId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn trait_required_item_names(
        &self,
        trait_id: TraitId,
    ) -> Maybe<OrderedHashSet<SmolStr>>;
    fn trait_item_by_name(
        &self,
        trait_id: TraitId,
        name: SmolStr,
    ) -> Maybe<Option<TraitItemId>>;
    fn trait_all_used_items(
        &self,
        trait_id: TraitId,
    ) -> Maybe<Arc<OrderedHashSet<LookupItemId>>>;
    fn trait_functions(
        &self,
        trait_id: TraitId,
    ) -> Maybe<OrderedHashMap<SmolStr, TraitFunctionId>>;
    fn trait_function_by_name(
        &self,
        trait_id: TraitId,
        name: SmolStr,
    ) -> Maybe<Option<TraitFunctionId>>;
    fn trait_types(
        &self,
        trait_id: TraitId,
    ) -> Maybe<OrderedHashMap<SmolStr, TraitTypeId>>;
    fn trait_type_by_name(
        &self,
        trait_id: TraitId,
        name: SmolStr,
    ) -> Maybe<Option<TraitTypeId>>;
    fn trait_constants(
        &self,
        trait_id: TraitId,
    ) -> Maybe<OrderedHashMap<SmolStr, TraitConstantId>>;
    fn trait_constant_by_name(
        &self,
        trait_id: TraitId,
        name: SmolStr,
    ) -> Maybe<Option<TraitConstantId>>;
    fn trait_impls(
        &self,
        trait_id: TraitId,
    ) -> Maybe<OrderedHashMap<SmolStr, TraitImplId>>;
    fn trait_impl_by_name(
        &self,
        trait_id: TraitId,
        name: SmolStr,
    ) -> Maybe<Option<TraitImplId>>;
    fn priv_trait_definition_data(
        &self,
        trait_id: TraitId,
    ) -> Maybe<TraitDefinitionData>;
    fn trait_type_diagnostics(
        &self,
        trait_type_id: TraitTypeId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn trait_type_generic_params(
        &self,
        trait_type_id: TraitTypeId,
    ) -> Maybe<Vec<GenericParam>>;
    fn trait_type_attributes(
        &self,
        trait_type_id: TraitTypeId,
    ) -> Maybe<Vec<Attribute>>;
    fn trait_type_resolver_data(
        &self,
        trait_type_id: TraitTypeId,
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_trait_type_generic_params_data(
        &self,
        trait_type_id: TraitTypeId,
    ) -> Maybe<GenericParamsData>;
    fn priv_trait_type_data(
        &self,
        type_id: TraitTypeId,
    ) -> Maybe<TraitItemTypeData>;
    fn trait_constant_diagnostics(
        &self,
        trait_constant: TraitConstantId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn trait_constant_attributes(
        &self,
        trait_constant: TraitConstantId,
    ) -> Maybe<Vec<Attribute>>;
    fn trait_constant_type(
        &self,
        trait_type_id: TraitConstantId,
    ) -> Maybe<TypeId>;
    fn trait_constant_resolver_data(
        &self,
        trait_constant: TraitConstantId,
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_trait_constant_data(
        &self,
        trait_constant: TraitConstantId,
    ) -> Maybe<TraitItemConstantData>;
    fn concrete_trait_constant_type(
        &self,
        concrete_trait_constant_id: ConcreteTraitConstantId,
    ) -> Maybe<TypeId>;
    fn trait_impl_diagnostics(
        &self,
        trait_impl: TraitImplId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn trait_impl_attributes(
        &self,
        trait_impl: TraitImplId,
    ) -> Maybe<Vec<Attribute>>;
    fn trait_impl_concrete_trait(
        &self,
        trait_impl_id: TraitImplId,
    ) -> Maybe<ConcreteTraitId>;
    fn trait_impl_resolver_data(
        &self,
        trait_impl: TraitImplId,
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_trait_impl_data(
        &self,
        trait_impl: TraitImplId,
    ) -> Maybe<TraitItemImplData>;
    fn concrete_trait_impl_concrete_trait(
        &self,
        concrete_trait_impl_id: ConcreteTraitImplId,
    ) -> Maybe<ConcreteTraitId>;
    fn trait_function_declaration_diagnostics(
        &self,
        trait_function_id: TraitFunctionId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn trait_function_signature(
        &self,
        trait_function_id: TraitFunctionId,
    ) -> Maybe<Signature>;
    fn trait_function_generic_params(
        &self,
        trait_function_id: TraitFunctionId,
    ) -> Maybe<Vec<GenericParam>>;
    fn priv_trait_function_generic_params_data(
        &self,
        trait_function_id: TraitFunctionId,
    ) -> Maybe<GenericParamsData>;
    fn trait_function_attributes(
        &self,
        trait_function_id: TraitFunctionId,
    ) -> Maybe<Vec<Attribute>>;
    fn trait_function_resolver_data(
        &self,
        trait_function_id: TraitFunctionId,
    ) -> Maybe<Arc<ResolverData>>;
    fn trait_function_declaration_inline_config(
        &self,
        trait_function_id: TraitFunctionId,
    ) -> Maybe<InlineConfiguration>;
    fn trait_function_declaration_implicit_precedence(
        &self,
        trait_function_id: TraitFunctionId,
    ) -> Maybe<ImplicitPrecedence>;
    fn trait_function_declaration_implicits(
        &self,
        trait_function_id: TraitFunctionId,
    ) -> Maybe<Vec<TypeId>>;
    fn priv_trait_function_declaration_data(
        &self,
        function_id: TraitFunctionId,
    ) -> Maybe<FunctionDeclarationData>;
    fn trait_function_body_diagnostics(
        &self,
        trait_function_id: TraitFunctionId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn trait_function_body(
        &self,
        trait_function_id: TraitFunctionId,
    ) -> Maybe<Option<Arc<FunctionBody>>>;
    fn priv_trait_function_body_data(
        &self,
        trait_function_id: TraitFunctionId,
    ) -> Maybe<Option<FunctionBodyData>>;
    fn concrete_trait_function_generic_params(
        &self,
        concrete_trait_function_id: ConcreteTraitGenericFunctionId,
    ) -> Maybe<Vec<GenericParam>>;
    fn concrete_trait_function_signature(
        &self,
        concrete_trait_function_id: ConcreteTraitGenericFunctionId,
    ) -> Maybe<Signature>;
    fn module_impl_ids_for_trait_filter(
        &self,
        module_id: ModuleId,
        trait_lookup_constraint: TraitFilter,
    ) -> Maybe<Vec<UninferredImpl>>;
    fn impl_impl_ids_for_trait_filter(
        &self,
        impl_id: ImplId,
        trait_lookup_constraint: TraitFilter,
    ) -> Maybe<Vec<UninferredImpl>>;
    fn canonic_trait_solutions(
        &self,
        canonical_trait: CanonicalTrait,
        lookup_context: ImplLookupContext,
    ) -> Result<SolutionSet<CanonicalImpl>, InferenceError>;
    fn impl_semantic_declaration_diagnostics(
        &self,
        impl_def_id: ImplDefId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn impl_def_generic_params_data(
        &self,
        impl_def_id: ImplDefId,
    ) -> Maybe<GenericParamsData>;
    fn impl_def_generic_params(
        &self,
        impl_def_id: ImplDefId,
    ) -> Maybe<Vec<GenericParam>>;
    fn impl_def_resolver_data(
        &self,
        impl_def_id: ImplDefId,
    ) -> Maybe<Arc<ResolverData>>;
    fn impl_def_concrete_trait(
        &self,
        impl_def_id: ImplDefId,
    ) -> Maybe<ConcreteTraitId>;
    fn impl_def_substitution(
        &self,
        impl_def_id: ImplDefId,
    ) -> Maybe<Arc<GenericSubstitution>>;
    fn impl_def_attributes(
        &self,
        impl_def_id: ImplDefId,
    ) -> Maybe<Vec<Attribute>>;
    fn impl_concrete_trait(&self, impl_id: ImplId) -> Maybe<ConcreteTraitId>;
    fn impl_def_trait(&self, impl_def_id: ImplDefId) -> Maybe<TraitId>;
    fn priv_impl_declaration_data(
        &self,
        impl_def_id: ImplDefId,
    ) -> Maybe<ImplDeclarationData>;
    fn impl_semantic_definition_diagnostics(
        &self,
        impl_def_id: ImplDefId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn impl_item_by_name(
        &self,
        impl_def_id: ImplDefId,
        name: SmolStr,
    ) -> Maybe<Option<ImplItemId>>;
    fn impl_implicit_impl_by_name(
        &self,
        impl_def_id: ImplDefId,
        name: SmolStr,
    ) -> Maybe<Option<TraitImplId>>;
    fn impl_all_used_items(
        &self,
        impl_def_id: ImplDefId,
    ) -> Maybe<Arc<OrderedHashSet<LookupItemId>>>;
    fn impl_types(
        &self,
        impl_def_id: ImplDefId,
    ) -> Maybe<Arc<OrderedHashMap<ImplTypeDefId, ItemTypeAlias>>>;
    fn impl_type_ids(
        &self,
        impl_def_id: ImplDefId,
    ) -> Maybe<Arc<[ImplTypeDefId]>>;
    fn impl_type_by_id(
        &self,
        impl_type_id: ImplTypeDefId,
    ) -> Maybe<Option<ItemTypeAlias>>;
    fn impl_type_by_trait_type(
        &self,
        impl_def_id: ImplDefId,
        trait_type_id: TraitTypeId,
    ) -> Maybe<ImplTypeDefId>;
    fn impl_constants(
        &self,
        impl_def_id: ImplDefId,
    ) -> Maybe<Arc<OrderedHashMap<ImplConstantDefId, ItemConstant>>>;
    fn impl_impls(
        &self,
        impl_def_id: ImplDefId,
    ) -> Maybe<Arc<OrderedHashMap<ImplImplDefId, ItemImplAlias>>>;
    fn impl_impl_ids(
        &self,
        impl_def_id: ImplDefId,
    ) -> Maybe<Arc<[ImplImplDefId]>>;
    fn impl_impl_by_id(
        &self,
        impl_impl_id: ImplImplDefId,
    ) -> Maybe<Option<ItemImplAlias>>;
    fn impl_impl_by_trait_impl(
        &self,
        impl_def_id: ImplDefId,
        trait_impl_id: TraitImplId,
    ) -> Maybe<ImplImplDefId>;
    fn is_implicit_impl_impl(
        &self,
        impl_def_id: ImplDefId,
        trait_impl_id: TraitImplId,
    ) -> Maybe<bool>;
    fn impl_constant_by_trait_constant(
        &self,
        impl_def_id: ImplDefId,
        trait_constant_id: TraitConstantId,
    ) -> Maybe<ImplConstantDefId>;
    fn impl_functions(
        &self,
        impl_def_id: ImplDefId,
    ) -> Maybe<OrderedHashMap<SmolStr, ImplFunctionId>>;
    fn impl_function_by_trait_function(
        &self,
        impl_def_id: ImplDefId,
        trait_function_id: TraitFunctionId,
    ) -> Maybe<Option<ImplFunctionId>>;
    fn priv_impl_definition_data(
        &self,
        impl_def_id: ImplDefId,
    ) -> Maybe<ImplDefinitionData>;
    fn priv_impl_is_fully_concrete(&self, impl_id: ImplId) -> bool;
    fn priv_impl_is_var_free(&self, impl_id: ImplId) -> bool;
    fn impl_type_def_semantic_diagnostics(
        &self,
        impl_type_def_id: ImplTypeDefId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn impl_type_def_resolved_type(
        &self,
        impl_type_def_id: ImplTypeDefId,
    ) -> Maybe<TypeId>;
    fn impl_type_def_generic_params(
        &self,
        impl_type_def_id: ImplTypeDefId,
    ) -> Maybe<Vec<GenericParam>>;
    fn impl_type_def_attributes(
        &self,
        impl_type_def_id: ImplTypeDefId,
    ) -> Maybe<Vec<Attribute>>;
    fn impl_type_def_resolver_data(
        &self,
        impl_type_def_id: ImplTypeDefId,
    ) -> Maybe<Arc<ResolverData>>;
    fn impl_type_def_trait_type(
        &self,
        impl_type_def_id: ImplTypeDefId,
    ) -> Maybe<TraitTypeId>;
    fn priv_impl_type_semantic_data(
        &self,
        impl_type_def_id: ImplTypeDefId,
        in_cycle: bool,
    ) -> Maybe<ImplItemTypeData>;
    fn priv_impl_type_def_generic_params_data(
        &self,
        impl_type_def_id: ImplTypeDefId,
    ) -> Maybe<GenericParamsData>;
    fn impl_type_concrete_implized(
        &self,
        impl_type_def_id: ImplTypeId,
    ) -> Maybe<TypeId>;
    fn impl_constant_def_semantic_diagnostics(
        &self,
        impl_constant_def_id: ImplConstantDefId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn impl_constant_def_value(
        &self,
        impl_constant_def_id: ImplConstantDefId,
    ) -> Maybe<ConstValueId>;
    fn impl_constant_def_resolver_data(
        &self,
        impl_constant_def_id: ImplConstantDefId,
    ) -> Maybe<Arc<ResolverData>>;
    fn impl_constant_def_trait_constant(
        &self,
        impl_constant_def_id: ImplConstantDefId,
    ) -> Maybe<TraitConstantId>;
    fn priv_impl_constant_semantic_data(
        &self,
        impl_constant_def_id: ImplConstantDefId,
        in_cycle: bool,
    ) -> Maybe<ImplItemConstantData>;
    fn impl_constant_implized_by_context(
        &self,
        impl_constant_id: ImplConstantId,
        impl_def_id: ImplDefId,
    ) -> Maybe<ConstValueId>;
    fn impl_constant_concrete_implized_value(
        &self,
        impl_constant_id: ImplConstantId,
    ) -> Maybe<ConstValueId>;
    fn impl_constant_concrete_implized_type(
        &self,
        impl_constant_id: ImplConstantId,
    ) -> Maybe<TypeId>;
    fn impl_impl_def_semantic_diagnostics(
        &self,
        impl_impl_def_id: ImplImplDefId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn impl_impl_def_resolver_data(
        &self,
        impl_impl_def_id: ImplImplDefId,
    ) -> Maybe<Arc<ResolverData>>;
    fn impl_impl_def_trait_impl(
        &self,
        impl_impl_def_id: ImplImplDefId,
    ) -> Maybe<TraitImplId>;
    fn impl_impl_def_impl(
        &self,
        impl_impl_def_id: ImplImplDefId,
        in_cycle: bool,
    ) -> Maybe<ImplId>;
    fn priv_impl_impl_semantic_data(
        &self,
        impl_impl_def_id: ImplImplDefId,
        in_cycle: bool,
    ) -> Maybe<ImplItemImplData>;
    fn priv_impl_impl_def_generic_params_data(
        &self,
        impl_impl_def_id: ImplImplDefId,
    ) -> Maybe<GenericParamsData>;
    fn implicit_impl_impl_semantic_diagnostics(
        &self,
        impl_def_id: ImplDefId,
        trait_impl_id: TraitImplId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn implicit_impl_impl_impl(
        &self,
        impl_def_id: ImplDefId,
        trait_impl_id: TraitImplId,
        in_cycle: bool,
    ) -> Maybe<ImplId>;
    fn priv_implicit_impl_impl_semantic_data(
        &self,
        impl_def_id: ImplDefId,
        trait_impl_id: TraitImplId,
        in_cycle: bool,
    ) -> Maybe<ImplicitImplImplData>;
    fn impl_impl_implized_by_context(
        &self,
        impl_impl_id: ImplImplId,
        impl_def_id: ImplDefId,
        in_cycle: bool,
    ) -> Maybe<ImplId>;
    fn impl_impl_concrete_implized(
        &self,
        impl_impl_id: ImplImplId,
    ) -> Maybe<ImplId>;
    fn impl_impl_concrete_trait(
        &self,
        impl_impl_id: ImplImplId,
    ) -> Maybe<ConcreteTraitId>;
    fn impl_function_declaration_diagnostics(
        &self,
        impl_function_id: ImplFunctionId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn impl_function_signature(
        &self,
        impl_function_id: ImplFunctionId,
    ) -> Maybe<Signature>;
    fn impl_function_generic_params(
        &self,
        impl_function_id: ImplFunctionId,
    ) -> Maybe<Vec<GenericParam>>;
    fn priv_impl_function_generic_params_data(
        &self,
        impl_function_id: ImplFunctionId,
    ) -> Maybe<GenericParamsData>;
    fn impl_function_attributes(
        &self,
        impl_function_id: ImplFunctionId,
    ) -> Maybe<Vec<Attribute>>;
    fn impl_function_resolver_data(
        &self,
        impl_function_id: ImplFunctionId,
    ) -> Maybe<Arc<ResolverData>>;
    fn impl_function_declaration_inline_config(
        &self,
        impl_function_id: ImplFunctionId,
    ) -> Maybe<InlineConfiguration>;
    fn impl_function_declaration_implicit_precedence(
        &self,
        impl_function_id: ImplFunctionId,
    ) -> Maybe<ImplicitPrecedence>;
    fn impl_function_declaration_implicits(
        &self,
        impl_function_id: ImplFunctionId,
    ) -> Maybe<Vec<TypeId>>;
    fn impl_function_trait_function(
        &self,
        impl_function_id: ImplFunctionId,
    ) -> Maybe<TraitFunctionId>;
    fn priv_impl_function_declaration_data(
        &self,
        impl_function_id: ImplFunctionId,
    ) -> Maybe<ImplFunctionDeclarationData>;
    fn impl_function_body_diagnostics(
        &self,
        impl_function_id: ImplFunctionId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn impl_function_body(
        &self,
        impl_function_id: ImplFunctionId,
    ) -> Maybe<Arc<FunctionBody>>;
    fn impl_function_body_resolver_data(
        &self,
        impl_function_id: ImplFunctionId,
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_impl_function_body_data(
        &self,
        impl_function_id: ImplFunctionId,
    ) -> Maybe<FunctionBodyData>;
    fn trait_type_implized_by_context(
        &self,
        trait_type_def_id: TraitTypeId,
        impl_def_id: ImplDefId,
    ) -> Maybe<TypeId>;
    fn free_function_declaration_diagnostics(
        &self,
        free_function_id: FreeFunctionId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn free_function_signature(
        &self,
        free_function_id: FreeFunctionId,
    ) -> Maybe<Signature>;
    fn free_function_declaration_implicits(
        &self,
        free_function_id: FreeFunctionId,
    ) -> Maybe<Vec<TypeId>>;
    fn free_function_declaration_implicit_precedence(
        &self,
        free_function_id: FreeFunctionId,
    ) -> Maybe<ImplicitPrecedence>;
    fn free_function_generic_params(
        &self,
        free_function_id: FreeFunctionId,
    ) -> Maybe<Vec<GenericParam>>;
    fn free_function_generic_params_data(
        &self,
        free_function_id: FreeFunctionId,
    ) -> Maybe<GenericParamsData>;
    fn free_function_declaration_resolver_data(
        &self,
        free_function_id: FreeFunctionId,
    ) -> Maybe<Arc<ResolverData>>;
    fn free_function_declaration_inline_config(
        &self,
        free_function_id: FreeFunctionId,
    ) -> Maybe<InlineConfiguration>;
    fn priv_free_function_declaration_data(
        &self,
        function_id: FreeFunctionId,
    ) -> Maybe<FunctionDeclarationData>;
    fn free_function_body_diagnostics(
        &self,
        free_function_id: FreeFunctionId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn free_function_body_resolver_data(
        &self,
        free_function_id: FreeFunctionId,
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_free_function_body_data(
        &self,
        free_function_id: FreeFunctionId,
    ) -> Maybe<FunctionBodyData>;
    fn function_declaration_diagnostics(
        &self,
        function_id: FunctionWithBodyId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn function_declaration_inline_config(
        &self,
        function_id: FunctionWithBodyId,
    ) -> Maybe<InlineConfiguration>;
    fn function_declaration_implicit_precedence(
        &self,
        function_id: FunctionWithBodyId,
    ) -> Maybe<ImplicitPrecedence>;
    fn function_with_body_signature(
        &self,
        function_id: FunctionWithBodyId,
    ) -> Maybe<Signature>;
    fn function_with_body_generic_params(
        &self,
        function_id: FunctionWithBodyId,
    ) -> Maybe<Vec<GenericParam>>;
    fn function_with_body_attributes(
        &self,
        function_id: FunctionWithBodyId,
    ) -> Maybe<Vec<Attribute>>;
    fn function_body_diagnostics(
        &self,
        function_id: FunctionWithBodyId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn function_body_expr(
        &self,
        function_id: FunctionWithBodyId,
    ) -> Maybe<ExprId>;
    fn function_body(
        &self,
        function_id: FunctionWithBodyId,
    ) -> Maybe<Arc<FunctionBody>>;
    fn priv_extern_function_declaration_data(
        &self,
        function_id: ExternFunctionId,
    ) -> Maybe<FunctionDeclarationData>;
    fn extern_function_declaration_inline_config(
        &self,
        extern_function_id: ExternFunctionId,
    ) -> Maybe<InlineConfiguration>;
    fn extern_function_declaration_diagnostics(
        &self,
        extern_function_id: ExternFunctionId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn extern_function_signature(
        &self,
        extern_function_id: ExternFunctionId,
    ) -> Maybe<Signature>;
    fn extern_function_declaration_generic_params(
        &self,
        extern_function_id: ExternFunctionId,
    ) -> Maybe<Vec<GenericParam>>;
    fn extern_function_declaration_generic_params_data(
        &self,
        extern_function_id: ExternFunctionId,
    ) -> Maybe<GenericParamsData>;
    fn extern_function_declaration_implicits(
        &self,
        extern_function_id: ExternFunctionId,
    ) -> Maybe<Vec<TypeId>>;
    fn extern_function_declaration_refs(
        &self,
        extern_function_id: ExternFunctionId,
    ) -> Maybe<Vec<Parameter>>;
    fn extern_function_declaration_resolver_data(
        &self,
        extern_function_id: ExternFunctionId,
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_extern_type_declaration_data(
        &self,
        type_id: ExternTypeId,
    ) -> Maybe<ExternTypeDeclarationData>;
    fn extern_type_declaration_diagnostics(
        &self,
        extern_type_id: ExternTypeId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn extern_type_declaration_generic_params(
        &self,
        extern_type_id: ExternTypeId,
    ) -> Maybe<Vec<GenericParam>>;
    fn extern_type_declaration_generic_params_data(
        &self,
        extern_type_id: ExternTypeId,
    ) -> Maybe<GenericParamsData>;
    fn extern_type_attributes(
        &self,
        extern_type_id: ExternTypeId,
    ) -> Maybe<Vec<Attribute>>;
    fn function_title_signature(
        &self,
        function_title_id: FunctionTitleId,
    ) -> Maybe<Signature>;
    fn function_title_generic_params(
        &self,
        function_title_id: FunctionTitleId,
    ) -> Maybe<Vec<GenericParam>>;
    fn concrete_function_signature(
        &self,
        function_id: FunctionId,
    ) -> Maybe<Signature>;
    fn generic_type_generic_params(
        &self,
        generic_type: GenericTypeId,
    ) -> Maybe<Vec<GenericParam>>;
    fn generic_param_semantic(
        &self,
        generic_param: GenericParamId,
    ) -> Maybe<GenericParam>;
    fn generic_param_diagnostics(
        &self,
        generic_param: GenericParamId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn generic_param_resolver_data(
        &self,
        generic_param: GenericParamId,
    ) -> Maybe<Arc<ResolverData>>;
    fn generic_impl_param_trait(
        &self,
        generic_param_id: GenericParamId,
    ) -> Maybe<TraitId>;
    fn priv_generic_param_data(
        &self,
        generic_param: GenericParamId,
        in_cycle: bool,
    ) -> Maybe<GenericParamData>;
    fn single_value_type(&self, ty: TypeId) -> Maybe<bool>;
    fn type_size_info(&self, ty: TypeId) -> Maybe<TypeSizeInformation>;
    fn type_info(
        &self,
        lookup_context: ImplLookupContext,
        ty: TypeId,
    ) -> Maybe<TypeInfo>;
    fn priv_type_is_fully_concrete(&self, ty: TypeId) -> bool;
    fn priv_type_is_var_free(&self, ty: TypeId) -> bool;
    fn expr_semantic(&self, function_id: FunctionWithBodyId, id: ExprId) -> Expr;
    fn pattern_semantic(
        &self,
        function_id: FunctionWithBodyId,
        id: PatternId,
    ) -> Pattern;
    fn statement_semantic(
        &self,
        function_id: FunctionWithBodyId,
        id: StatementId,
    ) -> Statement;
    fn lookup_resolved_generic_item_by_ptr(
        &self,
        id: LookupItemId,
        ptr: TerminalIdentifierPtr,
    ) -> Option<ResolvedGenericItem>;
    fn lookup_resolved_concrete_item_by_ptr(
        &self,
        id: LookupItemId,
        ptr: TerminalIdentifierPtr,
    ) -> Option<ResolvedConcreteItem>;
    fn module_semantic_diagnostics(
        &self,
        module_id: ModuleId,
    ) -> Maybe<Diagnostics<SemanticDiagnostic>>;
    fn file_semantic_diagnostics(
        &self,
        file_id: FileId,
    ) -> Maybe<Diagnostics<SemanticDiagnostic>>;
    fn core_crate(&self) -> CrateId;
    fn core_module(&self) -> ModuleId;
    fn core_felt252_ty(&self) -> TypeId;
    fn analyzer_plugins(&self) -> Vec<Arc<dyn AnalyzerPlugin>>;
    fn set_analyzer_plugins(&mut self, value__: Vec<Arc<dyn AnalyzerPlugin>>);
    fn set_analyzer_plugins_with_durability(
        &mut self,
        value__: Vec<Arc<dyn AnalyzerPlugin>>,
        durability__: Durability,
    );
    fn declared_allows(&self) -> Arc<OrderedHashSet<String>>;
    fn methods_in_module(
        &self,
        module_id: ModuleId,
        type_filter: TypeFilter,
    ) -> Arc<[TraitFunctionId]>;
    fn methods_in_crate(
        &self,
        crate_id: CrateId,
        type_filter: TypeFilter,
    ) -> Arc<[TraitFunctionId]>;
    fn visible_traits_from_module(
        &self,
        module_id: ModuleFileId,
    ) -> Option<Arc<OrderedHashMap<TraitId, String>>>;
    fn visible_traits_in_module(
        &self,
        module_id: ModuleId,
        user_module_file_id: ModuleFileId,
        include_parent: bool,
    ) -> Arc<[(TraitId, String)]>;
    fn visible_traits_in_crate(
        &self,
        crate_id: CrateId,
        user_module_file_id: ModuleFileId,
    ) -> Arc<[(TraitId, String)]>;
}

Required Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn intern_concrete_trait_type( &self, id: ConcreteTraitTypeLongId, ) -> ConcreteTraitTypeId

fn lookup_intern_concrete_trait_type( &self, key: ConcreteTraitTypeId, ) -> ConcreteTraitTypeLongId

fn intern_concrete_trait_constant( &self, id: ConcreteTraitConstantLongId, ) -> ConcreteTraitConstantId

fn lookup_intern_concrete_trait_constant( &self, key: ConcreteTraitConstantId, ) -> ConcreteTraitConstantLongId

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

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

fn intern_concrete_trait_impl( &self, id: ConcreteTraitImplLongId, ) -> ConcreteTraitImplId

fn lookup_intern_concrete_trait_impl( &self, key: ConcreteTraitImplId, ) -> ConcreteTraitImplLongId

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

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

fn intern_const_value(&self, id: ConstValue) -> ConstValueId

fn lookup_intern_const_value(&self, key: ConstValueId) -> ConstValue

fn intern_impl(&self, id: ImplLongId) -> ImplId

fn lookup_intern_impl(&self, key: ImplId) -> ImplLongId

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

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

fn intern_generated_impl(&self, id: GeneratedImplLongId) -> GeneratedImplId

fn lookup_intern_generated_impl( &self, key: GeneratedImplId, ) -> GeneratedImplLongId

fn intern_uninferred_generated_impl( &self, id: UninferredGeneratedImplLongId, ) -> UninferredGeneratedImplId

fn lookup_intern_uninferred_generated_impl( &self, key: UninferredGeneratedImplId, ) -> UninferredGeneratedImplLongId

fn priv_constant_semantic_data( &self, const_id: ConstantId, in_cycle: bool, ) -> Maybe<ConstantData>

Private query to compute data about a constant definition.

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

Returns the semantic diagnostics of a constant definition.

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

Returns the semantic data of a constant definition.

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

fn constant_const_value(&self, const_id: ConstantId) -> Maybe<ConstValueId>

fn constant_const_type(&self, const_id: ConstantId) -> Maybe<TypeId>

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

Private query to compute data about a use.

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

Returns the semantic diagnostics of a use.

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

fn priv_global_use_semantic_data( &self, global_use_id: GlobalUseId, ) -> Maybe<UseGlobalData>

Private query to compute data about a global use.

fn priv_global_use_imported_module( &self, global_use_id: GlobalUseId, ) -> Maybe<ModuleId>

Private query to compute the imported module, given a global use.

fn global_use_semantic_diagnostics( &self, global_use_id: GlobalUseId, ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic diagnostics of a global use.

fn priv_module_use_star_modules( &self, module_id: ModuleId, ) -> Arc<ImportedModules>

Private query to compute the imported modules of a module, using global uses.

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

Private query to compute data about the module.

fn module_item_by_name( &self, module_id: ModuleId, name: 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_item_info_by_name( &self, module_id: ModuleId, name: SmolStr, ) -> Maybe<Option<ModuleItemInfo>>

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

fn module_all_used_items( &self, module_id: ModuleId, ) -> Maybe<Arc<OrderedHashSet<LookupItemId>>>

Returns all the items used within the module.

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

Returns the attributes of a module.

fn module_usable_trait_ids( &self, module_id: ModuleId, ) -> Maybe<Arc<OrderedHashMap<TraitId, LookupItemId>>>

Finds all the trait ids usable in the module.

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

Private query to compute data about a struct declaration.

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

Returns the declaration diagnostics of a struct.

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

Returns the attributes of a struct.

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

Returns the generic parameters of an enum.

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

Returns the generic parameters data of an enum.

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

Returns the resolution resolved_items of a struct declaration.

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

Private query to compute data about a struct definition.

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

Returns the semantic diagnostics of a struct definition.

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

Returns the members of a struct.

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

Returns the resolution resolved_items of a struct definition.

fn concrete_struct_members( &self, concrete_struct_id: ConcreteStructId, ) -> Maybe<Arc<OrderedHashMap<SmolStr, Member>>>

Returns the concrete members of a struct.

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

Private query to compute data about an enum declaration.

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

Returns the diagnostics of an enum declaration.

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

Returns the generic parameters of an enum.

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

Returns the generic parameters data of an enum.

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

Returns the attributes attached to an enum.

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

Returns the resolution resolved_items of an enum declaration.

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

Private query to compute data about an enum definition.

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

Returns the definition diagnostics of an enum definition.

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

Returns the members of an enum.

fn variant_semantic( &self, enum_id: EnumId, variant_id: VariantId, ) -> Maybe<Variant>

Returns the semantic model of a variant.

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

Returns the resolution resolved_items of an enum definition.

fn module_type_alias_semantic_diagnostics( &self, module_type_alias_id: ModuleTypeAliasId, ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic diagnostics of a type alias.

fn module_type_alias_resolved_type( &self, module_type_alias_id: ModuleTypeAliasId, ) -> Maybe<TypeId>

Returns the resolved type of a type alias.

fn module_type_alias_generic_params( &self, enum_id: ModuleTypeAliasId, ) -> Maybe<Vec<GenericParam>>

Returns the generic parameters of a type alias.

fn module_type_alias_resolver_data( &self, module_type_alias_id: ModuleTypeAliasId, ) -> Maybe<Arc<ResolverData>>

Returns the resolution resolved_items of a type alias.

fn priv_module_type_alias_generic_params_data( &self, enum_id: ModuleTypeAliasId, ) -> Maybe<GenericParamsData>

Private query to compute the generic parameters data of a type alias.

fn priv_module_type_alias_semantic_data( &self, module_type_alias_id: ModuleTypeAliasId, in_cycle: bool, ) -> Maybe<ModuleTypeAliasData>

Private query to compute data about a type alias.

fn impl_alias_impl_def(&self, impl_alias_id: ImplAliasId) -> Maybe<ImplDefId>

Returns the impl definition pointed to by the impl alias, or an error if it points to something else.

fn priv_impl_alias_semantic_data( &self, impl_alias_id: ImplAliasId, in_cycle: bool, ) -> Maybe<ImplAliasData>

Private query to compute data about a type alias.

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

Returns the semantic diagnostics of a type alias.

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

Returns the resolved type of a type alias.

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

Returns the generic parameters of a type alias.

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

Returns the generic parameters data of a type alias.

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

Returns the resolution resolved_items of a type alias.

fn impl_alias_attributes( &self, impl_def_id: ImplAliasId, ) -> Maybe<Vec<Attribute>>

Returns the attributes attached to the impl alias.

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

Returns the semantic declaration diagnostics of a trait.

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

Returns the generic parameters of a trait.

fn trait_generic_params_data( &self, trait_id: TraitId, in_cycle: bool, ) -> Maybe<GenericParamsData>

Returns the generic parameters data of a trait.

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

Returns the attributes of a trait.

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

Returns the resolution resolved_items of a trait.

fn priv_trait_declaration_data( &self, trait_id: TraitId, ) -> Maybe<TraitDeclarationData>

Private query to compute declaration data about a trait.

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

Returns the semantic definition diagnostics of a trait.

fn trait_required_item_names( &self, trait_id: TraitId, ) -> Maybe<OrderedHashSet<SmolStr>>

Returns the names of all the non default implemented items of a trait.

fn trait_item_by_name( &self, trait_id: TraitId, name: SmolStr, ) -> Maybe<Option<TraitItemId>>

Returns the item of the trait, by the given name, if exists.

fn trait_all_used_items( &self, trait_id: TraitId, ) -> Maybe<Arc<OrderedHashSet<LookupItemId>>>

Returns all the items used within the trait.

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

Returns the functions of a trait.

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

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

fn trait_types( &self, trait_id: TraitId, ) -> Maybe<OrderedHashMap<SmolStr, TraitTypeId>>

Returns the types of a trait.

fn trait_type_by_name( &self, trait_id: TraitId, name: SmolStr, ) -> Maybe<Option<TraitTypeId>>

Returns the item type with the given name of the given trait, if exists.

fn trait_constants( &self, trait_id: TraitId, ) -> Maybe<OrderedHashMap<SmolStr, TraitConstantId>>

Returns the constants of a trait.

fn trait_constant_by_name( &self, trait_id: TraitId, name: SmolStr, ) -> Maybe<Option<TraitConstantId>>

Returns the item constants with the given name of the given trait, if exists.

fn trait_impls( &self, trait_id: TraitId, ) -> Maybe<OrderedHashMap<SmolStr, TraitImplId>>

Returns the constants of a trait.

fn trait_impl_by_name( &self, trait_id: TraitId, name: SmolStr, ) -> Maybe<Option<TraitImplId>>

Returns the item impls with the given name of the given trait, if exists.

fn priv_trait_definition_data( &self, trait_id: TraitId, ) -> Maybe<TraitDefinitionData>

Private query to compute definition data about a trait.

fn trait_type_diagnostics( &self, trait_type_id: TraitTypeId, ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic diagnostics of a trait type.

fn trait_type_generic_params( &self, trait_type_id: TraitTypeId, ) -> Maybe<Vec<GenericParam>>

Returns the generic params of a trait type.

fn trait_type_attributes( &self, trait_type_id: TraitTypeId, ) -> Maybe<Vec<Attribute>>

Returns the attributes of a trait type.

fn trait_type_resolver_data( &self, trait_type_id: TraitTypeId, ) -> Maybe<Arc<ResolverData>>

Returns the resolution resolved_items of a trait type.

fn priv_trait_type_generic_params_data( &self, trait_type_id: TraitTypeId, ) -> Maybe<GenericParamsData>

Private query to compute the generic params data of a trait type.

fn priv_trait_type_data(&self, type_id: TraitTypeId) -> Maybe<TraitItemTypeData>

Private query to compute data about a trait type.

fn trait_constant_diagnostics( &self, trait_constant: TraitConstantId, ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic diagnostics of a trait type.

fn trait_constant_attributes( &self, trait_constant: TraitConstantId, ) -> Maybe<Vec<Attribute>>

Returns the attributes of a trait constants.

fn trait_constant_type(&self, trait_type_id: TraitConstantId) -> Maybe<TypeId>

Returns the type of a trait constant.

fn trait_constant_resolver_data( &self, trait_constant: TraitConstantId, ) -> Maybe<Arc<ResolverData>>

Returns the resolution resolved_items of a trait constants.

fn priv_trait_constant_data( &self, trait_constant: TraitConstantId, ) -> Maybe<TraitItemConstantData>

Private query to compute data about a trait constant.

fn concrete_trait_constant_type( &self, concrete_trait_constant_id: ConcreteTraitConstantId, ) -> Maybe<TypeId>

Returns the type of a trait constant.

fn trait_impl_diagnostics( &self, trait_impl: TraitImplId, ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic diagnostics of a trait impls.

fn trait_impl_attributes( &self, trait_impl: TraitImplId, ) -> Maybe<Vec<Attribute>>

Returns the attributes of a trait impls.

fn trait_impl_concrete_trait( &self, trait_impl_id: TraitImplId, ) -> Maybe<ConcreteTraitId>

Returns the concrete trait of a trait impl.

fn trait_impl_resolver_data( &self, trait_impl: TraitImplId, ) -> Maybe<Arc<ResolverData>>

Returns the resolution resolved_items of a trait impls.

fn priv_trait_impl_data( &self, trait_impl: TraitImplId, ) -> Maybe<TraitItemImplData>

Private query to compute data about a trait impl.

fn concrete_trait_impl_concrete_trait( &self, concrete_trait_impl_id: ConcreteTraitImplId, ) -> Maybe<ConcreteTraitId>

Returns the concrete trait of a concrete trait impl.

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

Returns the semantic diagnostics of a trait function.

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

Returns the signature of a trait function.

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

Returns the generic params of a trait function.

fn priv_trait_function_generic_params_data( &self, trait_function_id: TraitFunctionId, ) -> Maybe<GenericParamsData>

Returns the generic params data of a trait function.

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

Returns the attributes of a trait function.

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

Returns the resolution resolved_items of a trait function.

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

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

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

Returns the implicits precedence of a trait function.

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

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

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

Private query to compute data about a trait function declaration.

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

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

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

Returns the body of a trait function, if any.

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

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

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

Returns the generic params of a concrete trait function.

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

Returns the signature of a concrete trait function.

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

Returns candidate ImplDefIds for a specific trait lookup constraint.

fn impl_impl_ids_for_trait_filter( &self, impl_id: ImplId, trait_lookup_constraint: TraitFilter, ) -> Maybe<Vec<UninferredImpl>>

fn canonic_trait_solutions( &self, canonical_trait: CanonicalTrait, lookup_context: ImplLookupContext, ) -> Result<SolutionSet<CanonicalImpl>, InferenceError>

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

Returns the semantic declaration diagnostics of an impl.

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

Returns the generic parameters data of an impl.

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

Returns the generic parameters of an impl.

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

Returns the resolution resolved_items of an impl.

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

Returns the concrete trait that is implemented by the impl.

fn impl_def_substitution( &self, impl_def_id: ImplDefId, ) -> Maybe<Arc<GenericSubstitution>>

Returns the substitution for generics for the impl.

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

Returns the attributes attached to the impl.

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

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

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

Returns the trait that is implemented by the impl, or an error if the RHS of the of is not a trait.

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

Private query to compute declaration data about an impl.

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

Returns the semantic definition diagnostics of an impl.

fn impl_item_by_name( &self, impl_def_id: ImplDefId, name: SmolStr, ) -> Maybe<Option<ImplItemId>>

Returns the item of the impl, by the given name, if exists.

fn impl_implicit_impl_by_name( &self, impl_def_id: ImplDefId, name: SmolStr, ) -> Maybe<Option<TraitImplId>>

Returns the trait impl of an implicit impl if name exists in trait and not in the impl.

fn impl_all_used_items( &self, impl_def_id: ImplDefId, ) -> Maybe<Arc<OrderedHashSet<LookupItemId>>>

Returns all the items used within the impl.

fn impl_types( &self, impl_def_id: ImplDefId, ) -> Maybe<Arc<OrderedHashMap<ImplTypeDefId, ItemTypeAlias>>>

Returns the type items in the impl.

fn impl_type_ids(&self, impl_def_id: ImplDefId) -> Maybe<Arc<[ImplTypeDefId]>>

Returns the ids of the type items in the impl.

fn impl_type_by_id( &self, impl_type_id: ImplTypeDefId, ) -> Maybe<Option<ItemTypeAlias>>

Returns the impl AST of the impl type that matches the given id, if exists.

fn impl_type_by_trait_type( &self, impl_def_id: ImplDefId, trait_type_id: TraitTypeId, ) -> Maybe<ImplTypeDefId>

Returns the impl type item that matches the given trait type item, if exists.

fn impl_constants( &self, impl_def_id: ImplDefId, ) -> Maybe<Arc<OrderedHashMap<ImplConstantDefId, ItemConstant>>>

Returns the constant items in the impl.

fn impl_impls( &self, impl_def_id: ImplDefId, ) -> Maybe<Arc<OrderedHashMap<ImplImplDefId, ItemImplAlias>>>

Returns the impls items in the impl.

fn impl_impl_ids(&self, impl_def_id: ImplDefId) -> Maybe<Arc<[ImplImplDefId]>>

Returns the ids of the impl items in the impl.

fn impl_impl_by_id( &self, impl_impl_id: ImplImplDefId, ) -> Maybe<Option<ItemImplAlias>>

Returns the impl AST of the impl impl that matches the given id, if exists.

fn impl_impl_by_trait_impl( &self, impl_def_id: ImplDefId, trait_impl_id: TraitImplId, ) -> Maybe<ImplImplDefId>

Returns the impl impl item that matches the given trait impl item, if exists.

fn is_implicit_impl_impl( &self, impl_def_id: ImplDefId, trait_impl_id: TraitImplId, ) -> Maybe<bool>

Returns whether trait_impl_id is an implicit impl in impl_def_id.

fn impl_constant_by_trait_constant( &self, impl_def_id: ImplDefId, trait_constant_id: TraitConstantId, ) -> Maybe<ImplConstantDefId>

Returns the impl constant item that matches the given trait constant item, if exists.

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

Returns the functions in the impl.

fn impl_function_by_trait_function( &self, impl_def_id: ImplDefId, trait_function_id: 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, impl_def_id: ImplDefId, ) -> Maybe<ImplDefinitionData>

Private query to compute definition data about an impl.

fn priv_impl_is_fully_concrete(&self, impl_id: ImplId) -> bool

Private query to check if an impl is fully concrete.

fn priv_impl_is_var_free(&self, impl_id: ImplId) -> bool

Private query to check if an impl contains no variables.

fn impl_type_def_semantic_diagnostics( &self, impl_type_def_id: ImplTypeDefId, ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic diagnostics of an impl item type.

fn impl_type_def_resolved_type( &self, impl_type_def_id: ImplTypeDefId, ) -> Maybe<TypeId>

Returns the resolved type of an impl item type.

fn impl_type_def_generic_params( &self, impl_type_def_id: ImplTypeDefId, ) -> Maybe<Vec<GenericParam>>

Returns the generic parameters of an impl item type.

fn impl_type_def_attributes( &self, impl_type_def_id: ImplTypeDefId, ) -> Maybe<Vec<Attribute>>

Returns the attributes of an impl type.

fn impl_type_def_resolver_data( &self, impl_type_def_id: ImplTypeDefId, ) -> Maybe<Arc<ResolverData>>

Returns the resolution resolved_items of an impl item type.

fn impl_type_def_trait_type( &self, impl_type_def_id: ImplTypeDefId, ) -> Maybe<TraitTypeId>

Returns the trait type of an impl type.

fn priv_impl_type_semantic_data( &self, impl_type_def_id: ImplTypeDefId, in_cycle: bool, ) -> Maybe<ImplItemTypeData>

Private query to compute data about an impl item type.

fn priv_impl_type_def_generic_params_data( &self, impl_type_def_id: ImplTypeDefId, ) -> Maybe<GenericParamsData>

Private query to compute data about the generic parameters of an impl item type.

fn impl_type_concrete_implized( &self, impl_type_def_id: ImplTypeId, ) -> Maybe<TypeId>

Returns the implized impl type if the impl is concrete. Returns a TypeId that’s not an impl type with a concrete impl.

fn impl_constant_def_semantic_diagnostics( &self, impl_constant_def_id: ImplConstantDefId, ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic diagnostics of an impl item constant.

fn impl_constant_def_value( &self, impl_constant_def_id: ImplConstantDefId, ) -> Maybe<ConstValueId>

Returns the resolved constant value of an impl item constant.

fn impl_constant_def_resolver_data( &self, impl_constant_def_id: ImplConstantDefId, ) -> Maybe<Arc<ResolverData>>

Returns the resolution resolved_items of an impl item constant.

fn impl_constant_def_trait_constant( &self, impl_constant_def_id: ImplConstantDefId, ) -> Maybe<TraitConstantId>

Returns the type of an impl item constant.

fn priv_impl_constant_semantic_data( &self, impl_constant_def_id: ImplConstantDefId, in_cycle: bool, ) -> Maybe<ImplItemConstantData>

Private query to compute data about an impl item constant.

fn impl_constant_implized_by_context( &self, impl_constant_id: ImplConstantId, impl_def_id: ImplDefId, ) -> Maybe<ConstValueId>

Returns the given impl constant, implized by the given impl context.

fn impl_constant_concrete_implized_value( &self, impl_constant_id: ImplConstantId, ) -> Maybe<ConstValueId>

Returns the implized impl constant value if the impl is concrete.

fn impl_constant_concrete_implized_type( &self, impl_constant_id: ImplConstantId, ) -> Maybe<TypeId>

Returns the implized impl constant type if the impl is concrete.

fn impl_impl_def_semantic_diagnostics( &self, impl_impl_def_id: ImplImplDefId, ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic diagnostics of an impl item impl.

fn impl_impl_def_resolver_data( &self, impl_impl_def_id: ImplImplDefId, ) -> Maybe<Arc<ResolverData>>

Returns the resolution resolved_items of an impl item impl.

fn impl_impl_def_trait_impl( &self, impl_impl_def_id: ImplImplDefId, ) -> Maybe<TraitImplId>

Returns the type of an impl item impl.

fn impl_impl_def_impl( &self, impl_impl_def_id: ImplImplDefId, in_cycle: bool, ) -> Maybe<ImplId>

Returns the resolved impl of an impl item impl.

fn priv_impl_impl_semantic_data( &self, impl_impl_def_id: ImplImplDefId, in_cycle: bool, ) -> Maybe<ImplItemImplData>

Private query to compute data about an impl item impl.

fn priv_impl_impl_def_generic_params_data( &self, impl_impl_def_id: ImplImplDefId, ) -> Maybe<GenericParamsData>

Private query to compute data about the generic parameters of an impl item impl.

fn implicit_impl_impl_semantic_diagnostics( &self, impl_def_id: ImplDefId, trait_impl_id: TraitImplId, ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic diagnostics of an implicit impl.

fn implicit_impl_impl_impl( &self, impl_def_id: ImplDefId, trait_impl_id: TraitImplId, in_cycle: bool, ) -> Maybe<ImplId>

Returns the resolved impl of an implicit impl.

fn priv_implicit_impl_impl_semantic_data( &self, impl_def_id: ImplDefId, trait_impl_id: TraitImplId, in_cycle: bool, ) -> Maybe<ImplicitImplImplData>

fn impl_impl_implized_by_context( &self, impl_impl_id: ImplImplId, impl_def_id: ImplDefId, in_cycle: bool, ) -> Maybe<ImplId>

Returns the implized impl impl if the impl is concrete.

fn impl_impl_concrete_implized(&self, impl_impl_id: ImplImplId) -> Maybe<ImplId>

Returns the implized impl impl value if the impl is concrete.

fn impl_impl_concrete_trait( &self, impl_impl_id: ImplImplId, ) -> Maybe<ConcreteTraitId>

Returns the concrete trait of an impl impl.

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

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

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

Returns the signature of an impl function.

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

Returns the generic params of an impl function.

fn priv_impl_function_generic_params_data( &self, impl_function_id: ImplFunctionId, ) -> Maybe<GenericParamsData>

Returns the generic params data of an impl function.

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

Returns the attributes of an impl function.

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

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

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

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

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

Returns the implicits precedence of an impl function.

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

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

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

Returns the trait function of an impl function.

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

Private query to compute data about an impl function declaration.

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

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

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

Returns the definition of an impl function.

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

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

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

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

fn trait_type_implized_by_context( &self, trait_type_def_id: TraitTypeId, impl_def_id: ImplDefId, ) -> Maybe<TypeId>

Returns the impl type for the given trait type, by implization by the given impl context, if the impl matches the trait of the trait type.

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

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

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

Returns the signature of a free function.

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

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

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

Returns the implicits precedence of a free function.

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

Returns the generic params of a free function.

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

Returns the generic params data of a free function.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Returns the signature of a function with a body.

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

Returns all the available generic params inside a function body.

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

Returns the attributes of a function with a body.

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

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

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

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

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

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

fn priv_extern_function_declaration_data( &self, function_id: 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, extern_function_id: ExternFunctionId, ) -> Maybe<InlineConfiguration>

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

fn extern_function_declaration_diagnostics( &self, extern_function_id: 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, extern_function_id: ExternFunctionId, ) -> Maybe<Signature>

Returns the signature of an extern function.

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

Returns the generic params of an extern function.

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

Returns the generic params data of an extern function.

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

Returns the explicit implicits of an extern function declaration.

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

Returns the ref parameters of an extern function declaration.

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

Returns the resolution resolved_items of an extern function.

fn priv_extern_type_declaration_data( &self, type_id: 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, extern_type_id: 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, extern_type_id: ExternTypeId, ) -> Maybe<Vec<GenericParam>>

Returns the generic params of an extern type.

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

Returns the generic params data of an extern type.

fn extern_type_attributes( &self, extern_type_id: ExternTypeId, ) -> Maybe<Vec<Attribute>>

Returns the attributes of an extern type.

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

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

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

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

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

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

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

Returns the generic params of a generic type.

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

Returns the semantic data of a generic param.

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

Returns the semantic diagnostics of a generic param.

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

Returns the resolver data of a generic param.

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

Returns the trait a generic param impl should implement. Panics if the generic param is not an impl generic param.

fn priv_generic_param_data( &self, generic_param: GenericParamId, in_cycle: bool, ) -> Maybe<GenericParamData>

Private query to compute data about a generic param.

fn single_value_type(&self, ty: TypeId) -> Maybe<bool>

Returns true if there is only one value for the given type and hence the values of the given type are all interchangeable. Examples include the unit type tuple of a unit type and empty structs. Always returns false for extern types.

fn type_size_info(&self, ty: TypeId) -> Maybe<TypeSizeInformation>

Returns the type size information for the given type.

fn type_info( &self, lookup_context: ImplLookupContext, ty: TypeId, ) -> Maybe<TypeInfo>

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

fn priv_type_is_fully_concrete(&self, ty: TypeId) -> bool

Private query to check if a type is fully concrete.

fn priv_type_is_var_free(&self, ty: TypeId) -> bool

Private query to check if a type contains no variables.

fn expr_semantic(&self, function_id: FunctionWithBodyId, id: ExprId) -> Expr

Assumes function and expression are present.

fn pattern_semantic( &self, function_id: FunctionWithBodyId, id: PatternId, ) -> Pattern

Assumes function and pattern are present.

fn statement_semantic( &self, function_id: FunctionWithBodyId, id: StatementId, ) -> Statement

Assumes function and statement are valid.

fn lookup_resolved_generic_item_by_ptr( &self, id: LookupItemId, ptr: TerminalIdentifierPtr, ) -> Option<ResolvedGenericItem>

fn lookup_resolved_concrete_item_by_ptr( &self, id: LookupItemId, ptr: TerminalIdentifierPtr, ) -> Option<ResolvedConcreteItem>

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

Aggregates module level semantic diagnostics.

fn file_semantic_diagnostics( &self, file_id: 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 analyzer_plugins(&self) -> Vec<Arc<dyn AnalyzerPlugin>>

fn set_analyzer_plugins(&mut self, value__: Vec<Arc<dyn AnalyzerPlugin>>)

Set the value of the analyzer_plugins input.

See analyzer_plugins for details.

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

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

Set the value of the analyzer_plugins input with a specific durability instead of the default of Durability::LOW. You can use Durability::MAX to promise that its value will never change again.

See analyzer_plugins for details.

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

fn declared_allows(&self) -> Arc<OrderedHashSet<String>>

Returns the set of allow that were declared as by a plugin. An allow that is not in this set will be handled as an unknown allow.

fn methods_in_module( &self, module_id: ModuleId, type_filter: TypeFilter, ) -> Arc<[TraitFunctionId]>

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

fn methods_in_crate( &self, crate_id: CrateId, type_filter: TypeFilter, ) -> Arc<[TraitFunctionId]>

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

fn visible_traits_from_module( &self, module_id: ModuleFileId, ) -> Option<Arc<OrderedHashMap<TraitId, String>>>

Returns all the traits visible from a module, alongside a visible use path to the trait.

fn visible_traits_in_module( &self, module_id: ModuleId, user_module_file_id: ModuleFileId, include_parent: bool, ) -> Arc<[(TraitId, String)]>

Returns all visible traits in a module, alongside a visible use path to the trait. user_module_file_id is the module from which the traits are should be visible. If include_parent is true, the parent module of module_id is also considered.

fn visible_traits_in_crate( &self, crate_id: CrateId, user_module_file_id: ModuleFileId, ) -> Arc<[(TraitId, String)]>

Returns all visible traits in a crate, alongside a visible use path to the trait. user_module_file_id is the module from which the traits are should be visible.

Trait Implementations

impl DebugWithDb<dyn SemanticGroup> for ClosureTypeLongId

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 ConcreteEnumLongId

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 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 GeneratedImplLongId

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 GenericFunctionId

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 ImplConstantId

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 ImplGenericFunctionId

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 ImplImplId

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 ImplLongId

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 ImplTypeId

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 TraitOrImplContext

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 UninferredGeneratedImplLongId

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> Intern<'a, dyn SemanticGroup + 'a, ConcreteEnumId> for ConcreteEnumLongId

fn intern( self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> ConcreteEnumId

impl<'a> Intern<'a, dyn SemanticGroup + 'a, ConcreteExternTypeId> for ConcreteExternTypeLongId

fn intern( self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> ConcreteExternTypeId

impl<'a> Intern<'a, dyn SemanticGroup + 'a, ConcreteFunctionWithBodyId> for ConcreteFunctionWithBody

fn intern( self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> ConcreteFunctionWithBodyId

impl<'a> Intern<'a, dyn SemanticGroup + 'a, ConcreteImplId> for ConcreteImplLongId

fn intern( self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> ConcreteImplId

impl<'a> Intern<'a, dyn SemanticGroup + 'a, ConcreteStructId> for ConcreteStructLongId

fn intern( self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> ConcreteStructId

impl<'a> Intern<'a, dyn SemanticGroup + 'a, ConcreteTraitConstantId> for ConcreteTraitConstantLongId

fn intern( self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> ConcreteTraitConstantId

impl<'a> Intern<'a, dyn SemanticGroup + 'a, ConcreteTraitGenericFunctionId> for ConcreteTraitGenericFunctionLongId

fn intern( self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> ConcreteTraitGenericFunctionId

impl<'a> Intern<'a, dyn SemanticGroup + 'a, ConcreteTraitId> for ConcreteTraitLongId

fn intern( self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> ConcreteTraitId

impl<'a> Intern<'a, dyn SemanticGroup + 'a, ConcreteTraitImplId> for ConcreteTraitImplLongId

fn intern( self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> ConcreteTraitImplId

impl<'a> Intern<'a, dyn SemanticGroup + 'a, ConcreteTraitTypeId> for ConcreteTraitTypeLongId

fn intern( self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> ConcreteTraitTypeId

impl<'a> Intern<'a, dyn SemanticGroup + 'a, ConstValueId> for ConstValue

fn intern( self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> ConstValueId

impl<'a> Intern<'a, dyn SemanticGroup + 'a, FunctionId> for FunctionLongId

fn intern( self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> FunctionId

impl<'a> Intern<'a, dyn SemanticGroup + 'a, GeneratedImplId> for GeneratedImplLongId

fn intern( self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> GeneratedImplId

impl<'a> Intern<'a, dyn SemanticGroup + 'a, ImplId> for ImplLongId

fn intern(self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized)) -> ImplId

impl<'a> Intern<'a, dyn SemanticGroup + 'a, ImplVarId> for ImplVar

fn intern( self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> ImplVarId

impl<'a> Intern<'a, dyn SemanticGroup + 'a, TypeId> for TypeLongId

fn intern(self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized)) -> TypeId

impl<'a> Intern<'a, dyn SemanticGroup + 'a, UninferredGeneratedImplId> for UninferredGeneratedImplLongId

fn intern( self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> UninferredGeneratedImplId

impl<'a> LookupIntern<'a, dyn SemanticGroup + 'a, ConcreteEnumLongId> for ConcreteEnumId

fn lookup_intern( &self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> ConcreteEnumLongId

impl<'a> LookupIntern<'a, dyn SemanticGroup + 'a, ConcreteExternTypeLongId> for ConcreteExternTypeId

fn lookup_intern( &self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> ConcreteExternTypeLongId

impl<'a> LookupIntern<'a, dyn SemanticGroup + 'a, ConcreteFunctionWithBody> for ConcreteFunctionWithBodyId

fn lookup_intern( &self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> ConcreteFunctionWithBody

impl<'a> LookupIntern<'a, dyn SemanticGroup + 'a, ConcreteImplLongId> for ConcreteImplId

fn lookup_intern( &self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> ConcreteImplLongId

impl<'a> LookupIntern<'a, dyn SemanticGroup + 'a, ConcreteStructLongId> for ConcreteStructId

fn lookup_intern( &self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> ConcreteStructLongId

impl<'a> LookupIntern<'a, dyn SemanticGroup + 'a, ConcreteTraitConstantLongId> for ConcreteTraitConstantId

fn lookup_intern( &self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> ConcreteTraitConstantLongId

impl<'a> LookupIntern<'a, dyn SemanticGroup + 'a, ConcreteTraitGenericFunctionLongId> for ConcreteTraitGenericFunctionId

fn lookup_intern( &self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> ConcreteTraitGenericFunctionLongId

impl<'a> LookupIntern<'a, dyn SemanticGroup + 'a, ConcreteTraitImplLongId> for ConcreteTraitImplId

fn lookup_intern( &self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> ConcreteTraitImplLongId

impl<'a> LookupIntern<'a, dyn SemanticGroup + 'a, ConcreteTraitLongId> for ConcreteTraitId

fn lookup_intern( &self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> ConcreteTraitLongId

impl<'a> LookupIntern<'a, dyn SemanticGroup + 'a, ConcreteTraitTypeLongId> for ConcreteTraitTypeId

fn lookup_intern( &self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> ConcreteTraitTypeLongId

impl<'a> LookupIntern<'a, dyn SemanticGroup + 'a, ConstValue> for ConstValueId

fn lookup_intern( &self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> ConstValue

impl<'a> LookupIntern<'a, dyn SemanticGroup + 'a, FunctionLongId> for FunctionId

fn lookup_intern( &self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> FunctionLongId

impl<'a> LookupIntern<'a, dyn SemanticGroup + 'a, GeneratedImplLongId> for GeneratedImplId

fn lookup_intern( &self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> GeneratedImplLongId

impl<'a> LookupIntern<'a, dyn SemanticGroup + 'a, ImplLongId> for ImplId

fn lookup_intern( &self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> ImplLongId

impl<'a> LookupIntern<'a, dyn SemanticGroup + 'a, ImplVar> for ImplVarId

fn lookup_intern( &self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> ImplVar

impl<'a> LookupIntern<'a, dyn SemanticGroup + 'a, TypeLongId> for TypeId

fn lookup_intern( &self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> TypeLongId

impl<'a> LookupIntern<'a, dyn SemanticGroup + 'a, UninferredGeneratedImplLongId> for UninferredGeneratedImplId

fn lookup_intern( &self, db: &(impl Upcast<dyn SemanticGroup + 'a> + ?Sized), ) -> UninferredGeneratedImplLongId

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

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

Implementors

impl<DB> SemanticGroup for DB

where DB: DefsGroup + Upcast<dyn DefsGroup> + Upcast<dyn ParserGroup> + Upcast<dyn FilesGroup> + AsFilesGroupMut + Elongate + Database + HasQueryGroup<SemanticDatabase>,