visitor for a few variants of ItemKind. also remove ExcessiveWidth

Author: Centri3

CHANGELOG.md

@@ -4632,7 +4632,6 @@ Released 2018-09-13
 [`eval_order_dependence`]: https://rust-lang.github.io/rust-clippy/master/index.html#eval_order_dependence
 [`excessive_indentation`]: https://rust-lang.github.io/rust-clippy/master/index.html#excessive_indentation
 [`excessive_precision`]: https://rust-lang.github.io/rust-clippy/master/index.html#excessive_precision
-[`excessive_width`]: https://rust-lang.github.io/rust-clippy/master/index.html#excessive_width
 [`exhaustive_enums`]: https://rust-lang.github.io/rust-clippy/master/index.html#exhaustive_enums
 [`exhaustive_structs`]: https://rust-lang.github.io/rust-clippy/master/index.html#exhaustive_structs
 [`exit`]: https://rust-lang.github.io/rust-clippy/master/index.html#exit

clippy_lints/src/declared_lints.rs

@@ -155,7 +155,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS_INFO,
     crate::excessive_bools::STRUCT_EXCESSIVE_BOOLS_INFO,
     crate::excessive_indentation::EXCESSIVE_INDENTATION_INFO,
-    crate::excessive_indentation::EXCESSIVE_WIDTH_INFO,
     crate::exhaustive_items::EXHAUSTIVE_ENUMS_INFO,
     crate::exhaustive_items::EXHAUSTIVE_STRUCTS_INFO,
     crate::exit::EXIT_INFO,

clippy_lints/src/excessive_indentation.rs

@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::{
-    visit::{walk_item, Visitor},
+    node_id::NodeId,
+    visit::{walk_item, FnKind, Visitor},
     *,
 };
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
@@ -30,28 +31,7 @@ declare_clippy_lint! {
     nursery,
     "checks for lines indented beyond a certain threshold"
 }
-declare_clippy_lint! {
-    /// ### What it does
-    ///
-    /// Checks for lines which are longer than a certain threshold.
-    ///
-    /// ### Why is this bad?
-    ///
-    /// It can severely hinder readability. Running rustfmt will almost always get any
-    /// lines below this threshold (or whatever you have set as max_width), but if it
-    /// fails, it's probably a sign you should refactor.
-    ///
-    /// ### Example
-    /// TODO
-    /// Use instead:
-    /// TODO
-    #[clippy::version = "1.70.0"]
-    pub EXCESSIVE_WIDTH,
-    nursery,
-    "checks for lines longer than a certain threshold"
-}
-// TODO: Split this into 2 structs
-impl_lint_pass!(ExcessiveIndentation => [EXCESSIVE_INDENTATION, EXCESSIVE_WIDTH]);
+impl_lint_pass!(ExcessiveIndentation => [EXCESSIVE_INDENTATION]);
 
 #[derive(Clone, Copy)]
 pub struct ExcessiveIndentation {
@@ -61,10 +41,17 @@ pub struct ExcessiveIndentation {
 }
 
 impl EarlyLintPass for ExcessiveIndentation {
-    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
-        match &item.kind {
-            _ => (),
-        }
+    fn check_crate(&mut self, cx: &EarlyContext<'_>, krate: &Crate) {
+        IndentationVisitor { indent: 0 }.visit_crate(krate);
+    }
+}
+
+/// RAII guard to add 1 to our indent counter when constructed, and remove 1 when dropped.
+struct IndentationGuard<'i>(&'i mut u64);
+
+impl<'i> IndentationGuard<'i> {
+    fn new(indent: &'i mut u64) -> Self {
+        Self(indent)
     }
 }
 
@@ -73,24 +60,75 @@ struct IndentationVisitor {
 }
 
 impl Visitor<'_> for IndentationVisitor {
+    fn visit_foreign_item(&mut self, item: &ForeignItem) {
+        match &item.kind {
+            ForeignItemKind::Static(.., expr) => {
+                if let Some(expr) = expr {
+                    self.visit_expr(&*expr)
+                }
+            },
+            ForeignItemKind::Fn(fk) if let Some(block) = fk.body.as_ref() => self.visit_block(block),
+            _ => (),
+        }
+    }
+
+    fn visit_block(&mut self, block: &Block) {
+        IndentationGuard::new(&mut self.indent);
+
+        todo!();
+    }
+
+    fn visit_expr(&mut self, expr: &Expr) {
+        todo!();
+    }
+
+    fn visit_fn(&mut self, fk: FnKind<'_>, _: Span, _: NodeId) {
+        IndentationGuard::new(&mut self.indent);
+
+        match fk {
+            FnKind::Fn(.., block) if let Some(block) = block => self.visit_block(block),
+            FnKind::Closure(.., expr) => self.visit_expr(expr),
+            _ => (),
+        }
+    }
+
+    fn visit_use_tree(&mut self, use_tree: &UseTree, _: NodeId, _: bool) {
+        // TODO: I don't think this should be linted, as some devious crate may decide to put some type
+        // nested within 10 modules. Maybe it can be optional using config?
+        IndentationGuard::new(&mut self.indent);
+
+        if let UseTreeKind::Nested(use_trees) = &use_tree.kind {
+            for use_tree in use_trees {
+                self.visit_use_tree(&use_tree.0, NodeId::MAX, bool::default());
+            }
+        }
+    }
+
     fn visit_crate(&mut self, krate: &Crate) {
-        for item in krate.items {
-            match item.kind {
+        for item in &krate.items {
+            match &item.kind {
                 // TODO:
                 // Use        ✅
-                // Static     ❌
-                // Const      ❌
+                // Static     ✅
+                // Const      ✅
                 // Fn         ❌
                 // Mod        ❌
-                // ForeignMod ❌
+                // ForeignMod ✅
                 // Enum       ❌
                 // Struct     ❌
                 // Union      ❌
                 // Trait      ❌
                 // Impl       ❌
-                // MacroDef   ❓
-                // Others don't increase indentation (unless your formatting is really weird) so they won't be included.
-                ItemKind::Use(use_tree) => todo!(),
+                // 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)
+                    }
+                },
                 _ => (),
             }
         }

clippy_lints/src/lib.rs

@@ -966,13 +966,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let excessive_width_threshold = conf.excessive_width_threshold;
     let excessive_width_ignore_indentation = conf.excessive_width_ignore_indentation;
     let excessive_indentation_threshold = conf.excessive_indentation_threshold;
-    store.register_early_pass(move || {
-        Box::new(excessive_indentation::ExcessiveIndentation {
-            excessive_width_threshold,
-            excessive_width_ignore_indentation,
-            excessive_indentation_threshold,
-        })
-    });
     store.register_late_pass(move |_| {
         Box::new(excessive_indentation::ExcessiveIndentation {
             excessive_width_threshold,