Move things around

Author: smoelius

clippy_utils/src/mir.rs

@@ -12,70 +12,21 @@ pub struct CloneUsage {
     /// Whether the clone value is mutated.
     pub clone_consumed_or_mutated: bool,
 }
+
 pub fn visit_clone_usage(
     cloned: mir::Local,
     clone: mir::Local,
     mir: &mir::Body<'_>,
     bb: mir::BasicBlock,
 ) -> CloneUsage {
-    struct V {
-        cloned: mir::Local,
-        clone: mir::Local,
-        result: CloneUsage,
-    }
-    impl<'tcx> mir::visit::Visitor<'tcx> for V {
-        fn visit_basic_block_data(&mut self, block: mir::BasicBlock, data: &mir::BasicBlockData<'tcx>) {
-            let statements = &data.statements;
-            for (statement_index, statement) in statements.iter().enumerate() {
-                self.visit_statement(statement, mir::Location { block, statement_index });
-            }
-
-            self.visit_terminator(
-                data.terminator(),
-                mir::Location {
-                    block,
-                    statement_index: statements.len(),
-                },
-            );
-        }
-
-        fn visit_place(&mut self, place: &mir::Place<'tcx>, ctx: PlaceContext, loc: mir::Location) {
-            let local = place.local;
-
-            if local == self.cloned
-                && !matches!(
-                    ctx,
-                    PlaceContext::MutatingUse(MutatingUseContext::Drop) | PlaceContext::NonUse(_)
-                )
-            {
-                self.result.cloned_used = true;
-                self.result.cloned_consume_or_mutate_loc = self.result.cloned_consume_or_mutate_loc.or_else(|| {
-                    matches!(
-                        ctx,
-                        PlaceContext::NonMutatingUse(NonMutatingUseContext::Move)
-                            | PlaceContext::MutatingUse(MutatingUseContext::Borrow)
-                    )
-                    .then(|| loc)
-                });
-            } else if local == self.clone {
-                match ctx {
-                    PlaceContext::NonMutatingUse(NonMutatingUseContext::Move)
-                    | PlaceContext::MutatingUse(MutatingUseContext::Borrow) => {
-                        self.result.clone_consumed_or_mutated = true;
-                    },
-                    _ => {},
-                }
-            }
-        }
-    }
-
     let init = CloneUsage {
         cloned_used: false,
         cloned_consume_or_mutate_loc: None,
         // Consider non-temporary clones consumed.
         // TODO: Actually check for mutation of non-temporaries.
         clone_consumed_or_mutated: mir.local_kind(clone) != mir::LocalKind::Temp,
     };
+
     traversal::ReversePostorder::new(mir, bb)
         .skip(1)
         .fold(init, |usage, (tbb, tdata)| {
@@ -100,3 +51,55 @@ pub fn visit_clone_usage(
             v.result
         })
 }
+
+struct V {
+    cloned: mir::Local,
+    clone: mir::Local,
+    result: CloneUsage,
+}
+
+impl<'tcx> mir::visit::Visitor<'tcx> for V {
+    fn visit_basic_block_data(&mut self, block: mir::BasicBlock, data: &mir::BasicBlockData<'tcx>) {
+        let statements = &data.statements;
+        for (statement_index, statement) in statements.iter().enumerate() {
+            self.visit_statement(statement, mir::Location { block, statement_index });
+        }
+
+        self.visit_terminator(
+            data.terminator(),
+            mir::Location {
+                block,
+                statement_index: statements.len(),
+            },
+        );
+    }
+
+    fn visit_place(&mut self, place: &mir::Place<'tcx>, ctx: PlaceContext, loc: mir::Location) {
+        let local = place.local;
+
+        if local == self.cloned
+            && !matches!(
+                ctx,
+                PlaceContext::MutatingUse(MutatingUseContext::Drop) | PlaceContext::NonUse(_)
+            )
+        {
+            self.result.cloned_used = true;
+            self.result.cloned_consume_or_mutate_loc = self.result.cloned_consume_or_mutate_loc.or_else(|| {
+                matches!(
+                    ctx,
+                    PlaceContext::NonMutatingUse(NonMutatingUseContext::Move)
+                        | PlaceContext::MutatingUse(MutatingUseContext::Borrow)
+                )
+                .then(|| loc)
+            });
+        } else if local == self.clone {
+            match ctx {
+                PlaceContext::NonMutatingUse(NonMutatingUseContext::Move)
+                | PlaceContext::MutatingUse(MutatingUseContext::Borrow) => {
+                    self.result.clone_consumed_or_mutated = true;
+                },
+                _ => {},
+            }
+        }
+    }
+}