checkpoint non-building state for rebase.

Author: pnkfelix

src/librustc/middle/resolve.rs

@@ -1662,6 +1662,10 @@ impl Resolver {
 
                     new_parent.import_resolutions.insert(ident, resolution);
                 }
+
+                debug!("(finished reduced graph for \
+                        external crate) building module \
+                        %s", final_ident);
               }
             }
           }
@@ -1744,6 +1748,7 @@ impl Resolver {
             fail!("didn't expect `%?`", def);
           }
         }
+
     }
 
     /**

src/librustc/middle/typeck/check/mod.rs

@@ -298,15 +298,22 @@ pub fn check_bare_fn(ccx: @mut CrateCtxt,
                      id: ast::node_id,
                      self_info: Option<SelfInfo>) {
     let fty = ty::node_id_to_type(ccx.tcx, id);
+
+    debug!("check_bare_fn decl: %? body: %? id: %? self_info: %?",
+           decl, body, id, self_info);
+
     match ty::get(fty).sty {
         ty::ty_bare_fn(ref fn_ty) => {
+            debug!("check_fn");
             let fcx =
                 check_fn(ccx, self_info, fn_ty.purity,
                          &fn_ty.sig, decl, id, body, Vanilla,
                          @Nil, blank_inherited(ccx));;
-
+            debug!("resolve_in_block");
             vtable::resolve_in_block(fcx, body);
+            debug!("regionck_fn");
             regionck::regionck_fn(fcx, body);
+            debug!("resolve_type_vars_in_fn");
             writeback::resolve_type_vars_in_fn(fcx, decl, body, self_info);
         }
         _ => ccx.tcx.sess.impossible_case(body.span,
@@ -538,6 +545,9 @@ pub fn check_method(ccx: @mut CrateCtxt,
                   span: method.explicit_self.span}
     });
 
+    debug!("check_method def_id: %? ty: %? opt_self_info: %?",
+           method_def_id, method_ty, opt_self_info);
+
     check_bare_fn(
         ccx,
         &method.decl,
@@ -612,6 +622,8 @@ pub fn check_item(ccx: @mut CrateCtxt, it: @ast::item) {
                 // bodies to check.
               }
               provided(m) => {
+                debug!("check provided method ccx, m: %?",
+                       ccx.tcx.sess.str_of(m.ident));
                 check_method(ccx, m);
               }
             }

src/librustc/middle/typeck/check/vtable.rs

@@ -201,6 +201,7 @@ fn lookup_vtable(vcx: &VtableContext,
 
     let tcx = vcx.tcx();
 
+    debug!("lookup_vtable fixup_ty");
     let ty = match fixup_ty(vcx, location_info, ty, is_early) {
         Some(ty) => ty,
         None => {
@@ -212,9 +213,11 @@ fn lookup_vtable(vcx: &VtableContext,
             return Some(vtable_param(0, 0));
         }
     };
+    debug!("lookup_vtable fixup_ty => %?", ty);
 
     match ty::get(ty).sty {
         ty::ty_param(param_ty {idx: n, def_id: did}) => {
+            debug!("lookup_vtable sty is ty_param");
             let mut n_bound = 0;
             let type_param_def = tcx.ty_param_defs.get(&did.node);
             for ty::each_bound_trait_and_supertraits(
@@ -238,15 +241,27 @@ fn lookup_vtable(vcx: &VtableContext,
         }
 
         _ => {
+            debug!("lookup_vtable sty not ty_param");
             let mut found = ~[];
 
             let mut impls_seen = HashSet::new();
 
-            match vcx.ccx.coherence_info.extension_methods.find(&trait_ref.def_id) {
+            let def_id = &trait_ref.def_id;
+            let ext_meths =
+                vcx.ccx.coherence_info.extension_methods.find(def_id);
+            debug!("lookup_vtable def_id: %? ext_meths: %?", def_id, ext_meths);
+            match ext_meths {
                 None => {
                     // Nothing found. Continue.
                 }
                 Some(implementations) => {
+                    let len = { // FIXME(#5074): stage0 requires it
+                        let implementations: &mut ~[@Impl] = *implementations;
+                        implementations.len()
+                    };
+
+                    debug!("lookup_vtable impls len: %?", len);
+
                     // implementations is the list of all impls in scope for
                     // trait_ref. (Usually, there's just one.)
                     for implementations.iter().advance |im| {
@@ -397,6 +412,7 @@ fn lookup_vtable(vcx: &VtableContext,
                 }
             }
 
+            debug!("lookup_vtable found.len: %u", found.len());
             match found.len() {
                 0 => { /* fallthrough */ }
                 1 => { return Some(/*bad*/copy found[0]); }

src/libsyntax/visit.rs

@@ -73,7 +73,12 @@ pub fn generics_of_fn(fk: &fn_kind) -> Generics {
 }
 
 trait Visitor {
-    fn visit_mod(&self, &_mod, span, node_id);
+    #[cfg(not(stage2))]
+    fn visit_mod(&self, m:&_mod, s:span, i:node_id);
+    #[cfg(stage2)]
+    fn visit_mod(&self, m:&_mod, s:span, i:node_id) {
+        walk_mod(self, m, s, i);
+    }
     fn visit_view_item(&self, @view_item);
     fn visit_foreign_item(&self, @foreign_item);
     fn visit_item(&self, @item);
@@ -687,7 +692,7 @@ fn walk_mod<V:Visitor>(v:&V, m: &_mod, _sp: span, _id: node_id) {
     for m.items.each |i| { v.visit_item(*i); }
 }
 
-fn walk_view_item<V:Visitor>(v:&V, _vi: @view_item) { }
+fn walk_view_item<V:Visitor>(_v:&V, _vi: @view_item) { }
 
 fn walk_local<V:Visitor>(v:&V, loc: @local) {
     v.visit_pat(loc.node.pat);
@@ -984,7 +989,7 @@ fn walk_exprs<V:Visitor>(v:&V, exprs: &[@expr]) {
     for exprs.each |ex| { v.visit_expr(*ex); }
 }
 
-fn walk_mac<V:Visitor>(v:&V, _m: &mac) {
+fn walk_mac<V:Visitor>(_v:&V, _m: &mac) {
     /* no user-serviceable parts inside */
 }