Struct DelegationResolver 

pub(crate) struct DelegationResolver<'a, 'hir>(&'a LoweringContext<'a, 'hir>);

Abstracts operations that are needed for delegation’s resolution, so resolution is independent of LoweringContext. Placed in a separate module so LoweringContext can not be accessed directly.

Tuple Fields

0: &'a LoweringContext<'a, 'hir>

Implementations

impl<'hir> DelegationResolver<'_, 'hir>

fn resolve_generics<'a>( &self, delegation: &'a Delegation, sig_id: DefId, ) -> Result<GenericsResolution<'a, 'hir>, ErrorGuaranteed>

fn get_user_args<'a>( &self, segment: &'a PathSegment, ) -> Option<&'a AngleBracketedArgs>

pub(super) fn resolve_and_generate_generics( &self, delegation: &Delegation, sig_id: DefId, ) -> Result<GenericsGenerationResults<'hir>, ErrorGuaranteed>

fn create_slots_from_args( tcx: TyCtxt<'_>, args: &AngleBracketedArgs, params: &'hir [GenericParamDef], add_first_self: bool, ) -> Vec<GenericArgSlot<&'hir GenericParamDef>>

Generates generic argument slots for user-specified args and generic params of the signature function. This function checks whether there are infers (kw::UnderscoreLifetime or kw::Underscore) in user-specified args, and if so we add Generate slot meaning we have to generate generic param for delegation and propagate it instead of this infer. We zip over user-specified args and signature generic params, so if there are more infers than generic params then we will not process all infers thus not generating more generic params then needed (anyway it is an error).

impl<'a, 'tcx> DelegationResolver<'a, 'tcx>

pub(crate) fn new(ctx: &'a LoweringContext<'a, 'tcx>) -> Self

pub(crate) fn tcx(&self) -> TyCtxt<'tcx>

pub(crate) fn owner_id(&self) -> LocalDefId

pub(crate) fn is_definition(&self, id: NodeId) -> bool

(from tests\ui\delegation\target-expr-removal-defs-inside.rs):

reuse impl Trait for S1 {
    some::path::<{ fn foo() {} }>::xd();
    fn foo() {}
    self.0
}

Constant from unresolved path will be in node_id_to_def_id, fn foo() {} will not be in node_id_to_def_id but will be in owners, both have LocalDefId, so we check those two maps.

pub(crate) fn get_resolution_id( &self, id: NodeId, ) -> Result<DefId, ErrorGuaranteed>

impl<'tcx> DelegationResolver<'_, 'tcx>

pub(super) fn resolve_delegation( &self, delegation: &Delegation, span: Span, ) -> Result<(DelegationResolution, GenericsGenerationResults<'tcx>), ErrorGuaranteed>

fn check_for_cycles( &self, def_id: DefId, span: Span, ) -> Result<(), ErrorGuaranteed>

fn check_block_soundness( &self, delegation: &Delegation, sig_id: DefId, is_method: bool, param_count: usize, ) -> Result<(bool, bool), ErrorGuaranteed>

fn create_sig_mapping( &self, delegation: &Delegation, span: Span, should_generate_block: bool, parent: LocalDefId, sig: FnSig<'tcx>, contains_defs: bool, ) -> Result<SigMapping, ErrorGuaranteed>

fn can_perform_self_mapping( &self, delegation: &Delegation, parent: LocalDefId, ) -> Result<bool, ErrorGuaranteed>

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 8 bytes