syntax: Replace unstable .cloned() with manual iter

Author: erickt

src/librustc/metadata/encoder.rs

@@ -1513,7 +1513,7 @@ fn encode_info_for_items(ecx: &EncodeContext,
                         &krate.module,
                         &[],
                         ast::CRATE_NODE_ID,
-                        [].iter().cloned().chain(LinkedPath::empty()),
+                        PathElems::new(&[], LinkedPath::empty()),
                         syntax::parse::token::special_idents::invalid.name,
                         ast::Public);
 
@@ -1874,7 +1874,7 @@ fn encode_misc_info(ecx: &EncodeContext,
     }
 
     // Encode reexports for the root module.
-    encode_reexports(ecx, rbml_w, 0, [].iter().cloned().chain(LinkedPath::empty()));
+    encode_reexports(ecx, rbml_w, 0, PathElems::new(&[], LinkedPath::empty()));
 
     rbml_w.end_tag();
     rbml_w.end_tag();

src/librustc/middle/ty.rs

@@ -5383,7 +5383,7 @@ pub fn with_path<T, F>(cx: &ctxt, id: ast::DefId, f: F) -> T where
     if id.krate == ast::LOCAL_CRATE {
         cx.map.with_path(id.node, f)
     } else {
-        f(csearch::get_item_path(cx, id).iter().cloned().chain(LinkedPath::empty()))
+        f(ast_map::PathElems::new(&csearch::get_item_path(cx, id), LinkedPath::empty()))
     }
 }
 

src/libsyntax/ast_map/mod.rs

@@ -25,7 +25,7 @@ use arena::TypedArena;
 use std::cell::RefCell;
 use std::fmt;
 use std::io;
-use std::iter::{self, repeat};
+use std::iter::repeat;
 use std::mem;
 use std::slice;
 
@@ -86,7 +86,31 @@ impl<'a> Iterator for LinkedPath<'a> {
 }
 
 /// The type of the iterator used by with_path.
-pub type PathElems<'a, 'b> = iter::Chain<iter::Cloned<slice::Iter<'a, PathElem>>, LinkedPath<'b>>;
+#[derive(Clone)]
+pub struct PathElems<'a, 'b> {
+    iter: slice::Iter<'a, PathElem>,
+    next: LinkedPath<'b>,
+}
+
+impl<'a, 'b> PathElems<'a, 'b> {
+    pub fn new(elems: &'a [PathElem], next: LinkedPath<'b>) -> Self {
+        PathElems {
+            iter: elems.iter(),
+            next: next,
+        }
+    }
+}
+
+impl<'a, 'b> Iterator for PathElems<'a, 'b> {
+    type Item = PathElem;
+
+    fn next(&mut self) -> Option<PathElem> {
+        match self.iter.next() {
+            Some(item) => Some(item.clone()),
+            None => self.next.next(),
+        }
+    }
+}
 
 pub fn path_to_string<PI: Iterator<Item=PathElem>>(path: PI) -> String {
     let itr = token::get_ident_interner();
@@ -427,10 +451,8 @@ impl<'ast> Map<'ast> {
         };
         if parent == id {
             match self.find_entry(id) {
-                Some(RootInlinedParent(data)) => {
-                    f(data.path.iter().cloned().chain(next))
-                }
-                _ => f([].iter().cloned().chain(next))
+                Some(RootInlinedParent(data)) => f(PathElems::new(&data.path, next)),
+                _ => f(PathElems::new(&[], next)),
             }
         } else {
             self.with_path_next(parent, LinkedPath::from(&LinkedPathNode {

src/libsyntax/lib.rs

@@ -26,7 +26,6 @@
        html_root_url = "http://doc.rust-lang.org/nightly/")]
 
 #![feature(collections)]
-#![feature(core)]
 #![feature(libc)]
 #![feature(rustc_private)]
 #![feature(staged_api)]