diff --git a/src/ast/field.rs b/src/ast/field.rs
index 44561b4..09beccd 100644
--- a/src/ast/field.rs
+++ b/src/ast/field.rs
@@ -69,6 +69,54 @@ impl HasSpan for Field {
 }
 
 impl Field {
+    pub fn access(base: Box<Expr>, index: Box<Expr>, span: Span) -> Self {
+        Self::Access {
+            expr: base,
+            s0: Space::empty(span),
+            s1: Space::empty(span),
+            index,
+            s2: Space::empty(span),
+            span,
+        }
+    }
+
+    pub fn assign(base: Box<Expr>, index: Box<Expr>, value: Box<Expr>, span: Span) -> Self {
+        Self::Assign {
+            expr: base,
+            s0: Space::empty(span),
+            s1: Space::empty(span),
+            index,
+            s2: Space::empty(span),
+            s3: Space::empty(span),
+            s4: Space::empty(span),
+            value,
+            span,
+        }
+    }
+
+    pub fn access_ident(base: Box<Expr>, ident: Ident, span: Span) -> Self {
+        Self::AccessIdent {
+            expr: base,
+            s0: Space::empty(span),
+            s1: Space::empty(span),
+            ident,
+            span,
+        }
+    }
+
+    pub fn assign_ident(base: Box<Expr>, ident: Ident, value: Box<Expr>, span: Span) -> Self {
+        Self::AssignIdent {
+            expr: base,
+            s0: Space::empty(span),
+            s1: Space::empty(span),
+            ident,
+            s2: Space::empty(span),
+            s3: Space::empty(span),
+            value,
+            span,
+        }
+    }
+
     pub fn expr(self) -> Expr {
         Expr::Field(self)
     }
diff --git a/src/desugar/call.rs b/src/desugar/call.rs
index 361bbf5..c231875 100644
--- a/src/desugar/call.rs
+++ b/src/desugar/call.rs
@@ -16,10 +16,8 @@ impl Call {
                 let new = BoundedSeparated::new(span)
                     .then(TableLitElem::named(Ident::new("call", span), expr, span))
                     .then(TableLitElem::named(Ident::new("arg", span), arg, span))
-                    .table_lit()
-                    .lit()
-                    .expr();
-                (new, true)
+                    .table_lit();
+                (new.lit().expr(), true)
             }
 
             Self::NoArg {
diff --git a/src/desugar/field.rs b/src/desugar/field.rs
index 1c8f948..3c269e2 100644
--- a/src/desugar/field.rs
+++ b/src/desugar/field.rs
@@ -1,4 +1,4 @@
-use crate::ast::{BoundedSeparated, Call, Expr, Field, Lit, Space, StringLit, TableConstrElem};
+use crate::ast::{BoundedSeparated, Call, Expr, Field, Lit, StringLit, TableConstrElem};
 use crate::builtin::Builtin;
 
 impl Field {
@@ -50,47 +50,35 @@ impl Field {
 
             Self::AccessIdent {
                 expr,
-                s0,
-                s1,
+                s0: _,
+                s1: _,
                 ident,
                 span,
             } => {
-                // `expr s0 . s1 ident´
-                // -> `expr s0 [ s1 ident_str ]`
-                let new = Self::Access {
+                let new = Self::access(
                     expr,
-                    s0,
-                    s1,
-                    index: StringLit::from_ident(ident).lit().expr().boxed(),
-                    s2: Space::empty(span),
+                    StringLit::from_ident(ident).lit().expr().boxed(),
                     span,
-                };
+                );
                 (new.expr(), true)
             }
 
             Self::AssignIdent {
                 expr,
-                s0,
-                s1,
+                s0: _,
+                s1: _,
                 ident,
-                s2,
-                s3,
+                s2: _,
+                s3: _,
                 value,
                 span,
             } => {
-                // `expr s0 . s1 ident s2 = s3 value`
-                // -> `expr s0 [ s1 ident_str ] s2 = s3 value`
-                let new = Self::Assign {
+                let new = Self::assign(
                     expr,
-                    s0,
-                    s1,
-                    index: StringLit::from_ident(ident).lit().expr().boxed(),
-                    s2: Space::empty(span),
-                    s3: s2,
-                    s4: s3,
+                    StringLit::from_ident(ident).lit().expr().boxed(),
                     value,
                     span,
-                };
+                );
                 (new.expr(), true)
             }
         }
diff --git a/src/desugar/table_constr.rs b/src/desugar/table_constr.rs
index cfa1c04..263d9d4 100644
--- a/src/desugar/table_constr.rs
+++ b/src/desugar/table_constr.rs
@@ -1,5 +1,5 @@
 use crate::ast::{
-    BoundedSeparated, Expr, Field, Ident, Line, TableConstr, TableConstrElem, TableLitElem,
+    BoundedSeparated, Expr, Field, Ident, TableConstr, TableConstrElem, TableLitElem,
 };
 use crate::span::HasSpan;
 
@@ -10,14 +10,14 @@ impl TableConstr {
         let (elems, setters) = self.0.remove_map(|e| match e {
             TableConstrElem::Lit(lit) => Ok(lit),
             TableConstrElem::Indexed {
-                s0,
+                s0: _,
                 index,
-                s1,
-                s2,
-                s3,
+                s1: _,
+                s2: _,
+                s3: _,
                 value,
                 span,
-            } => Err((s0, index, s1, s2, s3, value, span)),
+            } => Err((index, value, span)),
         });
 
         let mut expr = BoundedSeparated::new(span)
@@ -30,21 +30,8 @@ impl TableConstr {
             .lit()
             .expr();
 
-        // `sl [ s0 index s1 ] s2 = s3 value sr`
-        // -> `expr s0 [ s1 index s2 ] s3 = s4 s5 value`
-        for (s0, (s1, index, s2, s3, s4, value, span), s5) in setters {
-            expr = Field::Assign {
-                expr: expr.boxed(),
-                s0,
-                s1,
-                index,
-                s2,
-                s3,
-                s4: s4.then_line(Line::Empty).then(s5),
-                value,
-                span,
-            }
-            .expr();
+        for (_, (index, value, span), _) in setters {
+            expr = Field::assign(expr.boxed(), index, value, span).expr();
         }
 
         (expr, true)
diff --git a/src/desugar/var.rs b/src/desugar/var.rs
index fc1b221..9062ee6 100644
--- a/src/desugar/var.rs
+++ b/src/desugar/var.rs
@@ -8,45 +8,28 @@ impl Var {
     pub fn desugar(self) -> (Expr, bool) {
         match self {
             Self::Access {
-                s0,
+                s0: _,
                 index,
-                s1,
+                s1: _,
                 span,
             } => {
                 let scope = Call::no_arg(Lit::Builtin(Builtin::Scope, span).expr().boxed(), span);
-                let new = Field::Access {
-                    expr: scope.expr().boxed(),
-                    s0: Space::empty(span),
-                    s1: s0,
-                    index,
-                    s2: s1,
-                    span,
-                };
+                let new = Field::access(scope.expr().boxed(), index, span);
                 (new.expr(), true)
             }
 
             Self::Assign {
                 local: None,
-                s0,
+                s0: _,
                 index,
-                s1,
-                s2,
-                s3,
+                s1: _,
+                s2: _,
+                s3: _,
                 value,
                 span,
             } => {
                 let scope = Call::no_arg(Lit::Builtin(Builtin::Scope, span).expr().boxed(), span);
-                let new = Field::Assign {
-                    expr: scope.expr().boxed(),
-                    s0: Space::empty(span),
-                    s1: s0,
-                    index,
-                    s2: s1,
-                    s3: s2,
-                    s4: s3,
-                    value,
-                    span,
-                };
+                let new = Field::assign(scope.expr().boxed(), index, value, span);
                 (new.expr(), true)
             }