New upstream version 1.65.0+dfsg1

[rustc.git] / vendor / pest_meta / src / optimizer / unroller.rs

diff --git a/vendor/pest_meta/src/optimizer/unroller.rs b/vendor/pest_meta/src/optimizer/unroller.rs
index fff17336deef84d92db7ea5ce95eabefed41e3fe..e3c360d90934ff583185f2fe3f09f6b034f17023 100644 (file)
--- a/vendor/pest_meta/src/optimizer/unroller.rs
+++ b/vendor/pest_meta/src/optimizer/unroller.rs
@@ -7,61 +7,60 @@
 // option. All files in the project carrying such notice may not be copied,
 // modified, or distributed except according to those terms.
 
-use ast::*;
+use crate::ast::*;
 
 pub fn unroll(rule: Rule) -> Rule {
-    match rule {
-        Rule { name, ty, expr } => Rule {
-            name,
-            ty,
-            expr: expr.map_bottom_up(|expr| match expr {
-                Expr::RepOnce(expr) => Expr::Seq(expr.clone(), Box::new(Expr::Rep(expr))),
-                Expr::RepExact(expr, num) => (1..num + 1)
-                    .map(|_| *expr.clone())
-                    .rev()
-                    .fold(None, |rep, expr| match rep {
-                        None => Some(expr),
-                        Some(rep) => Some(Expr::Seq(Box::new(expr), Box::new(rep))),
-                    })
-                    .unwrap(),
-                Expr::RepMin(expr, min) => (1..min + 2)
-                    .map(|i| {
-                        if i <= min {
-                            *expr.clone()
-                        } else {
-                            Expr::Rep(expr.clone())
-                        }
-                    })
-                    .rev()
-                    .fold(None, |rep, expr| match rep {
-                        None => Some(expr),
-                        Some(rep) => Some(Expr::Seq(Box::new(expr), Box::new(rep))),
-                    })
-                    .unwrap(),
-                Expr::RepMax(expr, max) => (1..max + 1)
-                    .map(|_| Expr::Opt(expr.clone()))
-                    .rev()
-                    .fold(None, |rep, expr| match rep {
-                        None => Some(expr),
-                        Some(rep) => Some(Expr::Seq(Box::new(expr), Box::new(rep))),
-                    })
-                    .unwrap(),
-                Expr::RepMinMax(expr, min, max) => (1..max + 1)
-                    .map(|i| {
-                        if i <= min {
-                            *expr.clone()
-                        } else {
-                            Expr::Opt(expr.clone())
-                        }
-                    })
-                    .rev()
-                    .fold(None, |rep, expr| match rep {
-                        None => Some(expr),
-                        Some(rep) => Some(Expr::Seq(Box::new(expr), Box::new(rep))),
-                    })
-                    .unwrap(),
-                expr => expr,
-            }),
-        },
+    let Rule { name, ty, expr } = rule;
+    Rule {
+        name,
+        ty,
+        expr: expr.map_bottom_up(|expr| match expr {
+            Expr::RepOnce(expr) => Expr::Seq(expr.clone(), Box::new(Expr::Rep(expr))),
+            Expr::RepExact(expr, num) => (1..num + 1)
+                .map(|_| *expr.clone())
+                .rev()
+                .fold(None, |rep, expr| match rep {
+                    None => Some(expr),
+                    Some(rep) => Some(Expr::Seq(Box::new(expr), Box::new(rep))),
+                })
+                .unwrap(),
+            Expr::RepMin(expr, min) => (1..min + 2)
+                .map(|i| {
+                    if i <= min {
+                        *expr.clone()
+                    } else {
+                        Expr::Rep(expr.clone())
+                    }
+                })
+                .rev()
+                .fold(None, |rep, expr| match rep {
+                    None => Some(expr),
+                    Some(rep) => Some(Expr::Seq(Box::new(expr), Box::new(rep))),
+                })
+                .unwrap(),
+            Expr::RepMax(expr, max) => (1..max + 1)
+                .map(|_| Expr::Opt(expr.clone()))
+                .rev()
+                .fold(None, |rep, expr| match rep {
+                    None => Some(expr),
+                    Some(rep) => Some(Expr::Seq(Box::new(expr), Box::new(rep))),
+                })
+                .unwrap(),
+            Expr::RepMinMax(expr, min, max) => (1..max + 1)
+                .map(|i| {
+                    if i <= min {
+                        *expr.clone()
+                    } else {
+                        Expr::Opt(expr.clone())
+                    }
+                })
+                .rev()
+                .fold(None, |rep, expr| match rep {
+                    None => Some(expr),
+                    Some(rep) => Some(Expr::Seq(Box::new(expr), Box::new(rep))),
+                })
+                .unwrap(),
+            expr => expr,
+        }),
     }
 }