---

yaml
---
r: 220863
b: refs/heads/master
c: 4e67f9c
h: refs/heads/master
i:
  220861: 0521d83
  220859: 28b159b
  220855: dbf93c9
  220847: 18b283b
  220831: 5f480e0
  220799: 1e70e60
v: v3

Author: eternaleye

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: c9ef1a5c19b8f9a254b0fb0b79a3bebf0722a9ce
+refs/heads/master: 4e67f9c611e31691aa1be1f2b1e09dc523fa7056
 refs/heads/snap-stage3: d4432b37378ec55450e06799f5344b4b0f4b94e0
 refs/heads/try: b53c0f93eedcdedd4fd89bccc5a3a09d1c5cd23e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

trunk/src/librustc/middle/resolve_lifetime.rs

@@ -109,7 +109,7 @@ pub fn krate(sess: &Session, krate: &ast::Crate, def_map: &DefMap) -> NamedRegio
 
 impl<'a, 'v> Visitor<'v> for LifetimeContext<'a> {
     fn visit_item(&mut self, item: &ast::Item) {
-        // Items save/restore the set of labels. This way inner items
+        // Items save/restore the set of labels. This way innner items
         // can freely reuse names, be they loop labels or lifetimes.
         let saved = replace(&mut self.labels_in_fn, vec![]);
 
@@ -151,29 +151,6 @@ impl<'a, 'v> Visitor<'v> for LifetimeContext<'a> {
         replace(&mut self.labels_in_fn, saved);
     }
 
-    fn visit_foreign_item(&mut self, item: &ast::ForeignItem) {
-        // Items save/restore the set of labels. This way inner items
-        // can freely reuse names, be they loop labels or lifetimes.
-        let saved = replace(&mut self.labels_in_fn, vec![]);
-
-        // Items always introduce a new root scope
-        self.with(RootScope, |_, this| {
-            match item.node {
-                ast::ForeignItemFn(_, ref generics) => {
-                    this.visit_early_late(subst::FnSpace, generics, |this| {
-                        visit::walk_foreign_item(this, item);
-                    })
-                }
-                ast::ForeignItemStatic(..) => {
-                    visit::walk_foreign_item(this, item);
-                }
-            }
-        });
-
-        // Done traversing the item; restore saved set of labels.
-        replace(&mut self.labels_in_fn, saved);
-    }
-
     fn visit_fn(&mut self, fk: visit::FnKind<'v>, fd: &'v ast::FnDecl,
                 b: &'v ast::Block, s: Span, _: ast::NodeId) {
         match fk {

trunk/src/librustc/middle/ty.rs

@@ -3967,6 +3967,7 @@ def_type_content_sets! {
         None                                = 0b0000_0000__0000_0000__0000,
 
         // Things that are interior to the value (first nibble):
+        InteriorUnsized                     = 0b0000_0000__0000_0000__0001,
         InteriorUnsafe                      = 0b0000_0000__0000_0000__0010,
         InteriorParam                       = 0b0000_0000__0000_0000__0100,
         // InteriorAll                         = 0b00000000__00000000__1111,
@@ -3976,9 +3977,18 @@ def_type_content_sets! {
         OwnsDtor                            = 0b0000_0000__0000_0010__0000,
         OwnsAll                             = 0b0000_0000__1111_1111__0000,
 
+        // Things that are reachable by the value in any way (fourth nibble):
+        ReachesBorrowed                     = 0b0000_0010__0000_0000__0000,
+        ReachesMutable                      = 0b0000_1000__0000_0000__0000,
+        ReachesFfiUnsafe                    = 0b0010_0000__0000_0000__0000,
+        ReachesAll                          = 0b0011_1111__0000_0000__0000,
+
         // Things that mean drop glue is necessary
         NeedsDrop                           = 0b0000_0000__0000_0111__0000,
 
+        // Things that prevent values from being considered sized
+        Nonsized                            = 0b0000_0000__0000_0000__0001,
+
         // All bits
         All                                 = 0b1111_1111__1111_1111__1111
     }
@@ -3997,6 +4007,10 @@ impl TypeContents {
         self.intersects(TC::OwnsOwned)
     }
 
+    pub fn is_sized(&self, _: &ctxt) -> bool {
+        !self.intersects(TC::Nonsized)
+    }
+
     pub fn interior_param(&self) -> bool {
         self.intersects(TC::InteriorParam)
     }
@@ -4005,13 +4019,29 @@ impl TypeContents {
         self.intersects(TC::InteriorUnsafe)
     }
 
+    pub fn interior_unsized(&self) -> bool {
+        self.intersects(TC::InteriorUnsized)
+    }
+
     pub fn needs_drop(&self, _: &ctxt) -> bool {
         self.intersects(TC::NeedsDrop)
     }
 
     /// Includes only those bits that still apply when indirected through a `Box` pointer
     pub fn owned_pointer(&self) -> TypeContents {
-        TC::OwnsOwned | (*self & TC::OwnsAll)
+        TC::OwnsOwned | (
+            *self & (TC::OwnsAll | TC::ReachesAll))
+    }
+
+    /// Includes only those bits that still apply when indirected through a reference (`&`)
+    pub fn reference(&self, bits: TypeContents) -> TypeContents {
+        bits | (
+            *self & TC::ReachesAll)
+    }
+
+    /// Includes only those bits that still apply when indirected through a raw pointer (`*`)
+    pub fn unsafe_pointer(&self) -> TypeContents {
+        *self & TC::ReachesAll
     }
 
     pub fn union<T, F>(v: &[T], mut f: F) -> TypeContents where
@@ -4099,7 +4129,7 @@ impl<'tcx> TyS<'tcx> {
             let result = match ty.sty {
                 // usize and isize are ffi-unsafe
                 TyUint(ast::TyUs) | TyInt(ast::TyIs) => {
-                    TC::None
+                    TC::ReachesFfiUnsafe
                 }
 
                 // Scalar and unique types are sendable, and durable
@@ -4110,35 +4140,40 @@ impl<'tcx> TyS<'tcx> {
                 }
 
                 TyBox(typ) => {
-                    tc_ty(cx, typ, cache).owned_pointer()
+                    TC::ReachesFfiUnsafe | tc_ty(cx, typ, cache).owned_pointer()
                 }
 
-                TyTrait(_) => {
-                    TC::All - TC::InteriorParam
+                TyTrait(box TraitTy { ref bounds, .. }) => {
+                    object_contents(bounds) | TC::ReachesFfiUnsafe | TC::Nonsized
                 }
 
-                TyRawPtr(_) => {
-                    TC::None
+                TyRawPtr(ref mt) => {
+                    tc_ty(cx, mt.ty, cache).unsafe_pointer()
                 }
 
-                TyRef(_, _) => {
-                    TC::None
+                TyRef(r, ref mt) => {
+                    tc_ty(cx, mt.ty, cache).reference(borrowed_contents(*r, mt.mutbl)) |
+                        TC::ReachesFfiUnsafe
                 }
 
                 TyArray(ty, _) => {
                     tc_ty(cx, ty, cache)
                 }
 
                 TySlice(ty) => {
-                    tc_ty(cx, ty, cache)
+                    tc_ty(cx, ty, cache) | TC::Nonsized
                 }
-                TyStr => TC::None,
+                TyStr => TC::Nonsized,
 
                 TyStruct(did, substs) => {
                     let flds = cx.struct_fields(did, substs);
                     let mut res =
                         TypeContents::union(&flds[..],
-                                            |f| tc_ty(cx, f.mt.ty, cache));
+                                            |f| tc_mt(cx, f.mt, cache));
+
+                    if !cx.lookup_repr_hints(did).contains(&attr::ReprExtern) {
+                        res = res | TC::ReachesFfiUnsafe;
+                    }
 
                     if cx.has_dtor(did) {
                         res = res | TC::OwnsDtor;
@@ -4147,6 +4182,7 @@ impl<'tcx> TyS<'tcx> {
                 }
 
                 TyClosure(did, substs) => {
+                    // FIXME(#14449): `borrowed_contents` below assumes `&mut` closure.
                     let param_env = cx.empty_parameter_environment();
                     let infcx = infer::new_infer_ctxt(cx, &cx.tables, Some(param_env), false);
                     let upvars = infcx.closure_upvars(did, substs).unwrap();
@@ -4172,6 +4208,44 @@ impl<'tcx> TyS<'tcx> {
                         res = res | TC::OwnsDtor;
                     }
 
+                    if !variants.is_empty() {
+                        let repr_hints = cx.lookup_repr_hints(did);
+                        if repr_hints.len() > 1 {
+                            // this is an error later on, but this type isn't safe
+                            res = res | TC::ReachesFfiUnsafe;
+                        }
+
+                        match repr_hints.get(0) {
+                            Some(h) => if !h.is_ffi_safe() {
+                                res = res | TC::ReachesFfiUnsafe;
+                            },
+                            // ReprAny
+                            None => {
+                                res = res | TC::ReachesFfiUnsafe;
+
+                                // We allow ReprAny enums if they are eligible for
+                                // the nullable pointer optimization and the
+                                // contained type is an `extern fn`
+
+                                if variants.len() == 2 {
+                                    let mut data_idx = 0;
+
+                                    if variants[0].args.is_empty() {
+                                        data_idx = 1;
+                                    }
+
+                                    if variants[data_idx].args.len() == 1 {
+                                        match variants[data_idx].args[0].sty {
+                                            TyBareFn(..) => { res = res - TC::ReachesFfiUnsafe; }
+                                            _ => { }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+
                     apply_lang_items(cx, did, res)
                 }
 
@@ -4190,6 +4264,14 @@ impl<'tcx> TyS<'tcx> {
             result
         }
 
+        fn tc_mt<'tcx>(cx: &ctxt<'tcx>,
+                       mt: TypeAndMut<'tcx>,
+                       cache: &mut FnvHashMap<Ty<'tcx>, TypeContents>) -> TypeContents
+        {
+            let mc = TC::ReachesMutable.when(mt.mutbl == MutMutable);
+            mc | tc_ty(cx, mt.ty, cache)
+        }
+
         fn apply_lang_items(cx: &ctxt, did: ast::DefId, tc: TypeContents)
                             -> TypeContents {
             if Some(did) == cx.lang_items.unsafe_cell_type() {
@@ -4198,6 +4280,32 @@ impl<'tcx> TyS<'tcx> {
                 tc
             }
         }
+
+        /// Type contents due to containing a reference with
+        /// the region `region` and borrow kind `bk`.
+        fn borrowed_contents(region: ty::Region,
+                             mutbl: ast::Mutability)
+                             -> TypeContents {
+            let b = match mutbl {
+                ast::MutMutable => TC::ReachesMutable,
+                ast::MutImmutable => TC::None,
+            };
+            b | (TC::ReachesBorrowed).when(region != ty::ReStatic)
+        }
+
+        fn object_contents(bounds: &ExistentialBounds) -> TypeContents {
+            // These are the type contents of the (opaque) interior. We
+            // make no assumptions (other than that it cannot have an
+            // in-scope type parameter within, which makes no sense).
+            let mut tc = TC::All - TC::InteriorParam;
+            for bound in &bounds.builtin_bounds {
+                tc = tc - match bound {
+                    BoundSync | BoundSend | BoundCopy => TC::None,
+                    BoundSized => TC::Nonsized,
+                };
+            }
+            return tc;
+        }
     }
 
     fn impls_bound<'a>(&'tcx self, param_env: &ParameterEnvironment<'a,'tcx>,
@@ -4291,6 +4399,10 @@ impl<'tcx> TyS<'tcx> {
         result
     }
 
+    pub fn is_ffi_safe(&'tcx self, cx: &ctxt<'tcx>) -> bool {
+        !self.type_contents(cx).intersects(TC::ReachesFfiUnsafe)
+    }
+
     // True if instantiating an instance of `r_ty` requires an instance of `r_ty`.
     pub fn is_instantiable(&'tcx self, cx: &ctxt<'tcx>) -> bool {
         fn type_requires<'tcx>(cx: &ctxt<'tcx>, seen: &mut Vec<DefId>,