---

yaml
---
r: 134120
b: refs/heads/master
c: 5376b1c
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 2f9669c7489cc383bc6616c5f9ed217ae37e3d56
+refs/heads/master: 5376b1c79870c80d0081540c72ae060d3ed5d1f5
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 437179ed8bf7f7672f84b19265df1ce569e70490
 refs/heads/try: 777654cfccbfa39bc7f671d8e9629018ed8ca12d

trunk/src/doc/intro.md

@@ -300,7 +300,8 @@ Here's some code:
 use std::sync::Arc;
 
 fn main() {
-    let numbers = Arc::new(vec![1i, 2i, 3i]);
+    let numbers = vec![1i, 2i, 3i];
+    let numbers = Arc::new(numbers);
 
     for num in range(0u, 3) {
         let (tx, rx)  = channel();
@@ -345,7 +346,8 @@ and modify it to mutate the shared state:
 use std::sync::{Arc, Mutex};
 
 fn main() {
-    let numbers_lock = Arc::new(Mutex::new(vec![1i, 2i, 3i]));
+    let numbers = vec![1i, 2i, 3i];
+    let numbers_lock = Arc::new(Mutex::new(numbers));
 
     for num in range(0u, 3) {
         let (tx, rx)  = channel();

trunk/src/libcore/any.rs

@@ -94,7 +94,7 @@ pub enum Void { }
 pub trait Any: AnyPrivate {}
 
 /// An inner trait to ensure that only this module can call `get_type_id()`.
-pub trait AnyPrivate {
+trait AnyPrivate {
     /// Get the `TypeId` of `self`
     fn get_type_id(&self) -> TypeId;
 }

trunk/src/libcore/clone.rs

@@ -25,7 +25,9 @@ the `clone` method.
 
 /// A common trait for cloning an object.
 pub trait Clone {
-    /// Returns a copy of the value.
+    /// Returns a copy of the value. The contents of owned pointers
+    /// are copied to maintain uniqueness, while the contents of
+    /// managed pointers are not copied.
     fn clone(&self) -> Self;
 
     /// Perform copy-assignment from `source`.

trunk/src/libcore/iter.rs

@@ -2178,6 +2178,7 @@ pub type Iterate<'a, T> = Unfold<'a, T, IterateState<'a, T>>;
 
 /// Creates a new iterator that produces an infinite sequence of
 /// repeated applications of the given function `f`.
+#[allow(visible_private_types)]
 pub fn iterate<'a, T: Clone>(seed: T, f: |T|: 'a -> T) -> Iterate<'a, T> {
     Unfold::new((f, Some(seed), true), |st| {
         let &(ref mut f, ref mut val, ref mut first) = st;

trunk/src/libdebug/repr.rs

@@ -32,7 +32,7 @@ macro_rules! try( ($me:expr, $e:expr) => (
 
 /// Representations
 
-pub trait Repr {
+trait Repr {
     fn write_repr(&self, writer: &mut io::Writer) -> io::IoResult<()>;
 }
 

trunk/src/libgreen/lib.rs

@@ -218,7 +218,7 @@
 
 // NB this does *not* include globs, please keep it that way.
 #![feature(macro_rules, phase, default_type_params)]
-#![allow(deprecated)]
+#![allow(visible_private_types, deprecated)]
 
 #[cfg(test)] #[phase(plugin, link)] extern crate log;
 #[cfg(test)] extern crate rustuv;
@@ -385,7 +385,7 @@ pub struct SchedPool {
 /// keep track of how many tasks are currently running in the pool and then
 /// sending on a channel once the entire pool has been drained of all tasks.
 #[deriving(Clone)]
-pub struct TaskState {
+struct TaskState {
     cnt: Arc<AtomicUint>,
     done: Sender<()>,
 }

trunk/src/libnative/io/timer_unix.rs

@@ -66,14 +66,15 @@ pub struct Timer {
     inner: Option<Box<Inner>>,
 }
 
-pub struct Inner {
+struct Inner {
     cb: Option<Box<rtio::Callback + Send>>,
     interval: u64,
     repeat: bool,
     target: u64,
     id: uint,
 }
 
+#[allow(visible_private_types)]
 pub enum Req {
     // Add a new timer to the helper thread.
     NewTimer(Box<Inner>),

trunk/src/libregex/compile.rs

@@ -10,6 +10,7 @@
 
 // Enable this to squash warnings due to exporting pieces of the representation
 // for use with the regex! macro. See lib.rs for explanation.
+#![allow(visible_private_types)]
 
 use std::cmp;
 use parse;

trunk/src/libregex/re.rs

@@ -102,6 +102,7 @@ pub fn is_match(regex: &str, text: &str) -> Result<bool, parse::Error> {
 /// More details about the `regex!` macro can be found in the `regex` crate
 /// documentation.
 #[deriving(Clone)]
+#[allow(visible_private_types)]
 pub enum Regex {
     // The representation of `Regex` is exported to support the `regex!`
     // syntax extension. Do not rely on it.
@@ -515,6 +516,7 @@ impl Regex {
     }
 
     #[doc(hidden)]
+    #[allow(visible_private_types)]
     #[experimental]
     pub fn names_iter<'a>(&'a self) -> NamesIter<'a> {
         match *self {
@@ -532,7 +534,7 @@ impl Regex {
 
 }
 
-pub enum NamesIter<'a> {
+enum NamesIter<'a> {
     NamesIterNative(::std::slice::Items<'a, Option<&'static str>>),
     NamesIterDynamic(::std::slice::Items<'a, Option<String>>)
 }

trunk/src/librustc/driver/driver.rs

@@ -560,8 +560,8 @@ pub fn phase_6_link_output(sess: &Session,
                            trans: &CrateTranslation,
                            outputs: &OutputFilenames) {
     let old_path = os::getenv("PATH").unwrap_or_else(||String::new());
-    let mut new_path = os::split_paths(old_path.as_slice());
-    new_path.push_all_move(sess.host_filesearch().get_tools_search_paths());
+    let mut new_path = sess.host_filesearch().get_tools_search_paths();
+    new_path.push_all_move(os::split_paths(old_path.as_slice()));
     os::setenv("PATH", os::join_paths(new_path.as_slice()).unwrap());
 
     time(sess.time_passes(), "linking", (), |_|

trunk/src/librustc/lint/builtin.rs

@@ -1601,6 +1601,9 @@ declare_lint!(pub DEAD_ASSIGNMENT, Warn,
 declare_lint!(pub DEAD_CODE, Warn,
               "detect piece of code that will never be used")
 
+declare_lint!(pub VISIBLE_PRIVATE_TYPES, Warn,
+              "detect use of private types in exported type signatures")
+
 declare_lint!(pub UNREACHABLE_CODE, Warn,
               "detects unreachable code")
 
@@ -1633,6 +1636,7 @@ impl LintPass for HardwiredLints {
             UNUSED_VARIABLE,
             DEAD_ASSIGNMENT,
             DEAD_CODE,
+            VISIBLE_PRIVATE_TYPES,
             UNREACHABLE_CODE,
             WARNINGS,
             UNKNOWN_FEATURES,

trunk/src/librustc/middle/mem_categorization.rs

@@ -224,7 +224,7 @@ pub fn deref_kind(tcx: &ty::ctxt, t: ty::t) -> deref_kind {
     }
 }
 
-pub trait ast_node {
+trait ast_node {
     fn id(&self) -> ast::NodeId;
     fn span(&self) -> Span;
 }

trunk/src/librustc/middle/privacy.rs

@@ -16,6 +16,7 @@ use std::mem::replace;
 
 use metadata::csearch;
 use middle::def;
+use lint;
 use middle::resolve;
 use middle::ty;
 use middle::typeck::{MethodCall, MethodMap, MethodOrigin, MethodParam, MethodTypeParam};
@@ -1288,38 +1289,19 @@ impl<'a, 'tcx> VisiblePrivateTypesVisitor<'a, 'tcx> {
         };
         // A path can only be private if:
         // it's in this crate...
-        if !is_local(did) {
-            return false
-        }
-        // .. and it corresponds to a private type in the AST (this returns
-        // None for type parameters)
-        match self.tcx.map.find(did.node) {
-            Some(ast_map::NodeItem(ref item)) => item.vis != ast::Public,
-            Some(_) | None => false,
-        }
+        is_local(did) &&
+            // ... it's not exported (obviously) ...
+            !self.exported_items.contains(&did.node) &&
+            // .. and it corresponds to a type in the AST (this returns None for
+            // type parameters)
+            self.tcx.map.find(did.node).is_some()
     }
 
     fn trait_is_public(&self, trait_id: ast::NodeId) -> bool {
         // FIXME: this would preferably be using `exported_items`, but all
         // traits are exported currently (see `EmbargoVisitor.exported_trait`)
         self.public_items.contains(&trait_id)
     }
-
-    fn check_ty_param_bound(&self,
-                            span: Span,
-                            ty_param_bound: &ast::TyParamBound) {
-        match *ty_param_bound {
-            ast::TraitTyParamBound(ref trait_ref) => {
-                if !self.tcx.sess.features.borrow().visible_private_types &&
-                        self.path_is_private_type(trait_ref.ref_id) {
-                    self.tcx.sess.span_err(span,
-                                           "private type in exported type \
-                                            parameter bound");
-                }
-            }
-            _ => {}
-        }
-    }
 }
 
 impl<'a, 'b, 'tcx, 'v> Visitor<'v> for CheckTypeForPrivatenessVisitor<'a, 'b, 'tcx> {
@@ -1356,15 +1338,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for VisiblePrivateTypesVisitor<'a, 'tcx> {
             // namespace (the contents have their own privacies).
             ast::ItemForeignMod(_) => {}
 
-            ast::ItemTrait(_, _, ref bounds, _) => {
-                if !self.trait_is_public(item.id) {
-                    return
-                }
-
-                for bound in bounds.iter() {
-                    self.check_ty_param_bound(item.span, bound)
-                }
-            }
+            ast::ItemTrait(..) if !self.trait_is_public(item.id) => return,
 
             // impls need some special handling to try to offer useful
             // error messages without (too many) false positives
@@ -1497,19 +1471,6 @@ impl<'a, 'tcx, 'v> Visitor<'v> for VisiblePrivateTypesVisitor<'a, 'tcx> {
         visit::walk_item(self, item);
     }
 
-    fn visit_generics(&mut self, generics: &ast::Generics) {
-        for ty_param in generics.ty_params.iter() {
-            for bound in ty_param.bounds.iter() {
-                self.check_ty_param_bound(ty_param.span, bound)
-            }
-        }
-        for predicate in generics.where_clause.predicates.iter() {
-            for bound in predicate.bounds.iter() {
-                self.check_ty_param_bound(predicate.span, bound)
-            }
-        }
-    }
-
     fn visit_foreign_item(&mut self, item: &ast::ForeignItem) {
         if self.exported_items.contains(&item.id) {
             visit::walk_foreign_item(self, item)
@@ -1527,11 +1488,12 @@ impl<'a, 'tcx, 'v> Visitor<'v> for VisiblePrivateTypesVisitor<'a, 'tcx> {
     fn visit_ty(&mut self, t: &ast::Ty) {
         match t.node {
             ast::TyPath(ref p, _, path_id) => {
-                if !self.tcx.sess.features.borrow().visible_private_types &&
-                        self.path_is_private_type(path_id) {
-                    self.tcx.sess.span_err(p.span,
-                                           "private type in exported type \
-                                            signature");
+                if self.path_is_private_type(path_id) {
+                    self.tcx.sess.add_lint(
+                        lint::builtin::VISIBLE_PRIVATE_TYPES,
+                        path_id, p.span,
+                        "private type in exported type \
+                         signature".to_string());
                 }
             }
             _ => {}

trunk/src/librustc/middle/resolve_lifetime.rs

@@ -21,6 +21,7 @@ use driver::session::Session;
 use middle::subst;
 use syntax::ast;
 use syntax::codemap::Span;
+use syntax::owned_slice::OwnedSlice;
 use syntax::parse::token::special_idents;
 use syntax::parse::token;
 use syntax::print::pprust::{lifetime_to_string};
@@ -98,8 +99,22 @@ impl<'a, 'v> Visitor<'v> for LifetimeContext<'a> {
             ast::ItemTy(_, ref generics) |
             ast::ItemEnum(_, ref generics) |
             ast::ItemStruct(_, ref generics) |
-            ast::ItemImpl(ref generics, _, _, _) |
-            ast::ItemTrait(ref generics, _, _, _) => &generics.lifetimes
+            ast::ItemTrait(ref generics, _, _, _) => {
+                self.with(|scope, f| {
+                    f(EarlyScope(subst::TypeSpace,
+                                 &generics.lifetimes,
+                                 scope))
+                }, |v| v.check_lifetime_defs(&generics.lifetimes));
+                &generics.lifetimes
+            }
+            ast::ItemImpl(ref generics, _, _, _) => {
+                self.with(|scope, f| {
+                    f(EarlyScope(subst::TypeSpace,
+                                 &generics.lifetimes,
+                                 scope))
+                }, |v| v.check_lifetime_defs(&generics.lifetimes));
+                &generics.lifetimes
+            }
         };
 
         self.with(|_, f| f(EarlyScope(subst::TypeSpace, lifetimes, &ROOT_SCOPE)), |v| {
@@ -155,6 +170,20 @@ impl<'a, 'v> Visitor<'v> for LifetimeContext<'a> {
         }
         self.resolve_lifetime_ref(lifetime_ref);
     }
+
+    fn visit_generics(&mut self, generics: &ast::Generics) {
+        for ty_param in generics.ty_params.iter() {
+            self.visit_ty_param_bounds(&ty_param.bounds);
+            match ty_param.default {
+                Some(ref ty) => self.visit_ty(&**ty),
+                None => {}
+            }
+        }
+        for predicate in generics.where_clause.predicates.iter() {
+            self.visit_ident(predicate.span, predicate.ident);
+            self.visit_ty_param_bounds(&predicate.bounds);
+        }
+    }
 }
 
 impl<'a> LifetimeContext<'a> {
@@ -167,6 +196,47 @@ impl<'a> LifetimeContext<'a> {
         }))
     }
 
+    fn visit_ty_param_bounds(&mut self,
+                             bounds: &OwnedSlice<ast::TyParamBound>) {
+        for bound in bounds.iter() {
+            match *bound {
+                ast::TraitTyParamBound(ref trait_ref) => {
+                    self.visit_trait_ref(trait_ref);
+                }
+                ast::UnboxedFnTyParamBound(ref fn_decl) => {
+                    self.visit_unboxed_fn_ty_param_bound(&**fn_decl);
+                }
+                ast::RegionTyParamBound(ref lifetime) => {
+                    self.visit_lifetime_ref(lifetime);
+                }
+            }
+        }
+    }
+
+    fn visit_trait_ref(&mut self, trait_ref: &ast::TraitRef) {
+        self.with(|scope, f| {
+            f(LateScope(trait_ref.ref_id, &trait_ref.lifetimes, scope))
+        }, |v| {
+            v.check_lifetime_defs(&trait_ref.lifetimes);
+            for lifetime in trait_ref.lifetimes.iter() {
+                v.visit_lifetime_decl(lifetime);
+            }
+            v.visit_path(&trait_ref.path, trait_ref.ref_id);
+        })
+    }
+
+    fn visit_unboxed_fn_ty_param_bound(&mut self,
+                                       bound: &ast::UnboxedFnBound) {
+        self.with(|scope, f| {
+            f(LateScope(bound.ref_id, &bound.lifetimes, scope))
+        }, |v| {
+            for argument in bound.decl.inputs.iter() {
+                v.visit_ty(&*argument.ty);
+            }
+            v.visit_ty(&*bound.decl.output);
+        })
+    }
+
     /// Visits self by adding a scope and handling recursive walk over the contents with `walk`.
     fn visit_fn_decl(&mut self,
                      n: ast::NodeId,

trunk/src/librustc/middle/typeck/infer/error_reporting.rs

@@ -1110,6 +1110,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> {
                     ast::TraitTyParamBound(ast::TraitRef {
                         path: new_path,
                         ref_id: tr.ref_id,
+                        lifetimes: tr.lifetimes.clone(),
                     })
                 }
             }
@@ -1645,7 +1646,7 @@ impl<'a, 'tcx> ErrorReportingHelpers for InferCtxt<'a, 'tcx> {
     }
 }
 
-pub trait Resolvable {
+trait Resolvable {
     fn resolve(&self, infcx: &InferCtxt) -> Self;
     fn contains_error(&self) -> bool;
 }