Centralize attribute display

src/alias.rs

@@ -26,7 +26,7 @@ impl<'src> Alias<'src> {
 
 impl RecipeAlias<'_> {
   pub(crate) fn is_public(&self) -> bool {
-    !self.name.lexeme().starts_with('_') && !self.attributes.contains(AttributeKind::Private)
+    !self.name.lexeme().starts_with('_') && !self.attributes.private()
   }
 }
 

src/analyzer.rs

@@ -80,11 +80,10 @@ impl<'run, 'src> Analyzer<'run, 'src> {
           }
           Item::Module {
             absolute,
+            attributes,
             doc,
-            groups,
             name,
             optional,
-            private,
             ..
           } => {
             if let Some(absolute) = absolute {
@@ -93,12 +92,12 @@ impl<'run, 'src> Analyzer<'run, 'src> {
                 asts,
                 config,
                 doc.clone(),
-                groups.as_slice(),
+                &attributes.groups(),
                 loaded,
                 Some(*name),
                 overrides,
                 paths,
-                *private,
+                attributes.private(),
                 absolute,
               )?);
             } else if *optional {
@@ -116,7 +115,7 @@ impl<'run, 'src> Analyzer<'run, 'src> {
             self.analyze_set(set)?;
             self.sets.insert(set.clone());
           }
-          Item::Unexport { name } => {
+          Item::Unexport { name, .. } => {
             if !self.unexports.insert(name.lexeme().to_string()) {
               return Err(name.error(DuplicateUnexport {
                 variable: name.lexeme(),

src/assignment.rs

@@ -5,10 +5,6 @@ pub(crate) type Assignment<'src> = Binding<'src, Expression<'src>>;
 
 impl Display for Assignment<'_> {
   fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-    if self.private {
-      writeln!(f, "[private]")?;
-    }
-
     if self.export {
       write!(f, "export ")?;
     }

src/attribute_set.rs

@@ -16,10 +16,32 @@ impl<'src> AttributeSet<'src> {
     self.0.keys().find(|attribute| attribute.kind() == kind)
   }
 
+  pub(crate) fn groups(&self) -> Vec<StringLiteral<'src>> {
+    self
+      .0
+      .keys()
+      .filter_map(|attribute| {
+        if let Attribute::Group(group) = attribute {
+          Some(group.clone())
+        } else {
+          None
+        }
+      })
+      .collect()
+  }
+
   pub(crate) fn name(&self, attribute: &Attribute<'src>) -> Name<'src> {
     self.0[attribute]
   }
 
+  pub(crate) fn new() -> Self {
+    Self::default()
+  }
+
+  pub(crate) fn private(&self) -> bool {
+    self.contains(AttributeKind::Private)
+  }
+
   pub(crate) fn iter(&self) -> btree_map::Keys<'_, Attribute<'src>, Name<'src>> {
     self.0.keys()
   }

src/binding.rs

@@ -3,6 +3,8 @@ use super::*;
 /// A binding of `name` to `value`
 #[derive(Debug, Clone, PartialEq, Serialize)]
 pub(crate) struct Binding<'src, V = Value> {
+  #[serde(skip)]
+  pub(crate) attributes: AttributeSet<'src>,
   pub(crate) eager: bool,
   pub(crate) export: bool,
   #[serde(skip)]

src/compiler.rs

@@ -61,6 +61,7 @@ impl Compiler {
             relative,
             absolute,
             optional,
+            ..
           } => {
             let import = current
               .path

src/evaluator.rs

@@ -240,6 +240,7 @@ impl<'src, 'run> Evaluator<'src, 'run> {
       };
 
       self.scope.bind(Binding {
+        attributes: AttributeSet::new(),
         eager: assignment.eager,
         export: assignment.export
           || self
@@ -286,6 +287,7 @@ impl<'src, 'run> Evaluator<'src, 'run> {
     for ((name, number), argument) in function.parameters.iter().copied().zip(arguments) {
       let value = self.evaluate_value(argument)?;
       scope.bind(Binding {
+        attributes: AttributeSet::new(),
         eager: false,
         export: false,
         file_depth: 0,
@@ -809,6 +811,7 @@ impl<'src, 'run> Evaluator<'src, 'run> {
       };
 
       evaluator.scope.bind(Binding {
+        attributes: AttributeSet::new(),
         eager: false,
         export: parameter.export,
         file_depth: 0,

src/function_definition.rs

@@ -2,6 +2,7 @@ use super::*;
 
 #[derive(Debug, Clone, PartialEq)]
 pub(crate) struct FunctionDefinition<'src> {
+  pub(crate) attributes: AttributeSet<'src>,
   pub(crate) body: Expression<'src>,
   pub(crate) name: Name<'src>,
   pub(crate) parameters: Vec<(Name<'src>, Number)>,

src/item.rs

@@ -9,28 +9,77 @@ pub(crate) enum Item<'src> {
   Function(FunctionDefinition<'src>),
   Import {
     absolute: Option<PathBuf>,
+    attributes: AttributeSet<'src>,
     optional: bool,
     relative: StringLiteral<'src>,
   },
   Module {
     absolute: Option<PathBuf>,
+    attributes: AttributeSet<'src>,
     doc: Option<String>,
-    groups: Vec<StringLiteral<'src>>,
     name: Name<'src>,
     optional: bool,
-    private: bool,
     relative: Option<StringLiteral<'src>>,
   },
   Newline,
   Recipe(UnresolvedRecipe<'src>),
   Set(Set<'src>),
   Unexport {
+    attributes: AttributeSet<'src>,
     name: Name<'src>,
   },
 }
 
+impl<'src> Item<'src> {
+  fn attributes(&self) -> Option<&AttributeSet<'src>> {
+    match self {
+      Self::Alias(alias) => Some(&alias.attributes),
+      Self::Assignment(assignment) => Some(&assignment.attributes),
+      Self::Comment(_) | Self::Newline => None,
+      Self::Function(function) => Some(&function.attributes),
+      Self::Import { attributes, .. }
+      | Self::Module { attributes, .. }
+      | Self::Unexport { attributes, .. } => Some(attributes),
+      Self::Recipe(recipe) => Some(&recipe.attributes),
+      Self::Set(set) => Some(&set.attributes),
+    }
+  }
+
+  fn doc_comment(&self) -> Option<&str> {
+    match self {
+      Self::Module {
+        attributes, doc, ..
+      } => {
+        if attributes.contains(AttributeKind::Doc) {
+          None
+        } else {
+          doc.as_deref()
+        }
+      }
+      Self::Recipe(recipe) => {
+        if recipe.attributes.contains(AttributeKind::Doc) {
+          None
+        } else {
+          recipe.doc.as_deref()
+        }
+      }
+      _ => None,
+    }
+  }
+}
+
 impl ColorDisplay for Item<'_> {
   fn fmt(&self, f: &mut Formatter, color: Color) -> fmt::Result {
+    if let Some(doc) = self.doc_comment() {
+      writeln!(f, "# {doc}")?;
+    }
+
+    if let Some(attributes) = self.attributes() {
+      for attribute in attributes {
+        writeln!(f, "[{attribute}]")?;
+      }
+    }
+
     match self {
       Self::Alias(alias) => write!(f, "{alias}"),
       Self::Assignment(assignment) => write!(f, "{assignment}"),
@@ -57,21 +106,11 @@ impl ColorDisplay for Item<'_> {
         write!(f, " {relative}")
       }
       Self::Module {
-        doc,
-        groups,
         name,
         optional,
         relative,
         ..
       } => {
-        if let Some(doc) = doc {
-          writeln!(f, "# {doc}")?;
-        }
-
-        for group in groups {
-          writeln!(f, "[group: {group}]")?;
-        }
-
         write!(f, "mod")?;
 
         if *optional {
@@ -89,7 +128,7 @@ impl ColorDisplay for Item<'_> {
       Self::Newline => Ok(()),
       Self::Recipe(recipe) => write!(f, "{}", recipe.color_display(color)),
       Self::Set(set) => write!(f, "{set}"),
-      Self::Unexport { name } => write!(f, "unexport {name}"),
+      Self::Unexport { name, .. } => write!(f, "unexport {name}"),
     }
   }
 }

src/node.rs

@@ -70,7 +70,7 @@ impl<'src> Node<'src> for Item<'src> {
       }
       Self::Recipe(recipe) => recipe.tree(),
       Self::Set(set) => set.tree(),
-      Self::Unexport { name } => {
+      Self::Unexport { name, .. } => {
         let mut unexport = Tree::atom(Keyword::Unexport.lexeme());
         unexport.push_mut(name.lexeme().replace('-', "_"));
         unexport

src/parser.rs

@@ -531,7 +531,10 @@ impl<'run, 'src> Parser<'run, 'src> {
         Some(Keyword::Unexport) if self.line_is(&[Identifier, Identifier]) => {
           self.presume_keyword(Keyword::Unexport)?;
           let name = self.parse_name()?;
-          Item::Unexport { name }
+          Item::Unexport {
+            attributes: AttributeSet::new(),
+            name,
+          }
         }
         Some(Keyword::Import)
           if self.next_are(&[Identifier, Identifier, StringToken])
@@ -543,6 +546,7 @@ impl<'run, 'src> Parser<'run, 'src> {
           let relative = self.parse_string_literal()?;
           Item::Import {
             absolute: None,
+            attributes: AttributeSet::new(),
             optional,
             relative,
           }
@@ -579,22 +583,12 @@ impl<'run, 'src> Parser<'run, 'src> {
 
           let doc = self.take_doc_comment(&attributes);
 
-          let private = attributes.contains(AttributeKind::Private);
-
-          let mut groups = Vec::new();
-          for attribute in attributes {
-            if let Attribute::Group(group) = attribute {
-              groups.push(group);
-            }
-          }
-
           Item::Module {
             absolute: None,
+            attributes,
             doc,
-            groups,
             name,
             optional,
-            private,
             relative,
           }
         }
@@ -663,6 +657,7 @@ impl<'run, 'src> Parser<'run, 'src> {
     let body = self.parse_expression()?;
 
     Ok(FunctionDefinition {
+      attributes: AttributeSet::new(),
       body,
       name,
       parameters,
@@ -680,11 +675,12 @@ impl<'run, 'src> Parser<'run, 'src> {
     self.presume(ColonEquals)?;
     let value = self.parse_expression()?;
 
-    let private = attributes.contains(AttributeKind::Private);
-
     attributes.ensure_valid_attributes("assignment", *name, &[AttributeKind::Private])?;
 
+    let private = attributes.private();
+
     Ok(Assignment {
+      attributes,
       eager,
       export,
       file_depth: self.file_depth,
@@ -1398,7 +1394,7 @@ impl<'run, 'src> Parser<'run, 'src> {
       }));
     }
 
-    let private = name.lexeme().starts_with('_') || attributes.contains(AttributeKind::Private);
+    let private = name.lexeme().starts_with('_') || attributes.private();
 
     let doc = self.take_doc_comment(&attributes);
 
@@ -1578,7 +1574,11 @@ impl<'run, 'src> Parser<'run, 'src> {
     };
 
     if let Some(value) = set_bool {
-      return Ok(Set { name, value });
+      return Ok(Set {
+        attributes: AttributeSet::new(),
+        name,
+        value,
+      });
     }
 
     self.expect(ColonEquals)?;
@@ -1627,7 +1627,11 @@ impl<'run, 'src> Parser<'run, 'src> {
     };
 
     if let Some(value) = set_value {
-      return Ok(Set { name, value });
+      return Ok(Set {
+        attributes: AttributeSet::new(),
+        name,
+        value,
+      });
     }
 
     Err(name.error(CompileErrorKind::UnknownSetting {