finish destructuring items, add comment for expr destructuring

Author: Centri3

clippy_lints/src/excessive_indentation.rs

@@ -10,6 +10,7 @@ use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::CharPos;
 use rustc_span::Pos;
 use rustc_span::Span;
+use thin_vec::ThinVec;
 
 // TODO: This still needs to be implemented.
 declare_clippy_lint! {
@@ -41,8 +42,8 @@ pub struct ExcessiveIndentation {
 }
 
 impl EarlyLintPass for ExcessiveIndentation {
-    fn check_crate(&mut self, cx: &EarlyContext<'_>, krate: &Crate) {
-        IndentationVisitor { indent: 0 }.visit_crate(krate);
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+        IndentationVisitor { indent: 0 }.visit_item(item);
     }
 }
 
@@ -55,6 +56,12 @@ impl<'i> IndentationGuard<'i> {
     }
 }
 
+impl<'i> Drop for IndentationGuard<'i> {
+    fn drop(&mut self) {
+        *self.0 -= 1;
+    }
+}
+
 struct IndentationVisitor {
     indent: u64,
 }
@@ -79,7 +86,39 @@ impl Visitor<'_> for IndentationVisitor {
     }
 
     fn visit_expr(&mut self, expr: &Expr) {
-        todo!();
+        // TODO:
+        // Array      ❌
+        // ConstBlock ❌
+        // Call       ❌
+        // MethodCall ❌
+        // Tup        ❌
+        // Binary     ❌
+        // Unary      ❌
+        // Let        ❌
+        // If         ❌
+        // While      ❌
+        // ForLoop    ❌
+        // Loop       ❌
+        // Match      ❌
+        // Closure    ❌
+        // Block      ❌
+        // Async      ❌
+        // Await      ❌
+        // TryBlock   ❌
+        // Assign     ❌
+        // AssignOp   ❌
+        // Index      ❌
+        // Range      ❌
+        // AddrOf     ❌
+        // Break      ❌
+        // Continue   ❌
+        // Ret        ❌
+        // Struct     ❌
+        // Repeat     ❌
+        // Try        ❌
+        // Yield      ❌
+        // Yeet       ❌
+        // We want to destructure these until we find a Block, over, and over, and over again...
     }
 
     fn visit_fn(&mut self, fk: FnKind<'_>, _: Span, _: NodeId) {
@@ -104,33 +143,44 @@ impl Visitor<'_> for IndentationVisitor {
         }
     }
 
-    fn visit_crate(&mut self, krate: &Crate) {
-        for item in &krate.items {
-            match &item.kind {
-                // TODO:
-                // Use        ✅
-                // Static     ✅
-                // Const      ✅
-                // Fn         ❌
-                // Mod        ❌
-                // ForeignMod ✅
-                // Enum       ❌
-                // Struct     ❌
-                // Union      ❌
-                // Trait      ❌
-                // Impl       ❌
-                // Others should never increase indentation (unless your formatting is really weird), so they won't be included.
-                ItemKind::Use(use_tree) => self.visit_use_tree(use_tree, NodeId::MAX, bool::default()),
-                ItemKind::Static(static_item) if let Some(expr) = static_item.expr.as_ref() => self.visit_expr(&*expr),
-                ItemKind::Const(const_item) if let Some(expr) = const_item.expr.as_ref() => self.visit_expr(&*expr),
-                ItemKind::Fn(fk) if let Some(block) = fk.body.as_ref() => self.visit_block(block),
-                ItemKind::ForeignMod(foreign_mod) => {
-                    for item in &foreign_mod.items {
-                        self.visit_foreign_item(item)
+    fn visit_item(&mut self, item: &Item) {
+        match &item.kind {
+            ItemKind::Use(use_tree) => self.visit_use_tree(use_tree, NodeId::MAX, bool::default()),
+            ItemKind::Static(static_item) if let Some(expr) = static_item.expr.as_ref() => self.visit_expr(&*expr),
+            ItemKind::Const(const_item) if let Some(expr) = const_item.expr.as_ref() => self.visit_expr(&*expr),
+            ItemKind::Fn(fk) if let Some(block) = fk.body.as_ref() => self.visit_block(block),
+            ItemKind::Mod(.., mod_kind) if let ModKind::Loaded(items, inline, ..) = mod_kind => {
+                for item in items {
+                    self.visit_item(item);
+                }
+            }
+            ItemKind::ForeignMod(foreign_mod) => {
+                for item in &foreign_mod.items {
+                    self.visit_foreign_item(item)
+                }
+            },
+            // TODO: These 2 are duplicated
+            ItemKind::Trait(trit) => {
+                for item in &trit.items {
+                    match &item.kind {
+                        // TODO: This is copied from above, is this necessary?
+                        AssocItemKind::Const(const_item) if let Some(expr) = const_item.expr.as_ref() => self.visit_expr(&*expr),
+                        AssocItemKind::Fn(fk) if let Some(block) = fk.body.as_ref() => self.visit_block(block),
+                        _ => (),
+                    }
+                }                
+            }
+            ItemKind::Impl(imp) => {
+                for item in &imp.items {
+                    match &item.kind {
+                        // TODO: This is copied from above, is this necessary?
+                        AssocItemKind::Const(const_item) if let Some(expr) = const_item.expr.as_ref() => self.visit_expr(&*expr),
+                        AssocItemKind::Fn(fk) if let Some(block) = fk.body.as_ref() => self.visit_block(block),
+                        _ => (),
                     }
-                },
-                _ => (),
+                }
             }
+            _ => (),
         }
     }
 }