Changes .clone().into_inner() to .get() in sfv2

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

@@ -38,15 +38,15 @@ impl Format for ItemEnum {
             generics.format(formatted_code, formatter)?;
         }
 
-        let fields = self.fields.clone().into_inner();
+        let fields = self.fields.get();
 
         // Handle openning brace
         ItemEnum::open_curly_brace(formatted_code, formatter)?;
         // Determine alignment tactic
         match formatter.config.structures.field_alignment {
             FieldAlignment::AlignFields(enum_variant_align_threshold) => {
                 writeln!(formatted_code)?;
-                let value_pairs = fields.value_separator_pairs;
+                let value_pairs = &fields.value_separator_pairs;
                 // In first iteration we are going to be collecting the lengths of the enum variants.
                 let variant_length: Vec<usize> = value_pairs
                     .iter()

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

@@ -19,10 +19,7 @@ impl Format for ItemFn {
     ) -> Result<(), FormatterError> {
         self.fn_signature.format(formatted_code, formatter)?;
         Self::open_curly_brace(formatted_code, formatter)?;
-        self.body
-            .clone()
-            .into_inner()
-            .format(formatted_code, formatter)?;
+        self.body.get().format(formatted_code, formatter)?;
         Self::close_curly_brace(formatted_code, formatter)?;
 
         Ok(())
@@ -96,13 +93,13 @@ impl Format for FnSignature {
             self.name.as_str()
         )?;
         // `<T>`
-        if let Some(generics) = &self.generics.clone() {
+        if let Some(generics) = &self.generics {
             generics.format(formatted_code, formatter)?;
         }
         // `(`
         Self::open_parenthesis(formatted_code, formatter)?;
         // FnArgs
-        match self.arguments.clone().into_inner() {
+        match self.arguments.get() {
             FnArgs::Static(args) => {
                 args.format(formatted_code, formatter)?;
             }

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

@@ -38,7 +38,7 @@ impl Format for ItemImpl {
             formatter.shape.update_where_clause();
         }
         Self::open_curly_brace(formatted_code, formatter)?;
-        let contents = self.contents.clone().into_inner();
+        let contents = self.contents.get();
         for item in contents.iter() {
             item.format(formatted_code, formatter)?;
         }

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

@@ -25,7 +25,7 @@ impl Format for ItemStorage {
             .update_line_style(LineStyle::Multiline);
         // Add storage token
         write!(formatted_code, "{}", self.storage_token.span().as_str())?;
-        let fields = self.fields.clone().into_inner();
+        let fields = self.fields.get();
 
         // Handle openning brace
         Self::open_curly_brace(formatted_code, formatter)?;
@@ -34,7 +34,7 @@ impl Format for ItemStorage {
         match formatter.config.structures.field_alignment {
             FieldAlignment::AlignFields(storage_field_align_threshold) => {
                 writeln!(formatted_code)?;
-                let value_pairs = fields.value_separator_pairs;
+                let value_pairs = &fields.value_separator_pairs;
                 // In first iteration we are going to be collecting the lengths of the struct fields.
                 let field_length: Vec<usize> = value_pairs
                     .iter()

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

@@ -38,15 +38,15 @@ impl Format for ItemStruct {
             generics.format(formatted_code, formatter)?;
         }
 
-        let fields = self.fields.clone().into_inner();
+        let fields = self.fields.get();
 
         // Handle openning brace
         Self::open_curly_brace(formatted_code, formatter)?;
         // Determine alignment tactic
         match formatter.config.structures.field_alignment {
             FieldAlignment::AlignFields(enum_variant_align_threshold) => {
                 writeln!(formatted_code)?;
-                let value_pairs = fields.value_separator_pairs;
+                let value_pairs = &fields.value_separator_pairs;
                 // In first iteration we are going to be collecting the lengths of the struct variants.
                 let variant_length: Vec<usize> = value_pairs
                     .iter()

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

@@ -34,15 +34,15 @@ impl Format for ItemTrait {
         }
         write!(formatted_code, " ")?;
         Self::open_curly_brace(formatted_code, formatter)?;
-        for (fn_signature, semicolon_token) in self.trait_items.clone().into_inner() {
+        for (fn_signature, semicolon_token) in self.trait_items.get() {
             // format `Annotated<FnSignature>`
             fn_signature.format(formatted_code, formatter)?;
             writeln!(formatted_code, "{}\n", semicolon_token.ident().as_str())?;
         }
         formatted_code.pop(); // pop last ending newline
         if let Some(trait_defs) = &self.trait_defs_opt {
             Self::open_curly_brace(formatted_code, formatter)?;
-            for trait_items in trait_defs.clone().into_inner() {
+            for trait_items in trait_defs.get() {
                 write!(
                     formatted_code,
                     "{}",

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

@@ -54,14 +54,14 @@ impl FormatDecl for AttributeDecl {
         write!(line, "{}", self.hash_token.span().as_str())?;
         // `[`
         Self::open_square_bracket(line, formatter)?;
-        let attr = self.attribute.clone().into_inner();
+        let attr = self.attribute.get();
         // name e.g. `storage`
         write!(line, "{}", attr.name.span().as_str())?;
         // `(`
         Self::open_parenthesis(line, formatter)?;
         // format and add args e.g. `read, write`
-        if let Some(args) = attr.args {
-            args.into_inner().format(line, formatter)?;
+        if let Some(args) = &attr.args {
+            args.get().format(line, formatter)?;
         }
         // ')'
         Self::close_parenthesis(line, formatter)?;

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

@@ -115,7 +115,7 @@ where
         // Add opening brace's ByteSpan
         collected_spans.push(opening_brace_span);
         // Add T's collected ByteSpan
-        collected_spans.append(&mut self.clone().into_inner().leaf_spans());
+        collected_spans.append(&mut self.get().leaf_spans());
         let mut closing_brace_span = ByteSpan::from(self.span());
         closing_brace_span.start = closing_brace_span.end - 1;
         // Add closing brace's ByteSpan
@@ -135,7 +135,7 @@ where
         // Add opening paren's span
         collected_spans.push(opening_paren_span);
         // Add T's collected ByteSpan
-        collected_spans.append(&mut self.clone().into_inner().leaf_spans());
+        collected_spans.append(&mut self.get().leaf_spans());
         let mut closing_paren_span = ByteSpan::from(self.span());
         closing_paren_span.start = closing_paren_span.end - 1;
         // Add closing paren's ByteSpan
@@ -155,7 +155,7 @@ where
         // Add opening bracket's span
         collected_spans.push(opening_bracket_span);
         // Add T's collected ByteSpan
-        collected_spans.append(&mut self.clone().into_inner().leaf_spans());
+        collected_spans.append(&mut self.get().leaf_spans());
         let mut closing_bracket_span = ByteSpan::from(self.span());
         closing_bracket_span.start = closing_bracket_span.end - 1;
         // Add closing bracket's ByteSpan

sway-fmt-v2/src/utils/expr/asm_block.rs

@@ -21,16 +21,10 @@ impl Format for AsmBlock {
     ) -> Result<(), FormatterError> {
         write!(formatted_code, "{} ", self.asm_token.span().as_str())?;
         Self::open_parenthesis(formatted_code, formatter)?;
-        self.registers
-            .clone()
-            .into_inner()
-            .format(formatted_code, formatter)?;
+        self.registers.get().format(formatted_code, formatter)?;
         Self::close_parenthesis(formatted_code, formatter)?;
         Self::open_square_bracket(formatted_code, formatter)?;
-        self.contents
-            .clone()
-            .into_inner()
-            .format(formatted_code, formatter)?;
+        self.contents.get().format(formatted_code, formatter)?;
         Self::close_square_bracket(formatted_code, formatter)?;
 
         Ok(())

sway-fmt-v2/src/utils/expr/assignable.rs

@@ -27,7 +27,7 @@ impl Format for Assignable {
             Assignable::Index { target, arg } => {
                 target.format(formatted_code, formatter)?;
                 Expr::open_square_bracket(formatted_code, formatter)?;
-                arg.clone().into_inner().format(formatted_code, formatter)?;
+                arg.get().format(formatted_code, formatter)?;
                 Expr::close_square_bracket(formatted_code, formatter)?;
             }
             Assignable::FieldProjection {

sway-fmt-v2/src/utils/expr/conditional.rs

@@ -18,10 +18,7 @@ impl Format for IfExpr {
         write!(formatted_code, "{} ", self.if_token.span().as_str())?;
         self.condition.format(formatted_code, formatter)?;
         Self::open_curly_brace(formatted_code, formatter)?;
-        self.then_block
-            .clone()
-            .into_inner()
-            .format(formatted_code, formatter)?;
+        self.then_block.get().format(formatted_code, formatter)?;
         Self::close_curly_brace(formatted_code, formatter)?;
         if let Some(else_opt) = &self.else_opt {
             write!(formatted_code, "{} ", else_opt.0.span().as_str())?;
@@ -30,8 +27,7 @@ impl Format for IfExpr {
                 ControlFlow::Break(code_block_contents) => {
                     Self::open_curly_brace(formatted_code, formatter)?;
                     code_block_contents
-                        .clone()
-                        .into_inner()
+                        .get()
                         .format(formatted_code, formatter)?;
                     Self::close_curly_brace(formatted_code, formatter)?;
                 }
@@ -133,10 +129,7 @@ impl Format for MatchBranchKind {
                 comma_token_opt,
             } => {
                 Self::open_curly_brace(formatted_code, formatter)?;
-                block
-                    .clone()
-                    .into_inner()
-                    .format(formatted_code, formatter)?;
+                block.get().format(formatted_code, formatter)?;
                 Self::close_curly_brace(formatted_code, formatter)?;
                 if let Some(comma_token) = comma_token_opt {
                     write!(formatted_code, "{}", comma_token.span().as_str())?;

sway-fmt-v2/src/utils/expr/mod.rs

@@ -40,9 +40,7 @@ impl Format for Expr {
             Self::Literal(lit) => lit.format(formatted_code, formatter)?,
             Self::AbiCast { abi_token, args } => {
                 write!(formatted_code, "{}", abi_token.span().as_str())?;
-                args.clone()
-                    .into_inner()
-                    .format(formatted_code, formatter)?;
+                args.get().format(formatted_code, formatter)?;
             }
             Self::Struct { path, fields } => {
                 // store previous state and update expr kind
@@ -61,7 +59,7 @@ impl Format for Expr {
 
                 // get the largest field size and the size of the body
                 let (field_width, body_width) =
-                    get_field_width(&fields.clone().into_inner(), &mut formatter.clone())?;
+                    get_field_width(fields.get(), &mut formatter.clone())?;
 
                 // changes to the actual formatter
                 let expr_width = buf.chars().count() as usize;
@@ -104,25 +102,17 @@ impl Format for Expr {
             }
             Self::Parens(expr) => {
                 Self::open_parenthesis(formatted_code, formatter)?;
-                expr.clone()
-                    .into_inner()
-                    .format(formatted_code, formatter)?;
+                expr.get().format(formatted_code, formatter)?;
                 Self::close_parenthesis(formatted_code, formatter)?;
             }
             Self::Block(code_block) => {
                 CodeBlockContents::open_curly_brace(formatted_code, formatter)?;
-                code_block
-                    .clone()
-                    .into_inner()
-                    .format(formatted_code, formatter)?;
+                code_block.get().format(formatted_code, formatter)?;
                 CodeBlockContents::close_curly_brace(formatted_code, formatter)?;
             }
             Self::Array(array_descriptor) => {
                 ExprArrayDescriptor::open_square_bracket(formatted_code, formatter)?;
-                array_descriptor
-                    .clone()
-                    .into_inner()
-                    .format(formatted_code, formatter)?;
+                array_descriptor.get().format(formatted_code, formatter)?;
                 ExprArrayDescriptor::close_square_bracket(formatted_code, formatter)?;
             }
             Self::Asm(asm_block) => asm_block.format(formatted_code, formatter)?,
@@ -145,7 +135,7 @@ impl Format for Expr {
                 write!(formatted_code, "{} ", match_token.span().as_str())?;
                 value.format(formatted_code, formatter)?;
                 MatchBranch::open_curly_brace(formatted_code, formatter)?;
-                let branches = branches.clone().into_inner();
+                let branches = branches.get();
                 for match_branch in branches.iter() {
                     match_branch.format(formatted_code, formatter)?;
                 }
@@ -159,10 +149,7 @@ impl Format for Expr {
                 write!(formatted_code, "{} ", while_token.span().as_str())?;
                 condition.format(formatted_code, formatter)?;
                 CodeBlockContents::open_curly_brace(formatted_code, formatter)?;
-                block
-                    .clone()
-                    .into_inner()
-                    .format(formatted_code, formatter)?;
+                block.get().format(formatted_code, formatter)?;
                 CodeBlockContents::close_curly_brace(formatted_code, formatter)?;
             }
             Self::FuncApp { func, args } => {
@@ -176,15 +163,13 @@ impl Format for Expr {
                 }
                 func.format(formatted_code, formatter)?;
                 Self::open_parenthesis(formatted_code, formatter)?;
-                args.clone()
-                    .into_inner()
-                    .format(formatted_code, formatter)?;
+                args.get().format(formatted_code, formatter)?;
                 Self::close_parenthesis(formatted_code, formatter)?;
             }
             Self::Index { target, arg } => {
                 target.format(formatted_code, formatter)?;
                 Self::open_square_bracket(formatted_code, formatter)?;
-                arg.clone().into_inner().format(formatted_code, formatter)?;
+                arg.get().format(formatted_code, formatter)?;
                 Self::close_square_bracket(formatted_code, formatter)?;
             }
             Self::MethodCall {
@@ -215,10 +200,8 @@ impl Format for Expr {
                 // get the largest field size
                 let (mut field_width, mut body_width): (usize, usize) = (0, 0);
                 if let Some(contract_args) = &contract_args_opt {
-                    (field_width, body_width) = get_field_width(
-                        &contract_args.clone().into_inner(),
-                        &mut formatter.clone(),
-                    )?;
+                    (field_width, body_width) =
+                        get_field_width(contract_args.get(), &mut formatter.clone())?;
                 }
 
                 // changes to the actual formatter
@@ -520,7 +503,7 @@ fn format_expr_struct(
 ) -> Result<(), FormatterError> {
     path.format(formatted_code, formatter)?;
     ExprStructField::open_curly_brace(formatted_code, formatter)?;
-    let fields = &fields.clone().into_inner();
+    let fields = &fields.get();
     match formatter.shape.code_line.line_style {
         LineStyle::Inline => fields.format(formatted_code, formatter)?,
         // TODO: add field alignment
@@ -536,10 +519,7 @@ fn format_tuple(
     formatted_code: &mut FormattedCode,
     formatter: &mut Formatter,
 ) -> Result<(), FormatterError> {
-    tuple_descriptor
-        .clone()
-        .into_inner()
-        .format(formatted_code, formatter)?;
+    tuple_descriptor.get().format(formatted_code, formatter)?;
 
     Ok(())
 }
@@ -566,7 +546,7 @@ fn format_method_call(
     name.format(formatted_code, formatter)?;
     if let Some(contract_args) = &contract_args_opt {
         ExprStructField::open_curly_brace(formatted_code, formatter)?;
-        let contract_args = &contract_args.clone().into_inner();
+        let contract_args = &contract_args.get();
         match formatter.shape.code_line.line_style {
             LineStyle::Inline => {
                 contract_args.format(formatted_code, formatter)?;
@@ -579,9 +559,7 @@ fn format_method_call(
     }
     Expr::open_parenthesis(formatted_code, formatter)?;
     formatter.shape.reset_line_settings();
-    args.clone()
-        .into_inner()
-        .format(formatted_code, formatter)?;
+    args.get().format(formatted_code, formatter)?;
     Expr::close_parenthesis(formatted_code, formatter)?;
 
     Ok(())

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

@@ -4,10 +4,6 @@ use sway_ast::{GenericArgs, GenericParams};
 
 use super::shape::LineStyle;
 
-// In the future we will need to determine whether the generic arguments
-// are better suited with a `where` clause. At present they will be
-// formatted in line.
-//
 impl Format for GenericParams {
     fn format(
         &self,
@@ -40,7 +36,6 @@ impl Format for GenericArgs {
         formatted_code: &mut FormattedCode,
         formatter: &mut Formatter,
     ) -> Result<(), FormatterError> {
-        // Need to add `<Ty, CommaToken>` to `Punctuated::format()`
         let params = self.parameters.clone().into_inner();
 
         // `<`