---

yaml
---
r: 274519
b: refs/heads/stable
c: 5ed8e98
h: refs/heads/master
i:
  274517: f3de8f5
  274515: f386593
  274511: 67fc0de

Author: dirk

[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: 54664f188403a5bb72634b5e3ba9b2f7b60b4d9f
+refs/heads/stable: 5ed8e98ea220d797c213a356f354b958f4ccfc49
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/src/librustc_resolve/lib.rs

@@ -1468,7 +1468,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
             match search_module.parent_link {
                 NoParentLink => {
                     // No more parents. This module was unresolved.
-                    debug!("(resolving item in lexical scope) unresolved module");
+                    debug!("(resolving item in lexical scope) unresolved module: no parent module");
                     return Failed(None);
                 }
                 ModuleParentLink(parent_module_node, _) => {
@@ -3109,7 +3109,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
             }
             Indeterminate => None,
             Failed(err) => {
-                debug!("(resolving item path by identifier in lexical scope) failed to resolve {}",
+                debug!("(resolving item path by identifier in lexical scope) failed to \
+                        resolve `{}`",
                        name);
 
                 if let Some((span, msg)) = err {

branches/stable/src/librustc_resolve/resolve_imports.rs

@@ -11,6 +11,7 @@
 use self::ImportDirectiveSubclass::*;
 
 use DefModifiers;
+use DefOrModule;
 use Module;
 use Namespace::{self, TypeNS, ValueNS};
 use NameBinding;
@@ -50,7 +51,7 @@ pub enum Shadowable {
 }
 
 /// One import directive.
-#[derive(Debug)]
+#[derive(Debug,Clone)]
 pub struct ImportDirective {
     pub module_path: Vec<Name>,
     pub subclass: ImportDirectiveSubclass,
@@ -140,9 +141,11 @@ impl<'a> ImportResolution<'a> {
     }
 }
 
-struct ImportResolvingError {
+struct ImportResolvingError<'a> {
+    /// Module where the error happened
+    source_module: Module<'a>,
+    import_directive: ImportDirective,
     span: Span,
-    path: String,
     help: String,
 }
 
@@ -181,9 +184,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
                 // resolving failed
                 if errors.len() > 0 {
                     for e in errors {
-                        resolve_error(self.resolver,
-                                      e.span,
-                                      ResolutionError::UnresolvedImport(Some((&e.path, &e.help))));
+                        self.import_resolving_error(e)
                     }
                 } else {
                     // Report unresolved imports only if no hard error was already reported
@@ -200,11 +201,55 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
         }
     }
 
+    /// Resolves an `ImportResolvingError` into the correct enum discriminant
+    /// and passes that on to `resolve_error`.
+    fn import_resolving_error(&self, e: ImportResolvingError) {
+        // If it's a single failed import then create a "fake" import
+        // resolution for it so that later resolve stages won't complain.
+        if let SingleImport(target, _) = e.import_directive.subclass {
+            let mut import_resolutions = e.source_module.import_resolutions.borrow_mut();
+
+            let resolution = import_resolutions.entry((target, ValueNS)).or_insert_with(|| {
+                debug!("(resolving import error) adding import resolution for `{}`",
+                       target);
+
+                ImportResolution::new(e.import_directive.id,
+                                      e.import_directive.is_public)
+            });
+
+            if resolution.target.is_none() {
+                debug!("(resolving import error) adding fake target to import resolution of `{}`",
+                       target);
+
+                let name_binding = NameBinding {
+                    modifiers: DefModifiers::IMPORTABLE,
+                    def_or_module: DefOrModule::Def(Def::Err),
+                    span: None,
+                };
+
+                // Create a fake target pointing to a fake name binding in our
+                // own module
+                let target = Target::new(e.source_module,
+                                         name_binding,
+                                         Shadowable::Always);
+
+                resolution.target = Some(target);
+            }
+        }
+
+        let path = import_path_to_string(&e.import_directive.module_path,
+                                         e.import_directive.subclass);
+
+        resolve_error(self.resolver,
+                      e.span,
+                      ResolutionError::UnresolvedImport(Some((&path, &e.help))));
+    }
+
     /// Attempts to resolve imports for the given module and all of its
     /// submodules.
     fn resolve_imports_for_module_subtree(&mut self,
                                           module_: Module<'b>)
-                                          -> Vec<ImportResolvingError> {
+                                          -> Vec<ImportResolvingError<'b>> {
         let mut errors = Vec::new();
         debug!("(resolving imports for module subtree) resolving {}",
                module_to_string(&*module_));
@@ -232,7 +277,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
     }
 
     /// Attempts to resolve imports for the given module only.
-    fn resolve_imports_for_module(&mut self, module: Module<'b>) -> Vec<ImportResolvingError> {
+    fn resolve_imports_for_module(&mut self, module: Module<'b>) -> Vec<ImportResolvingError<'b>> {
         let mut errors = Vec::new();
 
         if module.all_imports_resolved() {
@@ -254,9 +299,9 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
                         None => (import_directive.span, String::new()),
                     };
                     errors.push(ImportResolvingError {
+                        source_module: module,
+                        import_directive: import_directive.clone(),
                         span: span,
-                        path: import_path_to_string(&import_directive.module_path,
-                                                    import_directive.subclass),
                         help: help,
                     });
                 }
@@ -784,7 +829,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
                                  namespace_name,
                                  name);
                 span_err!(self.resolver.session, import_directive.span, E0251, "{}", msg);
-           } else {
+            } else {
                 let target = Target::new(containing_module,
                                          name_binding.clone(),
                                          import_directive.shadowable);

branches/stable/src/librustc_trans/trans/debuginfo/mod.rs

@@ -200,13 +200,6 @@ pub fn finalize(cx: &CrateContext) {
                                         2)
         }
 
-        // Indicate that we want CodeView debug information on MSVC
-        if cx.sess().target.target.options.is_like_msvc {
-            llvm::LLVMRustAddModuleFlag(cx.llmod(),
-                                        "CodeView\0".as_ptr() as *const _,
-                                        1)
-        }
-
         // Prevent bitcode readers from deleting the debug info.
         let ptr = "Debug Info Version\0".as_ptr();
         llvm::LLVMRustAddModuleFlag(cx.llmod(), ptr as *const _,

branches/stable/src/libstd/sys/unix/fs.rs

@@ -211,14 +211,20 @@ impl DirEntry {
     #[cfg(any(target_os = "macos",
               target_os = "ios",
               target_os = "netbsd",
-              target_os = "openbsd",
-              target_os = "freebsd",
+              target_os = "openbsd"))]
+    fn name_bytes(&self) -> &[u8] {
+        unsafe {
+            ::slice::from_raw_parts(self.entry.d_name.as_ptr() as *const u8,
+                                    self.entry.d_namlen as usize)
+        }
+    }
+    #[cfg(any(target_os = "freebsd",
               target_os = "dragonfly",
               target_os = "bitrig"))]
     fn name_bytes(&self) -> &[u8] {
         unsafe {
             ::slice::from_raw_parts(self.entry.d_name.as_ptr() as *const u8,
-                                    self.entry.d_namlen as usize)
+                                    self.entry.d_namelen as usize)
         }
     }
     #[cfg(any(target_os = "android",

branches/stable/src/libstd/sys/unix/stack_overflow.rs

@@ -135,38 +135,26 @@ mod imp {
         Handler { _data: MAIN_ALTSTACK };
     }
 
-    unsafe fn get_stackp() -> *mut libc::c_void {
-        let stackp = mmap(ptr::null_mut(),
-                          SIGSTKSZ,
-                          PROT_READ | PROT_WRITE,
-                          MAP_PRIVATE | MAP_ANON,
-                          -1,
-                          0);
-        if stackp == MAP_FAILED {
+    pub unsafe fn make_handler() -> Handler {
+        let alt_stack = mmap(ptr::null_mut(),
+                             SIGSTKSZ,
+                             PROT_READ | PROT_WRITE,
+                             MAP_PRIVATE | MAP_ANON,
+                             -1,
+                             0);
+        if alt_stack == MAP_FAILED {
             panic!("failed to allocate an alternative stack");
         }
-        stackp
-    }
 
-    #[cfg(any(target_os = "linux",
-              target_os = "macos",
-              target_os = "bitrig",
-              target_os = "netbsd",
-              target_os = "openbsd"))]
-    unsafe fn get_stack() -> libc::stack_t {
-        libc::stack_t { ss_sp: get_stackp(), ss_flags: 0, ss_size: SIGSTKSZ }
-    }
+        let mut stack: libc::stack_t = mem::zeroed();
 
-    #[cfg(any(target_os = "freebsd",
-              target_os = "dragonfly"))]
-    unsafe fn get_stack() -> libc::stack_t {
-        libc::stack_t { ss_sp: get_stackp() as *mut i8, ss_flags: 0, ss_size: SIGSTKSZ }
-    }
+        stack.ss_sp = alt_stack;
+        stack.ss_flags = 0;
+        stack.ss_size = SIGSTKSZ;
 
-    pub unsafe fn make_handler() -> Handler {
-        let stack = get_stack();
         sigaltstack(&stack, ptr::null_mut());
-        Handler { _data: stack.ss_sp as *mut libc::c_void }
+
+        Handler { _data: alt_stack }
     }
 
     pub unsafe fn drop_handler(handler: &mut Handler) {

branches/stable/src/libtest/lib.rs

@@ -939,12 +939,18 @@ fn get_concurrency() -> usize {
     fn num_cpus() -> usize {
         let mut cpus: libc::c_uint = 0;
         let mut cpus_size = std::mem::size_of_val(&cpus);
+        let mut mib = [libc::CTL_HW, libc::HW_AVAILCPU, 0, 0];
 
         unsafe {
-            cpus = libc::sysconf(libc::_SC_NPROCESSORS_ONLN) as libc::c_uint;
+            libc::sysctl(mib.as_mut_ptr(),
+                         2,
+                         &mut cpus as *mut _ as *mut _,
+                         &mut cpus_size as *mut _ as *mut _,
+                         0 as *mut _,
+                         0);
         }
         if cpus < 1 {
-            let mut mib = [libc::CTL_HW, libc::HW_NCPU, 0, 0];
+            mib[1] = libc::HW_NCPU;
             unsafe {
                 libc::sysctl(mib.as_mut_ptr(),
                              2,

branches/stable/src/test/compile-fail/import-from-missing.rs

@@ -15,5 +15,8 @@ mod spam {
     pub fn ham() { }
 }
 
-fn main() { ham(); eggs(); }
-//~^ ERROR unresolved name `eggs`
+fn main() {
+    ham();
+    // Expect eggs to pass because the compiler inserts a fake name for it
+    eggs();
+}

branches/stable/src/test/compile-fail/import2.rs

@@ -11,10 +11,10 @@
 use baz::zed::bar;
 //~^ ERROR unresolved import `baz::zed::bar`. Could not find `zed` in `baz`
 
-
 mod baz {}
 mod zed {
     pub fn bar() { println!("bar3"); }
 }
-fn main() { bar(); }
-//~^ ERROR unresolved name `bar`
+fn main() {
+    bar();
+}

branches/stable/src/test/compile-fail/privacy3.rs

@@ -27,8 +27,10 @@ pub fn foo() {}
 fn test1() {
     use bar::gpriv;
     //~^ ERROR unresolved import `bar::gpriv`. There is no `gpriv` in `bar`
+
+    // This should pass because the compiler will insert a fake name binding
+    // for `gpriv`
     gpriv();
-    //~^ ERROR unresolved name `gpriv`
 }
 
 #[start] fn main(_: isize, _: *const *const u8) -> isize { 3 }

branches/stable/src/test/run-pass/backtrace-debuginfo.rs

@@ -14,7 +14,6 @@
 // seemingly completely unrelated change.
 // Unfortunately, LLVM has no "disable" option for this, so we have to set
 // "enable" to 0 instead.
-
 // compile-flags:-g -Cllvm-args=-enable-tail-merge=0
 // ignore-pretty as this critically relies on line numbers
 
@@ -28,23 +27,30 @@ macro_rules! pos {
     () => ((file!(), line!()))
 }
 
+#[cfg(all(unix,
+          not(target_os = "macos"),
+          not(target_os = "ios"),
+          not(target_os = "android"),
+          not(all(target_os = "linux", target_arch = "arm"))))]
 macro_rules! dump_and_die {
     ($($pos:expr),*) => ({
         // FIXME(#18285): we cannot include the current position because
         // the macro span takes over the last frame's file/line.
-        if cfg!(target_os = "macos") ||
-           cfg!(target_os = "ios") ||
-           cfg!(target_os = "android") ||
-           cfg!(all(target_os = "linux", target_arch = "arm")) ||
-           cfg!(all(windows, target_env = "gnu")) {
-            // skip these platforms as this support isn't implemented yet.
-        } else {
-            dump_filelines(&[$($pos),*]);
-            panic!();
-        }
+        dump_filelines(&[$($pos),*]);
+        panic!();
     })
 }
 
+// this does not work on Windows, Android, OSX or iOS
+#[cfg(not(all(unix,
+              not(target_os = "macos"),
+              not(target_os = "ios"),
+              not(target_os = "android"),
+              not(all(target_os = "linux", target_arch = "arm")))))]
+macro_rules! dump_and_die {
+    ($($pos:expr),*) => ({ let _ = [$($pos),*]; })
+}
+
 // we can't use a function as it will alter the backtrace
 macro_rules! check {
     ($counter:expr; $($pos:expr),*) => ({