---

yaml
---
r: 137209
b: refs/heads/release-prep
c: c586490
h: refs/heads/master
i:
  137207: 3b097f0
v: v3

Author: bors

[refs]

@@ -29,4 +29,4 @@ refs/tags/0.9: 36870b185fc5f5486636d4515f0e22677493f225
 refs/tags/0.10: ac33f2b15782272ae348dbd7b14b8257b2148b5a
 refs/heads/libuv-update-temp-branch: 6ed22c618766f1f2a2e108eef8ce3f51be0f70b7
 refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
-refs/heads/release-prep: cc31d9cabcc6c8ad396c1aae6257a4b5ea25cb46
+refs/heads/release-prep: c586490715a35d3c9dae17de7f8907c2f73168d3

branches/release-prep/mk/docs.mk

@@ -112,8 +112,8 @@ HTML_DEPS += doc/version_info.html
 doc/version_info.html: $(D)/version_info.html.template $(MKFILE_DEPS) \
                        $(wildcard $(D)/*.*) | doc/
 	@$(call E, version-info: $@)
-	$(Q)sed -e "s/VERSION/$(CFG_RELEASE)/; s/SHORT_HASH/$( \
-                    CFG_SHORT_VER_HASH)/; \
+	$(Q)sed -e "s/VERSION/$(CFG_RELEASE)/; \
+                s/SHORT_HASH/$(CFG_SHORT_VER_HASH)/; \
                 s/STAMP/$(CFG_VER_HASH)/;" $< >$@
 
 GENERATED += doc/version.tex doc/version_info.html

branches/release-prep/mk/main.mk

@@ -246,7 +246,7 @@ endif
 ######################################################################
 
 # FIXME: x86-ism
-LLVM_COMPONENTS=x86 arm mips ipo bitreader bitwriter linker asmparser jit mcjit \
+LLVM_COMPONENTS=x86 arm mips ipo bitreader bitwriter linker asmparser mcjit \
                 interpreter instrumentation
 
 # Only build these LLVM tools

branches/release-prep/src/doc/rustdoc.md

@@ -67,7 +67,7 @@ pub use std::option::Option;
 ```
 
 Doc comments are markdown, and are currently parsed with the
-[sundown][sundown] library. rustdoc does not yet do any fanciness such as
+[hoedown][hoedown] library. rustdoc does not yet do any fanciness such as
 referencing other items inline, like javadoc's `@see`. One exception to this
 is that the first paragraph will be used as the "summary" of an item in the
 generated documentation:
@@ -123,7 +123,7 @@ documentation. There is a search bar at the top, which is powered by some
 JavaScript and a statically-generated search index. No special web server is
 required for the search.
 
-[sundown]: https://github.com/vmg/sundown/
+[hoedown]: https://github.com/hoedown/hoedown
 
 # Testing the Documentation
 

branches/release-prep/src/libcollections/str.rs

@@ -778,13 +778,11 @@ pub trait StrAllocating: Str {
     /// Returns the Levenshtein Distance between two strings.
     fn lev_distance(&self, t: &str) -> uint {
         let me = self.as_slice();
-        let slen = me.len();
-        let tlen = t.len();
+        if me.is_empty() { return t.char_len(); }
+        if t.is_empty() { return me.char_len(); }
 
-        if slen == 0 { return tlen; }
-        if tlen == 0 { return slen; }
-
-        let mut dcol = Vec::from_fn(tlen + 1, |x| x);
+        let mut dcol = Vec::from_fn(t.len() + 1, |x| x);
+        let mut t_last = 0;
 
         for (i, sc) in me.chars().enumerate() {
 
@@ -799,15 +797,15 @@ pub trait StrAllocating: Str {
                     *dcol.get_mut(j + 1) = current;
                 } else {
                     *dcol.get_mut(j + 1) = cmp::min(current, next);
-                    *dcol.get_mut(j + 1) = cmp::min(dcol[j + 1],
-                                                    dcol[j]) + 1;
+                    *dcol.get_mut(j + 1) = cmp::min(dcol[j + 1], dcol[j]) + 1;
                 }
 
                 current = next;
+                t_last = j;
             }
         }
 
-        return dcol[tlen];
+        dcol[t_last + 1]
     }
 
     /// Returns an iterator over the string in Unicode Normalization Form D
@@ -1878,6 +1876,27 @@ mod tests {
         assert_eq!(words, vec!["Märy", "häd", "ä", "little", "lämb", "Little", "lämb"])
     }
 
+    #[test]
+    fn test_lev_distance() {
+        use std::char::{ from_u32, MAX };
+        // Test bytelength agnosticity
+        for c in range(0u32, MAX as u32)
+                 .filter_map(|i| from_u32(i))
+                 .map(|i| String::from_char(1, i)) {
+            assert_eq!(c[].lev_distance(c[]), 0);
+        }
+
+        let a = "\nMäry häd ä little lämb\n\nLittle lämb\n";
+        let b = "\nMary häd ä little lämb\n\nLittle lämb\n";
+        let c = "Mary häd ä little lämb\n\nLittle lämb\n";
+        assert_eq!(a.lev_distance(b), 1);
+        assert_eq!(b.lev_distance(a), 1);
+        assert_eq!(a.lev_distance(c), 2);
+        assert_eq!(c.lev_distance(a), 2);
+        assert_eq!(b.lev_distance(c), 1);
+        assert_eq!(c.lev_distance(b), 1);
+    }
+
     #[test]
     fn test_nfd_chars() {
         macro_rules! t {

branches/release-prep/src/libcore/atomic.rs

@@ -382,9 +382,9 @@ impl AtomicInt {
     /// # Examples
     ///
     /// ```
-    /// use std::sync::atomic::{AtomicUint, SeqCst};
+    /// use std::sync::atomic::{AtomicInt, SeqCst};
     ///
-    /// let foo = AtomicUint::new(0b101101);
+    /// let foo = AtomicInt::new(0b101101);
     /// assert_eq!(0b101101, foo.fetch_and(0b110011, SeqCst));
     /// assert_eq!(0b100001, foo.load(SeqCst));
     #[inline]
@@ -397,9 +397,9 @@ impl AtomicInt {
     /// # Examples
     ///
     /// ```
-    /// use std::sync::atomic::{AtomicUint, SeqCst};
+    /// use std::sync::atomic::{AtomicInt, SeqCst};
     ///
-    /// let foo = AtomicUint::new(0b101101);
+    /// let foo = AtomicInt::new(0b101101);
     /// assert_eq!(0b101101, foo.fetch_or(0b110011, SeqCst));
     /// assert_eq!(0b111111, foo.load(SeqCst));
     #[inline]
@@ -412,9 +412,9 @@ impl AtomicInt {
     /// # Examples
     ///
     /// ```
-    /// use std::sync::atomic::{AtomicUint, SeqCst};
+    /// use std::sync::atomic::{AtomicInt, SeqCst};
     ///
-    /// let foo = AtomicUint::new(0b101101);
+    /// let foo = AtomicInt::new(0b101101);
     /// assert_eq!(0b101101, foo.fetch_xor(0b110011, SeqCst));
     /// assert_eq!(0b011110, foo.load(SeqCst));
     #[inline]

branches/release-prep/src/libcore/intrinsics.rs

@@ -250,6 +250,13 @@ extern "rust-intrinsic" {
     /// Abort the execution of the process.
     pub fn abort() -> !;
 
+    /// Tell LLVM that this point in the code is not reachable,
+    /// enabling further optimizations.
+    ///
+    /// NB: This is very different from the `unreachable!()` macro!
+    #[cfg(not(stage0))]
+    pub fn unreachable() -> !;
+
     /// Execute a breakpoint trap, for inspection by a debugger.
     pub fn breakpoint();
 

branches/release-prep/src/librustc/middle/trans/debuginfo.rs

@@ -3164,8 +3164,7 @@ fn populate_scope_map(cx: &CrateContext,
                 parent_scope,
                 file_metadata,
                 loc.line as c_uint,
-                loc.col.to_uint() as c_uint,
-                0)
+                loc.col.to_uint() as c_uint)
         };
 
         scope_stack.push(ScopeStackEntry { scope_metadata: scope_metadata,
@@ -3290,8 +3289,7 @@ fn populate_scope_map(cx: &CrateContext,
                                 parent_scope,
                                 file_metadata,
                                 loc.line as c_uint,
-                                loc.col.to_uint() as c_uint,
-                                0)
+                                loc.col.to_uint() as c_uint)
                         };
 
                         scope_stack.push(ScopeStackEntry {

branches/release-prep/src/librustc/middle/trans/intrinsic.rs

@@ -228,6 +228,10 @@ pub fn trans_intrinsic_call<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, node: ast::N
             Unreachable(bcx);
             v
         }
+        (_, "unreachable") => {
+            Unreachable(bcx);
+            C_nil(ccx)
+        }
         (_, "breakpoint") => {
             let llfn = ccx.get_intrinsic(&("llvm.debugtrap"));
             Call(bcx, llfn, [], None)

branches/release-prep/src/librustc/middle/typeck/check/mod.rs

@@ -5591,6 +5591,7 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) {
     } else {
         match name.get() {
             "abort" => (0, Vec::new(), ty::mk_bot()),
+            "unreachable" => (0, Vec::new(), ty::mk_bot()),
             "breakpoint" => (0, Vec::new(), ty::mk_nil()),
             "size_of" |
             "pref_align_of" | "min_align_of" => (1u, Vec::new(), ty::mk_uint()),

branches/release-prep/src/librustc/middle/typeck/infer/error_reporting.rs

@@ -869,6 +869,19 @@ impl<'a, 'tcx> ErrorReporting for InferCtxt<'a, 'tcx> {
                         ast::TypeImplItem(_) => None,
                     }
                 },
+                ast_map::NodeTraitItem(ref item) => {
+                    match **item {
+                        ast::ProvidedMethod(ref m) => {
+                            Some((m.pe_fn_decl(),
+                                  m.pe_generics(),
+                                  m.pe_fn_style(),
+                                  m.pe_ident(),
+                                  Some(&m.pe_explicit_self().node),
+                                  m.span))
+                        }
+                        _ => None
+                    }
+                }
                 _ => None
             },
             None => None

branches/release-prep/src/librustc_llvm/lib.rs

@@ -1747,8 +1747,7 @@ extern {
                                            Scope: DIDescriptor,
                                            File: DIFile,
                                            Line: c_uint,
-                                           Col: c_uint,
-                                           Discriminator: c_uint)
+                                           Col: c_uint)
                                            -> DILexicalBlock;
 
     pub fn LLVMDIBuilderCreateStaticVariable(Builder: DIBuilderRef,
@@ -2179,12 +2178,10 @@ pub unsafe fn static_link_hack_this_sucks() {
 
     LLVMRustLinkInExternalBitcode(0 as *mut _, 0 as *const _, 0 as size_t);
 
-    LLVMLinkInJIT();
     LLVMLinkInMCJIT();
     LLVMLinkInInterpreter();
 
     extern {
-        fn LLVMLinkInJIT();
         fn LLVMLinkInMCJIT();
         fn LLVMLinkInInterpreter();
     }

branches/release-prep/src/libstd/io/mod.rs

@@ -1293,10 +1293,10 @@ impl<'a> Writer for Box<Writer+'a> {
 
 impl<'a> Writer for &'a mut Writer+'a {
     #[inline]
-    fn write(&mut self, buf: &[u8]) -> IoResult<()> { self.write(buf) }
+    fn write(&mut self, buf: &[u8]) -> IoResult<()> { (**self).write(buf) }
 
     #[inline]
-    fn flush(&mut self) -> IoResult<()> { self.flush() }
+    fn flush(&mut self) -> IoResult<()> { (**self).flush() }
 }
 
 /// A `RefWriter` is a struct implementing `Writer` which contains a reference

branches/release-prep/src/llvm

@@ -1 +1 @@
-Subproject commit e9d037419441d51ccb0f41aacbc64080b0c6e81b
+Subproject commit c9b823739d1357a058e7437c00bec6d2d0b00ed6

branches/release-prep/src/rustllvm/PassWrapper.cpp

@@ -118,7 +118,9 @@ LLVMRustAddAnalysisPasses(LLVMTargetMachineRef TM,
                           LLVMPassManagerRef PMR,
                           LLVMModuleRef M) {
     PassManagerBase *PM = unwrap(PMR);
-#if LLVM_VERSION_MINOR >= 5
+#if LLVM_VERSION_MINOR >= 6
+    PM->add(new DataLayoutPass());
+#elif LLVM_VERSION_MINOR == 5
     PM->add(new DataLayoutPass(unwrap(M)));
 #else
     PM->add(new DataLayout(unwrap(M)));
@@ -187,7 +189,12 @@ LLVMRustWriteOutputFile(LLVMTargetMachineRef Target,
   PassManager *PM = unwrap<PassManager>(PMR);
 
   std::string ErrorInfo;
-#if LLVM_VERSION_MINOR >= 4
+#if LLVM_VERSION_MINOR >= 6
+  std::error_code EC;
+  raw_fd_ostream OS(path, EC, sys::fs::F_None);
+  if (EC)
+    ErrorInfo = EC.message();
+#elif LLVM_VERSION_MINOR >= 4
   raw_fd_ostream OS(path, ErrorInfo, sys::fs::F_None);
 #else
   raw_fd_ostream OS(path, ErrorInfo, raw_fd_ostream::F_Binary);
@@ -210,7 +217,12 @@ LLVMRustPrintModule(LLVMPassManagerRef PMR,
   PassManager *PM = unwrap<PassManager>(PMR);
   std::string ErrorInfo;
 
-#if LLVM_VERSION_MINOR >= 4
+#if LLVM_VERSION_MINOR >= 6
+  std::error_code EC;
+  raw_fd_ostream OS(path, EC, sys::fs::F_None);
+  if (EC)
+    ErrorInfo = EC.message();
+#elif LLVM_VERSION_MINOR >= 4
   raw_fd_ostream OS(path, ErrorInfo, sys::fs::F_None);
 #else
   raw_fd_ostream OS(path, ErrorInfo, raw_fd_ostream::F_Binary);

branches/release-prep/src/rustllvm/RustWrapper.cpp

@@ -393,13 +393,12 @@ extern "C" LLVMValueRef LLVMDIBuilderCreateLexicalBlock(
     LLVMValueRef Scope,
     LLVMValueRef File,
     unsigned Line,
-    unsigned Col,
-    unsigned Discriminator) {
+    unsigned Col) {
     return wrap(Builder->createLexicalBlock(
         unwrapDI<DIDescriptor>(Scope),
         unwrapDI<DIFile>(File), Line, Col
-#if LLVM_VERSION_MINOR >= 5
-        , Discriminator
+#if LLVM_VERSION_MINOR == 5
+        , 0
 #endif
         ));
 }
@@ -415,7 +414,11 @@ extern "C" LLVMValueRef LLVMDIBuilderCreateStaticVariable(
     bool isLocalToUnit,
     LLVMValueRef Val,
     LLVMValueRef Decl = NULL) {
+#if LLVM_VERSION_MINOR == 6
+    return wrap(Builder->createGlobalVariable(unwrapDI<DIDescriptor>(Context),
+#else
     return wrap(Builder->createStaticVariable(unwrapDI<DIDescriptor>(Context),
+#endif
         Name,
         LinkageName,
         unwrapDI<DIFile>(File),
@@ -665,11 +668,18 @@ extern "C" void LLVMWriteValueToString(LLVMValueRef Value, RustStringRef str) {
 extern "C" bool
 LLVMRustLinkInExternalBitcode(LLVMModuleRef dst, char *bc, size_t len) {
     Module *Dst = unwrap(dst);
+#if LLVM_VERSION_MINOR == 5
     MemoryBuffer* buf = MemoryBuffer::getMemBufferCopy(StringRef(bc, len));
     ErrorOr<Module *> Src = llvm::getLazyBitcodeModule(buf, Dst->getContext());
+#else
+    std::unique_ptr<MemoryBuffer> buf = MemoryBuffer::getMemBufferCopy(StringRef(bc, len));
+    ErrorOr<Module *> Src = llvm::getLazyBitcodeModule(std::move(buf), Dst->getContext());
+#endif
     if (!Src) {
         LLVMRustSetLastError(Src.getError().message().c_str());
+#if LLVM_VERSION_MINOR == 5
         delete buf;
+#endif
         return false;
     }
 
@@ -712,12 +722,26 @@ LLVMRustOpenArchive(char *path) {
         return nullptr;
     }
 
+#if LLVM_VERSION_MINOR >= 6
+    ErrorOr<std::unique_ptr<Archive>> archive_or =
+        Archive::create(buf_or.get()->getMemBufferRef());
+
+    if (!archive_or) {
+        LLVMRustSetLastError(archive_or.getError().message().c_str());
+        return nullptr;
+    }
+
+    OwningBinary<Archive> *ret = new OwningBinary<Archive>(
+            std::move(archive_or.get()), std::move(buf_or.get()));
+#else
     std::error_code err;
     Archive *ret = new Archive(std::move(buf_or.get()), err);
     if (err) {
         LLVMRustSetLastError(err.message().c_str());
-        return NULL;
+        return nullptr;
     }
+#endif
+
     return ret;
 }
 #else
@@ -739,7 +763,14 @@ LLVMRustOpenArchive(char *path) {
 #endif
 
 extern "C" const char*
+#if LLVM_VERSION_MINOR >= 6
+LLVMRustArchiveReadSection(OwningBinary<Archive> *ob, char *name, size_t *size) {
+
+    std::unique_ptr<Archive> &ar = ob->getBinary();
+#else
 LLVMRustArchiveReadSection(Archive *ar, char *name, size_t *size) {
+#endif
+
 #if LLVM_VERSION_MINOR >= 5
     Archive::child_iterator child = ar->child_begin(),
                               end = ar->child_end();
@@ -765,7 +796,11 @@ LLVMRustArchiveReadSection(Archive *ar, char *name, size_t *size) {
 }
 
 extern "C" void
+#if LLVM_VERSION_MINOR >= 6
+LLVMRustDestroyArchive(OwningBinary<Archive> *ar) {
+#else
 LLVMRustDestroyArchive(Archive *ar) {
+#endif
     delete ar;
 }