Fuse iterators that call next multiple times

jongiddy · Apr 27, 2024 · 98f5a57 · 98f5a57
1 parent 95cd0ec
commit 98f5a57
Show file tree

Hide file tree

Showing 3 changed files with 10 additions and 9 deletions.
diff --git a/src/constant.rs b/src/constant.rs
@@ -57,10 +57,9 @@ pub fn evaluate_bool(expr: &Expr) -> Result<bool> {
 pub fn evaluate_range(expr: &Expr) -> Option<&syn::ExprRange> {
     match expr {
         Expr::Block(block) => {
-            if block.block.stmts.len() == 1 {
-                if let Stmt::Expr(expr, _) = &block.block.stmts[0] {
-                    return evaluate_range(expr);
-                }
+            let mut stmts = block.block.stmts.iter().fuse();
+            if let (Some(Stmt::Expr(expr, None)), None) = (stmts.next(), stmts.next()) {
+                return evaluate_range(expr);
             }
         }
         Expr::Range(range) => {

diff --git a/src/context.rs b/src/context.rs
@@ -680,7 +680,7 @@ impl<'a> TypleContext<'a> {
                 self.replace_expr(&mut index.expr, state)?;
                 if let Expr::Array(array) = &mut *index.index {
                     // t[[0]]
-                    let mut iter = array.elems.iter_mut();
+                    let mut iter = array.elems.iter_mut().fuse();
                     let (Some(field), None) = (iter.next(), iter.next()) else {
                         abort!(index.index, "unsupported tuple index");
                     };
@@ -751,7 +751,7 @@ impl<'a> TypleContext<'a> {
             Expr::Path(path) => {
                 self.replace_attrs(&mut path.attrs)?;
                 if path.qself.is_none() {
-                    let mut segments = path.path.segments.iter();
+                    let mut segments = path.path.segments.iter().fuse();
                     if let Some(syn::PathSegment {
                         ident: ident1,
                         arguments: PathArguments::None,
@@ -936,7 +936,7 @@ impl<'a> TypleContext<'a> {
                                     if let PathArguments::AngleBracketed(arguments) =
                                         &first.arguments
                                     {
-                                        let mut iter = arguments.args.iter();
+                                        let mut iter = arguments.args.iter().fuse();
                                         let (Some(arg), None) = (iter.next(), iter.next()) else {
                                             abort!(arguments, "expected constant expression");
                                         };
@@ -1119,7 +1119,7 @@ impl<'a> TypleContext<'a> {
                             &mut first.arguments,
                             segments.next(),
                         ) {
-                            let mut iter = arguments.args.iter_mut();
+                            let mut iter = arguments.args.iter_mut().fuse();
                             if let (Some(GenericArgument::Const(ref mut expr)), None) =
                                 (iter.next(), iter.next())
                             {

diff --git a/tests/compile/unzip.rs b/tests/compile/unzip.rs
@@ -70,7 +70,9 @@ where
 
 // A solution that does not modify the original trait is to add a new trait with
 // an associated method, implement it on the tuple type, and call it from an
-// impl for the original trait:
+// impl for the original trait. Note that the typle impl uses the input
+// types as generic parameters to select the implementation and uses associated
+// types for any interface types constructed using typle macros.
 
 pub trait TryUnzipTuple<T, E> {
     type Output;