---

yaml
---
r: 274719
b: refs/heads/stable
c: b5da60d
h: refs/heads/master
i:
  274717: e3aa9da
  274715: 82c27d4
  274711: 1666a47
  274703: 9428a1e
  274687: fe0a373

Author: bors

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: c0221c8897db309a79990367476177b1230bb264
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: 75acee2bdee0278e0dc9610bfd05eb4367e41c20
+refs/heads/stable: b5da60d03a5926adcb770e55bb3ef535583a4d37
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/src/libcollections/vec_deque.rs

@@ -1968,7 +1968,39 @@ impl<'a, T: 'a> ExactSizeIterator for Drain<'a, T> {}
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<A: PartialEq> PartialEq for VecDeque<A> {
     fn eq(&self, other: &VecDeque<A>) -> bool {
-        self.len() == other.len() && self.iter().zip(other).all(|(a, b)| a.eq(b))
+        if self.len() != other.len() {
+            return false;
+        }
+        let (sa, sb) = self.as_slices();
+        let (oa, ob) = other.as_slices();
+        if sa.len() == oa.len() {
+            sa == oa && sb == ob
+        } else if sa.len() < oa.len() {
+            // Always divisible in three sections, for example:
+            // self:  [a b c|d e f]
+            // other: [0 1 2 3|4 5]
+            // front = 3, mid = 1,
+            // [a b c] == [0 1 2] && [d] == [3] && [e f] == [4 5]
+            let front = sa.len();
+            let mid = oa.len() - front;
+
+            let (oa_front, oa_mid) = oa.split_at(front);
+            let (sb_mid, sb_back) = sb.split_at(mid);
+            debug_assert_eq!(sa.len(), oa_front.len());
+            debug_assert_eq!(sb_mid.len(), oa_mid.len());
+            debug_assert_eq!(sb_back.len(), ob.len());
+            sa == oa_front && sb_mid == oa_mid && sb_back == ob
+        } else {
+            let front = oa.len();
+            let mid = sa.len() - front;
+
+            let (sa_front, sa_mid) = sa.split_at(front);
+            let (ob_mid, ob_back) = ob.split_at(mid);
+            debug_assert_eq!(sa_front.len(), oa.len());
+            debug_assert_eq!(sa_mid.len(), ob_mid.len());
+            debug_assert_eq!(sb.len(), ob_back.len());
+            sa_front == oa && sa_mid == ob_mid && sb == ob_back
+        }
     }
 }
 

branches/stable/src/libcollectionstest/vec_deque.rs

@@ -624,6 +624,33 @@ fn test_hash_after_rotation() {
     }
 }
 
+#[test]
+fn test_eq_after_rotation() {
+    // test that two deques are equal even if elements are laid out differently
+    let len = 28;
+    let mut ring: VecDeque<i32> = (0..len as i32).collect();
+    let mut shifted = ring.clone();
+    for _ in 0..10 {
+        // shift values 1 step to the right by pop, sub one, push
+        ring.pop_front();
+        for elt in &mut ring {
+            *elt -= 1;
+        }
+        ring.push_back(len - 1);
+    }
+
+    // try every shift
+    for _ in 0..shifted.capacity() {
+        shifted.pop_front();
+        for elt in &mut shifted {
+            *elt -= 1;
+        }
+        shifted.push_back(len - 1);
+        assert_eq!(shifted, ring);
+        assert_eq!(ring, shifted);
+    }
+}
+
 #[test]
 fn test_ord() {
     let x = VecDeque::new();

branches/stable/src/librustc_back/target/asmjs_unknown_emscripten.rs

@@ -21,7 +21,6 @@ pub fn target() -> Target {
         no_compiler_rt: true,
         linker_is_gnu: true,
         allow_asm: false,
-        archive_format: "gnu".to_string(),
         obj_is_bitcode: true,
         .. Default::default()
     };

branches/stable/src/librustc_back/target/bitrig_base.rs

@@ -19,7 +19,6 @@ pub fn opts() -> TargetOptions {
         linker_is_gnu: true,
         has_rpath: true,
         position_independent_executables: true,
-        archive_format: "gnu".to_string(),
         exe_allocation_crate: "alloc_system".to_string(),
 
         .. Default::default()

branches/stable/src/librustc_back/target/dragonfly_base.rs

@@ -29,7 +29,6 @@ pub fn opts() -> TargetOptions {
             "-Wl,-z,noexecstack".to_string(),
         ),
         position_independent_executables: true,
-        archive_format: "gnu".to_string(),
         exe_allocation_crate: super::maybe_jemalloc(),
         .. Default::default()
     }

branches/stable/src/librustc_back/target/freebsd_base.rs

@@ -21,7 +21,6 @@ pub fn opts() -> TargetOptions {
             // Always enable NX protection when it is available
             "-Wl,-z,noexecstack".to_string(),
         ],
-        archive_format: "gnu".to_string(),
         exe_allocation_crate: super::maybe_jemalloc(),
 
         .. Default::default()

branches/stable/src/librustc_back/target/le32_unknown_nacl.rs

@@ -25,7 +25,6 @@ pub fn target() -> Target {
         no_compiler_rt: false,
         linker_is_gnu: true,
         allow_asm: false,
-        archive_format: "gnu".to_string(),
         .. Default::default()
     };
     Target {

branches/stable/src/librustc_back/target/linux_base.rs

@@ -31,7 +31,6 @@ pub fn opts() -> TargetOptions {
             "-Wl,-z,noexecstack".to_string(),
         ],
         position_independent_executables: true,
-        archive_format: "gnu".to_string(),
         exe_allocation_crate: super::maybe_jemalloc(),
         has_elf_tls: true,
         .. Default::default()

branches/stable/src/librustc_back/target/mod.rs

@@ -249,7 +249,7 @@ impl Default for TargetOptions {
             pre_link_objects_dll: Vec::new(),
             post_link_objects: Vec::new(),
             late_link_args: Vec::new(),
-            archive_format: String::new(),
+            archive_format: "gnu".to_string(),
             custom_unwind_resume: false,
             lib_allocation_crate: "alloc_system".to_string(),
             exe_allocation_crate: "alloc_system".to_string(),

branches/stable/src/librustc_back/target/netbsd_base.rs

@@ -29,7 +29,6 @@ pub fn opts() -> TargetOptions {
             "-Wl,-z,noexecstack".to_string(),
         ),
         position_independent_executables: true,
-        archive_format: "gnu".to_string(),
         .. Default::default()
     }
 }

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

@@ -29,7 +29,6 @@ pub fn opts() -> TargetOptions {
             "-Wl,-z,noexecstack".to_string(),
         ),
         position_independent_executables: true,
-        archive_format: "gnu".to_string(),
         exe_allocation_crate: "alloc_system".to_string(),
         .. Default::default()
     }

branches/stable/src/librustc_back/target/solaris_base.rs

@@ -18,7 +18,6 @@ pub fn opts() -> TargetOptions {
         executables: true,
         has_rpath: true,
         is_like_solaris: true,
-        archive_format: "gnu".to_string(),
         exe_allocation_crate: super::maybe_jemalloc(),
 
         .. Default::default()

branches/stable/src/librustc_back/target/windows_base.rs

@@ -25,7 +25,6 @@ pub fn opts() -> TargetOptions {
         staticlib_suffix: ".lib".to_string(),
         no_default_libraries: true,
         is_like_windows: true,
-        archive_format: "gnu".to_string(),
         pre_link_args: vec!(
             // And here, we see obscure linker flags #45. On windows, it has been
             // found to be necessary to have this flag to compile liblibc.

branches/stable/src/librustc_back/target/windows_msvc_base.rs

@@ -59,7 +59,6 @@ pub fn opts() -> TargetOptions {
             "/NOLOGO".to_string(),
             "/NXCOMPAT".to_string(),
         ],
-        archive_format: "gnu".to_string(),
         exe_allocation_crate: "alloc_system".to_string(),
 
         .. Default::default()

branches/stable/src/librustc_driver/lib.rs

@@ -164,7 +164,11 @@ pub fn run_compiler<'a>(args: &[String],
 
     let descriptions = diagnostics_registry();
 
-    do_or_return!(callbacks.early_callback(&matches, &descriptions, sopts.error_format), None);
+    do_or_return!(callbacks.early_callback(&matches,
+                                           &sopts,
+                                           &descriptions,
+                                           sopts.error_format),
+                                           None);
 
     let (odir, ofile) = make_output(&matches);
     let (input, input_file_path) = match make_input(&matches.free) {
@@ -251,6 +255,7 @@ pub trait CompilerCalls<'a> {
     // else (e.g., selecting input and output).
     fn early_callback(&mut self,
                       _: &getopts::Matches,
+                      _: &config::Options,
                       _: &diagnostics::registry::Registry,
                       _: ErrorOutputType)
                       -> Compilation {
@@ -324,34 +329,68 @@ pub trait CompilerCalls<'a> {
 #[derive(Copy, Clone)]
 pub struct RustcDefaultCalls;
 
+fn handle_explain(code: &str,
+                  descriptions: &diagnostics::registry::Registry,
+                  output: ErrorOutputType) {
+    let normalised = if !code.starts_with("E") {
+        format!("E{0:0>4}", code)
+    } else {
+        code.to_string()
+    };
+    match descriptions.find_description(&normalised) {
+        Some(ref description) => {
+            // Slice off the leading newline and print.
+            print!("{}", &description[1..]);
+        }
+        None => {
+            early_error(output, &format!("no extended information for {}", code));
+        }
+    }
+}
+
+fn check_cfg(sopts: &config::Options,
+             output: ErrorOutputType) {
+    let mut emitter: Box<Emitter> = match output {
+        config::ErrorOutputType::HumanReadable(color_config) => {
+            Box::new(errors::emitter::BasicEmitter::stderr(color_config))
+        }
+        config::ErrorOutputType::Json => Box::new(errors::json::JsonEmitter::basic()),
+    };
+
+    let mut saw_invalid_predicate = false;
+    for item in sopts.cfg.iter() {
+        match item.node {
+            ast::MetaList(ref pred, _) => {
+                saw_invalid_predicate = true;
+                emitter.emit(None,
+                             &format!("invalid predicate in --cfg command line argument: `{}`",
+                                      pred),
+                             None,
+                             errors::Level::Fatal);
+            }
+            _ => {},
+        }
+    }
+
+    if saw_invalid_predicate {
+        panic!(errors::FatalError);
+    }
+}
+
 impl<'a> CompilerCalls<'a> for RustcDefaultCalls {
     fn early_callback(&mut self,
                       matches: &getopts::Matches,
+                      sopts: &config::Options,
                       descriptions: &diagnostics::registry::Registry,
                       output: ErrorOutputType)
                       -> Compilation {
-        match matches.opt_str("explain") {
-            Some(ref code) => {
-                let normalised = if !code.starts_with("E") {
-                    format!("E{0:0>4}", code)
-                } else {
-                    code.to_string()
-                };
-                match descriptions.find_description(&normalised) {
-                    Some(ref description) => {
-                        // Slice off the leading newline and print.
-                        print!("{}", &description[1..]);
-                    }
-                    None => {
-                        early_error(output, &format!("no extended information for {}", code));
-                    }
-                }
-                return Compilation::Stop;
-            }
-            None => (),
+        if let Some(ref code) = matches.opt_str("explain") {
+            handle_explain(code, descriptions, output);
+            return Compilation::Stop;
         }
 
-        return Compilation::Continue;
+        check_cfg(sopts, output);
+        Compilation::Continue
     }
 
     fn no_input(&mut self,

branches/stable/src/librustc_mir/build/scope.rs

@@ -236,7 +236,7 @@ impl<'a,'tcx> Builder<'a,'tcx> {
         self.diverge_cleanup();
         let scope = self.scopes.pop().unwrap();
         assert_eq!(scope.extent, extent);
-        build_scope_drops(block, &scope, &self.scopes[..], &mut self.cfg)
+        build_scope_drops(&mut self.cfg, &scope, &self.scopes[..], block)
     }
 
 
@@ -254,8 +254,18 @@ impl<'a,'tcx> Builder<'a,'tcx> {
             self.hir.span_bug(span, &format!("extent {:?} does not enclose", extent))
         });
 
+        let tmp = self.get_unit_temp();
         for (idx, ref scope) in self.scopes.iter().enumerate().rev().take(scope_count) {
-            unpack!(block = build_scope_drops(block, scope, &self.scopes[..idx], &mut self.cfg));
+            unpack!(block = build_scope_drops(&mut self.cfg,
+                                              scope,
+                                              &self.scopes[..idx],
+                                              block));
+            if let Some(ref free_data) = scope.free {
+                let next = self.cfg.start_new_block();
+                let free = build_free(self.hir.tcx(), tmp.clone(), free_data, next);
+                self.cfg.terminate(block, free);
+                block = next;
+            }
         }
         self.cfg.terminate(block, Terminator::Goto { target: target });
     }
@@ -508,10 +518,10 @@ impl<'a,'tcx> Builder<'a,'tcx> {
 }
 
 /// Builds drops for pop_scope and exit_scope.
-fn build_scope_drops<'tcx>(mut block: BasicBlock,
+fn build_scope_drops<'tcx>(cfg: &mut CFG<'tcx>,
                            scope: &Scope<'tcx>,
                            earlier_scopes: &[Scope<'tcx>],
-                           cfg: &mut CFG<'tcx>)
+                           mut block: BasicBlock)
                            -> BlockAnd<()> {
     let mut iter = scope.drops.iter().rev().peekable();
     while let Some(drop_data) = iter.next() {
@@ -586,9 +596,10 @@ fn build_diverge_scope<'tcx>(tcx: &ty::ctxt<'tcx>,
         target = if let Some(cached_block) = free_data.cached_block {
             cached_block
         } else {
-            let t = build_free(tcx, cfg, unit_temp, free_data, target);
-            free_data.cached_block = Some(t);
-            t
+            let into = cfg.start_new_cleanup_block();
+            cfg.terminate(into, build_free(tcx, unit_temp, free_data, target));
+            free_data.cached_block = Some(into);
+            into
         }
     };
 
@@ -608,19 +619,16 @@ fn build_diverge_scope<'tcx>(tcx: &ty::ctxt<'tcx>,
 }
 
 fn build_free<'tcx>(tcx: &ty::ctxt<'tcx>,
-                    cfg: &mut CFG<'tcx>,
                     unit_temp: Lvalue<'tcx>,
                     data: &FreeData<'tcx>,
-                    target: BasicBlock)
-                    -> BasicBlock {
+                    target: BasicBlock) -> Terminator<'tcx> {
     let free_func = tcx.lang_items.box_free_fn()
                        .expect("box_free language item is missing");
     let substs = tcx.mk_substs(Substs::new(
         VecPerParamSpace::new(vec![], vec![], vec![data.item_ty]),
         VecPerParamSpace::new(vec![], vec![], vec![])
     ));
-    let block = cfg.start_new_cleanup_block();
-    cfg.terminate(block, Terminator::Call {
+    Terminator::Call {
         func: Operand::Constant(Constant {
             span: data.span,
             ty: tcx.lookup_item_type(free_func).ty.subst(tcx, substs),
@@ -633,6 +641,5 @@ fn build_free<'tcx>(tcx: &ty::ctxt<'tcx>,
         args: vec![Operand::Consume(data.value.clone())],
         destination: Some((unit_temp, target)),
         cleanup: None
-    });
-    block
+    }
 }