Struct ApiDependencyGraph 

pub struct ApiDependencyGraph<'tcx> {
    graph: Graph<DepNode<'tcx>, DepEdge>,
    node_indices: HashMap<DepNode<'tcx>, NodeIndex>,
    ty_nodes: Vec<NodeIndex>,
    api_nodes: Vec<NodeIndex>,
    tcx: TyCtxt<'tcx>,
}

Fields

graph: Graph<DepNode<'tcx>, DepEdge>

node_indices: HashMap<DepNode<'tcx>, NodeIndex>

ty_nodes: Vec<NodeIndex>

api_nodes: Vec<NodeIndex>

tcx: TyCtxt<'tcx>

Implementations

impl<'tcx> ApiDependencyGraph<'tcx>

pub fn eligible_nodes_with(&self, tys: &[Ty<'tcx>]) -> Vec<DepNode<'tcx>>

pub fn eligible_transforms_to( &self, ty: Ty<'tcx>, ) -> Vec<(TyWrapper<'tcx>, TransformKind)>

impl<'tcx> ApiDependencyGraph<'tcx>

pub fn dump_to_file(&self, path: impl AsRef<Path>) -> Result<()>

impl<'tcx> ApiDependencyGraph<'tcx>

pub fn dump_to_dot(&self) -> String

impl<'tcx> ApiDependencyGraph<'tcx>

pub fn resolve_generic_api( &mut self, non_generic_apis: &[DefId], generic_apis: &[DefId], max_iteration: usize, )

pub fn search_reachable_apis( &mut self, non_generic_apis: &[DefId], generic_apis: &[DefId], max_iteration: usize, ) -> HashMap<DefId, HashSet<Mono<'tcx>>>

pub fn add_mono_apis_from_map( &mut self, generic_map: &HashMap<DefId, HashSet<Mono<'tcx>>>, )

pub fn heuristic_select(&mut self, reserved: &mut [bool])

heuristic strategy: prioritize to reserve APIs that first arg of which is reachable. This is based on that we want to reserve APIs that have the same Self type ASAP.

pub fn minimal_select( &mut self, reserved: &mut [bool], generic_map: &HashMap<DefId, HashSet<Mono<'tcx>>>, )

pub fn prune_by_similarity( &mut self, generic_map: HashMap<DefId, HashSet<Mono<'tcx>>>, ) -> Vec<bool>

pub fn reserve_nodes(&mut self, reserved: &[bool]) -> usize

pub fn propagate_reserved( &self, node: NodeIndex, visited: &mut [bool], reserved: &mut [bool], ) -> bool

impl<'tcx> ApiDependencyGraph<'tcx>

pub fn update_transform_edges(&mut self)

fn add_possible_transform<const MAX_DEPTH: usize>( &mut self, current_ty: TyWrapper<'tcx>, depth: usize, ) -> Option<NodeIndex>

impl<'tcx> ApiDependencyGraph<'tcx>

pub fn new(tcx: TyCtxt<'tcx>) -> ApiDependencyGraph<'tcx>

pub fn num_api(&self) -> usize

pub fn num_ty(&self) -> usize

pub fn api_node_at(&self, idx: usize) -> DepNode<'tcx>

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

pub fn build(&mut self, config: &Config)

pub fn inner_graph(&self) -> &Graph<DepNode<'tcx>, DepEdge>

pub fn statistics(&self) -> Statistics

pub fn is_node_exist(&self, node: &DepNode<'tcx>) -> bool

pub fn get_or_create_index(&mut self, node: DepNode<'tcx>) -> NodeIndex

pub fn get_node_from_index(&self, index: NodeIndex) -> DepNode<'tcx>

pub fn get_index_by_ty(&self, ty: Ty<'tcx>) -> Option<NodeIndex>

pub fn get_index(&self, node: DepNode<'tcx>) -> Option<NodeIndex>

pub fn add_edge(&mut self, src: NodeIndex, dst: NodeIndex, edge: DepEdge)

pub fn add_edge_once(&mut self, src: NodeIndex, dst: NodeIndex, edge: DepEdge)

pub fn add_identity_api(&mut self, fn_did: DefId) -> bool

pub fn add_api(&mut self, fn_did: DefId, args: &[GenericArg<'tcx>]) -> bool

return true if the api is added successfully, false if it already exists.

pub fn all_transforms(&self, ty: Ty<'tcx>) -> Vec<TransformKind>

return all transform kind for ty that we intersted in.

pub fn is_start_node_index(&self, index: NodeIndex) -> bool

pub fn depth_map(&self) -> HashMap<DepNode<'tcx>, usize>

pub fn traverse_covered_api_with( &self, f_cover: &mut impl FnMut(DefId), f_total: &mut impl FnMut(DefId), )

fn recache(&mut self)

pub fn uncovered_api(&self) -> Vec<DefId>

pub fn estimate_coverage(&self) -> (usize, usize)

estimate_coverage treat each API as the distinct API. For example, if foo<T>, foo<U> are covered, this API return (2, 2).

pub fn estimate_coverage_distinct(&self) -> (usize, usize)

estimate_coverage_distinct treat mono API as the original generic API. For example, if foo<T>, foo<U> are covered, this API return (1, 1).

pub fn dump_apis<P: AsRef<Path>>(&self, path: P)

Trait Implementations

impl<'tcx> Clone for ApiDependencyGraph<'tcx>

fn clone(&self) -> ApiDependencyGraph<'tcx>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'tcx> Serialize for ApiDependencyGraph<'tcx>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.