From c5c4b55c2b3a3fb824c3fd64e33bb30f1b011b71 Mon Sep 17 00:00:00 2001
From: Akshay <nerdy@peppe.rs>
Date: Sat, 2 Oct 2021 20:53:19 +0530
Subject: new lint: legacy_let_syntax

---
 lib/src/make.rs | 45 +++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 41 insertions(+), 4 deletions(-)

(limited to 'lib/src/make.rs')

diff --git a/lib/src/make.rs b/lib/src/make.rs
index cf371a2..2a6450c 100644
--- a/lib/src/make.rs
+++ b/lib/src/make.rs
@@ -1,13 +1,20 @@
-use std::iter::IntoIterator;
+use std::{fmt::Write, iter::IntoIterator};
 
-use rnix::{SyntaxNode, types::{TypedNode, self, TokenWrapper}};
+use rnix::{
+    types::{self, TokenWrapper, TypedNode},
+    SyntaxNode,
+};
 
 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
@@ -30,7 +37,10 @@ pub fn inherit_stmt<'a>(nodes: impl IntoIterator<Item = &'a types::Ident>) -> ty
     ast_from_text(&format!("{{ inherit {}; }}", inherited_idents))
 }
 
-pub fn inherit_from_stmt<'a>(from: SyntaxNode, nodes: impl IntoIterator<Item = &'a types::Ident>) -> types::Inherit {
+pub fn inherit_from_stmt<'a>(
+    from: SyntaxNode,
+    nodes: impl IntoIterator<Item = &'a types::Ident>,
+) -> types::Inherit {
     let inherited_idents = nodes
         .into_iter()
         .map(|i| i.as_str().to_owned())
@@ -38,3 +48,30 @@ pub fn inherit_from_stmt<'a>(from: SyntaxNode, nodes: impl IntoIterator<Item = &
         .join(" ");
     ast_from_text(&format!("{{ inherit ({}) {}; }}", from, inherited_idents))
 }
+
+pub fn attrset(
+    inherits: impl IntoIterator<Item = types::Inherit>,
+    entries: impl IntoIterator<Item = types::KeyValue>,
+    recursive: bool,
+) -> types::AttrSet {
+    let mut buffer = String::new();
+
+    writeln!(buffer, "{}{{", if recursive { "rec " } else { "" }).unwrap();
+    for inherit in inherits.into_iter() {
+        writeln!(buffer, "    {}", inherit.node().text()).unwrap();
+    }
+    for entry in entries.into_iter() {
+        writeln!(buffer, "    {}", entry.node().text()).unwrap();
+    }
+    write!(buffer, "}}").unwrap();
+
+    ast_from_text(&buffer)
+}
+
+pub fn select(set: &SyntaxNode, index: &SyntaxNode) -> types::Select {
+    ast_from_text(&format!("{}.{}", set, index))
+}
+
+pub fn ident(text: &str) -> types::Ident {
+    ast_from_text(text)
+}
-- 
cgit v1.2.3