---

yaml
---
r: 228557
b: refs/heads/try
c: 44dd247
h: refs/heads/master
i:
  228555: 19fc2ae
v: v3

Author: brson

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: aca2057ed5fb7af3f8905b2bc01f72fa001c35c8
 refs/heads/snap-stage3: 1af31d4974e33027a68126fa5a5a3c2c6491824f
-refs/heads/try: 2afe47d1688726fd1e836deedaa0ad8c2ec891c7
+refs/heads/try: 44dd247cd5ced8ae8a8c6f1d04463abce21c8e9e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/configure

@@ -323,17 +323,6 @@ envopt() {
     fi
 }
 
-enable_if_not_disabled() {
-    local OP=$1
-    local UOP=$(echo $OP | tr '[:lower:]' '[:upper:]' | tr '\-' '\_')
-    local ENAB_V="CFG_ENABLE_$UOP"
-    local EXPLICITLY_DISABLED="CFG_DISABLE_${UOP}_PROVIDED"
-    eval VV=\$$EXPLICITLY_DISABLED
-    if [ -z "$VV" ]; then
-        eval $ENAB_V=1
-    fi
-}
-
 to_llvm_triple() {
     case $1 in
         i686-w64-mingw32) echo i686-pc-windows-gnu ;;
@@ -682,12 +671,10 @@ if [ -n "$CFG_ENABLE_DEBUG" ]; then
         CFG_DISABLE_OPTIMIZE=1
         CFG_DISABLE_OPTIMIZE_CXX=1
     fi
-
-    # Set following variables to 1 unless setting already provided
-    enable_if_not_disabled debug-assertions
-    enable_if_not_disabled debug-jemalloc
-    enable_if_not_disabled debuginfo
-    enable_if_not_disabled llvm-assertions
+    CFG_ENABLE_DEBUG_ASSERTIONS=1
+    CFG_ENABLE_DEBUG_JEMALLOC=1
+    CFG_ENABLE_DEBUGINFO=1
+    CFG_ENABLE_LLVM_ASSERTIONS=1
 fi
 
 # OK, now write the debugging options

branches/try/src/libcollections/slice.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Utilities for slice manipulation
+//! A dynamically-sized view into a contiguous sequence, `[T]`.
 //!
 //! The `slice` module contains useful code to help work with slice values.
 //! Slices are a view into a block of memory represented as a pointer and a

branches/try/src/libcollections/str.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Unicode string manipulation (the `str` type).
+//! Unicode string slices
 //!
 //! Rust's `str` type is one of the core primitive types of the language. `&str`
 //! is the borrowed string type. This type of string can only be created from

branches/try/src/libcore/atomic.rs

@@ -78,7 +78,6 @@ use intrinsics;
 use cell::UnsafeCell;
 
 use default::Default;
-use fmt;
 
 /// A boolean type which can be safely shared between threads.
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -1090,23 +1089,3 @@ pub fn fence(order: Ordering) {
         }
     }
 }
-
-macro_rules! impl_Debug {
-    ($($t:ident)*) => ($(
-        #[stable(feature = "atomic_debug", since = "1.3.0")]
-        impl fmt::Debug for $t {
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                f.debug_tuple(stringify!($t)).field(&self.load(Ordering::SeqCst)).finish()
-            }
-        }
-    )*);
-}
-
-impl_Debug!{ AtomicUsize AtomicIsize AtomicBool }
-
-#[stable(feature = "atomic_debug", since = "1.3.0")]
-impl<T> fmt::Debug for AtomicPtr<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("AtomicPtr").field(&self.load(Ordering::SeqCst)).finish()
-    }
-}

branches/try/src/libcore/ptr.rs

@@ -10,7 +10,7 @@
 
 // FIXME: talk about offset, copy_memory, copy_nonoverlapping_memory
 
-//! Operations on raw pointers, `*const T`, and `*mut T`.
+//! Raw, unsafe pointers, `*const T`, and `*mut T`
 //!
 //! Working with raw pointers in Rust is uncommon,
 //! typically limited to a few patterns.

branches/try/src/libcore/str/mod.rs

@@ -636,10 +636,10 @@ impl<'a, P: Pattern<'a>> SplitInternal<'a, P> {
 
 generate_pattern_iterators! {
     forward:
-        /// Created with the method `.split()`.
+        #[doc="Created with the method `.split()`."]
         struct Split;
     reverse:
-        /// Created with the method `.rsplit()`.
+        #[doc="Created with the method `.rsplit()`."]
         struct RSplit;
     stability:
         #[stable(feature = "rust1", since = "1.0.0")]
@@ -650,10 +650,10 @@ generate_pattern_iterators! {
 
 generate_pattern_iterators! {
     forward:
-        /// Created with the method `.split_terminator()`.
+        #[doc="Created with the method `.split_terminator()`."]
         struct SplitTerminator;
     reverse:
-        /// Created with the method `.rsplit_terminator()`.
+        #[doc="Created with the method `.rsplit_terminator()`."]
         struct RSplitTerminator;
     stability:
         #[stable(feature = "rust1", since = "1.0.0")]
@@ -696,10 +696,10 @@ impl<'a, P: Pattern<'a>> SplitNInternal<'a, P> {
 
 generate_pattern_iterators! {
     forward:
-        /// Created with the method `.splitn()`.
+        #[doc="Created with the method `.splitn()`."]
         struct SplitN;
     reverse:
-        /// Created with the method `.rsplitn()`.
+        #[doc="Created with the method `.rsplitn()`."]
         struct RSplitN;
     stability:
         #[stable(feature = "rust1", since = "1.0.0")]
@@ -730,10 +730,10 @@ impl<'a, P: Pattern<'a>> MatchIndicesInternal<'a, P> {
 
 generate_pattern_iterators! {
     forward:
-        /// Created with the method `.match_indices()`.
+        #[doc="Created with the method `.match_indices()`."]
         struct MatchIndices;
     reverse:
-        /// Created with the method `.rmatch_indices()`.
+        #[doc="Created with the method `.rmatch_indices()`."]
         struct RMatchIndices;
     stability:
         #[unstable(feature = "str_match_indices",
@@ -771,10 +771,10 @@ impl<'a, P: Pattern<'a>> MatchesInternal<'a, P> {
 
 generate_pattern_iterators! {
     forward:
-        /// Created with the method `.matches()`.
+        #[doc="Created with the method `.matches()`."]
         struct Matches;
     reverse:
-        /// Created with the method `.rmatches()`.
+        #[doc="Created with the method `.rmatches()`."]
         struct RMatches;
     stability:
         #[stable(feature = "str_matches", since = "1.2.0")]

branches/try/src/libcore/tuple.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Operations on tuples
+//! A finite heterogeneous sequence, `(T, U, ..)`
 //!
 //! To access a single element of a tuple one can use the `.0`
 //! field access syntax.

branches/try/src/librustc/middle/free_region.rs

@@ -13,21 +13,18 @@
 use middle::implicator::Implication;
 use middle::ty::{self, FreeRegion};
 use util::common::can_reach;
-use util::nodemap::{FnvHashMap, FnvHashSet};
+use util::nodemap::FnvHashMap;
 
 #[derive(Clone)]
 pub struct FreeRegionMap {
-    /// `map` maps from a free region `a` to a list of
+    /// `free_region_map` maps from a free region `a` to a list of
     /// free regions `bs` such that `a <= b for all b in bs`
     map: FnvHashMap<FreeRegion, Vec<FreeRegion>>,
-    /// regions that are required to outlive (and therefore be
-    /// equal to) 'static.
-    statics: FnvHashSet<FreeRegion>
 }
 
 impl FreeRegionMap {
     pub fn new() -> FreeRegionMap {
-        FreeRegionMap { map: FnvHashMap(), statics: FnvHashSet() }
+        FreeRegionMap { map: FnvHashMap() }
     }
 
     pub fn relate_free_regions_from_implications<'tcx>(&mut self,
@@ -62,8 +59,6 @@ impl FreeRegionMap {
                 }
                 ty::Predicate::RegionOutlives(ty::Binder(ty::OutlivesPredicate(r_a, r_b))) => {
                     match (r_a, r_b) {
-                        (ty::ReStatic, ty::ReFree(_)) => {},
-                        (ty::ReFree(fr_a), ty::ReStatic) => self.relate_to_static(fr_a),
                         (ty::ReFree(fr_a), ty::ReFree(fr_b)) => {
                             // Record that `'a:'b`. Or, put another way, `'b <= 'a`.
                             self.relate_free_regions(fr_b, fr_a);
@@ -81,12 +76,8 @@ impl FreeRegionMap {
         }
     }
 
-    fn relate_to_static(&mut self, sup: FreeRegion) {
-        self.statics.insert(sup);
-    }
-
-    fn relate_free_regions(&mut self, sub: FreeRegion, sup: FreeRegion) {
-       let mut sups = self.map.entry(sub).or_insert(Vec::new());
+    pub fn relate_free_regions(&mut self, sub: FreeRegion, sup: FreeRegion) {
+        let mut sups = self.map.entry(sub).or_insert(Vec::new());
         if !sups.contains(&sup) {
             sups.push(sup);
         }
@@ -97,7 +88,7 @@ impl FreeRegionMap {
     /// it is possible that `sub != sup` and `sub <= sup` and `sup <= sub`
     /// (that is, the user can give two different names to the same lifetime).
     pub fn sub_free_region(&self, sub: FreeRegion, sup: FreeRegion) -> bool {
-        can_reach(&self.map, sub, sup) || self.is_static(&sup)
+        can_reach(&self.map, sub, sup)
     }
 
     /// Determines whether one region is a subregion of another.  This is intended to run *after
@@ -125,17 +116,10 @@ impl FreeRegionMap {
                 (ty::ReFree(sub_fr), ty::ReFree(super_fr)) =>
                     self.sub_free_region(sub_fr, super_fr),
 
-                (ty::ReStatic, ty::ReFree(ref sup_fr)) => self.is_static(sup_fr),
-
                 _ =>
                     false,
             }
         }
     }
-
-    /// Determines whether this free-region is required to be 'static
-    pub fn is_static(&self, super_region: &ty::FreeRegion) -> bool {
-        debug!("is_static(super_region={:?})", super_region);
-        self.statics.iter().any(|s| can_reach(&self.map, *s, *super_region))
-    }
 }
+

branches/try/src/librustc/middle/infer/region_inference/mod.rs

@@ -869,8 +869,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
                 // is the scope `s_id`.  Otherwise, as we do not know
                 // big the free region is precisely, the GLB is undefined.
                 let fr_scope = fr.scope.to_code_extent();
-                if self.tcx.region_maps.nearest_common_ancestor(fr_scope, s_id) == fr_scope ||
-                        free_regions.is_static(fr) {
+                if self.tcx.region_maps.nearest_common_ancestor(fr_scope, s_id) == fr_scope {
                     Ok(s)
                 } else {
                     Err(TypeError::RegionsNoOverlap(b, a))

branches/try/src/librustc_back/target/openbsd_base.rs

@@ -27,7 +27,7 @@ pub fn opts() -> TargetOptions {
             "-Wl,--as-needed".to_string(),
         ),
         position_independent_executables: true,
-        archive_format: "gnu".to_string(),
+        archive_format: "bsd".to_string(),
         .. Default::default()
     }
 }

branches/try/src/librustc_lint/builtin.rs

@@ -1616,6 +1616,8 @@ impl LintPass for MissingDoc {
                 }
                 return
             },
+            ast::ItemConst(..) => "a constant",
+            ast::ItemStatic(..) => "a static",
             _ => return
         };
 

branches/try/src/librustc_trans/trans/common.rs

@@ -905,13 +905,11 @@ pub fn fulfill_obligation<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
     let vtable = selection.map(|predicate| {
         fulfill_cx.register_predicate_obligation(&infcx, predicate);
     });
-    let vtable = erase_regions(tcx,
-        &drain_fulfillment_cx_or_panic(span, &infcx, &mut fulfill_cx, &vtable)
-    );
+    let vtable = drain_fulfillment_cx_or_panic(span, &infcx, &mut fulfill_cx, &vtable);
 
-    info!("Cache miss: {:?} => {:?}", trait_ref, vtable);
-
-    ccx.trait_cache().borrow_mut().insert(trait_ref, vtable.clone());
+    info!("Cache miss: {:?}", trait_ref);
+    ccx.trait_cache().borrow_mut().insert(trait_ref,
+                                          vtable.clone());
 
     vtable
 }

branches/try/src/librustc_typeck/astconv.rs

@@ -1112,7 +1112,7 @@ fn report_ambiguous_associated_type(tcx: &ty::ctxt,
 // any ambiguity.
 fn find_bound_for_assoc_item<'tcx>(this: &AstConv<'tcx>,
                                    ty_param_node_id: ast::NodeId,
-                                   ty_param_name: ast::Name,
+                                   ty_param_name: Option<ast::Name>,
                                    assoc_name: ast::Name,
                                    span: Span)
                                    -> Result<ty::PolyTraitRef<'tcx>, ErrorReported>
@@ -1138,11 +1138,21 @@ fn find_bound_for_assoc_item<'tcx>(this: &AstConv<'tcx>,
         .filter(|b| this.trait_defines_associated_type_named(b.def_id(), assoc_name))
         .collect();
 
-    one_bound_for_assoc_type(tcx,
-                             suitable_bounds,
-                             &token::get_name(ty_param_name),
-                             &token::get_name(assoc_name),
-                             span)
+    if let Some(s) = ty_param_name {
+        // borrowck doesn't like this any other way
+        one_bound_for_assoc_type(tcx,
+                                 suitable_bounds,
+                                 &token::get_name(s),
+                                 &token::get_name(assoc_name),
+                                 span)
+    } else {
+        one_bound_for_assoc_type(tcx,
+                                 suitable_bounds,
+                                 "Self",
+                                 &token::get_name(assoc_name),
+                                 span)
+
+    }
 }
 
 
@@ -1241,11 +1251,7 @@ fn associated_path_def_to_ty<'tcx>(this: &AstConv<'tcx>,
         }
         (&ty::TyParam(_), def::DefSelfTy(Some(trait_did),  None)) => {
             assert_eq!(trait_did.krate, ast::LOCAL_CRATE);
-            match find_bound_for_assoc_item(this,
-                                            trait_did.node,
-                                            token::special_idents::type_self.name,
-                                            assoc_name,
-                                            span) {
+            match find_bound_for_assoc_item(this, trait_did.node, None, assoc_name, span) {
                 Ok(bound) => bound,
                 Err(ErrorReported) => return (tcx.types.err, ty_path_def),
             }
@@ -1254,7 +1260,7 @@ fn associated_path_def_to_ty<'tcx>(this: &AstConv<'tcx>,
             assert_eq!(param_did.krate, ast::LOCAL_CRATE);
             match find_bound_for_assoc_item(this,
                                             param_did.node,
-                                            param_name,
+                                            Some(param_name),
                                             assoc_name,
                                             span) {
                 Ok(bound) => bound,

branches/try/src/librustc_unicode/char.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Character manipulation (`char` type, Unicode Scalar Value)
+//! A Unicode scalar value
 //!
 //! This module provides the `CharExt` trait, as well as its
 //! implementation for the primitive `char` type, in order to allow

branches/try/src/librustdoc/clean/mod.rs

@@ -1947,10 +1947,6 @@ impl Span {
 
 impl Clean<Span> for syntax::codemap::Span {
     fn clean(&self, cx: &DocContext) -> Span {
-        if *self == DUMMY_SP {
-            return Span::empty();
-        }
-
         let cm = cx.sess().codemap();
         let filename = cm.span_to_filename(*self);
         let lo = cm.lookup_char_pos(self.lo);

branches/try/src/librustdoc/html/format.rs

@@ -540,19 +540,6 @@ impl fmt::Display for clean::Type {
     }
 }
 
-impl fmt::Display for clean::Impl {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        try!(write!(f, "impl{} ", self.generics));
-        if let Some(ref ty) = self.trait_ {
-            try!(write!(f, "{}{} for ",
-                        if self.polarity == Some(clean::ImplPolarity::Negative) { "!" } else { "" },
-                        *ty));
-        }
-        try!(write!(f, "{}{}", self.for_, WhereClause(&self.generics)));
-        Ok(())
-    }
-}
-
 impl fmt::Display for clean::Arguments {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         for (i, input) in self.values.iter().enumerate() {