Rollup of 12 pull requests

src/Cargo.lock

@@ -2048,6 +2048,7 @@ version = "0.0.0"
 dependencies = [
  "log 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "rustc 0.0.0",
+ "rustc_data_structures 0.0.0",
  "rustc_errors 0.0.0",
  "rustc_target 0.0.0",
  "syntax 0.0.0",

src/librustc/hir/lowering.rs

@@ -51,6 +51,8 @@ use lint::builtin::{self, PARENTHESIZED_PARAMS_IN_TYPES_AND_MODULES,
                     ELIDED_LIFETIMES_IN_PATHS};
 use middle::cstore::CrateStore;
 use rustc_data_structures::indexed_vec::IndexVec;
+use rustc_data_structures::small_vec::OneVector;
+use rustc_data_structures::thin_vec::ThinVec;
 use session::Session;
 use util::common::FN_OUTPUT_NAME;
 use util::nodemap::{DefIdMap, NodeMap};
@@ -71,7 +73,6 @@ use syntax::std_inject;
 use syntax::symbol::{keywords, Symbol};
 use syntax::tokenstream::{Delimited, TokenStream, TokenTree};
 use syntax::parse::token::Token;
-use syntax::util::small_vector::SmallVector;
 use syntax::visit::{self, Visitor};
 use syntax_pos::{Span, MultiSpan};
 
@@ -3136,12 +3137,12 @@ impl<'a> LoweringContext<'a> {
         &mut self,
         decl: &FnDecl,
         header: &FnHeader,
-        ids: &mut SmallVector<hir::ItemId>,
+        ids: &mut OneVector<hir::ItemId>,
     ) {
         if let Some(id) = header.asyncness.opt_return_id() {
             ids.push(hir::ItemId { id });
         }
-        struct IdVisitor<'a> { ids: &'a mut SmallVector<hir::ItemId> }
+        struct IdVisitor<'a> { ids: &'a mut OneVector<hir::ItemId> }
         impl<'a, 'b> Visitor<'a> for IdVisitor<'b> {
             fn visit_ty(&mut self, ty: &'a Ty) {
                 match ty.node {
@@ -3174,36 +3175,36 @@ impl<'a> LoweringContext<'a> {
         }
     }
 
-    fn lower_item_id(&mut self, i: &Item) -> SmallVector<hir::ItemId> {
+    fn lower_item_id(&mut self, i: &Item) -> OneVector<hir::ItemId> {
         match i.node {
             ItemKind::Use(ref use_tree) => {
-                let mut vec = SmallVector::one(hir::ItemId { id: i.id });
+                let mut vec = OneVector::one(hir::ItemId { id: i.id });
                 self.lower_item_id_use_tree(use_tree, i.id, &mut vec);
                 vec
             }
-            ItemKind::MacroDef(..) => SmallVector::new(),
+            ItemKind::MacroDef(..) => OneVector::new(),
             ItemKind::Fn(ref decl, ref header, ..) => {
-                let mut ids = SmallVector::one(hir::ItemId { id: i.id });
+                let mut ids = OneVector::one(hir::ItemId { id: i.id });
                 self.lower_impl_trait_ids(decl, header, &mut ids);
                 ids
             },
             ItemKind::Impl(.., None, _, ref items) => {
-                let mut ids = SmallVector::one(hir::ItemId { id: i.id });
+                let mut ids = OneVector::one(hir::ItemId { id: i.id });
                 for item in items {
                     if let ImplItemKind::Method(ref sig, _) = item.node {
                         self.lower_impl_trait_ids(&sig.decl, &sig.header, &mut ids);
                     }
                 }
                 ids
             },
-            _ => SmallVector::one(hir::ItemId { id: i.id }),
+            _ => OneVector::one(hir::ItemId { id: i.id }),
         }
     }
 
     fn lower_item_id_use_tree(&mut self,
                               tree: &UseTree,
                               base_id: NodeId,
-                              vec: &mut SmallVector<hir::ItemId>)
+                              vec: &mut OneVector<hir::ItemId>)
     {
         match tree.kind {
             UseTreeKind::Nested(ref nested_vec) => for &(ref nested, id) in nested_vec {
@@ -4295,8 +4296,8 @@ impl<'a> LoweringContext<'a> {
         }
     }
 
-    fn lower_stmt(&mut self, s: &Stmt) -> SmallVector<hir::Stmt> {
-        SmallVector::one(match s.node {
+    fn lower_stmt(&mut self, s: &Stmt) -> OneVector<hir::Stmt> {
+        OneVector::one(match s.node {
             StmtKind::Local(ref l) => Spanned {
                 node: hir::StmtKind::Decl(
                     P(Spanned {

src/librustc/hir/mod.rs

@@ -33,13 +33,13 @@ use syntax::ext::hygiene::SyntaxContext;
 use syntax::ptr::P;
 use syntax::symbol::{Symbol, keywords};
 use syntax::tokenstream::TokenStream;
-use syntax::util::ThinVec;
 use syntax::util::parser::ExprPrecedence;
 use ty::AdtKind;
 use ty::query::Providers;
 
 use rustc_data_structures::indexed_vec;
 use rustc_data_structures::sync::{ParallelIterator, par_iter, Send, Sync, scope};
+use rustc_data_structures::thin_vec::ThinVec;
 
 use serialize::{self, Encoder, Encodable, Decoder, Decodable};
 use std::collections::BTreeMap;

src/librustc/traits/auto_trait.rs

@@ -681,10 +681,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
                     }
                 }
                 &ty::Predicate::RegionOutlives(ref binder) => {
-                    if let Err(_) = select
-                        .infcx()
-                        .region_outlives_predicate(&dummy_cause, binder)
-                    {
+                    if select.infcx().region_outlives_predicate(&dummy_cause, binder).is_err() {
                         return false;
                     }
                 }

src/librustc/traits/error_reporting.rs

@@ -143,7 +143,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                 // Eventually I'll need to implement param-env-aware
                 // `Γ₁ ⊦ φ₁ => Γ₂ ⊦ φ₂` logic.
                 let param_env = ty::ParamEnv::empty();
-                if let Ok(_) = self.can_sub(param_env, error, implication) {
+                if self.can_sub(param_env, error, implication).is_ok() {
                     debug!("error_implies: {:?} -> {:?} -> {:?}", cond, error, implication);
                     return true
                 }

src/librustc/traits/query/outlives_bounds.rs

@@ -137,7 +137,7 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {
         // variables. Process these constraints.
         let mut fulfill_cx = FulfillmentContext::new();
         fulfill_cx.register_predicate_obligations(self, result.obligations);
-        if let Err(_) = fulfill_cx.select_all_or_error(self) {
+        if fulfill_cx.select_all_or_error(self).is_err() {
             self.tcx.sess.delay_span_bug(
                 span,
                 "implied_outlives_bounds failed to solve obligations from instantiation"

src/librustc/traits/select.rs

@@ -1587,8 +1587,8 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
                         -> bool
     {
         assert!(!skol_trait_ref.has_escaping_regions());
-        if let Err(_) = self.infcx.at(&obligation.cause, obligation.param_env)
-                                  .sup(ty::Binder::dummy(skol_trait_ref), trait_bound) {
+        if self.infcx.at(&obligation.cause, obligation.param_env)
+                     .sup(ty::Binder::dummy(skol_trait_ref), trait_bound).is_err() {
             return false;
         }
 

src/librustc/ty/instance.rs

@@ -294,7 +294,7 @@ fn resolve_associated_item<'a, 'tcx>(
             })
         }
         traits::VtableBuiltin(..) => {
-            if let Some(_) = tcx.lang_items().clone_trait() {
+            if tcx.lang_items().clone_trait().is_some() {
                 Some(Instance {
                     def: ty::InstanceDef::CloneShim(def_id, trait_ref.self_ty()),
                     substs: rcvr_substs

src/librustc_allocator/Cargo.toml

@@ -10,6 +10,7 @@ test = false
 
 [dependencies]
 rustc = { path = "../librustc" }
+rustc_data_structures = { path = "../librustc_data_structures" }
 rustc_errors = { path = "../librustc_errors" }
 rustc_target = { path = "../librustc_target" }
 syntax = { path = "../libsyntax" }

src/librustc_allocator/expand.rs

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 use rustc::middle::allocator::AllocatorKind;
+use rustc_data_structures::small_vec::OneVector;
 use rustc_errors;
 use syntax::{
     ast::{
@@ -28,8 +29,7 @@ use syntax::{
     fold::{self, Folder},
     parse::ParseSess,
     ptr::P,
-    symbol::Symbol,
-    util::small_vector::SmallVector,
+    symbol::Symbol
 };
 use syntax_pos::Span;
 
@@ -65,7 +65,7 @@ struct ExpandAllocatorDirectives<'a> {
 }
 
 impl<'a> Folder for ExpandAllocatorDirectives<'a> {
-    fn fold_item(&mut self, item: P<Item>) -> SmallVector<P<Item>> {
+    fn fold_item(&mut self, item: P<Item>) -> OneVector<P<Item>> {
         debug!("in submodule {}", self.in_submod);
 
         let name = if attr::contains_name(&item.attrs, "global_allocator") {
@@ -78,20 +78,20 @@ impl<'a> Folder for ExpandAllocatorDirectives<'a> {
             _ => {
                 self.handler
                     .span_err(item.span, "allocators must be statics");
-                return SmallVector::one(item);
+                return OneVector::one(item);
             }
         }
 
         if self.in_submod > 0 {
             self.handler
                 .span_err(item.span, "`global_allocator` cannot be used in submodules");
-            return SmallVector::one(item);
+            return OneVector::one(item);
         }
 
         if self.found {
             self.handler
                 .span_err(item.span, "cannot define more than one #[global_allocator]");
-            return SmallVector::one(item);
+            return OneVector::one(item);
         }
         self.found = true;
 
@@ -152,7 +152,7 @@ impl<'a> Folder for ExpandAllocatorDirectives<'a> {
         let module = f.cx.monotonic_expander().fold_item(module).pop().unwrap();
 
         // Return the item and new submodule
-        let mut ret = SmallVector::with_capacity(2);
+        let mut ret = OneVector::with_capacity(2);
         ret.push(item);
         ret.push(module);
 

src/librustc_allocator/lib.rs

@@ -12,6 +12,7 @@
 
 #[macro_use] extern crate log;
 extern crate rustc;
+extern crate rustc_data_structures;
 extern crate rustc_errors;
 extern crate rustc_target;
 extern crate syntax;

src/librustc_codegen_llvm/consts.rs

@@ -351,7 +351,7 @@ pub fn codegen_static<'a, 'tcx>(
         if attrs.flags.contains(CodegenFnAttrFlags::THREAD_LOCAL) {
             llvm::set_thread_local_mode(g, cx.tls_model);
 
-            // Do not allow LLVM to change the alignment of a TLS on macOS.
+            // Do not allow LLVM to change the alignment of a TLS on macOS and Fuchsia.
             //
             // By default a global's alignment can be freely increased.
             // This allows LLVM to generate more performant instructions
@@ -361,6 +361,10 @@ pub fn codegen_static<'a, 'tcx>(
             // respect any alignment given on the TLS (radar 24221680).
             // This will violate the alignment assumption, and causing segfault at runtime.
             //
+            // Fuchsia's libc currently does not support greater than 16-byte alignment
+            // of TLS segments, so this hack is also enabled temporarily for Fuchsia targets
+            // until libc is fixed.
+            //
             // This bug is very easy to trigger. In `println!` and `panic!`,
             // the `LOCAL_STDOUT`/`LOCAL_STDERR` handles are stored in a TLS,
             // which the values would be `mem::replace`d on initialization.
@@ -380,7 +384,9 @@ pub fn codegen_static<'a, 'tcx>(
             // will use load-unaligned instructions instead, and thus avoiding the crash.
             //
             // We could remove this hack whenever we decide to drop macOS 10.10 support.
-            if cx.tcx.sess.target.target.options.is_like_osx {
+            if cx.tcx.sess.target.target.options.is_like_osx ||
+                (cx.tcx.sess.target.target.target_os == "fuchsia")
+            {
                 let sect_name = if alloc.bytes.iter().all(|b| *b == 0) {
                     CStr::from_bytes_with_nul_unchecked(b"__DATA,__thread_bss\0")
                 } else {

src/librustc_data_structures/lib.rs

@@ -74,6 +74,7 @@ pub mod sorted_map;
 pub mod stable_hasher;
 pub mod sync;
 pub mod tiny_list;
+pub mod thin_vec;
 pub mod transitive_relation;
 pub mod tuple_slice;
 pub use ena::unify;

src/librustc_data_structures/small_vec.rs

@@ -29,6 +29,8 @@ use array_vec::Array;
 
 pub struct SmallVec<A: Array>(AccumulateVec<A>);
 
+pub type OneVector<T> = SmallVec<[T; 1]>;
+
 impl<A> Clone for SmallVec<A>
     where A: Array,
           A::Element: Clone {
@@ -222,6 +224,69 @@ mod tests {
 
     use super::*;
 
+    #[test]
+    fn test_len() {
+        let v: OneVector<isize> = OneVector::new();
+        assert_eq!(0, v.len());
+
+        assert_eq!(1, OneVector::one(1).len());
+        assert_eq!(5, OneVector::many(vec![1, 2, 3, 4, 5]).len());
+    }
+
+    #[test]
+    fn test_push_get() {
+        let mut v = OneVector::new();
+        v.push(1);
+        assert_eq!(1, v.len());
+        assert_eq!(1, v[0]);
+        v.push(2);
+        assert_eq!(2, v.len());
+        assert_eq!(2, v[1]);
+        v.push(3);
+        assert_eq!(3, v.len());
+        assert_eq!(3, v[2]);
+    }
+
+    #[test]
+    fn test_from_iter() {
+        let v: OneVector<isize> = (vec![1, 2, 3]).into_iter().collect();
+        assert_eq!(3, v.len());
+        assert_eq!(1, v[0]);
+        assert_eq!(2, v[1]);
+        assert_eq!(3, v[2]);
+    }
+
+    #[test]
+    fn test_move_iter() {
+        let v = OneVector::new();
+        let v: Vec<isize> = v.into_iter().collect();
+        assert_eq!(v, Vec::new());
+
+        let v = OneVector::one(1);
+        assert_eq!(v.into_iter().collect::<Vec<_>>(), [1]);
+
+        let v = OneVector::many(vec![1, 2, 3]);
+        assert_eq!(v.into_iter().collect::<Vec<_>>(), [1, 2, 3]);
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_expect_one_zero() {
+        let _: isize = OneVector::new().expect_one("");
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_expect_one_many() {
+        OneVector::many(vec![1, 2]).expect_one("");
+    }
+
+    #[test]
+    fn test_expect_one_one() {
+        assert_eq!(1, OneVector::one(1).expect_one(""));
+        assert_eq!(1, OneVector::many(vec![1]).expect_one(""));
+    }
+
     #[bench]
     fn fill_small_vec_1_10_with_cap(b: &mut Bencher) {
         b.iter(|| {

src/librustc_driver/pretty.rs

@@ -24,6 +24,8 @@ use rustc::session::Session;
 use rustc::session::config::{Input, OutputFilenames};
 use rustc_borrowck as borrowck;
 use rustc_borrowck::graphviz as borrowck_dot;
+use rustc_data_structures::small_vec::OneVector;
+use rustc_data_structures::thin_vec::ThinVec;
 use rustc_metadata::cstore::CStore;
 
 use rustc_mir::util::{write_mir_pretty, write_mir_graphviz};
@@ -33,8 +35,6 @@ use syntax::fold::{self, Folder};
 use syntax::print::{pprust};
 use syntax::print::pprust::PrintState;
 use syntax::ptr::P;
-use syntax::util::ThinVec;
-use syntax::util::small_vector::SmallVector;
 use syntax_pos::{self, FileName};
 
 use graphviz as dot;
@@ -727,7 +727,7 @@ impl<'a> fold::Folder for ReplaceBodyWithLoop<'a> {
         self.run(is_const, |s| fold::noop_fold_item_kind(i, s))
     }
 
-    fn fold_trait_item(&mut self, i: ast::TraitItem) -> SmallVector<ast::TraitItem> {
+    fn fold_trait_item(&mut self, i: ast::TraitItem) -> OneVector<ast::TraitItem> {
         let is_const = match i.node {
             ast::TraitItemKind::Const(..) => true,
             ast::TraitItemKind::Method(ast::MethodSig { ref decl, ref header, .. }, _) =>
@@ -737,7 +737,7 @@ impl<'a> fold::Folder for ReplaceBodyWithLoop<'a> {
         self.run(is_const, |s| fold::noop_fold_trait_item(i, s))
     }
 
-    fn fold_impl_item(&mut self, i: ast::ImplItem) -> SmallVector<ast::ImplItem> {
+    fn fold_impl_item(&mut self, i: ast::ImplItem) -> OneVector<ast::ImplItem> {
         let is_const = match i.node {
             ast::ImplItemKind::Const(..) => true,
             ast::ImplItemKind::Method(ast::MethodSig { ref decl, ref header, .. }, _) =>
@@ -785,7 +785,7 @@ impl<'a> fold::Folder for ReplaceBodyWithLoop<'a> {
             node: ast::ExprKind::Loop(P(empty_block), None),
             id: self.sess.next_node_id(),
             span: syntax_pos::DUMMY_SP,
-            attrs: ast::ThinVec::new(),
+                attrs: ThinVec::new(),
         });
 
         let loop_stmt = ast::Stmt {