Added more debugging output.

Author: ibabushkin

src/bin/cargo_semver.rs

@@ -135,6 +135,7 @@ impl<'a> WorkInfo<'a> {
 /// and/or defaults, and dispatch the actual analysis.
 // TODO: possibly reduce the complexity by finding where some info can be taken from directly
 fn do_main(config: &Config, matches: &Matches) -> CargoResult<()> {
+    debug!("running cargo-semver");
     fn parse_arg(opt: &str) -> CargoResult<NameAndVersion> {
         let mut split = opt.split('-');
         let name = if let Some(n) = split.next() {
@@ -196,6 +197,8 @@ fn do_main(config: &Config, matches: &Matches) -> CargoResult<()> {
         return Ok(());
     }
 
+    debug!("running rust-semverver on compiled crates");
+
     let mut child = Command::new("rust-semverver")
         .arg("--crate-type=lib")
         .args(&["--extern", &*format!("old={}", stable_rlib.display())])

src/bin/rust_semverver.rs

@@ -31,7 +31,6 @@ use syntax::ast;
 /// find their root modules and then proceed to walk their module trees.
 fn callback(state: &driver::CompileState, version: &str) {
     let tcx = state.tcx.unwrap();
-    // let cstore = &tcx.sess.cstore;
 
     let cnums = tcx
         .crates()
@@ -61,6 +60,7 @@ fn callback(state: &driver::CompileState, version: &str) {
         return;
     };
 
+    debug!("running semver analysis");
     let changes = run_analysis(tcx, old_def_id, new_def_id);
 
     changes.output(tcx.sess, version);
@@ -135,6 +135,7 @@ impl<'a> CompilerCalls<'a> for SemVerVerCompilerCalls {
         controller.after_analysis.callback = box move |state| {
             debug!("running rust-semverver after_analysis callback");
             callback(state, &version);
+            debug!("running other after_analysis callback");
             old_callback(state);
         };
         controller.after_analysis.stop = Compilation::Stop;

src/semcheck/mismatch.rs

@@ -45,13 +45,16 @@ impl<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> MismatchRelation<'a, 'gcx, 'tcx> {
         use rustc::hir::def::Def::*;
 
         while let Some((old_def_id, new_def_id)) = self.item_queue.pop_front() {
+            debug!("processing mismatch item pair, remaining: {}", self.item_queue.len());
+            debug!("old: {:?}, new: {:?}", old_def_id, new_def_id);
             match self.tcx.describe_def(old_def_id) {
                 Some(Trait(_)) | Some(Macro(_, _)) => continue,
                 _ => (),
             }
 
             let old_ty = self.tcx.type_of(old_def_id);
             let new_ty = self.tcx.type_of(new_def_id);
+            debug!("relating item pair");
             let _ = self.relate(&old_ty, &new_ty);
         }
     }
@@ -90,12 +93,14 @@ impl<'a, 'gcx, 'tcx> TypeRelation<'a, 'gcx, 'tcx> for MismatchRelation<'a, 'gcx,
     }
 
     fn relate<T: Relate<'tcx>>(&mut self, a: &T, b: &T) -> RelateResult<'tcx, T> {
+        debug!("relate: mismatch relation: a: {:?}, b: {:?}", a, b);
         Relate::relate(self, a, b)
     }
 
     fn tys(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> {
         use rustc::ty::TypeVariants::*;
 
+        debug!("tys: mismatch relation: a: {:?}, b: {:?}", a, b);
         let matching = match (&a.sty, &b.sty) {
             (&TyAdt(a_def, a_substs), &TyAdt(b_def, b_substs)) => {
                 if self.check_substs(a_substs, b_substs) {

src/semcheck/traverse.rs

@@ -36,20 +36,25 @@ pub fn run_analysis<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, old: DefId, new: DefI
     let mut id_mapping = IdMapping::new(old.krate, new.krate);
 
     // first pass
+    debug!("first pass started");
     diff_structure(&mut changes, &mut id_mapping, tcx, old, new);
 
     // second pass
+    debug!("second pass started");
     {
         let mut mismatch = MismatchRelation::new(tcx, &mut id_mapping);
+        debug!("constructed mismatch relation");
         mismatch.process();
     }
 
     // third pass
+    debug!("third pass started");
     for (old, new) in id_mapping.items() {
         diff_types(&mut changes, &id_mapping, tcx, old, new);
     }
 
     // fourth pass on impls
+    debug!("fourth pass started");
     diff_inherent_impls(&mut changes, &id_mapping, tcx);
     diff_trait_impls(&mut changes, &id_mapping, tcx);
 

tests/full.rs

@@ -27,8 +27,7 @@ macro_rules! full_test {
     # sanitize paths
     gsub(/-->.*"#, $crate_name, r#"/, "--> "#, $crate_name, r#"", $0);
     print;
-}
-                               "#, $crate_name, $crate_name);
+}"#, $crate_name, $crate_name);
             let out_file = Path::new("tests/full_cases")
                 .join(concat!($crate_name, "-", $old_version, "-", $new_version));