Add FromIterator<TokenStream> for TokenStream

This was left out by accident! It'll already be avaialable in 1.29.0 Rust, so
let's include it here as well.

Author: alexcrichton

src/lib.rs

@@ -182,6 +182,11 @@ impl FromIterator<TokenTree> for TokenStream {
         TokenStream::_new(streams.into_iter().collect())
     }
 }
+impl FromIterator<TokenStream> for TokenStream {
+    fn from_iter<I: IntoIterator<Item = TokenStream>>(streams: I) -> Self {
+        TokenStream::_new(streams.into_iter().map(|i| i.inner).collect())
+    }
+}
 
 /// Prints the token stream as a string that is supposed to be losslessly
 /// convertible back into the same token stream (modulo spans), except for

src/stable.rs

@@ -154,6 +154,18 @@ impl iter::FromIterator<TokenTree> for TokenStream {
     }
 }
 
+impl iter::FromIterator<TokenStream> for TokenStream {
+    fn from_iter<I: IntoIterator<Item = TokenStream>>(streams: I) -> Self {
+        let mut v = Vec::new();
+
+        for stream in streams.into_iter() {
+            v.extend(stream.inner);
+        }
+
+        TokenStream { inner: v }
+    }
+}
+
 impl Extend<TokenTree> for TokenStream {
     fn extend<I: IntoIterator<Item = TokenTree>>(&mut self, streams: I) {
         self.inner.extend(streams);

src/unstable.rs

@@ -206,6 +206,45 @@ impl iter::FromIterator<TokenTree> for TokenStream {
     }
 }
 
+impl iter::FromIterator<TokenStream> for TokenStream {
+    fn from_iter<I: IntoIterator<Item = TokenStream>>(streams: I) -> Self {
+        let mut streams = streams.into_iter();
+        match streams.next() {
+            #[cfg(slow_extend)]
+            Some(TokenStream::Nightly(first)) => {
+                let stream = iter::once(first).chain(streams.map(|s| {
+                    match s {
+                        TokenStream::Nightly(s) => s,
+                        TokenStream::Stable(_) => mismatch(),
+                    }
+                })).collect();
+                TokenStream::Nightly(stream)
+            }
+            #[cfg(not(slow_extend))]
+            Some(TokenStream::Nightly(mut first)) => {
+                first.extend(streams.map(|s| {
+                    match s {
+                        TokenStream::Nightly(s) => s,
+                        TokenStream::Stable(_) => mismatch(),
+                    }
+                }));
+                TokenStream::Nightly(first)
+            }
+            Some(TokenStream::Stable(mut first)) => {
+                first.extend(streams.map(|s| {
+                    match s {
+                        TokenStream::Stable(s) => s,
+                        TokenStream::Nightly(_) => mismatch(),
+                    }
+                }));
+                TokenStream::Stable(first)
+            }
+            None => TokenStream::new(),
+
+        }
+    }
+}
+
 impl Extend<TokenTree> for TokenStream {
     fn extend<I: IntoIterator<Item = TokenTree>>(&mut self, streams: I) {
         match self {