---

yaml
---
r: 216355
b: refs/heads/stable
c: 3f025fe
h: refs/heads/master
i:
  216353: 63e8917
  216351: 9ad4b06
v: v3

Author: nrc

[refs]

@@ -29,5 +29,5 @@ refs/heads/tmp: 378a370ff2057afeb1eae86eb6e78c476866a4a6
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: a5286998df566e736b32f6795bfc3803bdaf453d
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: e14af089a47d00af85565956421200f889978c7a
+refs/heads/stable: 3f025fe7b2763c8715325b573b08498ec27efd1e
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375

branches/stable/src/libcore/intrinsics.rs

@@ -255,17 +255,12 @@ extern "rust-intrinsic" {
     /// Returns `true` if a type is managed (will be allocated on the local heap)
     pub fn owns_managed<T>() -> bool;
 
-    /// Calculates the offset from a pointer.
+    /// Calculates the offset from a pointer. The offset *must* be in-bounds of
+    /// the object, or one-byte-past-the-end. An arithmetic overflow is also
+    /// undefined behaviour.
     ///
     /// This is implemented as an intrinsic to avoid converting to and from an
     /// integer, since the conversion would throw away aliasing information.
-    ///
-    /// # Safety
-    ///
-    /// Both the starting and resulting pointer must be either in bounds or one
-    /// byte past the end of an allocated object. If either pointer is out of
-    /// bounds or arithmetic overflow occurs then any further use of the
-    /// returned value will result in undefined behavior.
     pub fn offset<T>(dst: *const T, offset: isize) -> *const T;
 
     /// Copies `count * size_of<T>` bytes from `src` to `dst`. The source

branches/stable/src/libcore/ptr.rs

@@ -284,10 +284,9 @@ impl<T: ?Sized> *const T {
     ///
     /// # Safety
     ///
-    /// Both the starting and resulting pointer must be either in bounds or one
-    /// byte past the end of an allocated object. If either pointer is out of
-    /// bounds or arithmetic overflow occurs then
-    /// any further use of the returned value will result in undefined behavior.
+    /// The offset must be in-bounds of the object, or one-byte-past-the-end.
+    /// Otherwise `offset` invokes Undefined Behaviour, regardless of whether
+    /// the pointer is used.
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub unsafe fn offset(self, count: isize) -> *const T where T: Sized {

branches/stable/src/librustc/diagnostics.rs

@@ -168,25 +168,6 @@ match x {
 ```
 "##,
 
-E0013: r##"
-Static and const variables can refer to other const variables. But a const
-variable cannot refer to a static variable. For example, `Y` cannot refer to `X`
-here:
-
-```
-static X: i32 = 42;
-const Y: i32 = X;
-```
-
-To fix this, the value can be extracted as a const and then used:
-
-```
-const A: i32 = 42;
-static X: i32 = A;
-const Y: i32 = A;
-```
-"##,
-
 E0015: r##"
 The only function calls allowed in static or constant expressions are enum
 variant constructors or struct constructors (for unit or tuple structs). This
@@ -481,6 +462,7 @@ register_diagnostics! {
     E0010,
     E0011,
     E0012,
+    E0013,
     E0014,
     E0016,
     E0017,

branches/stable/src/librustc/lib.rs

@@ -39,7 +39,6 @@
 #![feature(path_ext)]
 #![feature(str_char)]
 #![feature(into_cow)]
-#![feature(fs_canonicalize)]
 #![feature(slice_patterns)]
 #![cfg_attr(test, feature(test))]
 
@@ -139,6 +138,7 @@ pub mod plugin;
 pub mod lint;
 
 pub mod util {
+    pub use rustc_back::fs;
     pub use rustc_back::sha2;
 
     pub mod common;

branches/stable/src/librustc/metadata/creader.rs

@@ -21,10 +21,8 @@ use metadata::decoder;
 use metadata::loader;
 use metadata::loader::CratePaths;
 
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::rc::Rc;
-use std::fs;
-
 use syntax::ast;
 use syntax::abi;
 use syntax::attr;
@@ -34,6 +32,7 @@ use syntax::parse;
 use syntax::parse::token::InternedString;
 use syntax::parse::token;
 use syntax::visit;
+use util::fs;
 use log;
 
 pub struct CrateReader<'a> {
@@ -323,7 +322,7 @@ impl<'a> CrateReader<'a> {
             let source = self.sess.cstore.get_used_crate_source(cnum).unwrap();
             if let Some(locs) = self.sess.opts.externs.get(name) {
                 let found = locs.iter().any(|l| {
-                    let l = fs::canonicalize(l).ok();
+                    let l = fs::realpath(&Path::new(&l[..])).ok();
                     source.dylib.as_ref().map(|p| &p.0) == l.as_ref() ||
                     source.rlib.as_ref().map(|p| &p.0) == l.as_ref()
                 });
@@ -665,7 +664,7 @@ fn import_codemap(local_codemap: &codemap::CodeMap,
                     .into_inner()
                     .map_in_place(|mbc|
                         codemap::MultiByteChar {
-                            pos: mbc.pos - start_pos,
+                            pos: mbc.pos + start_pos,
                             bytes: mbc.bytes
                         });
 

branches/stable/src/librustc/metadata/filesearch.rs

@@ -18,6 +18,7 @@ use std::fs;
 use std::io::prelude::*;
 use std::path::{Path, PathBuf};
 
+use util::fs as myfs;
 use session::search_paths::{SearchPaths, PathKind};
 
 #[derive(Copy, Clone)]
@@ -190,7 +191,7 @@ pub fn get_or_default_sysroot() -> PathBuf {
     // Follow symlinks.  If the resolved path is relative, make it absolute.
     fn canonicalize(path: Option<PathBuf>) -> Option<PathBuf> {
         path.and_then(|path| {
-            match fs::canonicalize(&path) {
+            match myfs::realpath(&path) {
                 Ok(canon) => Some(canon),
                 Err(e) => panic!("failed to get realpath: {}", e),
             }

branches/stable/src/librustc/metadata/loader.rs

@@ -225,12 +225,12 @@ use metadata::encoder;
 use metadata::filesearch::{FileSearch, FileMatches, FileDoesntMatch};
 use syntax::codemap::Span;
 use syntax::diagnostic::SpanHandler;
+use util::fs;
 use util::common;
 use rustc_back::target::Target;
 
 use std::cmp;
 use std::collections::HashMap;
-use std::fs;
 use std::io::prelude::*;
 use std::io;
 use std::path::{Path, PathBuf};
@@ -430,9 +430,9 @@ impl<'a> Context<'a> {
                                  .or_insert_with(|| (HashMap::new(), HashMap::new()));
             let (ref mut rlibs, ref mut dylibs) = *slot;
             if rlib {
-                rlibs.insert(fs::canonicalize(path).unwrap(), kind);
+                rlibs.insert(fs::realpath(path).unwrap(), kind);
             } else {
-                dylibs.insert(fs::canonicalize(path).unwrap(), kind);
+                dylibs.insert(fs::realpath(path).unwrap(), kind);
             }
 
             FileMatches
@@ -660,10 +660,10 @@ impl<'a> Context<'a> {
             // there's at most one rlib and at most one dylib.
             for loc in locs {
                 if loc.file_name().unwrap().to_str().unwrap().ends_with(".rlib") {
-                    rlibs.insert(fs::canonicalize(&loc).unwrap(),
+                    rlibs.insert(fs::realpath(&loc).unwrap(),
                                  PathKind::ExternFlag);
                 } else {
-                    dylibs.insert(fs::canonicalize(&loc).unwrap(),
+                    dylibs.insert(fs::realpath(&loc).unwrap(),
                                   PathKind::ExternFlag);
                 }
             }

branches/stable/src/librustc_back/fs.rs

@@ -0,0 +1,91 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::io;
+use std::path::{Path, PathBuf};
+
+#[cfg(windows)]
+pub fn realpath(original: &Path) -> io::Result<PathBuf> {
+    Ok(original.to_path_buf())
+}
+
+#[cfg(unix)]
+pub fn realpath(original: &Path) -> io::Result<PathBuf> {
+    use libc;
+    use std::ffi::{OsString, CString};
+    use std::os::unix::prelude::*;
+
+    extern {
+        fn realpath(pathname: *const libc::c_char, resolved: *mut libc::c_char)
+                    -> *mut libc::c_char;
+    }
+
+    let path = try!(CString::new(original.as_os_str().as_bytes()));
+    let mut buf = vec![0u8; 16 * 1024];
+    unsafe {
+        let r = realpath(path.as_ptr(), buf.as_mut_ptr() as *mut _);
+        if r.is_null() {
+            return Err(io::Error::last_os_error())
+        }
+    }
+    let p = buf.iter().position(|i| *i == 0).unwrap();
+    buf.truncate(p);
+    Ok(PathBuf::from(OsString::from_vec(buf)))
+}
+
+#[cfg(all(not(windows), test))]
+mod tests {
+    use tempdir::TempDir;
+    use std::fs::{self, File};
+    use super::realpath;
+
+    #[test]
+    fn realpath_works() {
+        let tmpdir = TempDir::new("rustc-fs").unwrap();
+        let tmpdir = realpath(tmpdir.path()).unwrap();
+        let file = tmpdir.join("test");
+        let dir = tmpdir.join("test2");
+        let link = dir.join("link");
+        let linkdir = tmpdir.join("test3");
+
+        File::create(&file).unwrap();
+        fs::create_dir(&dir).unwrap();
+        fs::soft_link(&file, &link).unwrap();
+        fs::soft_link(&dir, &linkdir).unwrap();
+
+        assert_eq!(realpath(&tmpdir).unwrap(), tmpdir);
+        assert_eq!(realpath(&file).unwrap(), file);
+        assert_eq!(realpath(&link).unwrap(), file);
+        assert_eq!(realpath(&linkdir).unwrap(), dir);
+        assert_eq!(realpath(&linkdir.join("link")).unwrap(), file);
+    }
+
+    #[test]
+    fn realpath_works_tricky() {
+        let tmpdir = TempDir::new("rustc-fs").unwrap();
+        let tmpdir = realpath(tmpdir.path()).unwrap();
+
+        let a = tmpdir.join("a");
+        let b = a.join("b");
+        let c = b.join("c");
+        let d = a.join("d");
+        let e = d.join("e");
+        let f = a.join("f");
+
+        fs::create_dir_all(&b).unwrap();
+        fs::create_dir_all(&d).unwrap();
+        File::create(&f).unwrap();
+        fs::soft_link("../d/e", &c).unwrap();
+        fs::soft_link("../f", &e).unwrap();
+
+        assert_eq!(realpath(&c).unwrap(), f);
+        assert_eq!(realpath(&e).unwrap(), f);
+    }
+}

branches/stable/src/librustc_back/lib.rs

@@ -41,7 +41,6 @@
 #![feature(path_ext)]
 #![feature(step_by)]
 #![feature(libc)]
-#![feature(fs_canonicalize)]
 #![cfg_attr(test, feature(test, rand))]
 
 extern crate syntax;
@@ -54,6 +53,7 @@ pub mod abi;
 pub mod archive;
 pub mod tempdir;
 pub mod arm;
+pub mod fs;
 pub mod mips;
 pub mod mipsel;
 pub mod rpath;

branches/stable/src/librustc_back/rpath.rs

@@ -10,8 +10,8 @@
 
 use std::collections::HashSet;
 use std::env;
+use std::io;
 use std::path::{Path, PathBuf};
-use std::fs;
 use syntax::ast;
 
 pub struct RPathConfig<'a> {
@@ -20,6 +20,7 @@ pub struct RPathConfig<'a> {
     pub is_like_osx: bool,
     pub has_rpath: bool,
     pub get_install_prefix_lib_path: &'a mut FnMut() -> PathBuf,
+    pub realpath: &'a mut FnMut(&Path) -> io::Result<PathBuf>,
 }
 
 pub fn get_rpath_flags(config: &mut RPathConfig) -> Vec<String> {
@@ -94,11 +95,11 @@ fn get_rpath_relative_to_output(config: &mut RPathConfig, lib: &Path) -> String
     };
 
     let cwd = env::current_dir().unwrap();
-    let mut lib = fs::canonicalize(&cwd.join(lib)).unwrap_or(cwd.join(lib));
+    let mut lib = (config.realpath)(&cwd.join(lib)).unwrap();
     lib.pop();
     let mut output = cwd.join(&config.out_filename);
     output.pop();
-    let output = fs::canonicalize(&output).unwrap_or(output);
+    let output = (config.realpath)(&output).unwrap();
     let relative = path_relative_from(&lib, &output)
         .expect(&format!("couldn't create relative path from {:?} to {:?}", output, lib));
     // FIXME (#9639): This needs to handle non-utf8 paths
@@ -230,6 +231,7 @@ mod tests {
                 is_like_osx: true,
                 out_filename: PathBuf::from("bin/rustc"),
                 get_install_prefix_lib_path: &mut || panic!(),
+                realpath: &mut |p| Ok(p.to_path_buf()),
             };
             let res = get_rpath_relative_to_output(config,
                                                    Path::new("lib/libstd.so"));
@@ -241,6 +243,7 @@ mod tests {
                 get_install_prefix_lib_path: &mut || panic!(),
                 has_rpath: true,
                 is_like_osx: false,
+                realpath: &mut |p| Ok(p.to_path_buf()),
             };
             let res = get_rpath_relative_to_output(config,
                                                    Path::new("lib/libstd.so"));