Adds attribute handling to sway-fmt-v2

sway-fmt-v2/src/fmt.rs

@@ -1,10 +1,9 @@
 use crate::utils::{
-    attributes::format_attributes, indent_style::Shape, newline_style::apply_newline_style,
-    program_type::insert_program_type,
+    indent_style::Shape, newline_style::apply_newline_style, program_type::insert_program_type,
 };
 use std::{path::Path, sync::Arc};
 use sway_core::BuildConfig;
-use sway_parse::ItemKind;
+use sway_parse::{attribute::Annotated, ItemKind};
 
 pub use crate::{
     config::manifest::Config,
@@ -57,7 +56,7 @@ impl Formatter {
             .map(|item| -> Result<String, FormatterError> {
                 use ItemKind::*;
                 // format attributes first, then add corresponding item
-                let mut buf = format_attributes(item.attribute_list, self);
+                let mut buf = Annotated::format(&item, self);
                 buf.push_str(&match item.value {
                     Use(item_use) => item_use.format(self),
                     Struct(item_struct) => item_struct.format(self),
@@ -86,14 +85,9 @@ impl Formatter {
 
 #[cfg(test)]
 mod tests {
-    use crate::utils::indent_style::Shape;
     use std::sync::Arc;
 
-    use super::{Config, Formatter};
-
-    fn get_formatter(config: Config, shape: Shape) -> Formatter {
-        Formatter { config, shape }
-    }
+    use super::Formatter;
 
     #[test]
     fn test_enum_without_variant_alignment() {
@@ -115,7 +109,7 @@ enum Color {
  Silver : (),
  Grey : (),
 }"#;
-        let mut formatter = get_formatter(Config::default(), Shape::default());
+        let mut formatter = Formatter::default();
         let formatted_sway_code =
             Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
         assert!(correct_sway_code == formatted_sway_code)
@@ -142,10 +136,9 @@ enum Color {
 }"#;
 
         // Creating a config with enum_variant_align_threshold that exceeds longest variant length
-        let mut config = Config::default();
-        config.structures.enum_variant_align_threshold = 20;
+        let mut formatter = Formatter::default();
+        formatter.config.structures.enum_variant_align_threshold = 20;
 
-        let mut formatter = get_formatter(config, Shape::default());
         let formatted_sway_code =
             Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
         assert!(correct_sway_code == formatted_sway_code)

sway-fmt-v2/src/utils/attributes.rs

@@ -1,11 +1,82 @@
-use crate::Formatter;
-use sway_parse::AttributeDecl;
+use crate::fmt::{Format, FormattedCode, Formatter};
+use sway_parse::{
+    attribute::{Annotated, AttributeDecl},
+    token::Delimiter,
+    Parse,
+};
 use sway_types::Spanned;
-pub fn format_attributes(attributes: Vec<AttributeDecl>, _formatter: &mut Formatter) -> String {
-    // TODO format attributes
-    attributes
-        .into_iter()
-        .map(|x| x.span().as_str().to_string())
-        .collect::<Vec<String>>()
-        .join("\n")
+
+use super::bracket::{Parenthesis, SquareBracket};
+
+impl<T: Parse> Format for Annotated<T> {
+    fn format(&self, formatter: &mut Formatter) -> FormattedCode {
+        let attributes = &self.attribute_list;
+        let mut formatted_code = String::new();
+
+        for attr in attributes {
+            AttributeDecl::format(attr, &mut formatted_code, formatter);
+        }
+
+        formatted_code
+    }
+}
+
+trait FormatDecl {
+    fn format(&self, line: &mut String, formatter: &mut Formatter);
+}
+
+impl FormatDecl for AttributeDecl {
+    fn format(&self, line: &mut String, formatter: &mut Formatter) {
+        // At some point there will be enough attributes to warrant the need
+        // of formatting the list according to `config::lists::ListTactic`.
+        // For now the default implementation will be `Horizontal`.
+        //
+        // `#`
+        line.push_str(self.hash_token.span().as_str());
+        // `[`
+        Self::open_square_bracket(line, formatter);
+        let attr = self.attribute.clone().into_inner();
+        // name e.g. `storage`
+        line.push_str(attr.name.span().as_str());
+        // `(`
+        Self::open_parenthesis(line, formatter);
+        // format and add args `read, write`
+        if let Some(args) = attr.args {
+            let mut args = args
+                .into_inner()
+                .value_separator_pairs
+                .iter()
+                .map(|arg| format!("{}{}", arg.0.as_str(), arg.1.span().as_str()))
+                .collect::<Vec<String>>()
+                .join(" ");
+            args.pop(); // pop the ending space
+            args.pop(); // pop the ending comma
+            line.push_str(&args);
+        }
+        // ')'
+        Self::close_parenthesis(line, formatter);
+        // `]\n`
+        Self::close_square_bracket(line, formatter);
+    }
+}
+
+impl SquareBracket for AttributeDecl {
+    fn open_square_bracket(line: &mut String, _formatter: &mut Formatter) {
+        line.push(Delimiter::as_open_char(Delimiter::Bracket));
+    }
+    fn close_square_bracket(line: &mut String, _formatter: &mut Formatter) {
+        line.push_str(&format!(
+            "{}\n",
+            Delimiter::as_close_char(Delimiter::Bracket)
+        ));
+    }
+}
+
+impl Parenthesis for AttributeDecl {
+    fn open_parenthesis(line: &mut String, _formatter: &mut Formatter) {
+        line.push(Delimiter::as_open_char(Delimiter::Parenthesis))
+    }
+    fn close_parenthesis(line: &mut String, _formatter: &mut Formatter) {
+        line.push(Delimiter::as_close_char(Delimiter::Parenthesis))
+    }
 }

sway-parse/src/lib.rs

@@ -17,7 +17,7 @@ pub mod pattern;
 mod priv_prelude;
 pub mod punctuated;
 pub mod statement;
-mod token;
+pub mod token;
 pub mod ty;
 pub mod where_clause;
 

sway-parse/src/token.rs

@@ -96,6 +96,13 @@ impl Delimiter {
             Delimiter::Bracket => '[',
         }
     }
+    pub fn as_close_char(self) -> char {
+        match self {
+            Delimiter::Parenthesis => ')',
+            Delimiter::Brace => '}',
+            Delimiter::Bracket => ']',
+        }
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]