---

yaml
---
r: 272807
b: refs/heads/beta
c: 064f17c
h: refs/heads/master
i:
  272805: 3aa51ed
  272803: 490dcdb
  272799: 04c45ad

Author: jseyfried

[refs]

@@ -23,7 +23,7 @@ refs/tags/0.9: 36870b185fc5f5486636d4515f0e22677493f225
 refs/tags/0.10: ac33f2b15782272ae348dbd7b14b8257b2148b5a
 refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
-refs/heads/beta: 07a1803dd3ca02c16b9820d0102a9dfc9c5ab7a5
+refs/heads/beta: 064f17c6a39af65982aa4bc33eb12ac531b4b32a
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/src/bootstrap/build/sanity.rs

@@ -79,7 +79,7 @@ pub fn check(build: &mut Build) {
         }
 
         // Make sure musl-root is valid if specified
-        if target.contains("musl") && target.contains("x86_64") {
+        if target.contains("musl") {
             match build.config.musl_root {
                 Some(ref root) => {
                     if fs::metadata(root.join("lib/libc.a")).is_err() {

branches/beta/src/doc/book/vectors.md

@@ -115,36 +115,6 @@ for i in v {
 }
 ```
 
-Note: You cannot use the vector again once you have iterated by taking ownership of the vector.
-You can iterate the vector multiple times by taking a reference to the vector whilst iterating. 
-For example, the following code does not compile.
-
-```rust,ignore
-let mut v = vec![1, 2, 3, 4, 5];
-
-for i in v {
-    println!("Take ownership of the vector and its element {}", i);
-}
-
-for i in v {
-    println!("Take ownership of the vector and its element {}", i);
-}
-```
-
-Whereas the following works perfectly,
-
-```rust
-let mut v = vec![1, 2, 3, 4, 5];
-
-for i in &v {
-    println!("This is a reference to {}", i);
-}
-
-for i in &v {
-    println!("This is a reference to {}", i);
-}
-```
-
 Vectors have many more useful methods, which you can read about in [their
 API documentation][vec].
 

branches/beta/src/libcore/iter.rs

@@ -1532,7 +1532,7 @@ pub trait Iterator {
     /// An iterator adaptor that applies a function, producing a single, final value.
     ///
     /// `fold()` takes two arguments: an initial value, and a closure with two
-    /// arguments: an 'accumulator', and an element. The closure returns the value that
+    /// arguments: an 'accumulator', and an element. It returns the value that
     /// the accumulator should have for the next iteration.
     ///
     /// The initial value is the value the accumulator will have on the first
@@ -3851,17 +3851,6 @@ impl<I> Iterator for Skip<I> where I: Iterator {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<I> ExactSizeIterator for Skip<I> where I: ExactSizeIterator {}
 
-#[stable(feature = "double_ended_skip_iterator", since = "1.8.0")]
-impl<I> DoubleEndedIterator for Skip<I> where I: DoubleEndedIterator + ExactSizeIterator {
-    fn next_back(&mut self) -> Option<Self::Item> {
-        if self.len() > 0 {
-            self.iter.next_back()
-        } else {
-            None
-        }
-    }
-}
-
 /// An iterator that only iterates over the first `n` iterations of `iter`.
 ///
 /// This `struct` is created by the [`take()`] method on [`Iterator`]. See its

branches/beta/src/libcore/str/mod.rs

@@ -1095,6 +1095,8 @@ fn eq_slice(a: &str, b: &str) -> bool {
 /// faster than comparing each byte in a loop.
 #[inline]
 unsafe fn cmp_slice(a: &str, b: &str, len: usize) -> i32 {
+    // NOTE: In theory n should be libc::size_t and not usize, but libc is not available here
+    #[allow(improper_ctypes)]
     extern { fn memcmp(s1: *const i8, s2: *const i8, n: usize) -> i32; }
     memcmp(a.as_ptr() as *const i8, b.as_ptr() as *const i8, len)
 }

branches/beta/src/libcoretest/iter.rs

@@ -303,44 +303,6 @@ fn test_iterator_skip() {
     assert_eq!(it.len(), 0);
 }
 
-#[test]
-fn test_iterator_skip_doubleended() {
-    let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];
-    let mut it = xs.iter().rev().skip(5);
-    assert_eq!(it.next(), Some(&15));
-    assert_eq!(it.by_ref().rev().next(), Some(&0));
-    assert_eq!(it.next(), Some(&13));
-    assert_eq!(it.by_ref().rev().next(), Some(&1));
-    assert_eq!(it.next(), Some(&5));
-    assert_eq!(it.by_ref().rev().next(), Some(&2));
-    assert_eq!(it.next(), Some(&3));
-    assert_eq!(it.next(), None);
-    let mut it = xs.iter().rev().skip(5).rev();
-    assert_eq!(it.next(), Some(&0));
-    assert_eq!(it.rev().next(), Some(&15));
-    let mut it_base = xs.iter();
-    {
-        let mut it = it_base.by_ref().skip(5).rev();
-        assert_eq!(it.next(), Some(&30));
-        assert_eq!(it.next(), Some(&20));
-        assert_eq!(it.next(), Some(&19));
-        assert_eq!(it.next(), Some(&17));
-        assert_eq!(it.next(), Some(&16));
-        assert_eq!(it.next(), Some(&15));
-        assert_eq!(it.next(), Some(&13));
-        assert_eq!(it.next(), None);
-    }
-    // make sure the skipped parts have not been consumed
-    assert_eq!(it_base.next(), Some(&0));
-    assert_eq!(it_base.next(), Some(&1));
-    assert_eq!(it_base.next(), Some(&2));
-    assert_eq!(it_base.next(), Some(&3));
-    assert_eq!(it_base.next(), Some(&5));
-    assert_eq!(it_base.next(), None);
-    let it = xs.iter().skip(5).rev();
-    assert_eq!(it.last(), Some(&13));
-}
-
 #[test]
 fn test_iterator_skip_nth() {
     let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30];

branches/beta/src/librustc_resolve/build_reduced_graph.rs

@@ -207,7 +207,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {
                                           ResolutionError::SelfImportsOnlyAllowedWithin);
                         }
 
-                        let subclass = SingleImport(binding, source_name);
+                        let subclass = ImportDirectiveSubclass::single(binding, source_name);
                         self.build_import_directive(parent,
                                                     module_path,
                                                     subclass,
@@ -258,9 +258,10 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {
                                     (module_path.to_vec(), name, rename)
                                 }
                             };
+                            let subclass = ImportDirectiveSubclass::single(rename, name);
                             self.build_import_directive(parent,
                                                         module_path,
-                                                        SingleImport(rename, name),
+                                                        subclass,
                                                         source_item.span,
                                                         source_item.node.id(),
                                                         is_public,
@@ -683,11 +684,6 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {
                               id: NodeId,
                               is_public: bool,
                               shadowable: Shadowable) {
-        module_.unresolved_imports
-               .borrow_mut()
-               .push(ImportDirective::new(module_path, subclass, span, id, is_public, shadowable));
-        self.unresolved_imports += 1;
-
         if is_public {
             module_.inc_pub_count();
         }
@@ -696,7 +692,7 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {
         // the appropriate flag.
 
         match subclass {
-            SingleImport(target, _) => {
+            SingleImport { target, .. } => {
                 module_.increment_outstanding_references_for(target, ValueNS);
                 module_.increment_outstanding_references_for(target, TypeNS);
             }
@@ -710,6 +706,11 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {
                 }
             }
         }
+
+        module_.unresolved_imports
+               .borrow_mut()
+               .push(ImportDirective::new(module_path, subclass, span, id, is_public, shadowable));
+        self.unresolved_imports += 1;
     }
 }
 

branches/beta/src/librustc_resolve/resolve_imports.rs

@@ -32,14 +32,31 @@ use syntax::codemap::Span;
 use syntax::util::lev_distance::find_best_match_for_name;
 
 use std::mem::replace;
+use std::cell::Cell;
 
 /// Contains data for specific types of import directives.
-#[derive(Copy, Clone,Debug)]
+#[derive(Clone, Debug)]
 pub enum ImportDirectiveSubclass {
-    SingleImport(Name /* target */, Name /* source */),
+    SingleImport {
+        target: Name,
+        source: Name,
+        type_determined: Cell<bool>,
+        value_determined: Cell<bool>,
+    },
     GlobImport,
 }
 
+impl ImportDirectiveSubclass {
+    pub fn single(target: Name, source: Name) -> Self {
+        SingleImport {
+            target: target,
+            source: source,
+            type_determined: Cell::new(false),
+            value_determined: Cell::new(false),
+        }
+    }
+}
+
 /// Whether an import can be shadowed by another import.
 #[derive(Debug,PartialEq,Clone,Copy)]
 pub enum Shadowable {
@@ -218,7 +235,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
     fn import_resolving_error(&self, e: ImportResolvingError<'b>) {
         // 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 {
+        if let SingleImport { target, .. } = e.import_directive.subclass {
             let dummy_binding = self.resolver.new_name_binding(NameBinding {
                 modifiers: DefModifiers::PRELUDE,
                 kind: NameBindingKind::Def(Def::Err),
@@ -304,15 +321,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
             .and_then(|containing_module| {
                 // We found the module that the target is contained
                 // within. Attempt to resolve the import within it.
-                if let SingleImport(target, source) = import_directive.subclass {
-                    self.resolve_single_import(module_,
-                                               containing_module,
-                                               target,
-                                               source,
-                                               import_directive)
-                } else {
-                    self.resolve_glob_import(module_, containing_module, import_directive)
-                }
+                self.resolve_import(module_, containing_module, import_directive)
             })
             .and_then(|()| {
                 // Decrement the count of unresolved imports.
@@ -332,36 +341,53 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
             })
     }
 
-    fn resolve_single_import(&mut self,
-                             module_: Module<'b>,
-                             target_module: Module<'b>,
-                             target: Name,
-                             source: Name,
-                             directive: &ImportDirective)
-                             -> ResolveResult<()> {
-        debug!("(resolving single import) resolving `{}` = `{}::{}` from `{}` id {}",
-               target,
-               module_to_string(&target_module),
-               source,
-               module_to_string(module_),
-               directive.id);
-
-        // If this is a circular import, we temporarily count it as determined so that
-        // it fails (as opposed to being indeterminate) when nothing else can define it.
-        if target_module.def_id() == module_.def_id() && source == target {
-            module_.decrement_outstanding_references_for(target, ValueNS);
-            module_.decrement_outstanding_references_for(target, TypeNS);
-        }
+    fn resolve_import(&mut self,
+                      module_: Module<'b>,
+                      target_module: Module<'b>,
+                      directive: &ImportDirective)
+                      -> ResolveResult<()> {
+        let (source, target, value_determined, type_determined) = match directive.subclass {
+            SingleImport { source, target, ref value_determined, ref type_determined } =>
+                (source, target, value_determined, type_determined),
+            GlobImport => return self.resolve_glob_import(module_, target_module, directive),
+        };
 
         // We need to resolve both namespaces for this to succeed.
-        let value_result =
-            self.resolver.resolve_name_in_module(target_module, source, ValueNS, false, true);
-        let type_result =
-            self.resolver.resolve_name_in_module(target_module, source, TypeNS, false, true);
-
-        if target_module.def_id() == module_.def_id() && source == target {
-            module_.increment_outstanding_references_for(target, ValueNS);
-            module_.increment_outstanding_references_for(target, TypeNS);
+        let (value_result, type_result) = {
+            let mut resolve_in_ns = |ns, determined: bool| {
+                // Temporarily count the directive as determined so that the resolution fails
+                // (as opposed to being indeterminate) when it can only be defined by the directive.
+                if !determined { module_.decrement_outstanding_references_for(target, ns) }
+                let result =
+                    self.resolver.resolve_name_in_module(target_module, source, ns, false, true);
+                if !determined { module_.increment_outstanding_references_for(target, ns) }
+                result
+            };
+            (resolve_in_ns(ValueNS, value_determined.get()),
+             resolve_in_ns(TypeNS, type_determined.get()))
+        };
+
+        for &(ns, result, determined) in &[(ValueNS, &value_result, value_determined),
+                                           (TypeNS, &type_result, type_determined)] {
+            if determined.get() { continue }
+            if let Indeterminate = *result { continue }
+
+            determined.set(true);
+            if let Success(binding) = *result {
+                if !binding.defined_with(DefModifiers::IMPORTABLE) {
+                    let msg = format!("`{}` is not directly importable", target);
+                    span_err!(self.resolver.session, directive.span, E0253, "{}", &msg);
+                }
+
+                let privacy_error = if !self.resolver.is_visible(binding, target_module) {
+                    Some(Box::new(PrivacyError(directive.span, source, binding)))
+                } else {
+                    None
+                };
+
+                self.define(module_, target, ns, directive.import(binding, privacy_error));
+            }
+            module_.decrement_outstanding_references_for(target, ns);
         }
 
         match (&value_result, &type_result) {
@@ -425,37 +451,22 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
             _ => {}
         }
 
+        // Report a privacy error here if all successful namespaces are privacy errors.
         let mut privacy_error = None;
-        let mut report_privacy_error = true;
-        for &(ns, result) in &[(ValueNS, &value_result), (TypeNS, &type_result)] {
-            if let Success(binding) = *result {
-                if !binding.defined_with(DefModifiers::IMPORTABLE) {
-                    let msg = format!("`{}` is not directly importable", target);
-                    span_err!(self.resolver.session, directive.span, E0253, "{}", &msg);
-                }
-
-                privacy_error = if !self.resolver.is_visible(binding, target_module) {
-                    Some(Box::new(PrivacyError(directive.span, source, binding)))
-                } else {
-                    report_privacy_error = false;
-                    None
-                };
-
-                self.define(module_, target, ns, directive.import(binding, privacy_error.clone()));
-            }
-        }
-
-        if report_privacy_error { // then all successful namespaces are privacy errors
-            // We report here so there is an error even if the imported name is not used
-            self.resolver.privacy_errors.push(*privacy_error.unwrap());
+        for &ns in &[ValueNS, TypeNS] {
+            privacy_error = match module_.resolve_name(target, ns, true) {
+                Success(&NameBinding {
+                    kind: NameBindingKind::Import { ref privacy_error, .. }, ..
+                }) => privacy_error.as_ref().map(|error| (**error).clone()),
+                _ => continue,
+            };
+            if privacy_error.is_none() { break }
         }
+        privacy_error.map(|error| self.resolver.privacy_errors.push(error));
 
         // Record what this import resolves to for later uses in documentation,
         // this may resolve to either a value or a type, but for documentation
         // purposes it's good enough to just favor one over the other.
-        module_.decrement_outstanding_references_for(target, ValueNS);
-        module_.decrement_outstanding_references_for(target, TypeNS);
-
         let def = match type_result.success().and_then(NameBinding::def) {
             Some(def) => def,
             None => value_result.success().and_then(NameBinding::def).unwrap(),
@@ -610,7 +621,7 @@ fn import_path_to_string(names: &[Name], subclass: ImportDirectiveSubclass) -> S
 
 fn import_directive_subclass_to_string(subclass: ImportDirectiveSubclass) -> String {
     match subclass {
-        SingleImport(_, source) => source.to_string(),
+        SingleImport { source, .. } => source.to_string(),
         GlobImport => "*".to_string(),
     }
 }