Trait cairo_lang_semantic::db::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, key0: FunctionLongId) -> FunctionId;
    fn lookup_intern_function(&self, key0: FunctionId) -> FunctionLongId;
    fn intern_concrete_function_with_body(
        &self,
        key0: ConcreteFunctionWithBody,
    ) -> ConcreteFunctionWithBodyId;
    fn lookup_intern_concrete_function_with_body(
        &self,
        key0: ConcreteFunctionWithBodyId,
    ) -> ConcreteFunctionWithBody;
    fn intern_concrete_struct(
        &self,
        key0: ConcreteStructLongId,
    ) -> ConcreteStructId;
    fn lookup_intern_concrete_struct(
        &self,
        key0: ConcreteStructId,
    ) -> ConcreteStructLongId;
    fn intern_concrete_enum(&self, key0: ConcreteEnumLongId) -> ConcreteEnumId;
    fn lookup_intern_concrete_enum(
        &self,
        key0: ConcreteEnumId,
    ) -> ConcreteEnumLongId;
    fn intern_concrete_extern_type(
        &self,
        key0: ConcreteExternTypeLongId,
    ) -> ConcreteExternTypeId;
    fn lookup_intern_concrete_extern_type(
        &self,
        key0: ConcreteExternTypeId,
    ) -> ConcreteExternTypeLongId;
    fn intern_concrete_trait(
        &self,
        key0: ConcreteTraitLongId,
    ) -> ConcreteTraitId;
    fn lookup_intern_concrete_trait(
        &self,
        key0: ConcreteTraitId,
    ) -> ConcreteTraitLongId;
    fn intern_concrete_trait_function(
        &self,
        key0: ConcreteTraitGenericFunctionLongId,
    ) -> ConcreteTraitGenericFunctionId;
    fn lookup_intern_concrete_trait_function(
        &self,
        key0: ConcreteTraitGenericFunctionId,
    ) -> ConcreteTraitGenericFunctionLongId;
    fn intern_concrete_trait_type(
        &self,
        key0: ConcreteTraitTypeLongId,
    ) -> ConcreteTraitTypeId;
    fn lookup_intern_concrete_trait_type(
        &self,
        key0: ConcreteTraitTypeId,
    ) -> ConcreteTraitTypeLongId;
    fn intern_concrete_trait_constant(
        &self,
        key0: ConcreteTraitConstantLongId,
    ) -> ConcreteTraitConstantId;
    fn lookup_intern_concrete_trait_constant(
        &self,
        key0: ConcreteTraitConstantId,
    ) -> ConcreteTraitConstantLongId;
    fn intern_concrete_impl(&self, key0: ConcreteImplLongId) -> ConcreteImplId;
    fn lookup_intern_concrete_impl(
        &self,
        key0: ConcreteImplId,
    ) -> ConcreteImplLongId;
    fn intern_concrete_trait_impl(
        &self,
        key0: ConcreteTraitImplLongId,
    ) -> ConcreteTraitImplId;
    fn lookup_intern_concrete_trait_impl(
        &self,
        key0: ConcreteTraitImplId,
    ) -> ConcreteTraitImplLongId;
    fn intern_type(&self, key0: TypeLongId) -> TypeId;
    fn lookup_intern_type(&self, key0: TypeId) -> TypeLongId;
    fn intern_const_value(&self, key0: ConstValue) -> ConstValueId;
    fn lookup_intern_const_value(&self, key0: ConstValueId) -> ConstValue;
    fn intern_impl(&self, key0: ImplLongId) -> ImplId;
    fn lookup_intern_impl(&self, key0: ImplId) -> ImplLongId;
    fn intern_impl_var(&self, key0: ImplVar) -> ImplVarId;
    fn lookup_intern_impl_var(&self, key0: ImplVarId) -> ImplVar;
    fn priv_constant_semantic_data(
        &self,
        key0: ConstantId,
    ) -> Maybe<ConstantData>;
    fn constant_semantic_diagnostics(
        &self,
        key0: ConstantId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn constant_semantic_data(&self, key0: ConstantId) -> Maybe<Constant>;
    fn constant_resolver_data(
        &self,
        key0: ConstantId,
    ) -> Maybe<Arc<ResolverData>>;
    fn constant_const_value(&self, key0: ConstantId) -> Maybe<ConstValue>;
    fn constant_const_type(&self, key0: ConstantId) -> Maybe<TypeId>;
    fn priv_use_semantic_data(&self, key0: UseId) -> Maybe<UseData>;
    fn use_semantic_diagnostics(
        &self,
        key0: UseId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn use_resolver_data(&self, key0: UseId) -> Maybe<Arc<ResolverData>>;
    fn priv_module_semantic_data(
        &self,
        key0: ModuleId,
    ) -> Maybe<Arc<ModuleSemanticData>>;
    fn module_item_by_name(
        &self,
        key0: ModuleId,
        key1: SmolStr,
    ) -> Maybe<Option<ModuleItemId>>;
    fn module_item_info_by_name(
        &self,
        key0: ModuleId,
        key1: SmolStr,
    ) -> Maybe<Option<ModuleItemInfo>>;
    fn module_attributes(&self, key0: ModuleId) -> Maybe<Vec<Attribute>>;
    fn module_usable_trait_ids(
        &self,
        key0: ModuleId,
    ) -> Maybe<Arc<OrderedHashSet<TraitId>>>;
    fn priv_struct_declaration_data(
        &self,
        key0: StructId,
    ) -> Maybe<StructDeclarationData>;
    fn struct_declaration_diagnostics(
        &self,
        key0: StructId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn struct_attributes(&self, key0: StructId) -> Maybe<Vec<Attribute>>;
    fn struct_generic_params(&self, key0: StructId) -> Maybe<Vec<GenericParam>>;
    fn struct_generic_params_data(
        &self,
        key0: StructId,
    ) -> Maybe<GenericParamsData>;
    fn struct_declaration_resolver_data(
        &self,
        key0: StructId,
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_struct_definition_data(
        &self,
        key0: StructId,
    ) -> Maybe<StructDefinitionData>;
    fn struct_definition_diagnostics(
        &self,
        key0: StructId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn struct_members(
        &self,
        key0: StructId,
    ) -> Maybe<OrderedHashMap<SmolStr, Member>>;
    fn struct_definition_resolver_data(
        &self,
        key0: StructId,
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_enum_declaration_data(
        &self,
        key0: EnumId,
    ) -> Maybe<EnumDeclarationData>;
    fn enum_declaration_diagnostics(
        &self,
        key0: EnumId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn enum_generic_params(&self, key0: EnumId) -> Maybe<Vec<GenericParam>>;
    fn enum_generic_params_data(&self, key0: EnumId) -> Maybe<GenericParamsData>;
    fn enum_attributes(&self, key0: EnumId) -> Maybe<Vec<Attribute>>;
    fn enum_declaration_resolver_data(
        &self,
        key0: EnumId,
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_enum_definition_data(
        &self,
        key0: EnumId,
    ) -> Maybe<EnumDefinitionData>;
    fn enum_definition_diagnostics(
        &self,
        key0: EnumId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn enum_variants(
        &self,
        key0: EnumId,
    ) -> Maybe<OrderedHashMap<SmolStr, VariantId>>;
    fn variant_semantic(&self, key0: EnumId, key1: VariantId) -> Maybe<Variant>;
    fn enum_definition_resolver_data(
        &self,
        key0: EnumId,
    ) -> Maybe<Arc<ResolverData>>;
    fn module_type_alias_semantic_diagnostics(
        &self,
        key0: ModuleTypeAliasId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn module_type_alias_resolved_type(
        &self,
        key0: ModuleTypeAliasId,
    ) -> Maybe<TypeId>;
    fn module_type_alias_generic_params(
        &self,
        key0: ModuleTypeAliasId,
    ) -> Maybe<Vec<GenericParam>>;
    fn module_type_alias_resolver_data(
        &self,
        key0: ModuleTypeAliasId,
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_module_type_alias_generic_params_data(
        &self,
        key0: ModuleTypeAliasId,
    ) -> Maybe<GenericParamsData>;
    fn priv_module_type_alias_semantic_data(
        &self,
        key0: ModuleTypeAliasId,
    ) -> Maybe<ModuleTypeAliasData>;
    fn impl_alias_impl_def(&self, key0: ImplAliasId) -> Maybe<ImplDefId>;
    fn priv_impl_alias_semantic_data(
        &self,
        key0: ImplAliasId,
    ) -> Maybe<ImplAliasData>;
    fn impl_alias_semantic_diagnostics(
        &self,
        key0: ImplAliasId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn impl_alias_resolved_impl(&self, key0: ImplAliasId) -> Maybe<ImplId>;
    fn impl_alias_generic_params(
        &self,
        key0: ImplAliasId,
    ) -> Maybe<Vec<GenericParam>>;
    fn impl_alias_generic_params_data(
        &self,
        key0: ImplAliasId,
    ) -> Maybe<GenericParamsData>;
    fn impl_alias_resolver_data(
        &self,
        key0: ImplAliasId,
    ) -> Maybe<Arc<ResolverData>>;
    fn impl_alias_attributes(&self, key0: ImplAliasId) -> Maybe<Vec<Attribute>>;
    fn trait_semantic_declaration_diagnostics(
        &self,
        key0: TraitId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn trait_generic_params(&self, key0: TraitId) -> Maybe<Vec<GenericParam>>;
    fn trait_generic_params_data(
        &self,
        key0: TraitId,
    ) -> Maybe<GenericParamsData>;
    fn trait_attributes(&self, key0: TraitId) -> Maybe<Vec<Attribute>>;
    fn trait_resolver_data(&self, key0: TraitId) -> Maybe<Arc<ResolverData>>;
    fn priv_trait_declaration_data(
        &self,
        key0: TraitId,
    ) -> Maybe<TraitDeclarationData>;
    fn trait_semantic_definition_diagnostics(
        &self,
        key0: TraitId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn trait_required_item_names(
        &self,
        key0: TraitId,
    ) -> Maybe<OrderedHashSet<SmolStr>>;
    fn trait_item_by_name(
        &self,
        key0: TraitId,
        key1: SmolStr,
    ) -> Maybe<Option<TraitItemId>>;
    fn trait_functions(
        &self,
        key0: TraitId,
    ) -> Maybe<OrderedHashMap<SmolStr, TraitFunctionId>>;
    fn trait_function_by_name(
        &self,
        key0: TraitId,
        key1: SmolStr,
    ) -> Maybe<Option<TraitFunctionId>>;
    fn trait_types(
        &self,
        key0: TraitId,
    ) -> Maybe<OrderedHashMap<SmolStr, TraitTypeId>>;
    fn trait_type_by_name(
        &self,
        key0: TraitId,
        key1: SmolStr,
    ) -> Maybe<Option<TraitTypeId>>;
    fn trait_constants(
        &self,
        key0: TraitId,
    ) -> Maybe<OrderedHashMap<SmolStr, TraitConstantId>>;
    fn trait_constant_by_name(
        &self,
        key0: TraitId,
        key1: SmolStr,
    ) -> Maybe<Option<TraitConstantId>>;
    fn trait_impls(
        &self,
        key0: TraitId,
    ) -> Maybe<OrderedHashMap<SmolStr, TraitImplId>>;
    fn trait_impl_by_name(
        &self,
        key0: TraitId,
        key1: SmolStr,
    ) -> Maybe<Option<TraitImplId>>;
    fn priv_trait_definition_data(
        &self,
        key0: TraitId,
    ) -> Maybe<TraitDefinitionData>;
    fn trait_type_diagnostics(
        &self,
        key0: TraitTypeId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn trait_type_generic_params(
        &self,
        key0: TraitTypeId,
    ) -> Maybe<Vec<GenericParam>>;
    fn trait_type_attributes(&self, key0: TraitTypeId) -> Maybe<Vec<Attribute>>;
    fn trait_type_resolver_data(
        &self,
        key0: TraitTypeId,
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_trait_type_generic_params_data(
        &self,
        key0: TraitTypeId,
    ) -> Maybe<GenericParamsData>;
    fn priv_trait_type_data(
        &self,
        key0: TraitTypeId,
    ) -> Maybe<TraitItemTypeData>;
    fn trait_constant_diagnostics(
        &self,
        key0: TraitConstantId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn trait_constant_attributes(
        &self,
        key0: TraitConstantId,
    ) -> Maybe<Vec<Attribute>>;
    fn trait_constant_type(&self, key0: TraitConstantId) -> Maybe<TypeId>;
    fn trait_constant_resolver_data(
        &self,
        key0: TraitConstantId,
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_trait_constant_data(
        &self,
        key0: TraitConstantId,
    ) -> Maybe<TraitItemConstantData>;
    fn concrete_trait_constant_type(
        &self,
        key0: ConcreteTraitConstantId,
    ) -> Maybe<TypeId>;
    fn trait_impl_diagnostics(
        &self,
        key0: TraitImplId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn trait_impl_attributes(&self, key0: TraitImplId) -> Maybe<Vec<Attribute>>;
    fn trait_impl_concrete_trait(
        &self,
        key0: TraitImplId,
    ) -> Maybe<ConcreteTraitId>;
    fn trait_impl_resolver_data(
        &self,
        key0: TraitImplId,
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_trait_impl_data(
        &self,
        key0: TraitImplId,
    ) -> Maybe<TraitItemImplData>;
    fn concrete_trait_impl_concrete_trait(
        &self,
        key0: ConcreteTraitImplId,
    ) -> Maybe<ConcreteTraitId>;
    fn trait_function_declaration_diagnostics(
        &self,
        key0: TraitFunctionId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn trait_function_signature(
        &self,
        key0: TraitFunctionId,
    ) -> Maybe<Signature>;
    fn trait_function_generic_params(
        &self,
        key0: TraitFunctionId,
    ) -> Maybe<Vec<GenericParam>>;
    fn priv_trait_function_generic_params_data(
        &self,
        key0: TraitFunctionId,
    ) -> Maybe<GenericParamsData>;
    fn trait_function_attributes(
        &self,
        key0: TraitFunctionId,
    ) -> Maybe<Vec<Attribute>>;
    fn trait_function_resolver_data(
        &self,
        key0: TraitFunctionId,
    ) -> Maybe<Arc<ResolverData>>;
    fn trait_function_declaration_inline_config(
        &self,
        key0: TraitFunctionId,
    ) -> Maybe<InlineConfiguration>;
    fn trait_function_declaration_implicit_precedence(
        &self,
        key0: TraitFunctionId,
    ) -> Maybe<ImplicitPrecedence>;
    fn trait_function_declaration_implicits(
        &self,
        key0: TraitFunctionId,
    ) -> Maybe<Vec<TypeId>>;
    fn priv_trait_function_declaration_data(
        &self,
        key0: TraitFunctionId,
    ) -> Maybe<FunctionDeclarationData>;
    fn trait_function_body_diagnostics(
        &self,
        key0: TraitFunctionId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn trait_function_body(
        &self,
        key0: TraitFunctionId,
    ) -> Maybe<Option<Arc<FunctionBody>>>;
    fn priv_trait_function_body_data(
        &self,
        key0: TraitFunctionId,
    ) -> Maybe<Option<FunctionBodyData>>;
    fn concrete_trait_function_generic_params(
        &self,
        key0: ConcreteTraitGenericFunctionId,
    ) -> Maybe<Vec<GenericParam>>;
    fn concrete_trait_function_signature(
        &self,
        key0: ConcreteTraitGenericFunctionId,
    ) -> Maybe<Signature>;
    fn module_impl_ids_for_trait_filter(
        &self,
        key0: ModuleId,
        key1: TraitFilter,
    ) -> Maybe<Vec<UninferredImpl>>;
    fn impl_impl_ids_for_trait_filter(
        &self,
        key0: ImplId,
        key1: TraitFilter,
    ) -> Maybe<Vec<UninferredImpl>>;
    fn canonic_trait_solutions(
        &self,
        key0: CanonicalTrait,
        key1: ImplLookupContext,
    ) -> Result<SolutionSet<CanonicalImpl>, InferenceError>;
    fn impl_semantic_declaration_diagnostics(
        &self,
        key0: ImplDefId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn impl_def_generic_params_data(
        &self,
        key0: ImplDefId,
    ) -> Maybe<GenericParamsData>;
    fn impl_def_generic_params(
        &self,
        key0: ImplDefId,
    ) -> Maybe<Vec<GenericParam>>;
    fn impl_def_resolver_data(
        &self,
        key0: ImplDefId,
    ) -> Maybe<Arc<ResolverData>>;
    fn impl_def_concrete_trait(&self, key0: ImplDefId) -> Maybe<ConcreteTraitId>;
    fn impl_def_substitution(
        &self,
        key0: ImplDefId,
    ) -> Maybe<Arc<GenericSubstitution>>;
    fn impl_def_attributes(&self, key0: ImplDefId) -> Maybe<Vec<Attribute>>;
    fn impl_concrete_trait(&self, key0: ImplId) -> Maybe<ConcreteTraitId>;
    fn impl_def_trait(&self, key0: ImplDefId) -> Maybe<TraitId>;
    fn priv_impl_declaration_data(
        &self,
        key0: ImplDefId,
    ) -> Maybe<ImplDeclarationData>;
    fn impl_semantic_definition_diagnostics(
        &self,
        key0: ImplDefId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn impl_item_by_name(
        &self,
        key0: ImplDefId,
        key1: SmolStr,
    ) -> Maybe<Option<ImplItemId>>;
    fn impl_implicit_impl_by_name(
        &self,
        key0: ImplDefId,
        key1: SmolStr,
    ) -> Maybe<Option<TraitImplId>>;
    fn impl_types(
        &self,
        key0: ImplDefId,
    ) -> Maybe<Arc<OrderedHashMap<ImplTypeDefId, ItemTypeAlias>>>;
    fn impl_type_ids(&self, key0: ImplDefId) -> Maybe<Arc<[ImplTypeDefId]>>;
    fn impl_type_by_id(
        &self,
        key0: ImplTypeDefId,
    ) -> Maybe<Option<ItemTypeAlias>>;
    fn impl_type_by_trait_type(
        &self,
        key0: ImplDefId,
        key1: TraitTypeId,
    ) -> Maybe<ImplTypeDefId>;
    fn impl_constants(
        &self,
        key0: ImplDefId,
    ) -> Maybe<Arc<OrderedHashMap<ImplConstantDefId, ItemConstant>>>;
    fn impl_impls(
        &self,
        key0: ImplDefId,
    ) -> Maybe<Arc<OrderedHashMap<ImplImplDefId, ItemImplAlias>>>;
    fn impl_impl_ids(&self, key0: ImplDefId) -> Maybe<Arc<[ImplImplDefId]>>;
    fn impl_impl_by_id(
        &self,
        key0: ImplImplDefId,
    ) -> Maybe<Option<ItemImplAlias>>;
    fn impl_impl_by_trait_impl(
        &self,
        key0: ImplDefId,
        key1: TraitImplId,
    ) -> Maybe<ImplImplDefId>;
    fn is_implicit_impl_impl(
        &self,
        key0: ImplDefId,
        key1: TraitImplId,
    ) -> Maybe<bool>;
    fn impl_constant_by_trait_constant(
        &self,
        key0: ImplDefId,
        key1: TraitConstantId,
    ) -> Maybe<ImplConstantDefId>;
    fn impl_functions(
        &self,
        key0: ImplDefId,
    ) -> Maybe<OrderedHashMap<SmolStr, ImplFunctionId>>;
    fn impl_function_by_trait_function(
        &self,
        key0: ImplDefId,
        key1: TraitFunctionId,
    ) -> Maybe<Option<ImplFunctionId>>;
    fn priv_impl_definition_data(
        &self,
        key0: ImplDefId,
    ) -> Maybe<ImplDefinitionData>;
    fn priv_impl_is_fully_concrete(&self, key0: ImplId) -> bool;
    fn priv_impl_is_var_free(&self, key0: ImplId) -> bool;
    fn impl_type_def_semantic_diagnostics(
        &self,
        key0: ImplTypeDefId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn impl_type_def_resolved_type(&self, key0: ImplTypeDefId) -> Maybe<TypeId>;
    fn impl_type_def_generic_params(
        &self,
        key0: ImplTypeDefId,
    ) -> Maybe<Vec<GenericParam>>;
    fn impl_type_def_attributes(
        &self,
        key0: ImplTypeDefId,
    ) -> Maybe<Vec<Attribute>>;
    fn impl_type_def_resolver_data(
        &self,
        key0: ImplTypeDefId,
    ) -> Maybe<Arc<ResolverData>>;
    fn impl_type_def_trait_type(
        &self,
        key0: ImplTypeDefId,
    ) -> Maybe<TraitTypeId>;
    fn priv_impl_type_semantic_data(
        &self,
        key0: ImplTypeDefId,
    ) -> Maybe<ImplItemTypeData>;
    fn priv_impl_type_def_generic_params_data(
        &self,
        key0: ImplTypeDefId,
    ) -> Maybe<GenericParamsData>;
    fn impl_type_concrete_implized(&self, key0: ImplTypeId) -> Maybe<TypeId>;
    fn impl_constant_def_semantic_diagnostics(
        &self,
        key0: ImplConstantDefId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn impl_constant_def_value(
        &self,
        key0: ImplConstantDefId,
    ) -> Maybe<ConstValueId>;
    fn impl_constant_def_resolver_data(
        &self,
        key0: ImplConstantDefId,
    ) -> Maybe<Arc<ResolverData>>;
    fn impl_constant_def_trait_constant(
        &self,
        key0: ImplConstantDefId,
    ) -> Maybe<TraitConstantId>;
    fn priv_impl_constant_semantic_data(
        &self,
        key0: ImplConstantDefId,
    ) -> Maybe<ImplItemConstantData>;
    fn impl_constant_implized_by_context(
        &self,
        key0: ImplConstantId,
        key1: ImplDefId,
    ) -> Maybe<ConstValueId>;
    fn impl_constant_concrete_implized_value(
        &self,
        key0: ImplConstantId,
    ) -> Maybe<ConstValueId>;
    fn impl_constant_concrete_implized_type(
        &self,
        key0: ImplConstantId,
    ) -> Maybe<TypeId>;
    fn impl_impl_def_semantic_diagnostics(
        &self,
        key0: ImplImplDefId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn impl_impl_def_resolver_data(
        &self,
        key0: ImplImplDefId,
    ) -> Maybe<Arc<ResolverData>>;
    fn impl_impl_def_trait_impl(
        &self,
        key0: ImplImplDefId,
    ) -> Maybe<TraitImplId>;
    fn impl_impl_def_impl(&self, key0: ImplImplDefId) -> Maybe<ImplId>;
    fn priv_impl_impl_semantic_data(
        &self,
        key0: ImplImplDefId,
    ) -> Maybe<ImplItemImplData>;
    fn priv_impl_impl_def_generic_params_data(
        &self,
        key0: ImplImplDefId,
    ) -> Maybe<GenericParamsData>;
    fn implicit_impl_impl_semantic_diagnostics(
        &self,
        key0: ImplDefId,
        key1: TraitImplId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn implicit_impl_impl_impl(
        &self,
        key0: ImplDefId,
        key1: TraitImplId,
    ) -> Maybe<ImplId>;
    fn priv_implicit_impl_impl_semantic_data(
        &self,
        key0: ImplDefId,
        key1: TraitImplId,
    ) -> Maybe<ImplicitImplImplData>;
    fn impl_impl_implized_by_context(
        &self,
        key0: ImplImplId,
        key1: ImplDefId,
    ) -> Maybe<ImplId>;
    fn impl_impl_concrete_implized(&self, key0: ImplImplId) -> Maybe<ImplId>;
    fn impl_impl_concrete_trait(
        &self,
        key0: ImplImplId,
    ) -> Maybe<ConcreteTraitId>;
    fn impl_function_declaration_diagnostics(
        &self,
        key0: ImplFunctionId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn impl_function_signature(&self, key0: ImplFunctionId) -> Maybe<Signature>;
    fn impl_function_generic_params(
        &self,
        key0: ImplFunctionId,
    ) -> Maybe<Vec<GenericParam>>;
    fn priv_impl_function_generic_params_data(
        &self,
        key0: ImplFunctionId,
    ) -> Maybe<GenericParamsData>;
    fn impl_function_attributes(
        &self,
        key0: ImplFunctionId,
    ) -> Maybe<Vec<Attribute>>;
    fn impl_function_resolver_data(
        &self,
        key0: ImplFunctionId,
    ) -> Maybe<Arc<ResolverData>>;
    fn impl_function_declaration_inline_config(
        &self,
        key0: ImplFunctionId,
    ) -> Maybe<InlineConfiguration>;
    fn impl_function_declaration_implicit_precedence(
        &self,
        key0: ImplFunctionId,
    ) -> Maybe<ImplicitPrecedence>;
    fn impl_function_declaration_implicits(
        &self,
        key0: ImplFunctionId,
    ) -> Maybe<Vec<TypeId>>;
    fn impl_function_trait_function(
        &self,
        key0: ImplFunctionId,
    ) -> Maybe<TraitFunctionId>;
    fn priv_impl_function_declaration_data(
        &self,
        key0: ImplFunctionId,
    ) -> Maybe<ImplFunctionDeclarationData>;
    fn impl_function_body_diagnostics(
        &self,
        key0: ImplFunctionId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn impl_function_body(
        &self,
        key0: ImplFunctionId,
    ) -> Maybe<Arc<FunctionBody>>;
    fn impl_function_body_resolver_data(
        &self,
        key0: ImplFunctionId,
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_impl_function_body_data(
        &self,
        key0: ImplFunctionId,
    ) -> Maybe<FunctionBodyData>;
    fn trait_type_implized_by_context(
        &self,
        key0: TraitTypeId,
        key1: ImplDefId,
    ) -> Maybe<TypeId>;
    fn free_function_declaration_diagnostics(
        &self,
        key0: FreeFunctionId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn free_function_signature(&self, key0: FreeFunctionId) -> Maybe<Signature>;
    fn free_function_declaration_implicits(
        &self,
        key0: FreeFunctionId,
    ) -> Maybe<Vec<TypeId>>;
    fn free_function_declaration_implicit_precedence(
        &self,
        key0: FreeFunctionId,
    ) -> Maybe<ImplicitPrecedence>;
    fn free_function_generic_params(
        &self,
        key0: FreeFunctionId,
    ) -> Maybe<Vec<GenericParam>>;
    fn free_function_generic_params_data(
        &self,
        key0: FreeFunctionId,
    ) -> Maybe<GenericParamsData>;
    fn free_function_declaration_resolver_data(
        &self,
        key0: FreeFunctionId,
    ) -> Maybe<Arc<ResolverData>>;
    fn free_function_declaration_inline_config(
        &self,
        key0: FreeFunctionId,
    ) -> Maybe<InlineConfiguration>;
    fn priv_free_function_declaration_data(
        &self,
        key0: FreeFunctionId,
    ) -> Maybe<FunctionDeclarationData>;
    fn free_function_body_diagnostics(
        &self,
        key0: FreeFunctionId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn free_function_body_resolver_data(
        &self,
        key0: FreeFunctionId,
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_free_function_body_data(
        &self,
        key0: FreeFunctionId,
    ) -> Maybe<FunctionBodyData>;
    fn function_declaration_diagnostics(
        &self,
        key0: FunctionWithBodyId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn function_declaration_inline_config(
        &self,
        key0: FunctionWithBodyId,
    ) -> Maybe<InlineConfiguration>;
    fn function_declaration_implicit_precedence(
        &self,
        key0: FunctionWithBodyId,
    ) -> Maybe<ImplicitPrecedence>;
    fn function_with_body_signature(
        &self,
        key0: FunctionWithBodyId,
    ) -> Maybe<Signature>;
    fn function_with_body_generic_params(
        &self,
        key0: FunctionWithBodyId,
    ) -> Maybe<Vec<GenericParam>>;
    fn function_with_body_attributes(
        &self,
        key0: FunctionWithBodyId,
    ) -> Maybe<Vec<Attribute>>;
    fn function_body_diagnostics(
        &self,
        key0: FunctionWithBodyId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn function_body_expr(&self, key0: FunctionWithBodyId) -> Maybe<ExprId>;
    fn function_body(
        &self,
        key0: FunctionWithBodyId,
    ) -> Maybe<Arc<FunctionBody>>;
    fn priv_extern_function_declaration_data(
        &self,
        key0: ExternFunctionId,
    ) -> Maybe<FunctionDeclarationData>;
    fn extern_function_declaration_inline_config(
        &self,
        key0: ExternFunctionId,
    ) -> Maybe<InlineConfiguration>;
    fn extern_function_declaration_diagnostics(
        &self,
        key0: ExternFunctionId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn extern_function_signature(
        &self,
        key0: ExternFunctionId,
    ) -> Maybe<Signature>;
    fn extern_function_declaration_generic_params(
        &self,
        key0: ExternFunctionId,
    ) -> Maybe<Vec<GenericParam>>;
    fn extern_function_declaration_generic_params_data(
        &self,
        key0: ExternFunctionId,
    ) -> Maybe<GenericParamsData>;
    fn extern_function_declaration_implicits(
        &self,
        key0: ExternFunctionId,
    ) -> Maybe<Vec<TypeId>>;
    fn extern_function_declaration_refs(
        &self,
        key0: ExternFunctionId,
    ) -> Maybe<Vec<Parameter>>;
    fn extern_function_declaration_resolver_data(
        &self,
        key0: ExternFunctionId,
    ) -> Maybe<Arc<ResolverData>>;
    fn priv_extern_type_declaration_data(
        &self,
        key0: ExternTypeId,
    ) -> Maybe<ExternTypeDeclarationData>;
    fn extern_type_declaration_diagnostics(
        &self,
        key0: ExternTypeId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn extern_type_declaration_generic_params(
        &self,
        key0: ExternTypeId,
    ) -> Maybe<Vec<GenericParam>>;
    fn extern_type_declaration_generic_params_data(
        &self,
        key0: ExternTypeId,
    ) -> Maybe<GenericParamsData>;
    fn extern_type_attributes(
        &self,
        key0: ExternTypeId,
    ) -> Maybe<Vec<Attribute>>;
    fn function_title_signature(
        &self,
        key0: FunctionTitleId,
    ) -> Maybe<Signature>;
    fn function_title_generic_params(
        &self,
        key0: FunctionTitleId,
    ) -> Maybe<Vec<GenericParam>>;
    fn concrete_function_signature(&self, key0: FunctionId) -> Maybe<Signature>;
    fn generic_type_generic_params(
        &self,
        key0: GenericTypeId,
    ) -> Maybe<Vec<GenericParam>>;
    fn generic_param_semantic(
        &self,
        key0: GenericParamId,
    ) -> Maybe<GenericParam>;
    fn generic_param_diagnostics(
        &self,
        key0: GenericParamId,
    ) -> Diagnostics<SemanticDiagnostic>;
    fn generic_param_resolver_data(
        &self,
        key0: GenericParamId,
    ) -> Maybe<Arc<ResolverData>>;
    fn generic_impl_param_trait(&self, key0: GenericParamId) -> Maybe<TraitId>;
    fn priv_generic_param_data(
        &self,
        key0: GenericParamId,
    ) -> Maybe<GenericParamData>;
    fn single_value_type(&self, key0: TypeId) -> Maybe<bool>;
    fn type_size_info(&self, key0: TypeId) -> Maybe<TypeSizeInformation>;
    fn type_info(
        &self,
        key0: ImplLookupContext,
        key1: TypeId,
    ) -> Maybe<TypeInfo>;
    fn priv_type_is_fully_concrete(&self, key0: TypeId) -> bool;
    fn priv_type_is_var_free(&self, key0: TypeId) -> bool;
    fn expr_semantic(&self, key0: FunctionWithBodyId, key1: ExprId) -> Expr;
    fn pattern_semantic(
        &self,
        key0: FunctionWithBodyId,
        key1: PatternId,
    ) -> Pattern;
    fn statement_semantic(
        &self,
        key0: FunctionWithBodyId,
        key1: StatementId,
    ) -> Statement;
    fn lookup_resolved_generic_item_by_ptr(
        &self,
        key0: LookupItemId,
        key1: TerminalIdentifierPtr,
    ) -> Option<ResolvedGenericItem>;
    fn lookup_resolved_concrete_item_by_ptr(
        &self,
        key0: LookupItemId,
        key1: TerminalIdentifierPtr,
    ) -> Option<ResolvedConcreteItem>;
    fn module_semantic_diagnostics(
        &self,
        key0: ModuleId,
    ) -> Maybe<Diagnostics<SemanticDiagnostic>>;
    fn file_semantic_diagnostics(
        &self,
        key0: FileId,
    ) -> Maybe<Diagnostics<SemanticDiagnostic>>;
    fn core_crate(&self) -> CrateId;
    fn core_module(&self) -> ModuleId;
    fn core_felt252_ty(&self) -> TypeId;
    fn 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 methods_in_module(
        &self,
        key0: ModuleId,
        key1: TypeFilter,
    ) -> Arc<[TraitFunctionId]>;
    fn methods_in_crate(
        &self,
        key0: CrateId,
        key1: TypeFilter,
    ) -> Arc<[TraitFunctionId]>;
}

Required Methods

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Private query to compute data about a constant definition.

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

Returns the semantic diagnostics of a constant definition.

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

Returns the semantic data of a constant definition.

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

fn constant_const_value(&self, key0: ConstantId) -> Maybe<ConstValue>

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

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

Private query to compute data about a use.

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

Returns the semantic diagnostics of a use.

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

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

Private query to compute data about the module.

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

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

fn module_item_info_by_name( &self, key0: ModuleId, key1: 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_attributes(&self, key0: ModuleId) -> Maybe<Vec<Attribute>>

Returns the attributes of a module.

fn module_usable_trait_ids( &self, key0: ModuleId, ) -> Maybe<Arc<OrderedHashSet<TraitId>>>

Finds all the trait ids usable in the module.

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

Private query to compute data about a struct declaration.

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

Returns the declaration diagnostics of a struct.

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

Returns the attributes of a struct.

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

Returns the generic parameters of an enum.

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

Returns the generic parameters data of an enum.

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

Returns the resolution resolved_items of a struct declaration.

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

Private query to compute data about a struct definition.

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

Returns the semantic diagnostics of a struct definition.

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

Returns the members of a struct.

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

Returns the resolution resolved_items of a struct definition.

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

Private query to compute data about an enum declaration.

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

Returns the diagnostics of an enum declaration.

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

Returns the generic parameters of an enum.

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

Returns the generic parameters data of an enum.

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

Returns the attributes attached to an enum.

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

Returns the resolution resolved_items of an enum declaration.

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

Private query to compute data about an enum definition.

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

Returns the definition diagnostics of an enum definition.

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

Returns the members of an enum.

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

Returns the semantic model of a variant.

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

Returns the resolution resolved_items of an enum definition.

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

Returns the semantic diagnostics of a type alias.

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

Returns the resolved type of a type alias.

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

Returns the generic parameters of a type alias.

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

Returns the resolution resolved_items of a type alias.

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

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

fn priv_module_type_alias_semantic_data( &self, key0: ModuleTypeAliasId, ) -> Maybe<ModuleTypeAliasData>

Private query to compute data about a type alias.

fn impl_alias_impl_def(&self, key0: 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, key0: ImplAliasId, ) -> Maybe<ImplAliasData>

Private query to compute data about a type alias.

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

Returns the semantic diagnostics of a type alias.

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

Returns the resolved type of a type alias.

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

Returns the generic parameters of a type alias.

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

Returns the generic parameters data of a type alias.

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

Returns the resolution resolved_items of a type alias.

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

Returns the attributes attached to the impl alias.

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

Returns the semantic declaration diagnostics of a trait.

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

Returns the generic parameters of a trait.

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

Returns the generic parameters data of a trait.

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

Returns the attributes of a trait.

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

Returns the resolution resolved_items of a trait.

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

Private query to compute declaration data about a trait.

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

Returns the semantic definition diagnostics of a trait.

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

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

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

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

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

Returns the functions of a trait.

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

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

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

Returns the types of a trait.

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

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

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

Returns the constants of a trait.

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

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

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

Returns the constants of a trait.

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

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

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

Private query to compute definition data about a trait.

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

Returns the semantic diagnostics of a trait type.

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

Returns the generic params of a trait type.

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

Returns the attributes of a trait type.

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

Returns the resolution resolved_items of a trait type.

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

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

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

Private query to compute data about a trait type.

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

Returns the semantic diagnostics of a trait type.

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

Returns the attributes of a trait constants.

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

Returns the type of a trait constant.

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

Returns the resolution resolved_items of a trait constants.

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

Private query to compute data about a trait constant.

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

Returns the type of a trait constant.

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

Returns the semantic diagnostics of a trait impls.

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

Returns the attributes of a trait impls.

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

Returns the concrete trait of a trait impl.

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

Returns the resolution resolved_items of a trait impls.

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

Private query to compute data about a trait impl.

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

Returns the concrete trait of a concrete trait impl.

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

Returns the semantic diagnostics of a trait function.

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

Returns the signature of a trait function.

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

Returns the generic params of a trait function.

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

Returns the generic params data of a trait function.

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

Returns the attributes of a trait function.

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

Returns the resolution resolved_items of a trait function.

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

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

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

Returns the implicits precedence of a trait function.

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

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

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

Private query to compute data about a trait function declaration.

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

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

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

Returns the body of a trait function, if any.

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

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

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

Returns the generic params of a concrete trait function.

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

Returns the signature of a concrete trait function.

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

Returns candidate ImplDefIds for a specific trait lookup constraint.

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

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

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

Returns the semantic declaration diagnostics of an impl.

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

Returns the generic parameters data of an impl.

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

Returns the generic parameters of an impl.

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

Returns the resolution resolved_items of an impl.

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

Returns the concrete trait that is implemented by the impl.

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

Returns the substitution for generics for the impl.

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

Returns the attributes attached to the impl.

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

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

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

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

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

Private query to compute declaration data about an impl.

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

Returns the semantic definition diagnostics of an impl.

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

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

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

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

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

Returns the type items in the impl.

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

Returns the ids of the type items in the impl.

fn impl_type_by_id(&self, key0: 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, key0: ImplDefId, key1: TraitTypeId, ) -> Maybe<ImplTypeDefId>

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

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

Returns the constant items in the impl.

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

Returns the impls items in the impl.

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

Returns the ids of the impl items in the impl.

fn impl_impl_by_id(&self, key0: 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, key0: ImplDefId, key1: TraitImplId, ) -> Maybe<ImplImplDefId>

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

fn is_implicit_impl_impl( &self, key0: ImplDefId, key1: TraitImplId, ) -> Maybe<bool>

Returns whether trait_impl_id is an implicit impl in impl_def_id.

fn impl_constant_by_trait_constant( &self, key0: ImplDefId, key1: TraitConstantId, ) -> Maybe<ImplConstantDefId>

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

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

Returns the functions in the impl.

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

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

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

Private query to compute definition data about an impl.

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

Private query to check if an impl is fully concrete.

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

Private query to check if an impl contains no variables.

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

Returns the semantic diagnostics of an impl item type.

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

Returns the resolved type of an impl item type.

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

Returns the generic parameters of an impl item type.

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

Returns the attributes of an impl type.

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

Returns the resolution resolved_items of an impl item type.

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

Returns the trait type of an impl type.

fn priv_impl_type_semantic_data( &self, key0: ImplTypeDefId, ) -> Maybe<ImplItemTypeData>

Private query to compute data about an impl item type.

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

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

fn impl_type_concrete_implized(&self, key0: 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, key0: ImplConstantDefId, ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic diagnostics of an impl item constant.

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

Returns the resolved constant value of an impl item constant.

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

Returns the resolution resolved_items of an impl item constant.

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

Returns the type of an impl item constant.

fn priv_impl_constant_semantic_data( &self, key0: ImplConstantDefId, ) -> Maybe<ImplItemConstantData>

Private query to compute data about an impl item constant.

fn impl_constant_implized_by_context( &self, key0: ImplConstantId, key1: ImplDefId, ) -> Maybe<ConstValueId>

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

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

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

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

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

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

Returns the semantic diagnostics of an impl item impl.

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

Returns the resolution resolved_items of an impl item impl.

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

Returns the type of an impl item impl.

fn impl_impl_def_impl(&self, key0: ImplImplDefId) -> Maybe<ImplId>

Returns the resolved impl of an impl item impl.

fn priv_impl_impl_semantic_data( &self, key0: ImplImplDefId, ) -> Maybe<ImplItemImplData>

Private query to compute data about an impl item impl.

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

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

fn implicit_impl_impl_semantic_diagnostics( &self, key0: ImplDefId, key1: TraitImplId, ) -> Diagnostics<SemanticDiagnostic>

Returns the semantic diagnostics of an implicit impl.

fn implicit_impl_impl_impl( &self, key0: ImplDefId, key1: TraitImplId, ) -> Maybe<ImplId>

Returns the resolved impl of an implicit impl.

fn priv_implicit_impl_impl_semantic_data( &self, key0: ImplDefId, key1: TraitImplId, ) -> Maybe<ImplicitImplImplData>

fn impl_impl_implized_by_context( &self, key0: ImplImplId, key1: ImplDefId, ) -> Maybe<ImplId>

Returns the implized impl impl if the impl is concrete.

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

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

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

Returns the concrete trait of an impl impl.

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

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

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

Returns the signature of an impl function.

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

Returns the generic params of an impl function.

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

Returns the generic params data of an impl function.

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

Returns the attributes of an impl function.

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

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

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

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

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

Returns the implicits precedence of an impl function.

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

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

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

Returns the trait function of an impl function.

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

Private query to compute data about an impl function declaration.

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

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

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

Returns the definition of an impl function.

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

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

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

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

fn trait_type_implized_by_context( &self, key0: TraitTypeId, key1: 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, key0: FreeFunctionId, ) -> Diagnostics<SemanticDiagnostic>

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

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

Returns the signature of a free function.

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

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

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

Returns the implicits precedence of a free function.

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

Returns the generic params of a free function.

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

Returns the generic params data of a free function.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Returns the signature of a function with a body.

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

Returns all the available generic params inside a function body.

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

Returns the attributes of a function with a body.

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

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

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

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

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

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

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

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

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

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

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

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

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

Returns the signature of an extern function.

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

Returns the generic params of an extern function.

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

Returns the generic params data of an extern function.

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

Returns the explicit implicits of an extern function declaration.

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

Returns the ref parameters of an extern function declaration.

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

Returns the resolution resolved_items of an extern function.

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

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

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

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

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

Returns the generic params of an extern type.

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

Returns the generic params data of an extern type.

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

Returns the attributes of an extern type.

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

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

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

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

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

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

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

Returns the generic params of a generic type.

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

Returns the semantic data of a generic param.

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

Returns the semantic diagnostics of a generic param.

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

Returns the resolver data of a generic param.

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

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

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

Private query to compute data about a generic param.

fn single_value_type(&self, key0: 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, key0: TypeId) -> Maybe<TypeSizeInformation>

Returns the type size information for the given type.

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

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

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

Private query to check if a type is fully concrete.

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

Private query to check if a type contains no variables.

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

Assumes function and expression are present.

fn pattern_semantic(&self, key0: FunctionWithBodyId, key1: PatternId) -> Pattern

Assumes function and pattern are present.

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

Assumes function and statement are valid.

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

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

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

Aggregates module level semantic diagnostics.

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

Aggregates file level semantic diagnostics.

fn core_crate(&self) -> CrateId

fn core_module(&self) -> ModuleId

fn core_felt252_ty(&self) -> TypeId

fn 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 and 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 methods_in_module( &self, key0: ModuleId, key1: TypeFilter, ) -> Arc<[TraitFunctionId]>

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

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

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

Trait Implementations

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 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 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, 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> 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, 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> Upcast<dyn SemanticGroup> for ExprFormatter<'a>

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