---

yaml
---
r: 212969
b: refs/heads/master
c: 8e969de
h: refs/heads/master
i:
  212967: cf2a935
v: v3

Author: IvanUkhov

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 3afc385ae1e25b3747980a1d2652a1fd8c282359
+refs/heads/master: 8e969dee689ecdb588434080a614a11fca0ecde7
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ba0e1cd8147d452c356aacb29fb87568ca26f111
 refs/heads/try: 1864973ae17213c5a58c4dd3f9af6d1b6c7d2e05

trunk/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

trunk/src/doc/trpl/traits.md

@@ -332,7 +332,7 @@ fn normal<T: ConvertTo<i64>>(x: &T) -> i64 {
 fn inverse<T>() -> T
         // this is using ConvertTo as if it were "ConvertFrom<i32>"
         where i32: ConvertTo<T> {
-    42.convert()
+    1i32.convert()
 }
 ```
 

trunk/src/libcore/char.rs

@@ -74,8 +74,17 @@ pub const MAX: char = '\u{10ffff}';
 /// ```
 /// use std::char;
 ///
-/// assert_eq!(char::from_u32(0x2764), Some('❤'));
-/// assert_eq!(char::from_u32(0x110000), None); // invalid character
+/// let c = char::from_u32(10084); // produces `Some(❤)`
+/// assert_eq!(c, Some('❤'));
+/// ```
+///
+/// An invalid character:
+///
+/// ```
+/// use std::char;
+///
+/// let none = char::from_u32(1114112);
+/// assert_eq!(none, None);
 /// ```
 #[inline]
 #[stable(feature = "rust1", since = "1.0.0")]

trunk/src/librustc/middle/check_const.rs

@@ -285,7 +285,7 @@ impl<'a, 'tcx> CheckCrateVisitor<'a, 'tcx> {
     fn check_static_type(&self, e: &ast::Expr) {
         let ty = ty::node_id_to_type(self.tcx, e.id);
         let infcx = infer::new_infer_ctxt(self.tcx);
-        let mut fulfill_cx = traits::FulfillmentContext::new(false);
+        let mut fulfill_cx = traits::FulfillmentContext::new();
         let cause = traits::ObligationCause::new(e.span, e.id, traits::SharedStatic);
         fulfill_cx.register_builtin_bound(&infcx, ty, ty::BoundSync, cause);
         let env = ty::empty_parameter_environment(self.tcx);

trunk/src/librustc/middle/dead.rs

@@ -48,7 +48,6 @@ struct MarkSymbolVisitor<'a, 'tcx: 'a> {
     struct_has_extern_repr: bool,
     ignore_non_const_paths: bool,
     inherited_pub_visibility: bool,
-    ignore_variant_stack: Vec<ast::NodeId>,
 }
 
 impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> {
@@ -61,7 +60,6 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> {
             struct_has_extern_repr: false,
             ignore_non_const_paths: false,
             inherited_pub_visibility: false,
-            ignore_variant_stack: vec![],
         }
     }
 
@@ -82,9 +80,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> {
                 def::DefPrimTy(_) => (),
                 def::DefVariant(enum_id, variant_id, _) => {
                     self.check_def_id(enum_id);
-                    if !self.ignore_variant_stack.contains(&variant_id.node) {
-                        self.check_def_id(variant_id);
-                    }
+                    self.check_def_id(variant_id);
                 }
                 _ => {
                     self.check_def_id(def.def_id());
@@ -276,23 +272,6 @@ impl<'a, 'tcx, 'v> Visitor<'v> for MarkSymbolVisitor<'a, 'tcx> {
         visit::walk_expr(self, expr);
     }
 
-    fn visit_arm(&mut self, arm: &ast::Arm) {
-        if arm.pats.len() == 1 {
-            let pat = &*arm.pats[0];
-            let variants = pat_util::necessary_variants(&self.tcx.def_map, pat);
-
-            // Inside the body, ignore constructions of variants
-            // necessary for the pattern to match. Those construction sites
-            // can't be reached unless the variant is constructed elsewhere.
-            let len = self.ignore_variant_stack.len();
-            self.ignore_variant_stack.push_all(&*variants);
-            visit::walk_arm(self, arm);
-            self.ignore_variant_stack.truncate(len);
-        } else {
-            visit::walk_arm(self, arm);
-        }
-    }
-
     fn visit_pat(&mut self, pat: &ast::Pat) {
         let def_map = &self.tcx.def_map;
         match pat.node {
@@ -414,11 +393,6 @@ fn create_and_seed_worklist(tcx: &ty::ctxt,
         worklist.push(*id);
     }
     for id in reachable_symbols {
-        // Reachable variants can be dead, because we warn about
-        // variants never constructed, not variants never used.
-        if let Some(ast_map::NodeVariant(..)) = tcx.map.find(*id) {
-            continue;
-        }
         worklist.push(*id);
     }
 

trunk/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))
                 }
             }
 

trunk/src/librustc/middle/pat_util.rs

@@ -201,27 +201,3 @@ pub fn def_to_path(tcx: &ty::ctxt, id: ast::DefId) -> ast::Path {
         span: DUMMY_SP,
     })
 }
-
-/// Return variants that are necessary to exist for the pattern to match.
-pub fn necessary_variants(dm: &DefMap, pat: &ast::Pat) -> Vec<ast::NodeId> {
-    let mut variants = vec![];
-    walk_pat(pat, |p| {
-        match p.node {
-            ast::PatEnum(_, _) |
-            ast::PatIdent(_, _, None) |
-            ast::PatStruct(..) => {
-                match dm.borrow().get(&p.id) {
-                    Some(&PathResolution { base_def: DefVariant(_, id, _), .. }) => {
-                        variants.push(id.node);
-                    }
-                    _ => ()
-                }
-            }
-            _ => ()
-        }
-        true
-    });
-    variants.sort();
-    variants.dedup();
-    variants
-}

trunk/src/librustc/middle/traits/fulfill.rs

@@ -28,10 +28,6 @@ use super::select::SelectionContext;
 use super::Unimplemented;
 use super::util::predicate_for_builtin_bound;
 
-pub struct FulfilledPredicates<'tcx> {
-    set: HashSet<ty::Predicate<'tcx>>
-}
-
 /// The fulfillment context is used to drive trait resolution.  It
 /// consists of a list of obligations that must be (eventually)
 /// satisfied. The job is to track which are satisfied, which yielded
@@ -48,7 +44,7 @@ pub struct FulfillmentContext<'tcx> {
     // than the `SelectionCache`: it avoids duplicate errors and
     // permits recursive obligations, which are often generated from
     // traits like `Send` et al.
-    duplicate_set: FulfilledPredicates<'tcx>,
+    duplicate_set: HashSet<ty::Predicate<'tcx>>,
 
     // A list of all obligations that have been registered with this
     // fulfillment context.
@@ -84,8 +80,6 @@ pub struct FulfillmentContext<'tcx> {
     // obligations (otherwise, it's easy to fail to walk to a
     // particular node-id).
     region_obligations: NodeMap<Vec<RegionObligation<'tcx>>>,
-
-    errors_will_be_reported: bool,
 }
 
 #[derive(Clone)]
@@ -96,30 +90,12 @@ pub struct RegionObligation<'tcx> {
 }
 
 impl<'tcx> FulfillmentContext<'tcx> {
-    /// Creates a new fulfillment context.
-    ///
-    /// `errors_will_be_reported` indicates whether ALL errors that
-    /// are generated by this fulfillment context will be reported to
-    /// the end user. This is used to inform caching, because it
-    /// allows us to conclude that traits that resolve successfully
-    /// will in fact always resolve successfully (in particular, it
-    /// guarantees that if some dependent obligation encounters a
-    /// problem, compilation will be aborted).  If you're not sure of
-    /// the right value here, pass `false`, as that is the more
-    /// conservative option.
-    ///
-    /// FIXME -- a better option would be to hold back on modifying
-    /// the global cache until we know that all dependent obligations
-    /// are also satisfied. In that case, we could actually remove
-    /// this boolean flag, and we'd also avoid the problem of squelching
-    /// duplicate errors that occur across fns.
-    pub fn new(errors_will_be_reported: bool) -> FulfillmentContext<'tcx> {
+    pub fn new() -> FulfillmentContext<'tcx> {
         FulfillmentContext {
-            duplicate_set: FulfilledPredicates::new(),
+            duplicate_set: HashSet::new(),
             predicates: Vec::new(),
             attempted_mark: 0,
             region_obligations: NodeMap(),
-            errors_will_be_reported: errors_will_be_reported,
         }
     }
 
@@ -189,7 +165,7 @@ impl<'tcx> FulfillmentContext<'tcx> {
 
         assert!(!obligation.has_escaping_regions());
 
-        if self.is_duplicate_or_add(infcx.tcx, &obligation.predicate) {
+        if !self.duplicate_set.insert(obligation.predicate.clone()) {
             debug!("register_predicate({}) -- already seen, skip", obligation.repr(infcx.tcx));
             return;
         }
@@ -255,28 +231,6 @@ impl<'tcx> FulfillmentContext<'tcx> {
         &self.predicates
     }
 
-    fn is_duplicate_or_add(&mut self, tcx: &ty::ctxt<'tcx>,
-                           predicate: &ty::Predicate<'tcx>)
-                           -> bool {
-        // This is a kind of dirty hack to allow us to avoid "rederiving"
-        // things that we have already proven in other methods.
-        //
-        // The idea is that any predicate that doesn't involve type
-        // parameters and which only involves the 'static region (and
-        // no other regions) is universally solvable, since impls are global.
-        //
-        // This is particularly important since even if we have a
-        // cache hit in the selection context, we still wind up
-        // evaluating the 'nested obligations'.  This cache lets us
-        // skip those.
-
-        if self.errors_will_be_reported && predicate.is_global() {
-            tcx.fulfilled_predicates.borrow_mut().is_duplicate_or_add(predicate)
-        } else {
-            self.duplicate_set.is_duplicate_or_add(predicate)
-        }
-    }
-
     /// Attempts to select obligations using `selcx`. If `only_new_obligations` is true, then it
     /// only attempts to select obligations that haven't been seen before.
     fn select<'a>(&mut self,
@@ -488,21 +442,3 @@ fn register_region_obligation<'tcx>(tcx: &ty::ctxt<'tcx>,
         .push(region_obligation);
 
 }
-
-impl<'tcx> FulfilledPredicates<'tcx> {
-    pub fn new() -> FulfilledPredicates<'tcx> {
-        FulfilledPredicates {
-            set: HashSet::new()
-        }
-    }
-
-    pub fn is_duplicate(&self, p: &ty::Predicate<'tcx>) -> bool {
-        self.set.contains(p)
-    }
-
-    fn is_duplicate_or_add(&mut self, p: &ty::Predicate<'tcx>) -> bool {
-        !self.set.insert(p.clone())
-    }
-}
-
-