feat(fmt): format struct (restoring fields from source for now) (#1318)

* feat(fmt): format struct (restoring source fields for now)

* feat(fmt): write doc comments for enums and structs

* test(fmt): unify tests for struct definition

fmt/src/formatter.rs

@@ -5,7 +5,7 @@ use std::fmt::Write;
 use indent_write::fmt::IndentWriter;
 use solang_parser::pt::{
     ContractDefinition, DocComment, EnumDefinition, Identifier, Loc, SourceUnit, SourceUnitPart,
-    StringLiteral,
+    StringLiteral, StructDefinition,
 };
 
 use crate::{
@@ -412,7 +412,13 @@ impl<'a, W: Write> Visitor for Formatter<'a, W> {
     }
 
     fn visit_enum(&mut self, enumeration: &mut EnumDefinition) -> VResult {
+        if !enumeration.doc.is_empty() {
+            enumeration.doc.visit(self)?;
+            writeln!(self)?;
+        }
+
         write!(self, "enum {} ", &enumeration.name.name)?;
+
         if enumeration.values.is_empty() {
             self.write_empty_brackets()?;
         } else {
@@ -436,6 +442,34 @@ impl<'a, W: Write> Visitor for Formatter<'a, W> {
         Ok(())
     }
 
+    fn visit_struct(&mut self, structure: &mut StructDefinition) -> VResult {
+        if !structure.doc.is_empty() {
+            structure.doc.visit(self)?;
+            writeln!(self)?;
+        }
+
+        write!(self, "struct {} ", &structure.name.name)?;
+
+        if structure.fields.is_empty() {
+            self.write_empty_brackets()?;
+        } else {
+            writeln!(self, "{{")?;
+
+            self.indent(1);
+            for field in structure.fields.iter_mut() {
+                field.visit(self)?;
+                self.visit_stray_semicolon()?;
+
+                writeln!(self)?;
+            }
+            self.dedent(1);
+
+            write!(self, "}}")?;
+        }
+
+        Ok(())
+    }
+
     fn visit_stray_semicolon(&mut self) -> VResult {
         write!(self, ";")?;
 
@@ -558,4 +592,21 @@ mod tests {
     fn import_directive() {
         test_directory("ImportDirective");
     }
+
+    #[test]
+    fn struct_definition() {
+        test_formatter(
+            FormatterConfig::default(),
+            "struct   Foo  {   
+              } struct   Bar  {    uint256 foo ;string bar ;  }",
+            "
+struct Foo {}
+
+struct Bar {
+    uint256 foo;
+    string bar;
+}
+",
+        );
+    }
 }

fmt/src/visit.rs

@@ -83,7 +83,7 @@ pub trait Visitor {
         Ok(())
     }
 
-    fn visit_var_def(&mut self, var: &mut VariableDefinition) -> VResult {
+    fn visit_var_definition(&mut self, var: &mut VariableDefinition) -> VResult {
         if !var.doc.is_empty() {
             self.visit_doc_comments(&mut var.doc)?;
             self.visit_newline()?;
@@ -94,6 +94,14 @@ pub trait Visitor {
         Ok(())
     }
 
+    /// Doesn't write semicolon at the end because variable declaration can be in both
+    /// struct definition and function body
+    fn visit_var_declaration(&mut self, var: &mut VariableDeclaration) -> VResult {
+        self.visit_source(var.loc)?;
+
+        Ok(())
+    }
+
     fn visit_return(&mut self, _expr: &mut Option<Expression>) -> VResult {
         Ok(())
     }
@@ -228,7 +236,7 @@ impl Visitable for SourceUnitPart {
             SourceUnitPart::EventDefinition(event) => v.visit_event(event),
             SourceUnitPart::ErrorDefinition(error) => v.visit_error(error),
             SourceUnitPart::FunctionDefinition(function) => v.visit_function(function),
-            SourceUnitPart::VariableDefinition(variable) => v.visit_var_def(variable),
+            SourceUnitPart::VariableDefinition(variable) => v.visit_var_definition(variable),
             SourceUnitPart::StraySemicolon(_) => v.visit_stray_semicolon(),
         }
     }
@@ -251,7 +259,7 @@ impl Visitable for ContractPart {
             ContractPart::EventDefinition(event) => v.visit_event(event),
             ContractPart::ErrorDefinition(error) => v.visit_error(error),
             ContractPart::EnumDefinition(enumeration) => v.visit_enum(enumeration),
-            ContractPart::VariableDefinition(variable) => v.visit_var_def(variable),
+            ContractPart::VariableDefinition(variable) => v.visit_var_definition(variable),
             ContractPart::FunctionDefinition(function) => v.visit_function(function),
             ContractPart::StraySemicolon(_) => v.visit_stray_semicolon(),
             ContractPart::Using(using) => v.visit_using(using),
@@ -266,3 +274,11 @@ impl Visitable for Statement {
         Ok(())
     }
 }
+
+impl Visitable for VariableDeclaration {
+    fn visit(&mut self, v: &mut impl Visitor) -> VResult {
+        v.visit_var_declaration(self)?;
+
+        Ok(())
+    }
+}