Add abi handling to sway-fmt-v2

sway-fmt-v2/src/fmt.rs

@@ -104,11 +104,11 @@ enum Color {
         let correct_sway_code = r#"contract;
 
 enum Color {
- Blue : (),
- Green : (),
- Red : (),
- Silver : (),
- Grey : (),
+    Blue : (),
+    Green : (),
+    Red : (),
+    Silver : (),
+    Grey : (),
 }"#;
         let mut formatter = Formatter::default();
         let formatted_sway_code =
@@ -129,11 +129,11 @@ enum Color {
         let correct_sway_code = r#"contract;
 
 enum Color {
- Blue   : (),
- Green  : (),
- Red    : (),
- Silver : (),
- Grey   : (),
+    Blue   : (),
+    Green  : (),
+    Red    : (),
+    Silver : (),
+    Grey   : (),
 }"#;
 
         // Creating a config with enum_variant_align_threshold that exceeds longest variant length
@@ -144,4 +144,26 @@ enum Color {
             Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
         assert!(correct_sway_code == formatted_sway_code)
     }
+    #[test]
+    fn test_item_abi() {
+        let sway_code_to_format = r#"contract;
+
+abi StorageMapExample {
+    #[storage(write,)]fn insert_into_map1(key: u64, value: u64);
+
+fn hello(key: u64, value: u64);
+}"#;
+        let correct_sway_code = r#"contract;
+
+abi StorageMapExample {
+    #[storage(write)]
+    fn insert_into_map1(key: u64, value: u64);
+
+    fn hello(key: u64, value: u64);
+}"#;
+        let mut formatter = Formatter::default();
+        let formatted_sway_code =
+            Formatter::format(&mut formatter, Arc::from(sway_code_to_format), None).unwrap();
+        assert!(dbg!(correct_sway_code) == dbg!(formatted_sway_code))
+    }
 }

sway-fmt-v2/src/items/item_abi.rs

@@ -1,8 +1,111 @@
-use crate::fmt::{Format, FormattedCode, Formatter};
-use sway_parse::ItemAbi;
+use crate::{
+    config::items::ItemBraceStyle,
+    fmt::{Format, FormattedCode, Formatter},
+    utils::{attribute::FormatDecl, bracket::CurlyBrace},
+};
+use sway_parse::{token::Delimiter, AttributeDecl, ItemAbi};
+use sway_types::Spanned;
 
 impl Format for ItemAbi {
-    fn format(&self, _formatter: &mut Formatter) -> FormattedCode {
-        todo!()
+    fn format(&self, formatter: &mut Formatter) -> FormattedCode {
+        let mut formatted_code = String::new();
+
+        // Add enum token
+        formatted_code.push_str(self.abi_token.span().as_str());
+        formatted_code.push(' ');
+
+        // Add name of the abi
+        formatted_code.push_str(self.name.as_str());
+        Self::open_curly_brace(&mut formatted_code, formatter);
+
+        // Add item fields
+        // abi_items
+        formatted_code += self
+            .abi_items
+            .clone()
+            .into_inner()
+            .iter()
+            .map(|item| -> FormattedCode {
+                let mut buf = String::new();
+                let attribute_list = item.0.attribute_list.clone();
+                // add indent + format attribute if it exists
+                if !attribute_list.is_empty() {
+                    buf.push_str(&formatter.shape.indent.to_string(formatter));
+                    for attr in attribute_list {
+                        AttributeDecl::format(&attr, &mut buf, formatter)
+                    }
+                }
+                // add indent + format item
+                buf.push_str(&formatter.shape.indent.to_string(formatter));
+                buf.push_str(&format!(
+                    "{}{}\n",
+                    item.0.value.span().as_str(), // FnSignature formatting (todo!)
+                    item.1.span().as_str(),       // SemicolonToken
+                ));
+
+                buf
+            })
+            .collect::<Vec<String>>()
+            .join("\n")
+            .as_str();
+        // abi_defs_opt
+        if let Some(abi_defs) = self.abi_defs_opt.clone() {
+            formatted_code += abi_defs
+                .into_inner()
+                .iter()
+                .map(|item| -> FormattedCode {
+                    let mut buf = String::new();
+                    let attribute_list = item.attribute_list.clone();
+                    // add indent + format attribute if it exists
+                    if !attribute_list.is_empty() {
+                        buf.push_str(&formatter.shape.indent.to_string(formatter));
+                        for attr in attribute_list {
+                            AttributeDecl::format(&attr, &mut buf, formatter)
+                        }
+                    }
+                    // add indent + format item
+                    buf.push_str(&formatter.shape.indent.to_string(formatter));
+                    buf.push_str(&item.value.format(formatter)); // ItemFn formatting (todo!)
+
+                    buf
+                })
+                .collect::<Vec<String>>()
+                .join("\n")
+                .as_str();
+        }
+        Self::close_curly_brace(&mut formatted_code, formatter);
+
+        formatted_code
+    }
+}
+
+impl CurlyBrace for ItemAbi {
+    fn open_curly_brace(line: &mut String, formatter: &mut Formatter) {
+        let brace_style = formatter.config.items.item_brace_style;
+        let extra_width = formatter.config.whitespace.tab_spaces;
+        let mut shape = formatter.shape;
+        let open_brace = Delimiter::Brace.as_open_char();
+        match brace_style {
+            ItemBraceStyle::AlwaysNextLine => {
+                // Add openning brace to the next line.
+                line.push_str(&format!("\n{}\n", open_brace));
+                shape = shape.block_indent(extra_width);
+            }
+            _ => {
+                // Add opening brace to the same line
+                line.push_str(&format!(" {}\n", open_brace));
+                shape = shape.block_indent(extra_width);
+            }
+        }
+
+        formatter.shape = shape;
+    }
+    fn close_curly_brace(line: &mut String, formatter: &mut Formatter) {
+        line.push(Delimiter::Brace.as_close_char());
+        // If shape is becoming left-most alligned or - indent just have the defualt shape
+        formatter.shape = formatter
+            .shape
+            .shrink_left(formatter.config.whitespace.tab_spaces)
+            .unwrap_or_default();
     }
 }

sway-fmt-v2/src/items/item_enum.rs

@@ -3,7 +3,7 @@ use crate::{
     fmt::{Format, FormattedCode, Formatter},
     utils::bracket::CurlyBrace,
 };
-use sway_parse::ItemEnum;
+use sway_parse::{token::Delimiter, ItemEnum};
 use sway_types::Spanned;
 
 impl Format for ItemEnum {
@@ -79,26 +79,30 @@ impl Format for ItemEnum {
 impl CurlyBrace for ItemEnum {
     fn open_curly_brace(line: &mut String, formatter: &mut Formatter) {
         let brace_style = formatter.config.items.item_brace_style;
+        let extra_width = formatter.config.whitespace.tab_spaces;
         let mut shape = formatter.shape;
+        let open_brace = Delimiter::Brace.as_open_char();
         match brace_style {
             ItemBraceStyle::AlwaysNextLine => {
                 // Add openning brace to the next line.
-                line.push_str("\n{\n");
-                shape = shape.block_indent(1);
+                line.push_str(&format!("\n{}\n", open_brace));
+                shape = shape.block_indent(extra_width);
             }
             _ => {
                 // Add opening brace to the same line
-                line.push_str(" {\n");
-                shape = shape.block_indent(1);
+                line.push_str(&format!(" {}\n", open_brace));
+                shape = shape.block_indent(extra_width);
             }
         }
 
         formatter.shape = shape;
     }
-
     fn close_curly_brace(line: &mut String, formatter: &mut Formatter) {
-        line.push('}');
-        // If shape is becoming left-most alligned or - indent just have the defualt shape
-        formatter.shape = formatter.shape.shrink_left(1).unwrap_or_default();
+        line.push(Delimiter::Brace.as_close_char());
+        // If shape is becoming left-most aligned or - indent just have the defualt shape
+        formatter.shape = formatter
+            .shape
+            .shrink_left(formatter.config.whitespace.tab_spaces)
+            .unwrap_or_default();
     }
 }

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

@@ -21,7 +21,7 @@ impl<T: Parse + Format> Format for Annotated<T> {
     }
 }
 
-trait FormatDecl {
+pub trait FormatDecl {
     fn format(&self, line: &mut String, formatter: &mut Formatter);
 }
 
@@ -42,16 +42,20 @@ impl FormatDecl for AttributeDecl {
         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
+            let args = args.into_inner().value_separator_pairs;
+            let mut buf = args
                 .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);
+            if args.len() == 1 {
+                buf.pop(); // pop the ending comma
+                line.push_str(&buf);
+            } else {
+                buf.pop(); // pop the ending space
+                buf.pop(); // pop the ending comma
+                line.push_str(&buf);
+            }
         }
         // ')'
         Self::close_parenthesis(line, formatter);