add some more debug! printouts

Author: nikomatsakis

src/librustc/middle/free_region.rs

@@ -161,6 +161,7 @@ impl<'tcx> FreeRegionMap<'tcx> {
     /// Record that `'sup:'sub`. Or, put another way, `'sub <= 'sup`.
     /// (with the exception that `'static: 'x` is not notable)
     pub fn relate_regions(&mut self, sub: Region<'tcx>, sup: Region<'tcx>) {
+        debug!("relate_regions(sub={:?}, sup={:?})", sub, sup);
         if (is_free(sub) || *sub == ty::ReStatic) && is_free(sup) {
             self.relation.add(sub, sup)
         }
@@ -172,9 +173,12 @@ impl<'tcx> FreeRegionMap<'tcx> {
                                       r_a: Region<'tcx>,
                                       r_b: Region<'tcx>)
                                       -> bool {
+        debug!("sub_free_regions(r_a={:?}, r_b={:?})", r_a, r_b);
         assert!(is_free(r_a));
         assert!(is_free(r_b));
-        self.relation.contains(&r_a, &r_b)
+        let result = r_a == r_b || self.relation.contains(&r_a, &r_b);
+        debug!("sub_free_regions: result={}", result);
+        result
     }
 
     /// Compute the least-upper-bound of two free regions. In some
@@ -186,6 +190,7 @@ impl<'tcx> FreeRegionMap<'tcx> {
                                       r_a: Region<'tcx>,
                                       r_b: Region<'tcx>)
                                       -> Region<'tcx> {
+        debug!("lub_free_regions(r_a={:?}, r_b={:?})", r_a, r_b);
         assert!(is_free(r_a));
         assert!(is_free(r_b));
         let result = if r_a == r_b { r_a } else {

src/librustc_typeck/check/mod.rs

@@ -228,6 +228,7 @@ pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
 /// Information about the anonymous, abstract types whose values we
 /// are inferring in this function (these are the `impl Trait` that
 /// appear in the return type).
+#[derive(Debug)]
 struct AnonTypeDecl<'tcx> {
     /// The substitutions that we apply to the abstract that that this
     /// `impl Trait` desugars to. e.g., if:
@@ -1989,8 +1990,8 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                 let ty_var = self.next_ty_var(TypeVariableOrigin::TypeInference(span));
 
                 let predicates_of = self.tcx.predicates_of(def_id);
-                debug!("instantiate_anon_types: predicates_of={:?}", predicates_of);
                 let bounds = predicates_of.instantiate(self.tcx, substs);
+                debug!("instantiate_anon_types: bounds={:?}", bounds);
 
                 let required_region_bounds =
                     self.tcx.required_region_bounds(ty, bounds.predicates.clone());

src/librustc_typeck/check/regionck.rs

@@ -135,7 +135,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                          item_id: ast::NodeId,
                          span: Span,
                          wf_tys: &[Ty<'tcx>]) {
-        debug!("regionck_item(item.id={:?}, wf_tys={:?}", item_id, wf_tys);
+        debug!("regionck_item(item.id={:?}, wf_tys={:?})", item_id, wf_tys);
         let subject = self.tcx.hir.local_def_id(item_id);
         let mut rcx = RegionCtxt::new(self, RepeatingScope(item_id), item_id, Subject(subject));
         rcx.free_region_map.relate_free_regions_from_predicates(
@@ -468,7 +468,7 @@ impl<'a, 'gcx, 'tcx> RegionCtxt<'a, 'gcx, 'tcx> {
             let concrete_ty = self.resolve_type(anon_defn.concrete_ty);
 
             debug!("constrain_anon_types: def_id={:?}", def_id);
-            debug!("constrain_anon_types: substs={:?}", anon_defn.substs);
+            debug!("constrain_anon_types: anon_defn={:#?}", anon_defn);
             debug!("constrain_anon_types: concrete_ty={:?}", concrete_ty);
 
             let abstract_type_generics = self.tcx.generics_of(def_id);