start excessive_indentation

Author: Centri3

.gitignore

@@ -1,3 +1,5 @@
+/target-ra
+
 # Used by CI to be able to push:
 /.github/deploy_key
 out

clippy_lints/src/declared_lints.rs

@@ -154,8 +154,8 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS_INFO,
     crate::excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS_INFO,
     crate::excessive_bools::STRUCT_EXCESSIVE_BOOLS_INFO,
-    crate::excessive_width::EXCESSIVE_INDENTATION_INFO,
-    crate::excessive_width::EXCESSIVE_WIDTH_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

@@ -0,0 +1,140 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use rustc_ast::{
+    ast::{ItemKind, UseTree, UseTreeKind},
+    Item,
+};
+use rustc_hir::*;
+use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::{declare_tool_lint, impl_lint_pass};
+use rustc_span::CharPos;
+use rustc_span::Pos;
+use rustc_span::Span;
+
+// TODO: This still needs to be implemented.
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Checks for lines which are indented beyond a certain threshold.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// It can severely hinder readability. The default is very generous; if you
+    /// exceed this, it's a sign you should refactor.
+    ///
+    /// ### Example
+    /// TODO
+    /// Use instead:
+    /// TODO
+    #[clippy::version = "1.70.0"]
+    pub EXCESSIVE_INDENTATION,
+    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]);
+
+#[derive(Clone, Copy)]
+pub struct ExcessiveIndentation {
+    pub excessive_width_threshold: u64,
+    pub excessive_width_ignore_indentation: bool,
+    pub excessive_indentation_threshold: u64,
+}
+
+impl EarlyLintPass for ExcessiveIndentation {
+    fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
+        match &item.kind {
+            // TODO:
+            // Use        ✅
+            // Static     ❌
+            // Const      ❌
+            // Fn         ❌
+            // Mod        ❌
+            // 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) => walk_use_tree(self, cx, use_tree, 0),
+            _ => (),
+        }
+    }
+}
+
+fn check_indent(conf: &mut ExcessiveIndentation, cx: &EarlyContext<'_>, span: Span, indent: u64) -> bool {
+    if indent > conf.excessive_indentation_threshold {
+        span_lint_and_help(cx, EXCESSIVE_INDENTATION, span, "a", None, "b");
+
+        return true;
+    }
+
+    false
+}
+
+fn walk_use_tree(conf: &mut ExcessiveIndentation, cx: &EarlyContext<'_>, use_tree: &UseTree, indent: u64) {
+    if check_indent(conf, cx, use_tree.span, indent) {
+        return;
+    }
+
+    if let UseTreeKind::Nested(use_trees) = use_tree.kind.clone() {
+        for use_tree in use_trees {
+            walk_use_tree(conf, cx, &use_tree.0, indent + 1);
+        }
+    }
+}
+
+impl LateLintPass<'_> for ExcessiveIndentation {
+    fn check_stmt(&mut self, cx: &LateContext<'_>, stmt: &Stmt<'_>) {
+        if in_external_macro(cx.sess(), stmt.span) {
+            return;
+        }
+
+        if let Ok(lines) = cx.sess().source_map().span_to_lines(stmt.span).map(|info| info.lines) {
+            for line in &lines {
+                let indentation = if self.excessive_width_ignore_indentation {
+                    line.start_col
+                } else {
+                    CharPos::from_usize(0)
+                };
+
+                // TODO: yeah, no.
+                if (line.end_col.to_usize()
+                    - line.start_col.to_usize() * self.excessive_width_ignore_indentation as usize)
+                    > self.excessive_width_threshold as usize
+                {
+                    span_lint_and_help(
+                        cx,
+                        EXCESSIVE_WIDTH,
+                        stmt.span,
+                        "this line is too long",
+                        None,
+                        "consider running rustfmt or refactoring this",
+                    );
+                }
+            }
+        }
+    }
+}

clippy_lints/src/excessive_width.rs

@@ -120,7 +120,7 @@ mod equatable_if_let;
 mod escape;
 mod eta_reduction;
 mod excessive_bools;
-mod excessive_width;
+mod excessive_indentation;
 mod exhaustive_items;
 mod exit;
 mod explicit_write;
@@ -966,8 +966,15 @@ 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_width::ExcessiveWidth {
+        Box::new(excessive_indentation::ExcessiveIndentation {
             excessive_width_threshold,
             excessive_width_ignore_indentation,
             excessive_indentation_threshold,

clippy_lints/src/lib.rs

@@ -0,0 +1,15 @@
+#![allow(unused)]
+#![warn(clippy::excessive_indentation)]
+
+#[rustfmt::skip]
+fn main() {
+    {
+        {
+            {
+                {
+                    println!("warning! :)");
+                }
+            }
+        }
+    }
+}

tests/ui-toml/excessive_width/excessive_indentation.rs

@@ -0,0 +1,77 @@
+#![allow(unused)]
+#![warn(clippy::excessive_indentation)]
+
+#[rustfmt::skip]
+use a::{b::{c::{d::{e::{f::{g::{h::{i::j::{k::{l::{m::{n::{o::{p::{}}}}}}}}}}}}}}};
+
+pub mod a {
+    pub mod b {
+        pub mod c {
+            pub mod d {
+                pub mod e {
+                    pub mod f {
+                        pub mod g {
+                            pub mod h {
+                                pub mod i {
+                                    pub mod j {
+                                        pub mod k {
+                                            pub mod l {
+                                                pub mod m {
+                                                    pub mod n {
+                                                        pub mod o {
+                                                            pub mod p {}
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+const A: u32 = 0u32;
+
+#[rustfmt::skip]
+fn main() {
+    {
+        {
+            {
+                {
+                    {
+                        {
+                            {
+                                {
+                                    {
+                                        {
+                                            {
+                                                {
+                                                    {
+                                                        {
+                                                            let _x = {
+                                                                dbg!("hello");
+                                                                2
+                                                            };
+
+                                                            println!("as you can tell, this is very excessive. you would never actually write this.")
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

tests/ui/excessive_indentation.rs

@@ -0,0 +1,11 @@
+error: a
+  --> $DIR/excessive_indentation.rs:5:52
+   |
+LL | use a::{b::{c::{d::{e::{f::{g::{h::{i::j::{k::{l::{m::{n::{o::{p::{}}}}}}}}}}}}}}};
+   |                                                    ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: b
+   = note: `-D clippy::excessive-indentation` implied by `-D warnings`
+
+error: aborting due to previous error
+