From c00900120d88c3d42666ed93716b821bd694e8d6 Mon Sep 17 00:00:00 2001
From: Akshay <nerdy@peppe.rs>
Date: Sat, 2 Oct 2021 13:39:11 +0530
Subject: new lint: manual_inherit

---
 lib/src/lints.rs                |  1 +
 lib/src/lints/empty_let_in.rs   |  3 +--
 lib/src/lints/manual_inherit.rs | 43 +++++++++++++++++++++++++++++++++++++++++
 lib/src/make.rs                 | 15 ++++++++++++--
 4 files changed, 58 insertions(+), 4 deletions(-)
 create mode 100644 lib/src/lints/manual_inherit.rs

(limited to 'lib')

diff --git a/lib/src/lints.rs b/lib/src/lints.rs
index a5fe0da..7d5cd30 100644
--- a/lib/src/lints.rs
+++ b/lib/src/lints.rs
@@ -3,4 +3,5 @@ use crate::lint_map;
 lint_map! {
     bool_comparison,
     empty_let_in,
+    manual_inherit,
 }
diff --git a/lib/src/lints/empty_let_in.rs b/lib/src/lints/empty_let_in.rs
index 4b074e7..207d253 100644
--- a/lib/src/lints/empty_let_in.rs
+++ b/lib/src/lints/empty_let_in.rs
@@ -3,8 +3,7 @@ use crate::{Lint, Metadata, Report, Rule, Suggestion};
 use if_chain::if_chain;
 use macros::lint;
 use rnix::{
-    types::{LetIn, TypedNode, 
-        EntryHolder},
+    types::{LetIn, TypedNode, EntryHolder},
     NodeOrToken, SyntaxElement, SyntaxKind,
 };
 
diff --git a/lib/src/lints/manual_inherit.rs b/lib/src/lints/manual_inherit.rs
new file mode 100644
index 0000000..2f8367f
--- /dev/null
+++ b/lib/src/lints/manual_inherit.rs
@@ -0,0 +1,43 @@
+use crate::{make, Lint, Metadata, Report, Rule, Suggestion};
+
+use if_chain::if_chain;
+use macros::lint;
+use rnix::{
+    types::{KeyValue, Ident, TypedNode, TokenWrapper},
+    NodeOrToken, SyntaxElement, SyntaxKind,
+};
+
+#[lint(
+    name = "manual inherit",
+    note = "Assignment instead of `inherit` keyword",
+    code = 3,
+    match_with = SyntaxKind::NODE_KEY_VALUE
+)]
+struct ManualInherit;
+
+impl Rule for ManualInherit {
+    fn validate(&self, node: &SyntaxElement) -> Option<Report> {
+        if_chain! {
+            if let NodeOrToken::Node(key_value_node) = node;
+            if let Some(key_value_stmt) = KeyValue::cast(key_value_node.clone());
+            if let Some(key_path) = key_value_stmt.key();
+            if let Some(key_node) = key_path.path().next();
+            if let Some(key) = Ident::cast(key_node);
+
+            if let Some(value_node) = key_value_stmt.value();
+            if let Some(value) = Ident::cast(value_node);
+
+            if key.as_str() == value.as_str();
+
+            then {
+                let at = node.text_range();
+                let replacement = make::inherit_stmt(&[key]).node().clone();
+                let message = format!("The assignment `{}` is better written with `inherit`", node);
+                Some(Self::report().suggest(at, message, Suggestion::new(at, replacement)))
+            } else {
+                None
+            }
+        }
+    }
+}
+
diff --git a/lib/src/make.rs b/lib/src/make.rs
index 0b21105..facd247 100644
--- a/lib/src/make.rs
+++ b/lib/src/make.rs
@@ -1,11 +1,13 @@
-use rnix::{SyntaxNode, types::{TypedNode, self}};
+use std::iter::IntoIterator;
+
+use rnix::{SyntaxNode, types::{TypedNode, self, TokenWrapper}};
 
 fn ast_from_text<N: TypedNode>(text: &str) -> N {
     let parse = rnix::parse(text);
     let node = match parse.node().descendants().find_map(N::cast) {
         Some(it) => it,
         None => {
-            panic!("Failed to make ast node `{}` from text {}", std::any::type_name::<N>(), text)
+            panic!("Failed to make ast node `{}` from text `{}`", std::any::type_name::<N>(), text)
         }
     };
     node
@@ -18,3 +20,12 @@ pub fn parenthesize(node: &SyntaxNode) -> types::Paren {
 pub fn unary_not(node: &SyntaxNode) -> types::UnaryOp {
     ast_from_text(&format!("!{}", node))
 }
+
+pub fn inherit_stmt<'a>(nodes: impl IntoIterator<Item = &'a types::Ident>) -> types::Inherit {
+    let inherited_idents = nodes
+        .into_iter()
+        .map(|i| i.as_str().to_owned())
+        .collect::<Vec<_>>()
+        .join(" ");
+    ast_from_text(&format!("{{ inherit {}; }}", inherited_idents))
+}
-- 
cgit v1.2.3