Struct CallStringResolver

pub struct CallStringResolver<'tcx, 'a> {
    cache: Cache<CallString, Instance<'tcx>>,
    tcx: TyCtxt<'tcx>,
    entrypoint_is_async: bool,
    body_cache: &'a BodyCache<'tcx>,
    marker_context: MarkerCtx<'tcx>,
    base: OnceCell<Instance<'tcx>>,
}

Cached resolution of CallStrings to Instances.

Only valid for a single controller. Each controller should initialize a new resolver.

Fields

cache: Cache<CallString, Instance<'tcx>>

tcx: TyCtxt<'tcx>

entrypoint_is_async: bool

body_cache: &'a BodyCache<'tcx>

marker_context: MarkerCtx<'tcx>

base: OnceCell<Instance<'tcx>>

Implementations

impl<'tcx, 'a> CallStringResolver<'tcx, 'a>

pub fn resolve(&self, cs: CallString) -> Instance<'tcx>

Tries to resolve to the monomophized function in which this call site exists. That is to say that return.def_id() == cs.leaf().function.

Unlike Self::resolve_internal this can be called on any valid CallString.

pub fn new( tcx: TyCtxt<'tcx>, entrypoint: Endpoint, body_cache: &'a BodyCache<'tcx>, marker_context: MarkerCtx<'tcx>, ) -> Self

fn resolve_internal(&self, cs: CallString) -> Instance<'tcx>

This resolves the monomorphized function being called at this call site.

This function is internal because it panics if cs.leaf().location is not either a function call or a statement where an async closure is created and assigned.