Fix existing privacy/visibility violations

This commit fixes all of the fallout of the previous commit which is an attempt
to refine privacy. There were a few unfortunate leaks which now must be plugged,
and the most horrible one is the current `shouldnt_be_public` module now inside
`std::rt`. I think that this either needs a slight reorganization of the
runtime, or otherwise it needs to just wait for the external users of these
modules to get replaced with their `rt` implementations.

Other fixes involve making things pub which should be pub, and otherwise
updating error messages that now reference privacy instead of referencing an
"unresolved name" (yay!).

Author: alexcrichton

src/libextra/container.rs

@@ -40,7 +40,7 @@ pub trait Deque<T> : Mutable {
 }
 
 #[cfg(test)]
-mod bench {
+pub mod bench {
     use std::container::MutableMap;
     use std::{vec, rand};
     use std::rand::Rng;

src/libextra/crypto/cryptoutil.rs

@@ -346,7 +346,7 @@ impl <T: FixedBuffer> StandardPadding for T {
 
 
 #[cfg(test)]
-mod test {
+pub mod test {
     use std::rand::{IsaacRng, Rng};
     use std::vec;
 

src/libextra/stats.rs

@@ -101,7 +101,8 @@ pub trait Stats {
 
 /// Extracted collection of all the summary statistics of a sample set.
 #[deriving(Clone, Eq)]
-struct Summary {
+#[allow(missing_doc)]
+pub struct Summary {
     sum: f64,
     min: f64,
     max: f64,

src/librustc/middle/borrowck/gather_loans/mod.rs

@@ -31,8 +31,8 @@ use syntax::ast_util::id_range;
 use syntax::codemap::Span;
 use syntax::print::pprust;
 use syntax::visit;
-use syntax::visit::Visitor;
-use syntax::ast::{Expr, fn_kind, fn_decl, Block, NodeId, Stmt, Pat, Local};
+use syntax::visit::{Visitor, fn_kind};
+use syntax::ast::{Expr, fn_decl, Block, NodeId, Stmt, Pat, Local};
 
 mod lifetime;
 mod restrictions;

src/librustc/middle/trans/datum.rs

@@ -581,7 +581,7 @@ impl Datum {
 
         if !header && !ty::type_contents(bcx.tcx(), content_ty).contains_managed() {
             let ptr = self.to_value_llval(bcx);
-            let ty = type_of(bcx.ccx(), content_ty);
+            let ty = type_of::type_of(bcx.ccx(), content_ty);
             let body = PointerCast(bcx, ptr, ty.ptr_to());
             Datum {val: body, ty: content_ty, mode: ByRef(ZeroMem)}
         } else { // has a header

src/librustc/middle/trans/expr.rs

@@ -1026,7 +1026,7 @@ fn trans_lvalue_unadjusted(bcx: @mut Block, expr: &ast::Expr) -> DatumBlock {
                         // which may not be equal to the enum's type for
                         // non-C-like enums.
                         let val = base::get_item_val(bcx.ccx(), did.node);
-                        let pty = type_of(bcx.ccx(), const_ty).ptr_to();
+                        let pty = type_of::type_of(bcx.ccx(), const_ty).ptr_to();
                         PointerCast(bcx, val, pty)
                     } else {
                         {
@@ -1040,7 +1040,7 @@ fn trans_lvalue_unadjusted(bcx: @mut Block, expr: &ast::Expr) -> DatumBlock {
                         }
 
                         unsafe {
-                            let llty = type_of(bcx.ccx(), const_ty);
+                            let llty = type_of::type_of(bcx.ccx(), const_ty);
                             let symbol = csearch::get_symbol(
                                 bcx.ccx().sess.cstore,
                                 did);
@@ -1396,7 +1396,7 @@ fn trans_unary_datum(bcx: @mut Block,
                         heap: heap) -> DatumBlock {
         let _icx = push_ctxt("trans_boxed_expr");
         if heap == heap_exchange {
-            let llty = type_of(bcx.ccx(), contents_ty);
+            let llty = type_of::type_of(bcx.ccx(), contents_ty);
             let size = llsize_of(bcx.ccx(), llty);
             let Result { bcx: bcx, val: val } = malloc_raw_dyn(bcx, contents_ty,
                                                                heap_exchange, size);

src/librustc/middle/trans/glue.rs

@@ -203,7 +203,7 @@ pub fn lazily_emit_tydesc_glue(ccx: @mut CrateContext,
                                field: uint,
                                ti: @mut tydesc_info) {
     let _icx = push_ctxt("lazily_emit_tydesc_glue");
-    let llfnty = Type::glue_fn(type_of::type_of(ccx, ti.ty).ptr_to());
+    let llfnty = Type::glue_fn(type_of(ccx, ti.ty).ptr_to());
 
     if lazily_emit_simplified_tydesc_glue(ccx, field, ti) {
         return;
@@ -345,7 +345,7 @@ pub fn make_visit_glue(bcx: @mut Block, v: ValueRef, t: ty::t) -> @mut Block {
                 bcx.tcx().sess.fatal(s);
             }
         };
-        let v = PointerCast(bcx, v, type_of::type_of(bcx.ccx(), object_ty).ptr_to());
+        let v = PointerCast(bcx, v, type_of(bcx.ccx(), object_ty).ptr_to());
         bcx = reflect::emit_calls_to_trait_visit_ty(bcx, t, v, visitor_trait.def_id);
         // The visitor is a boxed object and needs to be dropped
         add_clean(bcx, v, object_ty);

src/librustc/middle/typeck/coherence.rs

@@ -330,8 +330,8 @@ impl CoherenceChecker {
 
         let impl_poly_type = ty::lookup_item_type(tcx, impl_id);
 
-        let provided = ty::provided_trait_methods(tcx, trait_ref.def_id);
-        for trait_method in provided.iter() {
+        let prov = ty::provided_trait_methods(tcx, trait_ref.def_id);
+        for trait_method in prov.iter() {
             // Synthesize an ID.
             let new_id = tcx.sess.next_node_id();
             let new_did = local_def(new_id);

src/librustdoc/html/render.rs

@@ -126,7 +126,7 @@ enum Implementor {
 /// to be a fairly large and expensive structure to clone. Instead this adheres
 /// to both `Send` and `Freeze` so it may be stored in a `RWArc` instance and
 /// shared among the various rendering tasks.
-struct Cache {
+pub struct Cache {
     /// Mapping of typaram ids to the name of the type parameter. This is used
     /// when pretty-printing a type (so pretty printing doesn't have to
     /// painfully maintain a context like this)

src/librusti/program.rs

@@ -24,7 +24,7 @@ use utils::*;
 /// This structure keeps track of the state of the world for the code being
 /// executed in rusti.
 #[deriving(Clone)]
-struct Program {
+pub struct Program {
     /// All known local variables
     local_vars: HashMap<~str, LocalVariable>,
     /// New variables which will be present (learned from typechecking)