---

yaml
---
r: 227583
b: refs/heads/try
c: fba9cec
h: refs/heads/master
i:
  227581: 1fd3fa2
  227579: c841d2c
  227575: 02769d2
  227567: 635c8e4
  227551: 1475152
  227519: 8765cbe
  227455: 21ed1ea
  227327: bdc63d0
v: v3

Author: frewsxcv

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: aca2057ed5fb7af3f8905b2bc01f72fa001c35c8
 refs/heads/snap-stage3: 1af31d4974e33027a68126fa5a5a3c2c6491824f
-refs/heads/try: 81024d9931ef63316995294fc41accb641646c4f
+refs/heads/try: fba9cecab753a87957b9eac19f3c1cc27e048817
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/src/doc/reference.md

@@ -944,20 +944,9 @@ fn foo<T>(x: T) where T: Debug {
 ```
 
 When a generic function is referenced, its type is instantiated based on the
-context of the reference. For example, calling the `foo` function here:
-
-```
-use std::fmt::Debug;
-
-fn foo<T>(x: &[T]) where T: Debug {
-    // details elided
-    # ()
-}
-
-foo(&[1, 2]);
-```
-
-will instantiate type parameter `T` with `i32`.
+context of the reference. For example, calling the `iter` function defined
+above on `[1, 2]` will instantiate type parameter `T` with `i32`, and require
+the closure parameter to have type `Fn(i32)`.
 
 The type parameters can also be explicitly supplied in a trailing
 [path](#paths) component after the function name. This might be necessary if
@@ -2779,24 +2768,22 @@ meaning of the operators on standard types is given here.
 Like the [arithmetic operators](#arithmetic-operators), bitwise operators are
 syntactic sugar for calls to methods of built-in traits. This means that
 bitwise operators can be overridden for user-defined types. The default
-meaning of the operators on standard types is given here. Bitwise `&`, `|` and
-`^` applied to boolean arguments are equivalent to logical `&&`, `||` and `!=`
-evaluated in non-lazy fashion.
+meaning of the operators on standard types is given here.
 
 * `&`
-  : Bitwise AND.
+  : And.
     Calls the `bitand` method of the `std::ops::BitAnd` trait.
 * `|`
-  : Bitwise inclusive OR.
+  : Inclusive or.
     Calls the `bitor` method of the `std::ops::BitOr` trait.
 * `^`
-  : Bitwise exclusive OR.
+  : Exclusive or.
     Calls the `bitxor` method of the `std::ops::BitXor` trait.
 * `<<`
   : Left shift.
     Calls the `shl` method of the `std::ops::Shl` trait.
 * `>>`
-  : Right shift (arithmetic).
+  : Right shift.
     Calls the `shr` method of the `std::ops::Shr` trait.
 
 #### Lazy boolean operators

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

@@ -65,6 +65,7 @@ pub use self::InteriorKind::*;
 pub use self::FieldName::*;
 pub use self::ElementKind::*;
 pub use self::MutabilityCategory::*;
+pub use self::InteriorSafety::*;
 pub use self::AliasableReason::*;
 pub use self::Note::*;
 pub use self::deref_kind::*;
@@ -1384,6 +1385,12 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
     }
 }
 
+#[derive(Copy, Clone, Debug)]
+pub enum InteriorSafety {
+    InteriorUnsafe,
+    InteriorSafe
+}
+
 #[derive(Clone, Debug)]
 pub enum Aliasability {
     FreelyAliasable(AliasableReason),
@@ -1397,8 +1404,8 @@ pub enum AliasableReason {
     AliasableClosure(ast::NodeId), // Aliasable due to capture Fn closure env
     AliasableOther,
     UnaliasableImmutable, // Created as needed upon seeing ImmutableUnique
-    AliasableStatic,
-    AliasableStaticMut,
+    AliasableStatic(InteriorSafety),
+    AliasableStaticMut(InteriorSafety),
 }
 
 impl<'tcx> cmt_<'tcx> {
@@ -1462,10 +1469,16 @@ impl<'tcx> cmt_<'tcx> {
             }
 
             cat_static_item(..) => {
+                let int_safe = if ty::type_interior_is_unsafe(ctxt, self.ty) {
+                    InteriorUnsafe
+                } else {
+                    InteriorSafe
+                };
+
                 if self.mutbl.is_mutable() {
-                    FreelyAliasable(AliasableStaticMut)
+                    FreelyAliasable(AliasableStaticMut(int_safe))
                 } else {
-                    FreelyAliasable(AliasableStatic)
+                    FreelyAliasable(AliasableStatic(int_safe))
                 }
             }
 

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

@@ -3787,6 +3787,10 @@ impl fmt::Debug for TypeContents {
     }
 }
 
+pub fn type_interior_is_unsafe<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> bool {
+    type_contents(cx, ty).interior_unsafe()
+}
+
 pub fn type_contents<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> TypeContents {
     return memoized(&cx.tc_cache, ty, |ty| {
         tc_ty(cx, ty, &mut FnvHashMap())

branches/try/src/librustc_borrowck/borrowck/gather_loans/mod.rs

@@ -191,11 +191,23 @@ fn check_aliasability<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>,
             /* Uniquely accessible path -- OK for `&` and `&mut` */
             Ok(())
         }
-        (mc::Aliasability::FreelyAliasable(mc::AliasableStatic), ty::ImmBorrow) => {
-            // Borrow of an immutable static item.
-            Ok(())
+        (mc::Aliasability::FreelyAliasable(mc::AliasableStatic(safety)), ty::ImmBorrow) => {
+            // Borrow of an immutable static item:
+            match safety {
+                mc::InteriorUnsafe => {
+                    // If the static item contains an Unsafe<T>, it has interior
+                    // mutability.  In such cases, another phase of the compiler
+                    // will ensure that the type is `Sync` and then trans will
+                    // not put it in rodata, so this is ok to allow.
+                    Ok(())
+                }
+                mc::InteriorSafe => {
+                    // Immutable static can be borrowed, no problem.
+                    Ok(())
+                }
+            }
         }
-        (mc::Aliasability::FreelyAliasable(mc::AliasableStaticMut), _) => {
+        (mc::Aliasability::FreelyAliasable(mc::AliasableStaticMut(..)), _) => {
             // Even touching a static mut is considered unsafe. We assume the
             // user knows what they're doing in these cases.
             Ok(())

branches/try/src/librustc_typeck/check/coercion.rs

@@ -403,9 +403,8 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
                a.repr(self.tcx()),
                b.repr(self.tcx()));
 
-        let (is_ref, mt_a) = match a.sty {
-            ty::TyRef(_, mt) => (true, mt),
-            ty::TyRawPtr(mt) => (false, mt),
+        let mt_a = match a.sty {
+            ty::TyRef(_, mt) | ty::TyRawPtr(mt) => mt,
             _ => {
                 return self.subtype(a, b);
             }
@@ -419,15 +418,11 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
         // Although references and unsafe ptrs have the same
         // representation, we still register an AutoDerefRef so that
         // regionck knows that the region for `a` must be valid here.
-        if is_ref {
-            Ok(Some(AdjustDerefRef(AutoDerefRef {
-                autoderefs: 1,
-                autoref: Some(ty::AutoUnsafe(mutbl_b)),
-                unsize: None
-            })))
-        } else {
-            Ok(None)
-        }
+        Ok(Some(AdjustDerefRef(AutoDerefRef {
+            autoderefs: 1,
+            autoref: Some(ty::AutoUnsafe(mutbl_b)),
+            unsize: None
+        })))
     }
 }
 

branches/try/src/libstd/collections/mod.rs

@@ -66,7 +66,7 @@
 //! ### Use a `BTreeMap` when:
 //! * You're interested in what the smallest or largest key-value pair is.
 //! * You want to find the largest or smallest key that is smaller or larger
-//!   than something.
+//!   than something
 //! * You want to be able to get all of the entries in order on-demand.
 //! * You want a sorted map.
 //!
@@ -147,7 +147,7 @@
 //! relation to the number of elements in the collection.  VecMap should only be
 //! seriously considered for small keys.
 //!
-//! Note also that BTreeMap's precise performance depends on the value of B.
+//! Note also that BTreeMap's precise preformance depends on the value of B.
 //!
 //! # Correct and Efficient Usage of Collections
 //!
@@ -309,7 +309,7 @@
 //! If a `Vacant(entry)` is yielded, then the key *was not* found. In this case
 //! the only valid operation is to `insert` a value into the entry. When this is
 //! done, the vacant entry is consumed and converted into a mutable reference to
-//! the value that was inserted. This allows for further manipulation of the
+//! the the value that was inserted. This allows for further manipulation of the
 //! value beyond the lifetime of the search itself. This is useful if complex
 //! logic needs to be performed on the value regardless of whether the value was
 //! just inserted.

branches/try/src/libsyntax/codemap.rs

@@ -17,7 +17,7 @@
 //! within the CodeMap, which upon request can be converted to line and column
 //! information, source code snippets, etc.
 
-pub use self::ExpnFormat::*;
+pub use self::MacroFormat::*;
 
 use std::cell::RefCell;
 use std::ops::{Add, Sub};
@@ -228,17 +228,17 @@ pub struct FileMapAndBytePos { pub fm: Rc<FileMap>, pub pos: BytePos }
 
 
 // _____________________________________________________________________________
-// ExpnFormat, NameAndSpan, ExpnInfo, ExpnId
+// MacroFormat, NameAndSpan, ExpnInfo, ExpnId
 //
 
-/// The source of expansion.
-#[derive(Clone, Copy, Hash, Debug, PartialEq, Eq)]
-pub enum ExpnFormat {
+/// The syntax with which a macro was invoked.
+#[derive(Clone, Copy, Hash, Debug)]
+pub enum MacroFormat {
     /// e.g. #[derive(...)] <item>
     MacroAttribute,
     /// e.g. `format!()`
     MacroBang,
-    /// Syntax sugar expansion performed by the compiler (libsyntax::expand).
+    /// Expansion performed by the compiler (libsyntax::expand).
     CompilerExpansion,
 }
 
@@ -248,7 +248,7 @@ pub struct NameAndSpan {
     /// with this Span.
     pub name: String,
     /// The format with which the macro was invoked.
-    pub format: ExpnFormat,
+    pub format: MacroFormat,
     /// Whether the macro is allowed to use #[unstable]/feature-gated
     /// features internally without forcing the whole crate to opt-in
     /// to them.
@@ -259,11 +259,11 @@ pub struct NameAndSpan {
     pub span: Option<Span>
 }
 
-/// Extra information for tracking spans of macro and syntax sugar expansion
+/// Extra information for tracking macro expansion of spans
 #[derive(Hash, Debug)]
 pub struct ExpnInfo {
-    /// The location of the actual macro invocation or syntax sugar , e.g.
-    /// `let x = foo!();` or `if let Some(y) = x {}`
+    /// The location of the actual macro invocation, e.g. `let x =
+    /// foo!();`
     ///
     /// This may recursively refer to other macro invocations, e.g. if
     /// `foo!()` invoked `bar!()` internally, and there was an
@@ -272,7 +272,12 @@ pub struct ExpnInfo {
     /// call_site span would have its own ExpnInfo, with the call_site
     /// pointing to the `foo!` invocation.
     pub call_site: Span,
-    /// Information about the expansion.
+    /// Information about the macro and its definition.
+    ///
+    /// The `callee` of the inner expression in the `call_site`
+    /// example would point to the `macro_rules! bar { ... }` and that
+    /// of the `bar!()` invocation would point to the `macro_rules!
+    /// foo { ... }`.
     pub callee: NameAndSpan
 }
 
@@ -672,39 +677,7 @@ impl CodeMap {
 
     /// Lookup source information about a BytePos
     pub fn lookup_char_pos(&self, pos: BytePos) -> Loc {
-        let FileMapAndLine {fm: f, line: a} = self.lookup_line(pos);
-        let line = a + 1; // Line numbers start at 1
-        let chpos = self.bytepos_to_file_charpos(pos);
-        let linebpos = (*f.lines.borrow())[a];
-        let linechpos = self.bytepos_to_file_charpos(linebpos);
-        debug!("byte pos {:?} is on the line at byte pos {:?}",
-               pos, linebpos);
-        debug!("char pos {:?} is on the line at char pos {:?}",
-               chpos, linechpos);
-        debug!("byte is on line: {}", line);
-        assert!(chpos >= linechpos);
-        Loc {
-            file: f,
-            line: line,
-            col: chpos - linechpos
-        }
-    }
-
-    fn lookup_line(&self, pos: BytePos) -> FileMapAndLine {
-        let idx = self.lookup_filemap_idx(pos);
-
-        let files = self.files.borrow();
-        let f = (*files)[idx].clone();
-        let mut a = 0;
-        {
-            let lines = f.lines.borrow();
-            let mut b = lines.len();
-            while b - a > 1 {
-                let m = (a + b) / 2;
-                if (*lines)[m] > pos { b = m; } else { a = m; }
-            }
-        }
-        FileMapAndLine {fm: f, line: a}
+        self.lookup_pos(pos)
     }
 
     pub fn lookup_char_pos_adj(&self, pos: BytePos) -> LocWithOpt {
@@ -904,6 +877,42 @@ impl CodeMap {
         return a;
     }
 
+    fn lookup_line(&self, pos: BytePos) -> FileMapAndLine {
+        let idx = self.lookup_filemap_idx(pos);
+
+        let files = self.files.borrow();
+        let f = (*files)[idx].clone();
+        let mut a = 0;
+        {
+            let lines = f.lines.borrow();
+            let mut b = lines.len();
+            while b - a > 1 {
+                let m = (a + b) / 2;
+                if (*lines)[m] > pos { b = m; } else { a = m; }
+            }
+        }
+        FileMapAndLine {fm: f, line: a}
+    }
+
+    fn lookup_pos(&self, pos: BytePos) -> Loc {
+        let FileMapAndLine {fm: f, line: a} = self.lookup_line(pos);
+        let line = a + 1; // Line numbers start at 1
+        let chpos = self.bytepos_to_file_charpos(pos);
+        let linebpos = (*f.lines.borrow())[a];
+        let linechpos = self.bytepos_to_file_charpos(linebpos);
+        debug!("byte pos {:?} is on the line at byte pos {:?}",
+               pos, linebpos);
+        debug!("char pos {:?} is on the line at char pos {:?}",
+               chpos, linechpos);
+        debug!("byte is on line: {}", line);
+        assert!(chpos >= linechpos);
+        Loc {
+            file: f,
+            line: line,
+            col: chpos - linechpos
+        }
+    }
+
     pub fn record_expansion(&self, expn_info: ExpnInfo) -> ExpnId {
         let mut expansions = self.expansions.borrow_mut();
         expansions.push(expn_info);