[api-dep] feat: improve api-dep performance (#108)

* feat: complete api dependency graph generation

* remove redundant comment, keep lifetime.rs empty

* fix cargo fmt --check

* refactor graph structure, add generic node in api dep graph

* feat: refactor DepNode structure and use a better method to collect generic parameters

* fix cargo fmt check

* feat: extract lifetime constraint by subtyping

* update api-dep

Author: WIZeaz

rapx/src/analysis/api_dep/extract.rs

@@ -4,7 +4,7 @@ use rustc_hir::def_id::DefId;
 use rustc_infer::infer::region_constraints::Constraint;
 use rustc_infer::infer::{self, InferCtxt, TyCtxtInferExt};
 use rustc_infer::traits::ObligationCause;
-use rustc_middle::ty::{self, Ty, TyCtxt, TypeFoldable};
+use rustc_middle::ty::{self, TyCtxt, TypeFoldable};
 use rustc_span::Span;
 struct FreeVarFolder<'tcx, 'a> {
     cx: TyCtxt<'tcx>,
@@ -32,7 +32,7 @@ impl<'tcx> ty::TypeFolder<TyCtxt<'tcx>> for FreeVarFolder<'tcx, '_> {
     fn cx(&self) -> TyCtxt<'tcx> {
         self.cx
     }
-    fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
+    fn fold_region(&mut self, _: ty::Region<'tcx>) -> ty::Region<'tcx> {
         self.free_var_cnt += 1;
         self.infcx
             .next_region_var(infer::RegionVariableOrigin::BorrowRegion(self.span))

rapx/src/analysis/api_dep/graph.rs

@@ -20,6 +20,13 @@ pub struct ApiDepGraph<'tcx> {
     node_indices: HashMap<DepNode<'tcx>, NodeIndex>,
 }
 
+pub struct Statistics {
+    pub api_count: usize,
+    pub type_count: usize,
+    pub generic_param_count: usize,
+    pub edge_cnt: usize,
+}
+
 impl<'tcx> ApiDepGraph<'tcx> {
     pub fn new() -> ApiDepGraph<'tcx> {
         ApiDepGraph {
@@ -32,6 +39,32 @@ impl<'tcx> ApiDepGraph<'tcx> {
         &self.graph
     }
 
+    pub fn statistics(&self) -> Statistics {
+        let mut api_cnt = 0;
+        let mut ty_cnt = 0;
+        let mut generic_param_cnt = 0;
+        let mut edge_cnt = 0;
+
+        for node in self.graph.node_indices() {
+            match self.graph[node] {
+                DepNode::Api(_) => api_cnt += 1,
+                DepNode::Ty(_) => ty_cnt += 1,
+                DepNode::GenericParamDef(..) => generic_param_cnt += 1,
+            }
+        }
+
+        for edge in self.graph.edge_indices() {
+            edge_cnt += 1;
+        }
+
+        Statistics {
+            api_count: api_cnt,
+            type_count: ty_cnt,
+            generic_param_count: generic_param_cnt,
+            edge_cnt,
+        }
+    }
+
     pub fn get_node(&mut self, node: DepNode<'tcx>) -> NodeIndex {
         if let Some(node_index) = self.node_indices.get(&node) {
             *node_index

rapx/src/analysis/api_dep/graph/ty_wrapper.rs

@@ -190,7 +190,7 @@ pub fn desc_ty_str<'tcx>(ty: Ty<'tcx>, no: &mut usize, tcx: TyCtxt<'tcx>) -> Str
     match ty.kind() {
         ty::TyKind::Adt(adt_def, generic_arg) => {
             let mut ty_str = tcx.def_path_str(adt_def.did());
-            if (!generic_arg.is_empty()) {
+            if !generic_arg.is_empty() {
                 ty_str += "<";
                 ty_str += &generic_arg
                     .iter()

rapx/src/analysis/api_dep/mod.rs

@@ -1,19 +1,16 @@
 mod extract;
 mod graph;
 mod lifetime;
-mod ty;
 mod visitor;
-use crate::{rap_info, utils::fs::rap_create_file};
+use crate::{rap_debug, rap_info};
 use graph::ApiDepGraph;
 use rustc_hir::{
-    def_id::{DefId, LocalDefId},
+    def_id::{DefId, LocalDefId, LOCAL_CRATE},
     intravisit::{self, FnKind, Visitor},
     BodyId, FnDecl,
 };
-use rustc_middle::{dep_graph, ty::TyCtxt};
-use rustc_span::Span;
+use rustc_middle::ty::TyCtxt;
 
-use std::io::Write;
 use visitor::FnVisitor;
 
 pub struct ApiDep<'tcx> {
@@ -24,31 +21,34 @@ impl<'tcx> ApiDep<'tcx> {
     pub fn new(tcx: TyCtxt<'tcx>) -> ApiDep<'tcx> {
         ApiDep { tcx }
     }
-    pub fn start(&self) {
-        rap_info!("Build API dependency graph");
+    pub fn start(&self) -> ApiDepGraph<'tcx> {
+        let local_crate_name = self.tcx.crate_name(LOCAL_CRATE);
+        let local_crate_type = self.tcx.crate_types()[0];
+        rap_debug!(
+            "Build API dependency graph on {} ({})",
+            local_crate_name.as_str(),
+            local_crate_type
+        );
+
         let mut api_graph = ApiDepGraph::new();
         let mut fn_visitor = FnVisitor::new(self.tcx, &mut api_graph);
         self.tcx
             .hir()
             .visit_all_item_likes_in_crate(&mut fn_visitor);
-        rap_info!("visitor find {} APIs.", fn_visitor.fn_cnt());
-        let mut file = rap_create_file("visitor.txt", "fail when create file");
-        fn_visitor.write_funcs(&mut file);
+        rap_debug!("api-dep find {} APIs.", fn_visitor.fn_cnt());
 
-        api_graph.dump_to_dot("api_graph.dot", self.tcx);
+        let statistics = api_graph.statistics();
+        // print all statistics
+        rap_debug!(
+            "API Graph contains {} API nodes, {} type nodes, {} generic parameter def nodes",
+            statistics.api_count,
+            statistics.type_count,
+            statistics.generic_param_count
+        );
 
-        let mut file = rap_create_file("traverse.txt", "fail when create file");
-        let mut fn_cnt = 0;
-        // TODO: try self.tcx.mir_keys(())
-        for local_def_id in self.tcx.iter_local_def_id() {
-            let hir_map = self.tcx.hir();
-            if hir_map.maybe_body_owned_by(local_def_id).is_some() {
-                write!(&mut file, "{}\n", self.tcx.def_path_str(local_def_id))
-                    .expect("fail when write file");
-                // rap_info!("find API: {}", self.tcx.def_path_str(local_def_id));
-                fn_cnt += 1;
-            }
-        }
-        rap_info!("find {} APIs.", fn_cnt);
+        let dot_filename = format!("api_graph_{}_{}.dot", local_crate_name, local_crate_type);
+        rap_info!("Dump API dependency graph to {}", dot_filename);
+        api_graph.dump_to_dot(dot_filename, self.tcx);
+        api_graph
     }
 }