Merge pull request #106 from GuillaumeGomez/fix-iterator

Remove usage of transmute

src/js/token.rs

@@ -1059,32 +1059,12 @@ impl<'a> Tokens<'a> {
     }
 }
 
-pub struct IntoIterTokens<'a> {
-    inner: Tokens<'a>,
-}
-
 impl<'a> IntoIterator for Tokens<'a> {
-    type Item = (Token<'a>, Option<&'a Token<'a>>);
-    type IntoIter = IntoIterTokens<'a>;
-
-    fn into_iter(mut self) -> Self::IntoIter {
-        self.0.reverse();
-        IntoIterTokens { inner: self }
-    }
-}
+    type Item = Token<'a>;
+    type IntoIter = std::vec::IntoIter<Token<'a>>;
 
-impl<'a> Iterator for IntoIterTokens<'a> {
-    type Item = (Token<'a>, Option<&'a Token<'a>>);
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.inner.0.is_empty() {
-            None
-        } else {
-            let ret = self.inner.0.pop().expect("pop() failed");
-            // FIXME once generic traits' types are stabilized, use a second
-            // lifetime instead of transmute!
-            Some((ret, unsafe { std::mem::transmute(self.inner.0.last()) }))
-        }
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
     }
 }
 

src/js/utils.rs

@@ -559,17 +559,17 @@ var n = null;
 "#;
     let expected_result = "var x=['a','b',N,'d',{'x':N,'e':N,'z':'w'}];var n=N;";
 
-    let res: Tokens = crate::js::simple_minify(source)
-        .into_iter()
-        .filter(|(x, next)| crate::js::clean_token(x, next))
-        .map(|(t, _)| {
-            if t == Token::Keyword(Keyword::Null) {
+    let mut iter = crate::js::simple_minify(source).into_iter().peekable();
+    let mut tokens = Vec::new();
+    while let Some(token) = iter.next() {
+        if crate::js::clean_token(&token, &iter.peek()) {
+            tokens.push(if token == Token::Keyword(Keyword::Null) {
                 Token::Other("N")
             } else {
-                t
-            }
-        })
-        .collect::<Vec<_>>()
-        .into();
-    assert_eq!(res.to_string(), expected_result);
+                token
+            });
+        }
+    }
+    let tokens: Tokens = tokens.into();
+    assert_eq!(tokens.to_string(), expected_result);
 }