From 56d12bc6f6c46f01ca9f49a0f3a80a759e64c8ac Mon Sep 17 00:00:00 2001
From: Robert Masen <r.f.masen@gmail.com>
Date: Sun, 11 Jun 2023 10:32:50 -0500
Subject: [PATCH] Clippy and Fmt enforcement

---
 .github/workflows/rust.yml |  18 ++
 src/decl.rs                | 604 +++++++++++++++++++------------------
 src/expr.rs                | 325 +++++++++++---------
 src/lib.rs                 | 158 +++++-----
 src/pat.rs                 |  51 ++--
 src/spanned/convert.rs     |   7 +-
 src/spanned/decl.rs        | 274 +++++++++--------
 src/spanned/expr.rs        | 474 ++++++++++++++++-------------
 src/spanned/mod.rs         | 190 ++++++------
 src/spanned/pat.rs         |  96 +++---
 src/spanned/stmt.rs        | 279 ++++++++++-------
 src/spanned/tokens.rs      |  53 +---
 src/stmt.rs                | 186 ++++++------
 13 files changed, 1470 insertions(+), 1245 deletions(-)
 create mode 100644 .github/workflows/rust.yml

diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
new file mode 100644
index 0000000..f343b1f
--- /dev/null
+++ b/.github/workflows/rust.yml
@@ -0,0 +1,18 @@
+name: Rust
+
+on: [push]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: fmt check
+      run: cargo fmt --check
+    - name: clippy
+      run: cargo clippy -- -Dwarnings
+    - name: Build
+      run: cargo build
+    
diff --git a/src/decl.rs b/src/decl.rs
index 52ea0b9..41117c0 100644
--- a/src/decl.rs
+++ b/src/decl.rs
@@ -1,295 +1,309 @@
-use crate::expr::{Expr, Lit};
-use crate::pat::Pat;
-use crate::{VarKind, IntoAllocated};
-use crate::{Class, Func, Ident};
-
-#[cfg(feature = "serde")]
-use serde::{Serialize, Deserialize};
-
-/// The declaration of a variable, function, class, import or export
-#[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
-pub enum Decl<T> {
-    /// A variable declaration
-    /// ```js
-    /// var x, b;
-    /// let y, a = 0;
-    /// const q = 100
-    /// ```
-    Var(VarKind, Vec<VarDecl<T>>),
-    /// A function declaration
-    /// ```js
-    /// function thing() {}
-    /// ```
-    Func(Func<T>),
-    /// A class declaration
-    /// ```js
-    /// class Thing {}
-    /// ```
-    Class(Class<T>),
-    /// An import declaration
-    /// ```js
-    /// import * as moment from 'moment';
-    /// import Thing, {thing} from 'stuff';
-    /// ```
-    Import(Box<ModImport<T>>),
-    /// An export declaration
-    /// ```js
-    /// export function thing() {}
-    /// ```
-    Export(Box<ModExport<T>>),
-}
-
-impl<T> IntoAllocated for Decl<T> where T: ToString {
-    type Allocated = Decl<String>;
-
-    fn into_allocated(self) -> Self::Allocated {
-        match self {
-            Decl::Var(k, decls) => Decl::Var(k, decls.into_iter().map(|d| d.into_allocated()).collect()),
-            Decl::Func(inner) => Decl::Func(inner.into_allocated()),
-            Decl::Class(inner) => Decl::Class(inner.into_allocated()),
-            Decl::Import(inner) => Decl::Import(inner.into_allocated()),
-            Decl::Export(inner) => Decl::Export(inner.into_allocated()),
-        }
-    }
-}
-
-/// The identifier and optional value of a variable declaration
-#[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
-pub struct VarDecl<T> {
-    pub id: Pat<T>,
-    pub init: Option<Expr<T>>,
-}
-
-impl<T> IntoAllocated for VarDecl<T> where T: ToString {
-    type Allocated = VarDecl<String>;
-
-    fn into_allocated(self) -> Self::Allocated {
-        VarDecl {
-            id: self.id.into_allocated(),
-            init: self.init.map(|i| i.into_allocated()),
-        }
-    }
-}
-
-/// A declaration that imports exported
-/// members of another module
-///
-/// ```js
-/// import {Thing} from './stuff.js';
-/// ```
-#[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
-pub struct ModImport<T> {
-    pub specifiers: Vec<ImportSpecifier<T>>,
-    pub source: Lit<T>,
-}
-
-impl<T> IntoAllocated for ModImport<T> where T: ToString {
-    type Allocated = ModImport<String>;
-
-    fn into_allocated(self) -> Self::Allocated {
-        ModImport {
-            specifiers: self.specifiers.into_iter().map(|s| s.into_allocated()).collect(),
-            source: self.source.into_allocated(),
-        }
-    }
-}
-
-/// The name of the thing being imported
-#[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
-pub enum ImportSpecifier<T> {
-    /// A specifier in curly braces, this might
-    /// have a local alias
-    ///
-    /// ```js
-    /// import {Thing} from './stuff.js';
-    /// import {People as Persons} from './places.js';
-    /// ```
-    Normal(Vec<NormalImportSpec<T>>),
-    /// A specifier that has been exported with the
-    /// default keyword, this should not be wrapped in
-    /// curly braces.
-    /// ```js
-    /// import DefaultThing from './stuff/js';
-    /// ```
-    Default(Ident<T>),
-    /// Import all exported members from a module
-    /// in a namespace.
-    ///
-    /// ```js
-    /// import * as Moment from 'moment.js';
-    /// ```
-    Namespace(Ident<T>),
-}
-
-impl<T> IntoAllocated for ImportSpecifier<T> where T: ToString {
-    type Allocated = ImportSpecifier<String>;
-
-    fn into_allocated(self) -> Self::Allocated {
-        match self {
-            ImportSpecifier::Normal(inner) => ImportSpecifier::Normal(inner.into_iter().map(|n| n.into_allocated()).collect()),
-            ImportSpecifier::Default(inner) => ImportSpecifier::Default(inner.into_allocated()),
-            ImportSpecifier::Namespace(inner) => ImportSpecifier::Namespace(inner.into_allocated()),
-        }
-    }
-}
-
-#[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
-pub struct NormalImportSpec<T> {
-    pub alias: Option<Ident<T>>,
-    pub imported: Ident<T>,
-}
-
-impl<T> IntoAllocated for NormalImportSpec<T> where T: ToString {
-    type Allocated = NormalImportSpec<String>;
-
-    fn into_allocated(self) -> Self::Allocated {
-        NormalImportSpec {
-            alias: self.alias.map(|i| i.into_allocated()),
-            imported: self.imported.into_allocated(),
-        }
-    }
-}
-
-/// Something exported from this module
-#[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
-pub enum ModExport<T> {
-    /// ```js
-    /// export default function() {};
-    /// //or
-    /// export default 1;
-    /// ```
-    Default(DefaultExportDecl<T>),
-    ///```js
-    /// export {foo} from 'mod';
-    /// //or
-    /// export {foo as bar} from 'mod';
-    /// //or
-    /// export var foo = 1;
-    /// //or
-    /// export function bar() {
-    /// }
-    /// ```
-    Named(NamedExportDecl<T>),
-    /// ```js
-    /// export * from 'mod';
-    /// ```
-    All {
-        alias: Option<Ident<T>>,
-        name: Lit<T>,
-    },
-}
-
-impl<T> IntoAllocated for ModExport<T> where T: ToString {
-    type Allocated = ModExport<String>;
-
-    fn into_allocated(self) -> Self::Allocated {
-        match self {
-            ModExport::Default(inner) => ModExport::Default(inner.into_allocated()),
-            ModExport::Named(inner) => ModExport::Named(inner.into_allocated()),
-            ModExport::All { alias, name } => ModExport::All { alias: alias.map(|i| i.into_allocated()), name: name.into_allocated()},
-        }
-    }
-}
-
-/// An export that has a name
-/// ```js
-/// export function thing() {}
-/// export {stuff} from 'place';
-#[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
-pub enum NamedExportDecl<T> {
-    Decl(Decl<T>),
-    Specifier(Vec<ExportSpecifier<T>>, Option<Lit<T>>),
-}
-
-impl<T> IntoAllocated for NamedExportDecl<T> where T: ToString {
-    type Allocated = NamedExportDecl<String>;
-
-    fn into_allocated(self) -> Self::Allocated {
-        match self {
-            NamedExportDecl::Decl(inner) => NamedExportDecl::Decl(inner.into_allocated()),
-            NamedExportDecl::Specifier(specs, lit) => NamedExportDecl::Specifier(specs.into_iter().map(|s| s.into_allocated()).collect(), lit.map(|l| l.into_allocated())),
-        }
-    }
-}
-
-/// A default export
-/// ```js
-/// export default class Thing {}
-/// ```
-#[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
-pub enum DefaultExportDecl<T> {
-    Decl(Decl<T>),
-    Expr(Expr<T>),
-}
-
-impl<T> IntoAllocated for DefaultExportDecl<T> where T: ToString {
-    type Allocated = DefaultExportDecl<String>;
-
-    fn into_allocated(self) -> Self::Allocated {
-        match self {
-            DefaultExportDecl::Decl(inner) => DefaultExportDecl::Decl(inner.into_allocated()),
-            DefaultExportDecl::Expr(inner) => DefaultExportDecl::Expr(inner.into_allocated()),
-        }
-    }
-}
-
-/// The name of the thing being exported
-/// this might include an alias
-/// ```js
-/// //no-alias
-/// export {Thing} from 'place';
-/// //aliased
-/// export {Stuff as NewThing} from 'place'
-/// ```
-#[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
-pub struct ExportSpecifier<T> {
-    pub local: Ident<T>,
-    pub alias: Option<Ident<T>>,
-}
-
-impl<T> IntoAllocated for ExportSpecifier<T> where T: ToString {
-    type Allocated = ExportSpecifier<String>;
-
-    fn into_allocated(self) -> Self::Allocated {
-        ExportSpecifier {
-            local: self.local.into_allocated(),
-            alias: self.alias.map(|a| a.into_allocated()),
-        }
-    }
-}
+use crate::expr::{Expr, Lit};
+use crate::pat::Pat;
+use crate::{Class, Func, Ident};
+use crate::{IntoAllocated, VarKind};
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+/// The declaration of a variable, function, class, import or export
+#[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub enum Decl<T> {
+    /// A variable declaration
+    /// ```js
+    /// var x, b;
+    /// let y, a = 0;
+    /// const q = 100
+    /// ```
+    Var(VarKind, Vec<VarDecl<T>>),
+    /// A function declaration
+    /// ```js
+    /// function thing() {}
+    /// ```
+    Func(Func<T>),
+    /// A class declaration
+    /// ```js
+    /// class Thing {}
+    /// ```
+    Class(Class<T>),
+    /// An import declaration
+    /// ```js
+    /// import * as moment from 'moment';
+    /// import Thing, {thing} from 'stuff';
+    /// ```
+    Import(Box<ModImport<T>>),
+    /// An export declaration
+    /// ```js
+    /// export function thing() {}
+    /// ```
+    Export(Box<ModExport<T>>),
+}
+
+impl<T> IntoAllocated for Decl<T>
+where
+    T: ToString,
+{
+    type Allocated = Decl<String>;
+
+    fn into_allocated(self) -> Self::Allocated {
+        match self {
+            Decl::Var(k, decls) => {
+                Decl::Var(k, decls.into_iter().map(|d| d.into_allocated()).collect())
+            }
+            Decl::Func(inner) => Decl::Func(inner.into_allocated()),
+            Decl::Class(inner) => Decl::Class(inner.into_allocated()),
+            Decl::Import(inner) => Decl::Import(inner.into_allocated()),
+            Decl::Export(inner) => Decl::Export(inner.into_allocated()),
+        }
+    }
+}
+
+/// The identifier and optional value of a variable declaration
+#[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct VarDecl<T> {
+    pub id: Pat<T>,
+    pub init: Option<Expr<T>>,
+}
+
+impl<T> IntoAllocated for VarDecl<T>
+where
+    T: ToString,
+{
+    type Allocated = VarDecl<String>;
+
+    fn into_allocated(self) -> Self::Allocated {
+        VarDecl {
+            id: self.id.into_allocated(),
+            init: self.init.map(|i| i.into_allocated()),
+        }
+    }
+}
+
+/// A declaration that imports exported
+/// members of another module
+///
+/// ```js
+/// import {Thing} from './stuff.js';
+/// ```
+#[derive(PartialEq, Debug, Clone)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct ModImport<T> {
+    pub specifiers: Vec<ImportSpecifier<T>>,
+    pub source: Lit<T>,
+}
+
+impl<T> IntoAllocated for ModImport<T>
+where
+    T: ToString,
+{
+    type Allocated = ModImport<String>;
+
+    fn into_allocated(self) -> Self::Allocated {
+        ModImport {
+            specifiers: self
+                .specifiers
+                .into_iter()
+                .map(|s| s.into_allocated())
+                .collect(),
+            source: self.source.into_allocated(),
+        }
+    }
+}
+
+/// The name of the thing being imported
+#[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub enum ImportSpecifier<T> {
+    /// A specifier in curly braces, this might
+    /// have a local alias
+    ///
+    /// ```js
+    /// import {Thing} from './stuff.js';
+    /// import {People as Persons} from './places.js';
+    /// ```
+    Normal(Vec<NormalImportSpec<T>>),
+    /// A specifier that has been exported with the
+    /// default keyword, this should not be wrapped in
+    /// curly braces.
+    /// ```js
+    /// import DefaultThing from './stuff/js';
+    /// ```
+    Default(Ident<T>),
+    /// Import all exported members from a module
+    /// in a namespace.
+    ///
+    /// ```js
+    /// import * as Moment from 'moment.js';
+    /// ```
+    Namespace(Ident<T>),
+}
+
+impl<T> IntoAllocated for ImportSpecifier<T>
+where
+    T: ToString,
+{
+    type Allocated = ImportSpecifier<String>;
+
+    fn into_allocated(self) -> Self::Allocated {
+        match self {
+            ImportSpecifier::Normal(inner) => {
+                ImportSpecifier::Normal(inner.into_iter().map(|n| n.into_allocated()).collect())
+            }
+            ImportSpecifier::Default(inner) => ImportSpecifier::Default(inner.into_allocated()),
+            ImportSpecifier::Namespace(inner) => ImportSpecifier::Namespace(inner.into_allocated()),
+        }
+    }
+}
+
+#[derive(PartialEq, Debug, Clone)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct NormalImportSpec<T> {
+    pub alias: Option<Ident<T>>,
+    pub imported: Ident<T>,
+}
+
+impl<T> IntoAllocated for NormalImportSpec<T>
+where
+    T: ToString,
+{
+    type Allocated = NormalImportSpec<String>;
+
+    fn into_allocated(self) -> Self::Allocated {
+        NormalImportSpec {
+            alias: self.alias.map(|i| i.into_allocated()),
+            imported: self.imported.into_allocated(),
+        }
+    }
+}
+
+/// Something exported from this module
+#[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub enum ModExport<T> {
+    /// ```js
+    /// export default function() {};
+    /// //or
+    /// export default 1;
+    /// ```
+    Default(DefaultExportDecl<T>),
+    ///```js
+    /// export {foo} from 'mod';
+    /// //or
+    /// export {foo as bar} from 'mod';
+    /// //or
+    /// export var foo = 1;
+    /// //or
+    /// export function bar() {
+    /// }
+    /// ```
+    Named(NamedExportDecl<T>),
+    /// ```js
+    /// export * from 'mod';
+    /// ```
+    All {
+        alias: Option<Ident<T>>,
+        name: Lit<T>,
+    },
+}
+
+impl<T> IntoAllocated for ModExport<T>
+where
+    T: ToString,
+{
+    type Allocated = ModExport<String>;
+
+    fn into_allocated(self) -> Self::Allocated {
+        match self {
+            ModExport::Default(inner) => ModExport::Default(inner.into_allocated()),
+            ModExport::Named(inner) => ModExport::Named(inner.into_allocated()),
+            ModExport::All { alias, name } => ModExport::All {
+                alias: alias.map(|i| i.into_allocated()),
+                name: name.into_allocated(),
+            },
+        }
+    }
+}
+
+/// An export that has a name
+/// ```js
+/// export function thing() {}
+/// export {stuff} from 'place';
+#[derive(PartialEq, Debug, Clone)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub enum NamedExportDecl<T> {
+    Decl(Decl<T>),
+    Specifier(Vec<ExportSpecifier<T>>, Option<Lit<T>>),
+}
+
+impl<T> IntoAllocated for NamedExportDecl<T>
+where
+    T: ToString,
+{
+    type Allocated = NamedExportDecl<String>;
+
+    fn into_allocated(self) -> Self::Allocated {
+        match self {
+            NamedExportDecl::Decl(inner) => NamedExportDecl::Decl(inner.into_allocated()),
+            NamedExportDecl::Specifier(specs, lit) => NamedExportDecl::Specifier(
+                specs.into_iter().map(|s| s.into_allocated()).collect(),
+                lit.map(|l| l.into_allocated()),
+            ),
+        }
+    }
+}
+
+/// A default export
+/// ```js
+/// export default class Thing {}
+/// ```
+#[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub enum DefaultExportDecl<T> {
+    Decl(Decl<T>),
+    Expr(Expr<T>),
+}
+
+impl<T> IntoAllocated for DefaultExportDecl<T>
+where
+    T: ToString,
+{
+    type Allocated = DefaultExportDecl<String>;
+
+    fn into_allocated(self) -> Self::Allocated {
+        match self {
+            DefaultExportDecl::Decl(inner) => DefaultExportDecl::Decl(inner.into_allocated()),
+            DefaultExportDecl::Expr(inner) => DefaultExportDecl::Expr(inner.into_allocated()),
+        }
+    }
+}
+
+/// The name of the thing being exported
+/// this might include an alias
+/// ```js
+/// //no-alias
+/// export {Thing} from 'place';
+/// //aliased
+/// export {Stuff as NewThing} from 'place'
+/// ```
+#[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct ExportSpecifier<T> {
+    pub local: Ident<T>,
+    pub alias: Option<Ident<T>>,
+}
+
+impl<T> IntoAllocated for ExportSpecifier<T>
+where
+    T: ToString,
+{
+    type Allocated = ExportSpecifier<String>;
+
+    fn into_allocated(self) -> Self::Allocated {
+        ExportSpecifier {
+            local: self.local.into_allocated(),
+            alias: self.alias.map(|a| a.into_allocated()),
+        }
+    }
+}
diff --git a/src/expr.rs b/src/expr.rs
index ae34a5f..5a9f69b 100644
--- a/src/expr.rs
+++ b/src/expr.rs
@@ -1,16 +1,13 @@
 use crate::pat::Pat;
-use crate::{AssignOp, BinaryOp, LogicalOp, PropKind, UnaryOp, UpdateOp, IntoAllocated};
+use crate::{AssignOp, BinaryOp, IntoAllocated, LogicalOp, PropKind, UnaryOp, UpdateOp};
 use crate::{Class, Func, FuncArg, FuncBody, Ident};
 
 #[cfg(feature = "serde")]
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 
 /// A slightly more granular program part that a statement
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum Expr<T> {
     /// `[0,,]`
     Array(ArrayExpr<T>),
@@ -94,14 +91,25 @@ pub enum Expr<T> {
     Yield(YieldExpr<T>),
 }
 
-impl<T> IntoAllocated for Expr<T> where T: ToString {
+impl<T> IntoAllocated for Expr<T>
+where
+    T: ToString,
+{
     type Allocated = Expr<String>;
 
     fn into_allocated(self) -> Self::Allocated {
         match self {
-            Expr::Array(inner) => Expr::Array(inner.into_iter().map(|o| o.map(|e| e.into_allocated())).collect()),
+            Expr::Array(inner) => Expr::Array(
+                inner
+                    .into_iter()
+                    .map(|o| o.map(|e| e.into_allocated()))
+                    .collect(),
+            ),
             Expr::ArrowFunc(inner) => Expr::ArrowFunc(inner.into_allocated()),
-            Expr::ArrowParamPlaceHolder(args, is_async) => Expr::ArrowParamPlaceHolder(args.into_iter().map(|a| a.into_allocated()).collect(), is_async),
+            Expr::ArrowParamPlaceHolder(args, is_async) => Expr::ArrowParamPlaceHolder(
+                args.into_iter().map(|a| a.into_allocated()).collect(),
+                is_async,
+            ),
             Expr::Assign(inner) => Expr::Assign(inner.into_allocated()),
             Expr::Await(inner) => Expr::Await(inner.into_allocated()),
             Expr::Binary(inner) => Expr::Binary(inner.into_allocated()),
@@ -116,7 +124,9 @@ impl<T> IntoAllocated for Expr<T> where T: ToString {
             Expr::MetaProp(inner) => Expr::MetaProp(inner.into_allocated()),
             Expr::New(inner) => Expr::New(inner.into_allocated()),
             Expr::Obj(inner) => Expr::Obj(inner.into_iter().map(|p| p.into_allocated()).collect()),
-            Expr::Sequence(inner) => Expr::Sequence(inner.into_iter().map(|e| e.into_allocated()).collect()),
+            Expr::Sequence(inner) => {
+                Expr::Sequence(inner.into_iter().map(|e| e.into_allocated()).collect())
+            }
             Expr::Spread(inner) => Expr::Spread(inner.into_allocated()),
             Expr::Super => Expr::Super,
             Expr::TaggedTemplate(inner) => Expr::TaggedTemplate(inner.into_allocated()),
@@ -140,15 +150,16 @@ pub type ArrayExpr<T> = Vec<Option<Expr<T>>>;
 pub type ObjExpr<T> = Vec<ObjProp<T>>;
 /// A single part of an object literal
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub enum ObjProp<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub enum ObjProp<T> {
     Prop(Prop<T>),
     Spread(Expr<T>),
 }
 
-impl<T> IntoAllocated for ObjProp<T> where T: ToString {
+impl<T> IntoAllocated for ObjProp<T>
+where
+    T: ToString,
+{
     type Allocated = ObjProp<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -161,10 +172,7 @@ impl<T> IntoAllocated for ObjProp<T> where T: ToString {
 
 /// A single part of an object literal or class
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct Prop<T> {
     pub key: PropKey<T>,
     pub value: PropValue<T>,
@@ -175,7 +183,10 @@ pub struct Prop<T> {
     pub is_static: bool,
 }
 
-impl<T> IntoAllocated for Prop<T> where T: ToString {
+impl<T> IntoAllocated for Prop<T>
+where
+    T: ToString,
+{
     type Allocated = Prop<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -193,16 +204,17 @@ impl<T> IntoAllocated for Prop<T> where T: ToString {
 
 /// An object literal or class property identifier
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub enum PropKey<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub enum PropKey<T> {
     Lit(Lit<T>),
     Expr(Expr<T>),
     Pat(Pat<T>),
 }
 
-impl<T> IntoAllocated for PropKey<T> where T: ToString {
+impl<T> IntoAllocated for PropKey<T>
+where
+    T: ToString,
+{
     type Allocated = PropKey<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -216,17 +228,17 @@ impl<T> IntoAllocated for PropKey<T> where T: ToString {
 
 /// The value of an object literal or class property
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum PropValue<T> {
     Expr(Expr<T>),
     Pat(Pat<T>),
     None,
 }
 
-impl<T> IntoAllocated for PropValue<T> where T: ToString {
+impl<T> IntoAllocated for PropValue<T>
+where
+    T: ToString,
+{
     type Allocated = PropValue<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -240,16 +252,17 @@ impl<T> IntoAllocated for PropValue<T> where T: ToString {
 
 /// An operation that takes one argument
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub struct UnaryExpr<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct UnaryExpr<T> {
     pub operator: UnaryOp,
     pub prefix: bool,
     pub argument: Box<Expr<T>>,
 }
 
-impl<T> IntoAllocated for UnaryExpr<T> where T: ToString {
+impl<T> IntoAllocated for UnaryExpr<T>
+where
+    T: ToString,
+{
     type Allocated = UnaryExpr<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -263,16 +276,17 @@ impl<T> IntoAllocated for UnaryExpr<T> where T: ToString {
 
 /// Increment or decrementing a value
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub struct UpdateExpr<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct UpdateExpr<T> {
     pub operator: UpdateOp,
     pub argument: Box<Expr<T>>,
     pub prefix: bool,
 }
 
-impl<T> IntoAllocated for UpdateExpr<T> where T: ToString {
+impl<T> IntoAllocated for UpdateExpr<T>
+where
+    T: ToString,
+{
     type Allocated = UpdateExpr<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -286,16 +300,17 @@ impl<T> IntoAllocated for UpdateExpr<T> where T: ToString {
 
 /// An operation that requires 2 arguments
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub struct BinaryExpr<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct BinaryExpr<T> {
     pub operator: BinaryOp,
     pub left: Box<Expr<T>>,
     pub right: Box<Expr<T>>,
 }
 
-impl<T> IntoAllocated for BinaryExpr<T> where T: ToString {
+impl<T> IntoAllocated for BinaryExpr<T>
+where
+    T: ToString,
+{
     type Allocated = BinaryExpr<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -309,16 +324,17 @@ impl<T> IntoAllocated for BinaryExpr<T> where T: ToString {
 
 /// An assignment or update + assignment operation
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub struct AssignExpr<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct AssignExpr<T> {
     pub operator: AssignOp,
     pub left: AssignLeft<T>,
     pub right: Box<Expr<T>>,
 }
 
-impl<T> IntoAllocated for AssignExpr<T> where T: ToString {
+impl<T> IntoAllocated for AssignExpr<T>
+where
+    T: ToString,
+{
     type Allocated = AssignExpr<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -332,15 +348,16 @@ impl<T> IntoAllocated for AssignExpr<T> where T: ToString {
 
 /// The value being assigned to
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub enum AssignLeft<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub enum AssignLeft<T> {
     Pat(Pat<T>),
     Expr(Box<Expr<T>>),
 }
 
-impl<T> IntoAllocated for AssignLeft<T> where T: ToString {
+impl<T> IntoAllocated for AssignLeft<T>
+where
+    T: ToString,
+{
     type Allocated = AssignLeft<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -357,16 +374,17 @@ impl<T> IntoAllocated for AssignLeft<T> where T: ToString {
 /// false || true
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub struct LogicalExpr<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct LogicalExpr<T> {
     pub operator: LogicalOp,
     pub left: Box<Expr<T>>,
     pub right: Box<Expr<T>>,
 }
 
-impl<T> IntoAllocated for LogicalExpr<T> where T: ToString {
+impl<T> IntoAllocated for LogicalExpr<T>
+where
+    T: ToString,
+{
     type Allocated = LogicalExpr<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -384,16 +402,17 @@ impl<T> IntoAllocated for LogicalExpr<T> where T: ToString {
 /// c.stuff;
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub struct MemberExpr<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct MemberExpr<T> {
     pub object: Box<Expr<T>>,
     pub property: Box<Expr<T>>,
     pub computed: bool,
 }
 
-impl<T> IntoAllocated for MemberExpr<T> where T: ToString {
+impl<T> IntoAllocated for MemberExpr<T>
+where
+    T: ToString,
+{
     type Allocated = MemberExpr<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -410,16 +429,17 @@ impl<T> IntoAllocated for MemberExpr<T> where T: ToString {
 /// var a = true ? 'stuff' : 'things';
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub struct ConditionalExpr<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct ConditionalExpr<T> {
     pub test: Box<Expr<T>>,
     pub alternate: Box<Expr<T>>,
     pub consequent: Box<Expr<T>>,
 }
 
-impl<T> IntoAllocated for ConditionalExpr<T> where T: ToString {
+impl<T> IntoAllocated for ConditionalExpr<T>
+where
+    T: ToString,
+{
     type Allocated = ConditionalExpr<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -436,21 +456,26 @@ impl<T> IntoAllocated for ConditionalExpr<T> where T: ToString {
 /// Math.random()
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub struct CallExpr<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct CallExpr<T> {
     pub callee: Box<Expr<T>>,
     pub arguments: Vec<Expr<T>>,
 }
 
-impl<T> IntoAllocated for CallExpr<T> where T: ToString {
+impl<T> IntoAllocated for CallExpr<T>
+where
+    T: ToString,
+{
     type Allocated = CallExpr<String>;
 
     fn into_allocated(self) -> Self::Allocated {
         CallExpr {
             callee: self.callee.into_allocated(),
-            arguments: self.arguments.into_iter().map(IntoAllocated::into_allocated).collect(),
+            arguments: self
+                .arguments
+                .into_iter()
+                .map(IntoAllocated::into_allocated)
+                .collect(),
         }
     }
 }
@@ -460,21 +485,26 @@ impl<T> IntoAllocated for CallExpr<T> where T: ToString {
 /// new Uint8Array(32);
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub struct NewExpr<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct NewExpr<T> {
     pub callee: Box<Expr<T>>,
     pub arguments: Vec<Expr<T>>,
 }
 
-impl<T> IntoAllocated for NewExpr<T> where T: ToString {
+impl<T> IntoAllocated for NewExpr<T>
+where
+    T: ToString,
+{
     type Allocated = NewExpr<String>;
 
     fn into_allocated(self) -> Self::Allocated {
         NewExpr {
             callee: self.callee.into_allocated(),
-            arguments: self.arguments.into_iter().map(|a| a.into_allocated()).collect(),
+            arguments: self
+                .arguments
+                .into_iter()
+                .map(|a| a.into_allocated())
+                .collect(),
         }
     }
 }
@@ -490,10 +520,8 @@ pub type SequenceExpr<T> = Vec<Expr<T>>;
 /// }
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub struct ArrowFuncExpr<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct ArrowFuncExpr<T> {
     pub id: Option<Ident<T>>,
     pub params: Vec<FuncArg<T>>,
     pub body: ArrowFuncBody<T>,
@@ -502,13 +530,20 @@ pub type SequenceExpr<T> = Vec<Expr<T>>;
     pub is_async: bool,
 }
 
-impl<T> IntoAllocated for ArrowFuncExpr<T> where T: ToString {
+impl<T> IntoAllocated for ArrowFuncExpr<T>
+where
+    T: ToString,
+{
     type Allocated = ArrowFuncExpr<String>;
 
     fn into_allocated(self) -> Self::Allocated {
         ArrowFuncExpr {
             id: self.id.map(|i| i.into_allocated()),
-            params: self.params.into_iter().map(|p| p.into_allocated()).collect(),
+            params: self
+                .params
+                .into_iter()
+                .map(|p| p.into_allocated())
+                .collect(),
             body: self.body.into_allocated(),
             expression: self.expression,
             generator: self.generator,
@@ -519,15 +554,16 @@ impl<T> IntoAllocated for ArrowFuncExpr<T> where T: ToString {
 
 /// The body portion of an arrow function can be either an expression or a block of statements
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub enum ArrowFuncBody<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub enum ArrowFuncBody<T> {
     FuncBody(FuncBody<T>),
     Expr(Box<Expr<T>>),
 }
 
-impl<T> IntoAllocated for ArrowFuncBody<T> where T: ToString {
+impl<T> IntoAllocated for ArrowFuncBody<T>
+where
+    T: ToString,
+{
     type Allocated = ArrowFuncBody<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -547,15 +583,16 @@ impl<T> IntoAllocated for ArrowFuncBody<T> where T: ToString {
 /// }
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub struct YieldExpr<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct YieldExpr<T> {
     pub argument: Option<Box<Expr<T>>>,
     pub delegate: bool,
 }
 
-impl<T> IntoAllocated for YieldExpr<T> where T: ToString {
+impl<T> IntoAllocated for YieldExpr<T>
+where
+    T: ToString,
+{
     type Allocated = YieldExpr<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -568,15 +605,16 @@ impl<T> IntoAllocated for YieldExpr<T> where T: ToString {
 /// A Template literal preceded by a function identifier
 /// see [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#Tagged_templates) for more details
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub struct TaggedTemplateExpr<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct TaggedTemplateExpr<T> {
     pub tag: Box<Expr<T>>,
     pub quasi: TemplateLit<T>,
 }
 
-impl<T> IntoAllocated for TaggedTemplateExpr<T> where T: ToString {
+impl<T> IntoAllocated for TaggedTemplateExpr<T>
+where
+    T: ToString,
+{
     type Allocated = TaggedTemplateExpr<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -592,31 +630,36 @@ impl<T> IntoAllocated for TaggedTemplateExpr<T> where T: ToString {
 /// `I own ${0} birds`;
 /// ```
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct TemplateLit<T> {
     pub quasis: Vec<TemplateElement<T>>,
     pub expressions: Vec<Expr<T>>,
 }
 
-impl<T> IntoAllocated for TemplateLit<T> where T: ToString {
+impl<T> IntoAllocated for TemplateLit<T>
+where
+    T: ToString,
+{
     type Allocated = TemplateLit<String>;
 
     fn into_allocated(self) -> Self::Allocated {
         TemplateLit {
-            quasis: self.quasis.into_iter().map(|e| e.into_allocated()).collect(),
-            expressions: self.expressions.into_iter().map(|e| e.into_allocated()).collect(),
+            quasis: self
+                .quasis
+                .into_iter()
+                .map(|e| e.into_allocated())
+                .collect(),
+            expressions: self
+                .expressions
+                .into_iter()
+                .map(|e| e.into_allocated())
+                .collect(),
         }
     }
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum QuasiQuote {
     /// `
     BackTick,
@@ -628,10 +671,7 @@ pub enum QuasiQuote {
 
 /// The text part of a `TemplateLiteral`
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct TemplateElement<T> {
     pub open_quote: QuasiQuote,
     /// The non-quoted version
@@ -639,7 +679,10 @@ pub struct TemplateElement<T> {
     pub close_quote: QuasiQuote,
 }
 
-impl<T> IntoAllocated for TemplateElement<T> where T: ToString {
+impl<T> IntoAllocated for TemplateElement<T>
+where
+    T: ToString,
+{
     type Allocated = TemplateElement<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -671,15 +714,16 @@ impl<T> TemplateElement<T> {
 /// }
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub struct MetaProp<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct MetaProp<T> {
     pub meta: Ident<T>,
     pub property: Ident<T>,
 }
 
-impl<T> IntoAllocated for MetaProp<T> where T: ToString {
+impl<T> IntoAllocated for MetaProp<T>
+where
+    T: ToString,
+{
     type Allocated = MetaProp<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -692,10 +736,7 @@ impl<T> IntoAllocated for MetaProp<T> where T: ToString {
 
 /// A literal value
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum Lit<T> {
     /// `null`
     Null,
@@ -722,7 +763,10 @@ pub enum Lit<T> {
     Template(TemplateLit<T>),
 }
 
-impl<T> IntoAllocated for Lit<T> where T: ToString {
+impl<T> IntoAllocated for Lit<T>
+where
+    T: ToString,
+{
     type Allocated = Lit<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -750,15 +794,16 @@ impl<T> Lit<T> {
 }
 
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub enum StringLit<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub enum StringLit<T> {
     Double(T),
     Single(T),
 }
 
-impl<T> IntoAllocated for StringLit<T> where T: ToString {
+impl<T> IntoAllocated for StringLit<T>
+where
+    T: ToString,
+{
     type Allocated = StringLit<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -802,22 +847,22 @@ where
 }
 /// A regular expression literal
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct RegEx<T> {
     pub pattern: T,
     pub flags: Option<T>,
 }
 
-impl<T> IntoAllocated for RegEx<T> where T: ToString {
+impl<T> IntoAllocated for RegEx<T>
+where
+    T: ToString,
+{
     type Allocated = RegEx<String>;
 
     fn into_allocated(self) -> Self::Allocated {
         RegEx {
             pattern: self.pattern.to_string(),
-            flags: self.flags.map(|f| f.to_string())
+            flags: self.flags.map(|f| f.to_string()),
         }
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index 8bc9ace..0908e4a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -5,7 +5,7 @@ pub mod spanned;
 pub mod stmt;
 
 #[cfg(feature = "serde")]
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 
 use std::{borrow::Cow, fmt::Debug};
 
@@ -15,15 +15,15 @@ use pat::Pat;
 use stmt::Stmt;
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct Ident<T> {
     pub name: T,
 }
 
-impl<T> IntoAllocated for Ident<T> where T: ToString {
+impl<T> IntoAllocated for Ident<T>
+where
+    T: ToString,
+{
     type Allocated = Ident<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -57,10 +57,7 @@ impl<'a> From<Cow<'a, str>> for Ident<Cow<'a, str>> {
 /// with a flag denoting if the representation is
 /// a ES6 Mod or a Script.
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum Program<T> {
     /// An ES6 Mod
     Mod(Vec<ProgramPart<T>>),
@@ -68,13 +65,20 @@ pub enum Program<T> {
     Script(Vec<ProgramPart<T>>),
 }
 
-impl<T> IntoAllocated for Program<T> where T: ToString  {
+impl<T> IntoAllocated for Program<T>
+where
+    T: ToString,
+{
     type Allocated = Program<String>;
 
     fn into_allocated(self) -> Self::Allocated {
         match self {
-            Program::Mod(inner) => Program::Mod(inner.into_iter().map(|p| p.into_allocated()).collect()),
-            Program::Script(inner) => Program::Script(inner.into_iter().map(|p| p.into_allocated()).collect()),
+            Program::Mod(inner) => {
+                Program::Mod(inner.into_iter().map(|p| p.into_allocated()).collect())
+            }
+            Program::Script(inner) => {
+                Program::Script(inner.into_iter().map(|p| p.into_allocated()).collect())
+            }
         }
     }
 }
@@ -91,10 +95,7 @@ impl<T> Program<T> {
 /// A single part of a Javascript program.
 /// This will be either a Directive, Decl or a Stmt
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum ProgramPart<T> {
     /// A Directive like `'use strict';`
     Dir(Dir<T>),
@@ -104,7 +105,10 @@ pub enum ProgramPart<T> {
     Stmt(Stmt<T>),
 }
 
-impl<T> IntoAllocated for ProgramPart<T> where T: ToString {
+impl<T> IntoAllocated for ProgramPart<T>
+where
+    T: ToString,
+{
     type Allocated = ProgramPart<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -128,16 +132,16 @@ impl<T> ProgramPart<T> {
 /// pretty much always `'use strict'`, this can appear at the
 /// top of a file or function
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct Dir<T> {
     pub expr: Lit<T>,
     pub dir: T,
 }
 
-impl<T> IntoAllocated for Dir<T> where T: ToString {
+impl<T> IntoAllocated for Dir<T>
+where
+    T: ToString,
+{
     type Allocated = Dir<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -159,10 +163,7 @@ impl<T> IntoAllocated for Dir<T> where T: ToString {
 /// let y = function q() {}
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct Func<T> {
     pub id: Option<Ident<T>>,
     pub params: Vec<FuncArg<T>>,
@@ -171,13 +172,20 @@ pub struct Func<T> {
     pub is_async: bool,
 }
 
-impl<T> IntoAllocated for Func<T> where T: ToString {
+impl<T> IntoAllocated for Func<T>
+where
+    T: ToString,
+{
     type Allocated = Func<String>;
 
     fn into_allocated(self) -> Self::Allocated {
         Func {
             id: self.id.map(IntoAllocated::into_allocated),
-            params: self.params.into_iter().map(|p| p.into_allocated()).collect(),
+            params: self
+                .params
+                .into_iter()
+                .map(|p| p.into_allocated())
+                .collect(),
             body: self.body.into_allocated(),
             generator: self.generator,
             is_async: self.is_async,
@@ -205,16 +213,16 @@ impl<T> Func<T> {
 
 /// A single function argument from a function signature
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum FuncArg<T> {
     Expr(Expr<T>),
     Pat(Pat<T>),
 }
 
-impl<T> IntoAllocated for FuncArg<T> where T: ToString {
+impl<T> IntoAllocated for FuncArg<T>
+where
+    T: ToString,
+{
     type Allocated = FuncArg<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -236,13 +244,13 @@ impl<T> FuncArg<T> {
 
 /// The block statement that makes up the function's body
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct FuncBody<T>(pub Vec<ProgramPart<T>>);
 
-impl<T> IntoAllocated for FuncBody<T> where T: ToString {
+impl<T> IntoAllocated for FuncBody<T>
+where
+    T: ToString,
+{
     type Allocated = FuncBody<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -277,17 +285,17 @@ impl<T> IntoAllocated for FuncBody<T> where T: ToString {
 /// }
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct Class<T> {
     pub id: Option<Ident<T>>,
     pub super_class: Option<Box<Expr<T>>>,
     pub body: ClassBody<T>,
 }
 
-impl<T> IntoAllocated for Class<T> where T: ToString {
+impl<T> IntoAllocated for Class<T>
+where
+    T: ToString,
+{
     type Allocated = Class<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -300,17 +308,22 @@ impl<T> IntoAllocated for Class<T> where T: ToString {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct ClassBody<T>(pub Vec<Prop<T>>);
 
-impl<T> IntoAllocated for ClassBody<T> where T: ToString {
+impl<T> IntoAllocated for ClassBody<T>
+where
+    T: ToString,
+{
     type Allocated = ClassBody<String>;
 
     fn into_allocated(self) -> Self::Allocated {
-        ClassBody(self.0.into_iter().map(IntoAllocated::into_allocated).collect())
+        ClassBody(
+            self.0
+                .into_iter()
+                .map(IntoAllocated::into_allocated)
+                .collect(),
+        )
     }
 }
 
@@ -326,10 +339,7 @@ impl<T> Class<T> {
 
 /// The kind of variable being defined (`var`/`let`/`const`)
 #[derive(Debug, Clone, PartialEq, Copy)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 #[cfg_attr(
     all(feature = "serde", feature = "esprima"),
     serde(rename_all = "camelCase", untagged)
@@ -342,10 +352,7 @@ pub enum VarKind {
 
 /// The available operators for assignment Exprs
 #[derive(Debug, Clone, PartialEq, Copy)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum AssignOp {
     Equal,
     PlusEqual,
@@ -364,10 +371,7 @@ pub enum AssignOp {
 
 /// The available logical operators
 #[derive(Debug, Clone, PartialEq, Copy)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum LogicalOp {
     Or,
     And,
@@ -375,10 +379,7 @@ pub enum LogicalOp {
 
 /// The available operations for `Binary` Exprs
 #[derive(Debug, Clone, PartialEq, Copy)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum BinaryOp {
     Equal,
     NotEqual,
@@ -406,10 +407,7 @@ pub enum BinaryOp {
 
 /// `++` or `--`
 #[derive(Debug, Clone, PartialEq, Copy)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum UpdateOp {
     Increment,
     Decrement,
@@ -418,10 +416,7 @@ pub enum UpdateOp {
 /// The allowed operators for an Expr
 /// to be `Unary`
 #[derive(Debug, Clone, PartialEq, Copy)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum UnaryOp {
     Minus,
     Plus,
@@ -434,10 +429,7 @@ pub enum UnaryOp {
 
 /// A flag for determining what kind of property
 #[derive(Debug, Clone, PartialEq, Copy)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum PropKind {
     /// A property with a value
     Init,
@@ -457,7 +449,10 @@ pub trait IntoAllocated {
     fn into_allocated(self) -> Self::Allocated;
 }
 
-impl<T> IntoAllocated for Box<T> where T: IntoAllocated {
+impl<T> IntoAllocated for Box<T>
+where
+    T: IntoAllocated,
+{
     type Allocated = Box<T::Allocated>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -465,7 +460,10 @@ impl<T> IntoAllocated for Box<T> where T: IntoAllocated {
     }
 }
 
-impl<T> IntoAllocated for Option<T> where T: IntoAllocated {
+impl<T> IntoAllocated for Option<T>
+where
+    T: IntoAllocated,
+{
     type Allocated = Option<T::Allocated>;
     fn into_allocated(self) -> Self::Allocated {
         self.map(IntoAllocated::into_allocated)
diff --git a/src/pat.rs b/src/pat.rs
index a62d5dc..f7bce99 100644
--- a/src/pat.rs
+++ b/src/pat.rs
@@ -2,15 +2,12 @@ use crate::expr::{Expr, Prop};
 use crate::{Ident, IntoAllocated};
 
 #[cfg(feature = "serde")]
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 
 /// All of the different ways you can declare an identifier
 /// and/or value
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum Pat<T> {
     Ident(Ident<T>),
     Obj(ObjPat<T>),
@@ -19,14 +16,22 @@ pub enum Pat<T> {
     Assign(AssignPat<T>),
 }
 
-impl<T> IntoAllocated for Pat<T> where T: ToString {
+impl<T> IntoAllocated for Pat<T>
+where
+    T: ToString,
+{
     type Allocated = Pat<String>;
 
     fn into_allocated(self) -> Self::Allocated {
         match self {
             Pat::Ident(inner) => Pat::Ident(inner.into_allocated()),
             Pat::Obj(inner) => Pat::Obj(inner.into_iter().map(|a| a.into_allocated()).collect()),
-            Pat::Array(inner) => Pat::Array(inner.into_iter().map(|o| o.map(|a| a.into_allocated())).collect()),
+            Pat::Array(inner) => Pat::Array(
+                inner
+                    .into_iter()
+                    .map(|o| o.map(|a| a.into_allocated()))
+                    .collect(),
+            ),
             Pat::RestElement(inner) => Pat::RestElement(inner.into_allocated()),
             Pat::Assign(inner) => Pat::Assign(inner.into_allocated()),
         }
@@ -40,15 +45,16 @@ impl<T> Pat<T> {
 }
 
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub enum ArrayPatPart<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub enum ArrayPatPart<T> {
     Pat(Pat<T>),
     Expr(Expr<T>),
 }
 
-impl<T> IntoAllocated for ArrayPatPart<T> where T: ToString {
+impl<T> IntoAllocated for ArrayPatPart<T>
+where
+    T: ToString,
+{
     type Allocated = ArrayPatPart<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -63,15 +69,16 @@ impl<T> IntoAllocated for ArrayPatPart<T> where T: ToString {
 pub type ObjPat<T> = Vec<ObjPatPart<T>>;
 /// A single part of an ObjectPat
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub enum ObjPatPart<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub enum ObjPatPart<T> {
     Assign(Prop<T>),
     Rest(Box<Pat<T>>),
 }
 
-impl<T> IntoAllocated for ObjPatPart<T> where T: ToString {
+impl<T> IntoAllocated for ObjPatPart<T>
+where
+    T: ToString,
+{
     type Allocated = ObjPatPart<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -84,16 +91,16 @@ impl<T> IntoAllocated for ObjPatPart<T> where T: ToString {
 
 /// An assignment as a pattern
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct AssignPat<T> {
     pub left: Box<Pat<T>>,
     pub right: Box<Expr<T>>,
 }
 
-impl<T> IntoAllocated for AssignPat<T> where T: ToString {
+impl<T> IntoAllocated for AssignPat<T>
+where
+    T: ToString,
+{
     type Allocated = AssignPat<String>;
 
     fn into_allocated(self) -> Self::Allocated {
diff --git a/src/spanned/convert.rs b/src/spanned/convert.rs
index 76d3409..2be8578 100644
--- a/src/spanned/convert.rs
+++ b/src/spanned/convert.rs
@@ -156,7 +156,7 @@ mod decl {
         fn from(other: ExportSpecifier<T>) -> Self {
             let local: crate::Ident<T> = other.local.into();
             Self {
-                local: local,
+                local,
                 alias: other.alias.map(|a| a.ident.into()),
             }
         }
@@ -361,12 +361,11 @@ mod expr {
 
     impl<T> From<UpdateExpr<T>> for crate::expr::UpdateExpr<T> {
         fn from(other: UpdateExpr<T>) -> Self {
-            let ret = Self {
+            Self {
                 prefix: other.prefix(),
                 operator: other.operator.into(),
                 argument: Box::new(From::from(*other.argument)),
-            };
-            ret
+            }
         }
     }
 
diff --git a/src/spanned/decl.rs b/src/spanned/decl.rs
index 616f185..d358f42 100644
--- a/src/spanned/decl.rs
+++ b/src/spanned/decl.rs
@@ -1,8 +1,8 @@
-use crate::IntoAllocated;
 use crate::spanned::expr::{Expr, Lit};
 use crate::spanned::pat::Pat;
 use crate::spanned::VarKind;
 use crate::spanned::{Class, Func, Ident};
+use crate::IntoAllocated;
 
 use super::tokens::{
     As, Asterisk, CloseBrace, Default, Equal, Export, From, Import, OpenBrace, Semicolon, Token,
@@ -10,14 +10,11 @@ use super::tokens::{
 use super::{ListEntry, Node, SourceLocation};
 
 #[cfg(feature = "serde")]
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 
 /// The declaration of a variable, function, class, import or export
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum Decl<T> {
     /// A variable declaration
     /// ```js
@@ -58,7 +55,6 @@ pub enum Decl<T> {
     },
 }
 
-
 impl<T> IntoAllocated for Decl<T>
 where
     T: ToString,
@@ -68,12 +64,18 @@ where
         match self {
             Decl::Var { decls, semi_colon } => Decl::Var {
                 decls: decls.into_allocated(),
-                semi_colon: semi_colon,
+                semi_colon,
             },
             Decl::Func(f) => Decl::Func(f.into_allocated()),
             Decl::Class(c) => Decl::Class(c.into_allocated()),
-            Decl::Import { import, semi_colon } => Decl::Import { import: import.into_allocated(), semi_colon },
-            Decl::Export { export, semi_colon } => Decl::Export { export: export.into_allocated(), semi_colon },
+            Decl::Import { import, semi_colon } => Decl::Import {
+                import: import.into_allocated(),
+                semi_colon,
+            },
+            Decl::Export { export, semi_colon } => Decl::Export {
+                export: export.into_allocated(),
+                semi_colon,
+            },
         }
     }
 }
@@ -115,16 +117,12 @@ impl<T> Node for Decl<T> {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct VarDecls<T> {
     pub keyword: VarKind,
     pub decls: Vec<ListEntry<VarDecl<T>>>,
 }
 
-
 impl<T> IntoAllocated for VarDecls<T>
 where
     T: ToString,
@@ -153,17 +151,13 @@ impl<T> Node for VarDecls<T> {
 
 /// The identifier and optional value of a variable declaration
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct VarDecl<T> {
     pub id: Pat<T>,
     pub eq: Option<Equal>,
     pub init: Option<Expr<T>>,
 }
 
-
 impl<T> IntoAllocated for VarDecl<T>
 where
     T: ToString,
@@ -195,16 +189,16 @@ impl<T> Node for VarDecl<T> {
 /// in an ES Mod, it would be either an import or
 /// export at the top level
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum ModDecl<T> {
     Import(ModImport<T>),
     Export(ModExport<T>),
 }
 
-impl<T> IntoAllocated for ModDecl<T> where T: ToString {
+impl<T> IntoAllocated for ModDecl<T>
+where
+    T: ToString,
+{
     type Allocated = ModDecl<String>;
     fn into_allocated(self) -> ModDecl<String> {
         match self {
@@ -230,10 +224,7 @@ impl<T> Node for ModDecl<T> {
 /// import {Thing} from './stuff.js';
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct ModImport<T> {
     pub keyword_import: Import,
     pub specifiers: Vec<ListEntry<ImportSpecifier<T>>>,
@@ -241,10 +232,22 @@ pub struct ModImport<T> {
     pub source: Lit<T>,
 }
 
-impl<T> IntoAllocated for ModImport<T> where T: ToString {
+impl<T> IntoAllocated for ModImport<T>
+where
+    T: ToString,
+{
     type Allocated = ModImport<String>;
     fn into_allocated(self) -> ModImport<String> {
-        ModImport { keyword_import:self.keyword_import, specifiers: self.specifiers.into_iter().map(|s| s.into_allocated()).collect(), keyword_from: self.keyword_from, source: self.source.into_allocated() }
+        ModImport {
+            keyword_import: self.keyword_import,
+            specifiers: self
+                .specifiers
+                .into_iter()
+                .map(|s| s.into_allocated())
+                .collect(),
+            keyword_from: self.keyword_from,
+            source: self.source.into_allocated(),
+        }
     }
 }
 
@@ -259,10 +262,7 @@ impl<T> Node for ModImport<T> {
 
 /// The name of the thing being imported
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum ImportSpecifier<T> {
     /// A specifier in curly braces, this might
     /// have a local alias
@@ -290,7 +290,10 @@ pub enum ImportSpecifier<T> {
     Namespace(NamespaceImportSpec<T>),
 }
 
-impl<T> IntoAllocated for ImportSpecifier<T> where T: ToString {
+impl<T> IntoAllocated for ImportSpecifier<T>
+where
+    T: ToString,
+{
     type Allocated = ImportSpecifier<String>;
     fn into_allocated(self) -> ImportSpecifier<String> {
         match self {
@@ -312,17 +315,17 @@ impl<T> Node for ImportSpecifier<T> {
 }
 
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct NormalImportSpecs<T> {
     pub open_brace: OpenBrace,
     pub specs: Vec<ListEntry<NormalImportSpec<T>>>,
     pub close_brace: CloseBrace,
 }
 
-impl<T> IntoAllocated for NormalImportSpecs<T> where T: ToString {
+impl<T> IntoAllocated for NormalImportSpecs<T>
+where
+    T: ToString,
+{
     type Allocated = NormalImportSpecs<String>;
     fn into_allocated(self) -> NormalImportSpecs<String> {
         NormalImportSpecs {
@@ -343,19 +346,22 @@ impl<T> Node for NormalImportSpecs<T> {
 }
 
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct NormalImportSpec<T> {
     pub imported: Ident<T>,
     pub alias: Option<Alias<T>>,
 }
 
-impl<T> IntoAllocated for NormalImportSpec<T> where T: ToString {
+impl<T> IntoAllocated for NormalImportSpec<T>
+where
+    T: ToString,
+{
     type Allocated = NormalImportSpec<String>;
     fn into_allocated(self) -> NormalImportSpec<String> {
-        NormalImportSpec { imported: self.imported.into_allocated(), alias: self.alias.map(|a| a.into_allocated()) }
+        NormalImportSpec {
+            imported: self.imported.into_allocated(),
+            alias: self.alias.map(|a| a.into_allocated()),
+        }
     }
 }
 
@@ -373,18 +379,20 @@ impl<T> Node for NormalImportSpec<T> {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct DefaultImportSpec<T> {
     pub id: Ident<T>,
 }
 
-impl<T> IntoAllocated for DefaultImportSpec<T> where T: ToString {
+impl<T> IntoAllocated for DefaultImportSpec<T>
+where
+    T: ToString,
+{
     type Allocated = DefaultImportSpec<String>;
     fn into_allocated(self) -> DefaultImportSpec<String> {
-        DefaultImportSpec { id: self.id.into_allocated() }
+        DefaultImportSpec {
+            id: self.id.into_allocated(),
+        }
     }
 }
 
@@ -395,17 +403,17 @@ impl<T> Node for DefaultImportSpec<T> {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct NamespaceImportSpec<T> {
     pub star: Asterisk,
     pub keyword: As,
     pub ident: Ident<T>,
 }
 
-impl<T> IntoAllocated for NamespaceImportSpec<T> where T: ToString {
+impl<T> IntoAllocated for NamespaceImportSpec<T>
+where
+    T: ToString,
+{
     type Allocated = NamespaceImportSpec<String>;
     fn into_allocated(self) -> NamespaceImportSpec<String> {
         NamespaceImportSpec {
@@ -426,19 +434,22 @@ impl<T> Node for NamespaceImportSpec<T> {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct ModExport<T> {
     pub keyword: Export,
     pub spec: ModExportSpecifier<T>,
 }
 
-impl<T> IntoAllocated for ModExport<T> where T: ToString {
+impl<T> IntoAllocated for ModExport<T>
+where
+    T: ToString,
+{
     type Allocated = ModExport<String>;
     fn into_allocated(self) -> ModExport<String> {
-        ModExport { keyword: self.keyword, spec: self.spec.into_allocated() }
+        ModExport {
+            keyword: self.keyword,
+            spec: self.spec.into_allocated(),
+        }
     }
 }
 
@@ -453,10 +464,7 @@ impl<T> Node for ModExport<T> {
 
 /// Something exported from this module
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum ModExportSpecifier<T> {
     /// ```js
     /// export default function() {};
@@ -489,13 +497,29 @@ pub enum ModExportSpecifier<T> {
     },
 }
 
-impl<T> IntoAllocated for ModExportSpecifier<T> where T: ToString {
+impl<T> IntoAllocated for ModExportSpecifier<T>
+where
+    T: ToString,
+{
     type Allocated = ModExportSpecifier<String>;
     fn into_allocated(self) -> ModExportSpecifier<String> {
         match self {
-            ModExportSpecifier::Default { keyword, value } => ModExportSpecifier::Default {keyword, value: value.into_allocated()},
+            ModExportSpecifier::Default { keyword, value } => ModExportSpecifier::Default {
+                keyword,
+                value: value.into_allocated(),
+            },
             ModExportSpecifier::Named(inner) => ModExportSpecifier::Named(inner.into_allocated()),
-            ModExportSpecifier::All { star, alias, keyword, name } => ModExportSpecifier::All { star, alias: alias.map(|a| a.into_allocated()), keyword: keyword, name: name.into_allocated()},
+            ModExportSpecifier::All {
+                star,
+                alias,
+                keyword,
+                name,
+            } => ModExportSpecifier::All {
+                star,
+                alias: alias.map(|a| a.into_allocated()),
+                keyword,
+                name: name.into_allocated(),
+            },
         }
     }
 }
@@ -521,16 +545,16 @@ impl<T> Node for ModExportSpecifier<T> {
 /// export function thing() {}
 /// export {stuff} from 'place';
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum NamedExportDecl<T> {
     Decl(Decl<T>),
     Specifier(NamedExportSpec<T>),
 }
 
-impl<T> IntoAllocated for NamedExportDecl<T> where T: ToString {
+impl<T> IntoAllocated for NamedExportDecl<T>
+where
+    T: ToString,
+{
     type Allocated = NamedExportDecl<String>;
     fn into_allocated(self) -> NamedExportDecl<String> {
         match self {
@@ -550,16 +574,16 @@ impl<T> Node for NamedExportDecl<T> {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct DefaultExportDecl<T> {
     pub keyword: Default,
     pub value: DefaultExportDeclValue<T>,
 }
 
-impl<T> IntoAllocated for DefaultExportDecl<T> where T: ToString {
+impl<T> IntoAllocated for DefaultExportDecl<T>
+where
+    T: ToString,
+{
     type Allocated = DefaultExportDecl<String>;
     fn into_allocated(self) -> DefaultExportDecl<String> {
         DefaultExportDecl {
@@ -583,17 +607,17 @@ impl<T> Node for DefaultExportDecl<T> {
 /// export default class Thing {}
 /// ```
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum ExportDeclValue<T> {
     Decl(Decl<T>),
     Expr(Expr<T>),
     List(ExportList<T>),
 }
 
-impl<T> IntoAllocated for ExportDeclValue<T> where T: ToString {
+impl<T> IntoAllocated for ExportDeclValue<T>
+where
+    T: ToString,
+{
     type Allocated = ExportDeclValue<String>;
     fn into_allocated(self) -> ExportDeclValue<String> {
         match self {
@@ -615,21 +639,25 @@ impl<T> Node for ExportDeclValue<T> {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum DefaultExportDeclValue<T> {
     Decl(Decl<T>),
     Expr(Expr<T>),
 }
 
-impl<T> IntoAllocated for DefaultExportDeclValue<T> where T: ToString {
+impl<T> IntoAllocated for DefaultExportDeclValue<T>
+where
+    T: ToString,
+{
     type Allocated = DefaultExportDeclValue<String>;
     fn into_allocated(self) -> DefaultExportDeclValue<String> {
         match self {
-            DefaultExportDeclValue::Decl(inner) => DefaultExportDeclValue::Decl(inner.into_allocated()),
-            DefaultExportDeclValue::Expr(inner) => DefaultExportDeclValue::Expr(inner.into_allocated()),
+            DefaultExportDeclValue::Decl(inner) => {
+                DefaultExportDeclValue::Decl(inner.into_allocated())
+            }
+            DefaultExportDeclValue::Expr(inner) => {
+                DefaultExportDeclValue::Expr(inner.into_allocated())
+            }
         }
     }
 }
@@ -644,16 +672,16 @@ impl<T> Node for DefaultExportDeclValue<T> {
 }
 
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct NamedExportSpec<T> {
     pub list: ExportList<T>,
     pub source: Option<NamedExportSource<T>>,
 }
 
-impl<T> IntoAllocated for NamedExportSpec<T> where T: ToString {
+impl<T> IntoAllocated for NamedExportSpec<T>
+where
+    T: ToString,
+{
     type Allocated = NamedExportSpec<String>;
     fn into_allocated(self) -> NamedExportSpec<String> {
         NamedExportSpec {
@@ -677,16 +705,16 @@ impl<T> Node for NamedExportSpec<T> {
 }
 
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct NamedExportSource<T> {
     pub keyword_from: From,
     pub module: Lit<T>,
 }
 
-impl<T> IntoAllocated for NamedExportSource<T> where T: ToString {
+impl<T> IntoAllocated for NamedExportSource<T>
+where
+    T: ToString,
+{
     type Allocated = NamedExportSource<String>;
     fn into_allocated(self) -> NamedExportSource<String> {
         NamedExportSource {
@@ -706,20 +734,28 @@ impl<T> Node for NamedExportSource<T> {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct ExportList<T> {
     pub open_brace: OpenBrace,
     pub elements: Vec<ListEntry<ExportSpecifier<T>>>,
     pub close_brace: CloseBrace,
 }
 
-impl<T> IntoAllocated for ExportList<T> where T: ToString {
+impl<T> IntoAllocated for ExportList<T>
+where
+    T: ToString,
+{
     type Allocated = ExportList<String>;
     fn into_allocated(self) -> ExportList<String> {
-        ExportList { open_brace: self.open_brace, elements: self.elements.into_iter().map(|e| e.into_allocated()).collect(), close_brace: self.close_brace }
+        ExportList {
+            open_brace: self.open_brace,
+            elements: self
+                .elements
+                .into_iter()
+                .map(|e| e.into_allocated())
+                .collect(),
+            close_brace: self.close_brace,
+        }
     }
 }
 
@@ -741,16 +777,16 @@ impl<T> Node for ExportList<T> {
 /// export {Stuff as NewThing} from 'place'
 /// ```
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct ExportSpecifier<T> {
     pub local: Ident<T>,
     pub alias: Option<Alias<T>>,
 }
 
-impl<T> IntoAllocated for ExportSpecifier<T> where T: ToString {
+impl<T> IntoAllocated for ExportSpecifier<T>
+where
+    T: ToString,
+{
     type Allocated = ExportSpecifier<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -775,16 +811,16 @@ impl<T> Node for ExportSpecifier<T> {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct Alias<T> {
     pub keyword: As,
     pub ident: Ident<T>,
 }
 
-impl<T> IntoAllocated for Alias<T> where T: ToString {
+impl<T> IntoAllocated for Alias<T>
+where
+    T: ToString,
+{
     type Allocated = Alias<String>;
 
     fn into_allocated(self) -> Self::Allocated {
diff --git a/src/spanned/expr.rs b/src/spanned/expr.rs
index 67f113f..ba3cb33 100644
--- a/src/spanned/expr.rs
+++ b/src/spanned/expr.rs
@@ -1,6 +1,6 @@
-use crate::IntoAllocated;
 use crate::spanned::pat::Pat;
 use crate::spanned::{Class, Func, FuncArg, FuncBody, Ident};
+use crate::IntoAllocated;
 
 use super::tokens::{
     AssignOp, Asterisk, Async, Await, BinaryOp, CloseBrace, CloseBracket, CloseParen, Colon, Comma,
@@ -10,14 +10,11 @@ use super::tokens::{
 };
 use super::{FuncArgEntry, ListEntry, Node, Slice, SourceLocation};
 #[cfg(feature = "serde")]
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 
 /// A slightly more granular program part that a statement
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum Expr<T> {
     /// `[0,,]`
     Array(ArrayExpr<T>),
@@ -102,13 +99,18 @@ pub enum Expr<T> {
     Yield(YieldExpr<T>),
 }
 
-impl<T> IntoAllocated for Expr<T> where T: ToString {
+impl<T> IntoAllocated for Expr<T>
+where
+    T: ToString,
+{
     type Allocated = Expr<String>;
     fn into_allocated(self) -> Self::Allocated {
         match self {
             Expr::Array(inner) => Expr::Array(inner.into_allocated()),
             Expr::ArrowFunc(inner) => Expr::ArrowFunc(inner.into_allocated()),
-            Expr::ArrowParamPlaceHolder(inner) => Expr::ArrowParamPlaceHolder(inner.into_allocated()),
+            Expr::ArrowParamPlaceHolder(inner) => {
+                Expr::ArrowParamPlaceHolder(inner.into_allocated())
+            }
             Expr::Assign(inner) => Expr::Assign(inner.into_allocated()),
             Expr::Await(inner) => Expr::Await(inner.into_allocated()),
             Expr::Binary(inner) => Expr::Binary(inner.into_allocated()),
@@ -123,7 +125,12 @@ impl<T> IntoAllocated for Expr<T> where T: ToString {
             Expr::MetaProp(inner) => Expr::MetaProp(inner.into_allocated()),
             Expr::New(inner) => Expr::New(inner.into_allocated()),
             Expr::Obj(inner) => Expr::Obj(inner.into_allocated()),
-            Expr::Sequence(inner) => Expr::Sequence(inner.into_iter().map(IntoAllocated::into_allocated).collect()),
+            Expr::Sequence(inner) => Expr::Sequence(
+                inner
+                    .into_iter()
+                    .map(IntoAllocated::into_allocated)
+                    .collect(),
+            ),
             Expr::Spread(inner) => Expr::Spread(inner.into_allocated()),
             Expr::Super(inner) => Expr::Super(inner),
             Expr::TaggedTemplate(inner) => Expr::TaggedTemplate(inner.into_allocated()),
@@ -173,22 +180,26 @@ type ArrayExprEntry<T> = ListEntry<Option<Expr<T>>>;
 
 /// `[a, b, c]`
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct ArrayExpr<T> {
     pub open_bracket: OpenBracket,
     pub elements: Vec<ArrayExprEntry<T>>,
     pub close_bracket: CloseBracket,
 }
 
-impl<T> IntoAllocated for ArrayExpr<T> where T: ToString {
+impl<T> IntoAllocated for ArrayExpr<T>
+where
+    T: ToString,
+{
     type Allocated = ArrayExpr<String>;
     fn into_allocated(self) -> Self::Allocated {
         ArrayExpr {
             open_bracket: self.open_bracket,
-            elements: self.elements.into_iter().map(IntoAllocated::into_allocated).collect(),
+            elements: self
+                .elements
+                .into_iter()
+                .map(IntoAllocated::into_allocated)
+                .collect(),
             close_bracket: self.close_bracket,
         }
     }
@@ -205,23 +216,27 @@ impl<T> Node for ArrayExpr<T> {
 
 /// `{a: 'b', c, ...d}`
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct ObjExpr<T> {
     pub open_brace: OpenBrace,
     pub props: Vec<ListEntry<ObjProp<T>>>,
     pub close_brace: CloseBrace,
 }
 
-impl<T> IntoAllocated for ObjExpr<T> where T: ToString {
+impl<T> IntoAllocated for ObjExpr<T>
+where
+    T: ToString,
+{
     type Allocated = ObjExpr<String>;
 
     fn into_allocated(self) -> Self::Allocated {
         ObjExpr {
             open_brace: self.open_brace,
-            props: self.props.into_iter().map(IntoAllocated::into_allocated).collect(),
+            props: self
+                .props
+                .into_iter()
+                .map(IntoAllocated::into_allocated)
+                .collect(),
             close_brace: self.close_brace,
         }
     }
@@ -238,16 +253,16 @@ impl<T> Node for ObjExpr<T> {
 
 /// A single part of an object literal
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum ObjProp<T> {
     Prop(Prop<T>),
     Spread(SpreadExpr<T>),
 }
 
-impl<T> IntoAllocated for ObjProp<T> where T: ToString {
+impl<T> IntoAllocated for ObjProp<T>
+where
+    T: ToString,
+{
     type Allocated = ObjProp<String>;
     fn into_allocated(self) -> Self::Allocated {
         match self {
@@ -267,16 +282,16 @@ impl<T> Node for ObjProp<T> {
 }
 
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct SpreadExpr<T> {
     pub dots: Ellipsis,
     pub expr: Expr<T>,
 }
 
-impl<T> IntoAllocated for SpreadExpr<T> where T: ToString {
+impl<T> IntoAllocated for SpreadExpr<T>
+where
+    T: ToString,
+{
     type Allocated = SpreadExpr<String>;
     fn into_allocated(self) -> Self::Allocated {
         SpreadExpr {
@@ -296,10 +311,7 @@ impl<T> Node for SpreadExpr<T> {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum Prop<T> {
     Init(PropInit<T>),
     Method(PropMethod<T>),
@@ -308,7 +320,10 @@ pub enum Prop<T> {
     Set(PropSet<T>),
 }
 
-impl<T> IntoAllocated for Prop<T> where T: ToString {
+impl<T> IntoAllocated for Prop<T>
+where
+    T: ToString,
+{
     type Allocated = Prop<String>;
     fn into_allocated(self) -> Self::Allocated {
         match self {
@@ -358,23 +373,23 @@ impl<T> Prop<T> {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct PropInit<T> {
     pub key: PropInitKey<T>,
     pub colon: Option<Colon>,
     pub value: Option<PropValue<T>>,
 }
 
-impl<T> IntoAllocated for PropInit<T> where T: ToString {
+impl<T> IntoAllocated for PropInit<T>
+where
+    T: ToString,
+{
     type Allocated = PropInit<String>;
     fn into_allocated(self) -> Self::Allocated {
         PropInit {
             key: self.key.into_allocated(),
             colon: self.colon,
-            value: self.value.into_allocated()
+            value: self.value.into_allocated(),
         }
     }
 }
@@ -402,16 +417,16 @@ impl<T> PropInit<T> {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct PropInitKey<T> {
     pub value: PropKey<T>,
     pub brackets: Option<(OpenBracket, CloseBracket)>,
 }
 
-impl<T> IntoAllocated for PropInitKey<T> where T: ToString {
+impl<T> IntoAllocated for PropInitKey<T>
+where
+    T: ToString,
+{
     type Allocated = PropInitKey<String>;
     fn into_allocated(self) -> Self::Allocated {
         PropInitKey {
@@ -435,10 +450,7 @@ impl<T> Node for PropInitKey<T> {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct PropMethod<T> {
     pub keyword_static: Option<Static>,
     pub keyword_async: Option<Async>,
@@ -450,7 +462,10 @@ pub struct PropMethod<T> {
     pub body: FuncBody<T>,
 }
 
-impl<T> IntoAllocated for PropMethod<T> where T: ToString {
+impl<T> IntoAllocated for PropMethod<T>
+where
+    T: ToString,
+{
     type Allocated = PropMethod<String>;
     fn into_allocated(self) -> Self::Allocated {
         PropMethod {
@@ -459,7 +474,11 @@ impl<T> IntoAllocated for PropMethod<T> where T: ToString {
             id: self.id.into_allocated(),
             star: self.star,
             open_paren: self.open_paren,
-            params: self.params.into_iter().map(IntoAllocated::into_allocated).collect(),
+            params: self
+                .params
+                .into_iter()
+                .map(IntoAllocated::into_allocated)
+                .collect(),
             close_paren: self.close_paren,
             body: self.body.into_allocated(),
         }
@@ -483,10 +502,7 @@ impl<T> Node for PropMethod<T> {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct PropCtor<T> {
     pub keyword: PropInitKey<T>,
     pub open_paren: OpenParen,
@@ -495,13 +511,20 @@ pub struct PropCtor<T> {
     pub body: FuncBody<T>,
 }
 
-impl<T> IntoAllocated for PropCtor<T> where T: ToString {
+impl<T> IntoAllocated for PropCtor<T>
+where
+    T: ToString,
+{
     type Allocated = PropCtor<String>;
     fn into_allocated(self) -> Self::Allocated {
         PropCtor {
             keyword: self.keyword.into_allocated(),
             open_paren: self.open_paren,
-            params: self.params.into_iter().map(IntoAllocated::into_allocated).collect(),
+            params: self
+                .params
+                .into_iter()
+                .map(IntoAllocated::into_allocated)
+                .collect(),
             close_paren: self.close_paren,
             body: self.body.into_allocated(),
         }
@@ -518,10 +541,7 @@ impl<T> Node for PropCtor<T> {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct PropGet<T> {
     pub keyword_static: Option<Static>,
     pub keyword_get: Get,
@@ -531,7 +551,10 @@ pub struct PropGet<T> {
     pub body: FuncBody<T>,
 }
 
-impl<T> IntoAllocated for PropGet<T> where T: ToString {
+impl<T> IntoAllocated for PropGet<T>
+where
+    T: ToString,
+{
     type Allocated = PropGet<String>;
     fn into_allocated(self) -> Self::Allocated {
         PropGet {
@@ -561,10 +584,7 @@ impl<T> Node for PropGet<T> {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct PropSet<T> {
     pub keyword_static: Option<Static>,
     pub keyword_set: Set,
@@ -575,7 +595,10 @@ pub struct PropSet<T> {
     pub body: FuncBody<T>,
 }
 
-impl<T> IntoAllocated for PropSet<T> where T: ToString {
+impl<T> IntoAllocated for PropSet<T>
+where
+    T: ToString,
+{
     type Allocated = PropSet<String>;
     fn into_allocated(self) -> Self::Allocated {
         PropSet {
@@ -607,17 +630,17 @@ impl<T> Node for PropSet<T> {
 
 /// An object literal or class property identifier
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum PropKey<T> {
     Lit(Lit<T>),
     Expr(Expr<T>),
     Pat(Pat<T>),
 }
 
-impl<T> IntoAllocated for PropKey<T> where T: ToString {
+impl<T> IntoAllocated for PropKey<T>
+where
+    T: ToString,
+{
     type Allocated = PropKey<String>;
     fn into_allocated(self) -> Self::Allocated {
         match self {
@@ -640,17 +663,17 @@ impl<T> Node for PropKey<T> {
 
 /// The value of an object literal or class property
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum PropValue<T> {
     Expr(Expr<T>),
     Pat(Pat<T>),
     Method(PropMethod<T>),
 }
 
-impl<T> IntoAllocated for PropValue<T> where T: ToString {
+impl<T> IntoAllocated for PropValue<T>
+where
+    T: ToString,
+{
     type Allocated = PropValue<String>;
     fn into_allocated(self) -> Self::Allocated {
         match self {
@@ -673,16 +696,16 @@ impl<T> Node for PropValue<T> {
 
 /// An operation that takes one argument
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct UnaryExpr<T> {
     pub operator: UnaryOp,
     pub argument: Box<Expr<T>>,
 }
 
-impl<T> IntoAllocated for UnaryExpr<T> where T: ToString {
+impl<T> IntoAllocated for UnaryExpr<T>
+where
+    T: ToString,
+{
     type Allocated = UnaryExpr<String>;
     fn into_allocated(self) -> Self::Allocated {
         UnaryExpr {
@@ -711,16 +734,16 @@ impl<T> Node for UnaryExpr<T> {
 
 /// Increment or decrementing a value
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct UpdateExpr<T> {
     pub operator: UpdateOp,
     pub argument: Box<Expr<T>>,
 }
 
-impl<T> IntoAllocated for UpdateExpr<T> where T: ToString {
+impl<T> IntoAllocated for UpdateExpr<T>
+where
+    T: ToString,
+{
     type Allocated = UpdateExpr<String>;
     fn into_allocated(self) -> Self::Allocated {
         UpdateExpr {
@@ -756,17 +779,17 @@ impl<T> Node for UpdateExpr<T> {
 
 /// An operation that requires 2 arguments
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct BinaryExpr<T> {
     pub operator: BinaryOp,
     pub left: Box<Expr<T>>,
     pub right: Box<Expr<T>>,
 }
 
-impl<T> IntoAllocated for BinaryExpr<T> where T: ToString {
+impl<T> IntoAllocated for BinaryExpr<T>
+where
+    T: ToString,
+{
     type Allocated = BinaryExpr<String>;
     fn into_allocated(self) -> Self::Allocated {
         BinaryExpr {
@@ -788,17 +811,17 @@ impl<T> Node for BinaryExpr<T> {
 
 /// An assignment or update + assignment operation
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct AssignExpr<T> {
     pub operator: AssignOp,
     pub left: AssignLeft<T>,
     pub right: Box<Expr<T>>,
 }
 
-impl<T> IntoAllocated for AssignExpr<T> where T: ToString {
+impl<T> IntoAllocated for AssignExpr<T>
+where
+    T: ToString,
+{
     type Allocated = AssignExpr<String>;
     fn into_allocated(self) -> Self::Allocated {
         AssignExpr {
@@ -819,16 +842,16 @@ impl<T> Node for AssignExpr<T> {
 }
 
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct AwaitExpr<T> {
     pub keyword: Await,
     pub expr: Expr<T>,
 }
 
-impl<T> IntoAllocated for AwaitExpr<T> where T: ToString {
+impl<T> IntoAllocated for AwaitExpr<T>
+where
+    T: ToString,
+{
     type Allocated = AwaitExpr<String>;
     fn into_allocated(self) -> Self::Allocated {
         AwaitExpr {
@@ -849,16 +872,16 @@ impl<T> Node for AwaitExpr<T> {
 
 /// The value being assigned to
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum AssignLeft<T> {
     Pat(Pat<T>),
     Expr(Box<Expr<T>>),
 }
 
-impl<T> IntoAllocated for AssignLeft<T> where T: ToString {
+impl<T> IntoAllocated for AssignLeft<T>
+where
+    T: ToString,
+{
     type Allocated = AssignLeft<String>;
     fn into_allocated(self) -> Self::Allocated {
         match self {
@@ -883,17 +906,17 @@ impl<T> Node for AssignLeft<T> {
 /// false || true
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct LogicalExpr<T> {
     pub operator: LogicalOp,
     pub left: Box<Expr<T>>,
     pub right: Box<Expr<T>>,
 }
 
-impl<T> IntoAllocated for LogicalExpr<T> where T: ToString {
+impl<T> IntoAllocated for LogicalExpr<T>
+where
+    T: ToString,
+{
     type Allocated = LogicalExpr<String>;
     fn into_allocated(self) -> Self::Allocated {
         LogicalExpr {
@@ -919,24 +942,24 @@ impl<T> Node for LogicalExpr<T> {
 /// c.stuff;
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct MemberExpr<T> {
     pub object: Box<Expr<T>>,
     pub property: Box<Expr<T>>,
     pub indexer: MemberIndexer,
 }
 
-impl<T> IntoAllocated for MemberExpr<T> where T: ToString {
+impl<T> IntoAllocated for MemberExpr<T>
+where
+    T: ToString,
+{
     type Allocated = MemberExpr<String>;
 
     fn into_allocated(self) -> Self::Allocated {
         MemberExpr {
             object: self.object.into_allocated(),
             property: self.property.into_allocated(),
-            indexer: self.indexer
+            indexer: self.indexer,
         }
     }
 }
@@ -961,10 +984,7 @@ impl<T> Node for MemberExpr<T> {
 }
 
 #[derive(PartialEq, Debug, Clone, Copy)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum MemberIndexer {
     Period(Period),
     Computed {
@@ -993,10 +1013,7 @@ impl Node for MemberIndexer {
 /// var a = true ? 'stuff' : 'things';
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct ConditionalExpr<T> {
     pub test: Box<Expr<T>>,
     pub question_mark: QuestionMark,
@@ -1005,7 +1022,10 @@ pub struct ConditionalExpr<T> {
     pub consequent: Box<Expr<T>>,
 }
 
-impl<T> IntoAllocated for ConditionalExpr<T> where T: ToString {
+impl<T> IntoAllocated for ConditionalExpr<T>
+where
+    T: ToString,
+{
     type Allocated = ConditionalExpr<String>;
     fn into_allocated(self) -> Self::Allocated {
         ConditionalExpr {
@@ -1031,10 +1051,7 @@ impl<T> Node for ConditionalExpr<T> {
 /// Math.random()
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct CallExpr<T> {
     pub callee: Box<Expr<T>>,
     pub open_paren: OpenParen,
@@ -1042,14 +1059,21 @@ pub struct CallExpr<T> {
     pub close_paren: CloseParen,
 }
 
-impl<T> IntoAllocated for CallExpr<T> where T: ToString {
+impl<T> IntoAllocated for CallExpr<T>
+where
+    T: ToString,
+{
     type Allocated = CallExpr<String>;
 
     fn into_allocated(self) -> Self::Allocated {
         CallExpr {
             callee: self.callee.into_allocated(),
             open_paren: self.open_paren,
-            arguments: self.arguments.into_iter().map(IntoAllocated::into_allocated).collect(),
+            arguments: self
+                .arguments
+                .into_iter()
+                .map(IntoAllocated::into_allocated)
+                .collect(),
             close_paren: self.close_paren,
         }
     }
@@ -1069,10 +1093,7 @@ impl<T> Node for CallExpr<T> {
 /// new Uint8Array(32);
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct NewExpr<T> {
     pub keyword: New,
     pub callee: Box<Expr<T>>,
@@ -1081,7 +1102,10 @@ pub struct NewExpr<T> {
     pub close_paren: Option<CloseParen>,
 }
 
-impl<T> IntoAllocated for NewExpr<T> where T: ToString {
+impl<T> IntoAllocated for NewExpr<T>
+where
+    T: ToString,
+{
     type Allocated = NewExpr<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -1089,7 +1113,11 @@ impl<T> IntoAllocated for NewExpr<T> where T: ToString {
             keyword: self.keyword,
             callee: self.callee.into_allocated(),
             open_paren: self.open_paren,
-            arguments: self.arguments.into_iter().map(IntoAllocated::into_allocated).collect(),
+            arguments: self
+                .arguments
+                .into_iter()
+                .map(IntoAllocated::into_allocated)
+                .collect(),
             close_paren: self.close_paren,
         }
     }
@@ -1106,7 +1134,7 @@ impl<T> Node for NewExpr<T> {
         };
         SourceLocation {
             start: self.keyword.start(),
-            end: end,
+            end,
         }
     }
 }
@@ -1134,10 +1162,7 @@ impl<T> Node for SequenceExpr<T> {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct ArrowParamPlaceHolder<T> {
     // async keyword
     pub keyword: Option<Async>,
@@ -1146,13 +1171,20 @@ pub struct ArrowParamPlaceHolder<T> {
     pub close_paren: Option<CloseParen>,
 }
 
-impl<T> IntoAllocated for ArrowParamPlaceHolder<T> where T: ToString {
+impl<T> IntoAllocated for ArrowParamPlaceHolder<T>
+where
+    T: ToString,
+{
     type Allocated = ArrowParamPlaceHolder<String>;
     fn into_allocated(self) -> Self::Allocated {
         ArrowParamPlaceHolder {
             keyword: self.keyword,
             open_paren: self.open_paren,
-            args: self.args.into_iter().map(IntoAllocated::into_allocated).collect(),
+            args: self
+                .args
+                .into_iter()
+                .map(IntoAllocated::into_allocated)
+                .collect(),
             close_paren: self.close_paren,
         }
     }
@@ -1188,10 +1220,7 @@ impl<T> Node for ArrowParamPlaceHolder<T> {
 /// }
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct ArrowFuncExpr<T> {
     pub keyword: Option<Async>,
     pub star: Option<Asterisk>,
@@ -1202,17 +1231,24 @@ pub struct ArrowFuncExpr<T> {
     pub body: ArrowFuncBody<T>,
 }
 
-impl<T> IntoAllocated for ArrowFuncExpr<T> where T: ToString {
+impl<T> IntoAllocated for ArrowFuncExpr<T>
+where
+    T: ToString,
+{
     type Allocated = ArrowFuncExpr<String>;
     fn into_allocated(self) -> Self::Allocated {
         ArrowFuncExpr {
             keyword: self.keyword,
             star: self.star,
             open_paren: self.open_paren,
-            params: self.params.into_iter().map(IntoAllocated::into_allocated).collect(),
+            params: self
+                .params
+                .into_iter()
+                .map(IntoAllocated::into_allocated)
+                .collect(),
             close_paren: self.close_paren,
             arrow: self.arrow,
-            body: self.body.into_allocated()
+            body: self.body.into_allocated(),
         }
     }
 }
@@ -1237,16 +1273,16 @@ impl<T> Node for ArrowFuncExpr<T> {
 
 /// The body portion of an arrow function can be either an expression or a block of statements
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum ArrowFuncBody<T> {
     FuncBody(FuncBody<T>),
     Expr(Box<Expr<T>>),
 }
 
-impl<T> IntoAllocated for ArrowFuncBody<T> where T: ToString {
+impl<T> IntoAllocated for ArrowFuncBody<T>
+where
+    T: ToString,
+{
     type Allocated = ArrowFuncBody<String>;
     fn into_allocated(self) -> Self::Allocated {
         match self {
@@ -1274,17 +1310,17 @@ impl<T> Node for ArrowFuncBody<T> {
 /// }
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct YieldExpr<T> {
     pub keyword: Yield,
     pub argument: Option<Box<Expr<T>>>,
     pub star: Option<Asterisk>,
 }
 
-impl<T> IntoAllocated for YieldExpr<T> where T: ToString {
+impl<T> IntoAllocated for YieldExpr<T>
+where
+    T: ToString,
+{
     type Allocated = YieldExpr<String>;
     fn into_allocated(self) -> Self::Allocated {
         YieldExpr {
@@ -1312,16 +1348,16 @@ impl<T> Node for YieldExpr<T> {
 /// A Template literal preceded by a function identifier
 /// see [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#Tagged_templates) for more details
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct TaggedTemplateExpr<T> {
     pub tag: Box<Expr<T>>,
     pub quasi: TemplateLit<T>,
 }
 
-impl<T> IntoAllocated for TaggedTemplateExpr<T> where T: ToString {
+impl<T> IntoAllocated for TaggedTemplateExpr<T>
+where
+    T: ToString,
+{
     type Allocated = TaggedTemplateExpr<String>;
     fn into_allocated(self) -> Self::Allocated {
         TaggedTemplateExpr {
@@ -1345,26 +1381,33 @@ impl<T> Node for TaggedTemplateExpr<T> {
 /// `I own ${0} birds`;
 /// ```
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct TemplateLit<T> {
     pub quasis: Vec<TemplateElement<T>>,
     pub expressions: Vec<Expr<T>>,
 }
 
-impl<T> IntoAllocated for TemplateLit<T> where T: ToString {
+impl<T> IntoAllocated for TemplateLit<T>
+where
+    T: ToString,
+{
     type Allocated = TemplateLit<String>;
     fn into_allocated(self) -> Self::Allocated {
         TemplateLit {
-            quasis: self.quasis.into_iter().map(IntoAllocated::into_allocated).collect(),
-            expressions: self.expressions.into_iter().map(IntoAllocated::into_allocated).collect(),
+            quasis: self
+                .quasis
+                .into_iter()
+                .map(IntoAllocated::into_allocated)
+                .collect(),
+            expressions: self
+                .expressions
+                .into_iter()
+                .map(IntoAllocated::into_allocated)
+                .collect(),
         }
     }
 }
 
-
 impl<T> Node for TemplateLit<T> {
     fn loc(&self) -> SourceLocation {
         let start = self
@@ -1386,17 +1429,17 @@ impl<T> Node for TemplateLit<T> {
 
 /// The text part of a `TemplateLiteral`
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct TemplateElement<T> {
     pub open_quote: QuasiQuote,
     pub content: Slice<T>,
     pub close_quote: QuasiQuote,
 }
 
-impl<T> IntoAllocated for TemplateElement<T> where T: ToString {
+impl<T> IntoAllocated for TemplateElement<T>
+where
+    T: ToString,
+{
     type Allocated = TemplateElement<String>;
     fn into_allocated(self) -> Self::Allocated {
         TemplateElement {
@@ -1439,17 +1482,17 @@ impl<T> Node for TemplateElement<T> {
 /// }
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct MetaProp<T> {
     pub meta: Ident<T>,
     pub dot: Period,
     pub property: Ident<T>,
 }
 
-impl<T> IntoAllocated for MetaProp<T> where T: ToString {
+impl<T> IntoAllocated for MetaProp<T>
+where
+    T: ToString,
+{
     type Allocated = MetaProp<String>;
     fn into_allocated(self) -> Self::Allocated {
         MetaProp {
@@ -1471,10 +1514,7 @@ impl<T> Node for MetaProp<T> {
 
 /// A literal value
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum Lit<T> {
     /// `null`
     Null(Null),
@@ -1501,7 +1541,10 @@ pub enum Lit<T> {
     Template(TemplateLit<T>),
 }
 
-impl<T> IntoAllocated for Lit<T> where T: ToString {
+impl<T> IntoAllocated for Lit<T>
+where
+    T: ToString,
+{
     type Allocated = Lit<String>;
     fn into_allocated(self) -> Self::Allocated {
         match self {
@@ -1526,10 +1569,7 @@ impl<T> Lit<T> {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum Boolean {
     True(True),
     False(False),
@@ -1582,17 +1622,17 @@ impl<T> Node for Lit<T> {
 }
 
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct StringLit<T> {
     pub open_quote: Quote,
     pub content: Slice<T>,
     pub close_quote: Quote,
 }
 
-impl<T> IntoAllocated for StringLit<T> where T: ToString {
+impl<T> IntoAllocated for StringLit<T>
+where
+    T: ToString,
+{
     type Allocated = StringLit<String>;
     fn into_allocated(self) -> Self::Allocated {
         StringLit {
@@ -1614,10 +1654,7 @@ impl<T> Node for StringLit<T> {
 
 /// A regular expression literal
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct RegEx<T> {
     pub open_slash: ForwardSlash,
     pub pattern: Slice<T>,
@@ -1625,7 +1662,10 @@ pub struct RegEx<T> {
     pub flags: Option<Slice<T>>,
 }
 
-impl<T> IntoAllocated for RegEx<T> where T: ToString {
+impl<T> IntoAllocated for RegEx<T>
+where
+    T: ToString,
+{
     type Allocated = RegEx<String>;
     fn into_allocated(self) -> Self::Allocated {
         RegEx {
@@ -1652,17 +1692,17 @@ impl<T> Node for RegEx<T> {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct WrappedExpr<T> {
     pub open_paren: OpenParen,
     pub expr: Expr<T>,
     pub close_paren: CloseParen,
 }
 
-impl<T> IntoAllocated for WrappedExpr<T> where T: ToString {
+impl<T> IntoAllocated for WrappedExpr<T>
+where
+    T: ToString,
+{
     type Allocated = WrappedExpr<String>;
     fn into_allocated(self) -> Self::Allocated {
         WrappedExpr {
@@ -1683,16 +1723,16 @@ impl<T> Node for WrappedExpr<T> {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct SequenceExprEntry<T> {
     pub expr: Expr<T>,
     pub comma: Option<Comma>,
 }
 
-impl<T> IntoAllocated for SequenceExprEntry<T> where T: ToString {
+impl<T> IntoAllocated for SequenceExprEntry<T>
+where
+    T: ToString,
+{
     type Allocated = SequenceExprEntry<String>;
     fn into_allocated(self) -> Self::Allocated {
         SequenceExprEntry {
diff --git a/src/spanned/mod.rs b/src/spanned/mod.rs
index 3052860..d65e13a 100644
--- a/src/spanned/mod.rs
+++ b/src/spanned/mod.rs
@@ -13,7 +13,7 @@ use stmt::Stmt;
 use crate::IntoAllocated;
 
 #[cfg(feature = "serde")]
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 
 use self::{
     pat::RestPat,
@@ -28,10 +28,7 @@ pub trait Node {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct Ident<T> {
     pub slice: Slice<T>,
 }
@@ -46,7 +43,6 @@ where
     }
 }
 
-
 impl<T> IntoAllocated for Ident<T>
 where
     T: ToString,
@@ -83,10 +79,7 @@ impl<T> Ident<T> {
 /// with a flag denoting if the representation is
 /// a ES6 Mod or a Script.
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum Program<T> {
     /// An ES6 Mod
     Mod(Vec<ProgramPart<T>>),
@@ -94,12 +87,25 @@ pub enum Program<T> {
     Script(Vec<ProgramPart<T>>),
 }
 
-impl<T> IntoAllocated for Program<T> where T: ToString {
+impl<T> IntoAllocated for Program<T>
+where
+    T: ToString,
+{
     type Allocated = Program<String>;
     fn into_allocated(self) -> Program<String> {
         match self {
-            Program::Mod(parts) => Program::Mod(parts.into_iter().map(IntoAllocated::into_allocated).collect()),
-            Program::Script(parts) => Program::Script(parts.into_iter().map(IntoAllocated::into_allocated).collect()),
+            Program::Mod(parts) => Program::Mod(
+                parts
+                    .into_iter()
+                    .map(IntoAllocated::into_allocated)
+                    .collect(),
+            ),
+            Program::Script(parts) => Program::Script(
+                parts
+                    .into_iter()
+                    .map(IntoAllocated::into_allocated)
+                    .collect(),
+            ),
         }
     }
 }
@@ -139,10 +145,7 @@ impl<T> Node for Vec<ProgramPart<T>> {
 /// A single part of a Javascript program.
 /// This will be either a Directive, Decl or a Stmt
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum ProgramPart<T> {
     /// A Directive like `'use strict';`
     Dir(Dir<T>),
@@ -152,7 +155,10 @@ pub enum ProgramPart<T> {
     Stmt(Stmt<T>),
 }
 
-impl<T> IntoAllocated for ProgramPart<T> where T: ToString {
+impl<T> IntoAllocated for ProgramPart<T>
+where
+    T: ToString,
+{
     type Allocated = ProgramPart<String>;
     fn into_allocated(self) -> ProgramPart<String> {
         match self {
@@ -185,17 +191,17 @@ impl<T> ProgramPart<T> {
 /// pretty much always `'use strict'`, this can appear at the
 /// top of a file or function
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct Dir<T> {
     pub expr: Lit<T>,
     pub dir: T,
     pub semi_colon: Option<Semicolon>,
 }
 
-impl<T> IntoAllocated for Dir<T> where T: ToString {
+impl<T> IntoAllocated for Dir<T>
+where
+    T: ToString,
+{
     type Allocated = Dir<String>;
     fn into_allocated(self) -> Dir<String> {
         Dir {
@@ -230,10 +236,7 @@ impl<T> Node for Dir<T> {
 /// let y = function q() {}
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct Func<T> {
     pub keyword: Function,
     pub id: Option<Ident<T>>,
@@ -254,7 +257,6 @@ impl<T> Func<T> {
     }
 }
 
-
 impl<T> IntoAllocated for Func<T>
 where
     T: ToString,
@@ -265,7 +267,11 @@ where
             keyword: self.keyword,
             id: self.id.map(|i| i.into_allocated()),
             open_paren: self.open_paren,
-            params: self.params.into_iter().map(|p| p.into_allocated()).collect(),
+            params: self
+                .params
+                .into_iter()
+                .map(|p| p.into_allocated())
+                .collect(),
             close_paren: self.close_paren,
             body: self.body.into_allocated(),
             star: self.star,
@@ -287,19 +293,22 @@ impl<T> Node for Func<T> {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct FuncArgEntry<T> {
     pub value: FuncArg<T>,
     pub comma: Option<Comma>,
 }
 
-impl<T> IntoAllocated for FuncArgEntry<T> where T: ToString {
+impl<T> IntoAllocated for FuncArgEntry<T>
+where
+    T: ToString,
+{
     type Allocated = FuncArgEntry<String>;
     fn into_allocated(self) -> FuncArgEntry<String> {
-        FuncArgEntry { value: self.value.into_allocated(), comma: self.comma }
+        FuncArgEntry {
+            value: self.value.into_allocated(),
+            comma: self.comma,
+        }
     }
 }
 
@@ -317,17 +326,17 @@ impl<T> Node for FuncArgEntry<T> {
 
 /// A single function argument from a function signature
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum FuncArg<T> {
     Expr(Expr<T>),
     Pat(Pat<T>),
     Rest(Box<RestPat<T>>),
 }
 
-impl<T> IntoAllocated for FuncArg<T> where T: ToString {
+impl<T> IntoAllocated for FuncArg<T>
+where
+    T: ToString,
+{
     type Allocated = FuncArg<String>;
     fn into_allocated(self) -> FuncArg<String> {
         match self {
@@ -350,20 +359,24 @@ impl<T> Node for FuncArg<T> {
 
 /// The block statement that makes up the function's body
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct FuncBody<T> {
     pub open_brace: OpenBrace,
     pub stmts: Vec<ProgramPart<T>>,
     pub close_brace: CloseBrace,
 }
 
-impl<T> IntoAllocated for FuncBody<T> where T: ToString {
+impl<T> IntoAllocated for FuncBody<T>
+where
+    T: ToString,
+{
     type Allocated = FuncBody<String>;
     fn into_allocated(self) -> FuncBody<String> {
-        FuncBody { open_brace: self.open_brace, stmts: self.stmts.into_iter().map(|s| s.into_allocated()).collect(), close_brace: self.close_brace }
+        FuncBody {
+            open_brace: self.open_brace,
+            stmts: self.stmts.into_iter().map(|s| s.into_allocated()).collect(),
+            close_brace: self.close_brace,
+        }
     }
 }
 
@@ -403,10 +416,7 @@ impl<T> Node for FuncBody<T> {
 /// }
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct Class<T> {
     pub keyword: tokens::Class,
     pub id: Option<Ident<T>>,
@@ -414,12 +424,14 @@ pub struct Class<T> {
     pub body: ClassBody<T>,
 }
 
-
-impl<T> IntoAllocated for Class<T> where T: ToString {
+impl<T> IntoAllocated for Class<T>
+where
+    T: ToString,
+{
     type Allocated = Class<String>;
     fn into_allocated(self) -> Class<String> {
         Class {
-            keyword: self.keyword, 
+            keyword: self.keyword,
             id: self.id.map(|i| i.into_allocated()),
             super_class: self.super_class.map(|s| s.into_allocated()),
             body: self.body.into_allocated(),
@@ -437,37 +449,48 @@ impl<T> Node for Class<T> {
 }
 
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct SuperClass<T> {
     pub keyword_extends: Extends,
     pub expr: Expr<T>,
 }
 
-impl<T> IntoAllocated for SuperClass<T> where T: ToString {
+impl<T> IntoAllocated for SuperClass<T>
+where
+    T: ToString,
+{
     type Allocated = SuperClass<String>;
     fn into_allocated(self) -> SuperClass<String> {
-        SuperClass { keyword_extends: self.keyword_extends, expr: self.expr.into_allocated() }
+        SuperClass {
+            keyword_extends: self.keyword_extends,
+            expr: self.expr.into_allocated(),
+        }
     }
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct ClassBody<T> {
     pub open_brace: OpenBrace,
     pub props: Vec<Prop<T>>,
     pub close_brace: CloseBrace,
 }
 
-impl<T> IntoAllocated for ClassBody<T> where T: ToString {
+impl<T> IntoAllocated for ClassBody<T>
+where
+    T: ToString,
+{
     type Allocated = ClassBody<String>;
     fn into_allocated(self) -> ClassBody<String> {
-        ClassBody { open_brace: self.open_brace, props: self.props.into_iter().map(IntoAllocated::into_allocated).collect(), close_brace: self.close_brace }
+        ClassBody {
+            open_brace: self.open_brace,
+            props: self
+                .props
+                .into_iter()
+                .map(IntoAllocated::into_allocated)
+                .collect(),
+            close_brace: self.close_brace,
+        }
     }
 }
 
@@ -481,10 +504,7 @@ impl<T> Node for ClassBody<T> {
 
 /// The kind of variable being defined (`var`/`let`/`const`)
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum VarKind {
     Var(Option<Var>),
     Let(Let),
@@ -514,13 +534,14 @@ impl VarKind {
             VarKind::Const(_) => 4,
         }
     }
+
+    pub const fn is_empty(&self) -> bool {
+        matches!(self, VarKind::Var(None))
+    }
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct Slice<T> {
     pub source: T,
     pub loc: SourceLocation,
@@ -542,17 +563,14 @@ where
 impl<T> Slice<T> {
     pub fn new(source: T, start_line: u32, start_col: u32, end_line: u32, end_column: u32) -> Self {
         Self {
-            source: source,
+            source,
             loc: SourceLocation::new(start_line, start_col, end_line, end_column),
         }
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Copy)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct SourceLocation {
     pub start: Position,
     pub end: Position,
@@ -587,10 +605,7 @@ impl core::cmp::PartialOrd for SourceLocation {
 }
 
 #[derive(Debug, Clone, PartialEq, Copy)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct Position {
     pub line: u32,
     pub column: u32,
@@ -657,16 +672,16 @@ impl std::ops::Sub<u32> for Position {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct ListEntry<Item> {
     pub item: Item,
     pub comma: Option<Comma>,
 }
 
-impl<Item> IntoAllocated for ListEntry<Item> where Item: IntoAllocated {
+impl<Item> IntoAllocated for ListEntry<Item>
+where
+    Item: IntoAllocated,
+{
     type Allocated = ListEntry<Item::Allocated>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -678,7 +693,6 @@ impl<Item> IntoAllocated for ListEntry<Item> where Item: IntoAllocated {
 }
 
 impl<Item> ListEntry<Item> {
-
     pub fn no_comma(item: Item) -> Self {
         Self { item, comma: None }
     }
diff --git a/src/spanned/pat.rs b/src/spanned/pat.rs
index 07855ff..6a5eacd 100644
--- a/src/spanned/pat.rs
+++ b/src/spanned/pat.rs
@@ -1,19 +1,16 @@
-use crate::IntoAllocated;
 use crate::spanned::expr::{Expr, Prop};
 use crate::spanned::Ident;
+use crate::IntoAllocated;
 
 use super::tokens::{CloseBrace, CloseBracket, Comma, Ellipsis, OpenBrace, OpenBracket, Token};
 use super::{AssignOp, ListEntry, Node, SourceLocation};
 #[cfg(feature = "serde")]
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 
 /// All of the different ways you can declare an identifier
 /// and/or value
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum Pat<T> {
     Ident(Ident<T>),
     Obj(ObjPat<T>),
@@ -21,7 +18,10 @@ pub enum Pat<T> {
     Assign(AssignPat<T>),
 }
 
-impl<T> IntoAllocated for Pat<T> where T: ToString {
+impl<T> IntoAllocated for Pat<T>
+where
+    T: ToString,
+{
     type Allocated = Pat<String>;
     fn into_allocated(self) -> Self::Allocated {
         match self {
@@ -45,22 +45,26 @@ impl<T> Node for Pat<T> {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct ArrayPat<T> {
     pub open_bracket: OpenBracket,
     pub elements: Vec<ListEntry<Option<ArrayPatPart<T>>>>,
     pub close_bracket: CloseBracket,
 }
 
-impl<T> IntoAllocated for ArrayPat<T> where T: ToString {
+impl<T> IntoAllocated for ArrayPat<T>
+where
+    T: ToString,
+{
     type Allocated = ArrayPat<String>;
     fn into_allocated(self) -> Self::Allocated {
         ArrayPat {
             open_bracket: self.open_bracket,
-            elements: self.elements.into_iter().map(IntoAllocated::into_allocated).collect(),
+            elements: self
+                .elements
+                .into_iter()
+                .map(IntoAllocated::into_allocated)
+                .collect(),
             close_bracket: self.close_bracket,
         }
     }
@@ -76,16 +80,16 @@ impl<T> Node for ArrayPat<T> {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct ArrayElement<T> {
     pub part: Option<ArrayPatPart<T>>,
     pub comma: Option<Comma>,
 }
 
-impl<T> IntoAllocated for ArrayElement<T> where T: ToString {
+impl<T> IntoAllocated for ArrayElement<T>
+where
+    T: ToString,
+{
     type Allocated = ArrayElement<String>;
     fn into_allocated(self) -> Self::Allocated {
         ArrayElement {
@@ -96,17 +100,17 @@ impl<T> IntoAllocated for ArrayElement<T> where T: ToString {
 }
 
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum ArrayPatPart<T> {
     Pat(Pat<T>),
     Expr(Expr<T>),
     Rest(RestPat<T>),
 }
 
-impl<T> IntoAllocated for ArrayPatPart<T> where T: ToString {
+impl<T> IntoAllocated for ArrayPatPart<T>
+where
+    T: ToString,
+{
     type Allocated = ArrayPatPart<String>;
     fn into_allocated(self) -> Self::Allocated {
         match self {
@@ -131,22 +135,26 @@ type ObjEntry<T> = ListEntry<ObjPatPart<T>>;
 
 /// similar to an `ObjectExpr`
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct ObjPat<T> {
     pub open_brace: OpenBrace,
     pub props: Vec<ObjEntry<T>>,
     pub close_brace: CloseBrace,
 }
 
-impl<T> IntoAllocated for ObjPat<T> where T: ToString {
+impl<T> IntoAllocated for ObjPat<T>
+where
+    T: ToString,
+{
     type Allocated = ObjPat<String>;
     fn into_allocated(self) -> Self::Allocated {
         ObjPat {
             open_brace: self.open_brace,
-            props: self.props.into_iter().map(IntoAllocated::into_allocated).collect(),
+            props: self
+                .props
+                .into_iter()
+                .map(IntoAllocated::into_allocated)
+                .collect(),
             close_brace: self.close_brace,
         }
     }
@@ -163,16 +171,16 @@ impl<T> Node for ObjPat<T> {
 
 /// A single part of an ObjectPat
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum ObjPatPart<T> {
     Assign(Prop<T>),
     Rest(Box<RestPat<T>>),
 }
 
-impl<T> IntoAllocated for ObjPatPart<T> where T: ToString {
+impl<T> IntoAllocated for ObjPatPart<T>
+where
+    T: ToString,
+{
     type Allocated = ObjPatPart<String>;
     fn into_allocated(self) -> Self::Allocated {
         match self {
@@ -192,16 +200,16 @@ impl<T> Node for ObjPatPart<T> {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct RestPat<T> {
     pub dots: Ellipsis,
     pub pat: Pat<T>,
 }
 
-impl<T> IntoAllocated for RestPat<T> where T: ToString {
+impl<T> IntoAllocated for RestPat<T>
+where
+    T: ToString,
+{
     type Allocated = RestPat<String>;
     fn into_allocated(self) -> Self::Allocated {
         RestPat {
@@ -222,17 +230,17 @@ impl<T> Node for RestPat<T> {
 
 /// An assignment as a pattern
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct AssignPat<T> {
     pub left: Box<Pat<T>>,
     pub operator: AssignOp,
     pub right: Box<Expr<T>>,
 }
 
-impl<T> IntoAllocated for AssignPat<T> where T: ToString {
+impl<T> IntoAllocated for AssignPat<T>
+where
+    T: ToString,
+{
     type Allocated = AssignPat<String>;
     fn into_allocated(self) -> Self::Allocated {
         AssignPat {
diff --git a/src/spanned/stmt.rs b/src/spanned/stmt.rs
index 4ab3e44..d5233a2 100644
--- a/src/spanned/stmt.rs
+++ b/src/spanned/stmt.rs
@@ -1,9 +1,9 @@
-use crate::IntoAllocated;
 use crate::spanned::decl::VarDecl;
 use crate::spanned::expr::Expr;
 use crate::spanned::pat::Pat;
 use crate::spanned::VarKind;
 use crate::spanned::{Ident, ProgramPart};
+use crate::IntoAllocated;
 
 use super::decl::VarDecls;
 use super::tokens::{
@@ -13,14 +13,11 @@ use super::tokens::{
 };
 use super::{ListEntry, Node, SourceLocation};
 #[cfg(feature = "serde")]
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 
 /// A slightly more granular part of an es program than ProgramPart
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum Stmt<T> {
     /// Any expression
     Expr {
@@ -212,29 +209,76 @@ pub enum Stmt<T> {
     },
 }
 
-impl<T> IntoAllocated for Stmt<T> where T: ToString {
+impl<T> IntoAllocated for Stmt<T>
+where
+    T: ToString,
+{
     type Allocated = Stmt<String>;
     fn into_allocated(self) -> Self::Allocated {
         match self {
-            Stmt::Expr { expr, semi_colon } => Stmt::Expr { expr: expr.into_allocated(), semi_colon },
+            Stmt::Expr { expr, semi_colon } => Stmt::Expr {
+                expr: expr.into_allocated(),
+                semi_colon,
+            },
             Stmt::Block(inner) => Stmt::Block(inner.into_allocated()),
             Stmt::Empty(inner) => Stmt::Empty(inner),
-            Stmt::Debugger { keyword, semi_colon } => Stmt::Debugger { keyword, semi_colon },
+            Stmt::Debugger {
+                keyword,
+                semi_colon,
+            } => Stmt::Debugger {
+                keyword,
+                semi_colon,
+            },
             Stmt::With(inner) => Stmt::With(inner.into_allocated()),
-            Stmt::Return { keyword, value, semi_colon } => Stmt::Return { keyword, value: value.into_allocated(), semi_colon },
+            Stmt::Return {
+                keyword,
+                value,
+                semi_colon,
+            } => Stmt::Return {
+                keyword,
+                value: value.into_allocated(),
+                semi_colon,
+            },
             Stmt::Labeled(inner) => Stmt::Labeled(inner.into_allocated()),
-            Stmt::Break { keyword, label, semi_colon } => Stmt::Break { keyword, label: label.into_allocated(), semi_colon},
-            Stmt::Continue { keyword, label, semi_colon } => Stmt::Continue { keyword, label: label.into_allocated(), semi_colon },
+            Stmt::Break {
+                keyword,
+                label,
+                semi_colon,
+            } => Stmt::Break {
+                keyword,
+                label: label.into_allocated(),
+                semi_colon,
+            },
+            Stmt::Continue {
+                keyword,
+                label,
+                semi_colon,
+            } => Stmt::Continue {
+                keyword,
+                label: label.into_allocated(),
+                semi_colon,
+            },
             Stmt::If(inner) => Stmt::If(inner.into_allocated()),
             Stmt::Switch(inner) => Stmt::Switch(inner.into_allocated()),
-            Stmt::Throw { keyword, expr, semi_colon } => Stmt::Throw { keyword, expr: expr.into_allocated(), semi_colon },
+            Stmt::Throw {
+                keyword,
+                expr,
+                semi_colon,
+            } => Stmt::Throw {
+                keyword,
+                expr: expr.into_allocated(),
+                semi_colon,
+            },
             Stmt::Try(inner) => Stmt::Try(inner.into_allocated()),
             Stmt::While(inner) => Stmt::While(inner.into_allocated()),
             Stmt::DoWhile(inner) => Stmt::DoWhile(inner.into_allocated()),
             Stmt::For(inner) => Stmt::For(inner.into_allocated()),
             Stmt::ForIn(inner) => Stmt::ForIn(inner.into_allocated()),
             Stmt::ForOf(inner) => Stmt::ForOf(inner.into_allocated()),
-            Stmt::Var { decls, semi_colon } => Stmt::Var { decls: decls.into_allocated(), semi_colon },
+            Stmt::Var { decls, semi_colon } => Stmt::Var {
+                decls: decls.into_allocated(),
+                semi_colon,
+            },
         }
     }
 }
@@ -375,10 +419,7 @@ impl<T> Node for Stmt<T> {
 /// //rand !== 0
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct WithStmt<T> {
     pub keyword: With,
     pub open_paren: OpenParen,
@@ -387,7 +428,10 @@ pub struct WithStmt<T> {
     pub body: Box<Stmt<T>>,
 }
 
-impl<T> IntoAllocated for WithStmt<T> where T: ToString {
+impl<T> IntoAllocated for WithStmt<T>
+where
+    T: ToString,
+{
     type Allocated = WithStmt<String>;
     fn into_allocated(self) -> Self::Allocated {
         WithStmt {
@@ -417,17 +461,17 @@ impl<T> Node for WithStmt<T> {
 /// }
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct LabeledStmt<T> {
     pub label: Ident<T>,
     pub colon: Colon,
     pub body: Box<Stmt<T>>,
 }
 
-impl<T> IntoAllocated for LabeledStmt<T> where T: ToString {
+impl<T> IntoAllocated for LabeledStmt<T>
+where
+    T: ToString,
+{
     type Allocated = LabeledStmt<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -457,10 +501,7 @@ impl<T> Node for LabeledStmt<T> {
 /// }
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct IfStmt<T> {
     pub keyword: If,
     pub open_paren: OpenParen,
@@ -470,7 +511,10 @@ pub struct IfStmt<T> {
     pub alternate: Option<Box<ElseStmt<T>>>,
 }
 
-impl<T> IntoAllocated for IfStmt<T> where T: ToString {
+impl<T> IntoAllocated for IfStmt<T>
+where
+    T: ToString,
+{
     type Allocated = IfStmt<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -498,16 +542,16 @@ impl<T> Node for IfStmt<T> {
 }
 
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct ElseStmt<T> {
     pub keyword: Else,
     pub body: Stmt<T>,
 }
 
-impl<T> IntoAllocated for ElseStmt<T> where T: ToString {
+impl<T> IntoAllocated for ElseStmt<T>
+where
+    T: ToString,
+{
     type Allocated = ElseStmt<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -542,10 +586,7 @@ impl<T> Node for ElseStmt<T> {
 /// }
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct SwitchStmt<T> {
     pub keyword: Switch,
     pub open_paren: OpenParen,
@@ -556,7 +597,10 @@ pub struct SwitchStmt<T> {
     pub close_brace: CloseBrace,
 }
 
-impl<T> IntoAllocated for SwitchStmt<T> where T: ToString {
+impl<T> IntoAllocated for SwitchStmt<T>
+where
+    T: ToString,
+{
     type Allocated = SwitchStmt<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -566,7 +610,11 @@ impl<T> IntoAllocated for SwitchStmt<T> where T: ToString {
             discriminant: self.discriminant.into_allocated(),
             close_paren: self.close_paren,
             open_brace: self.open_brace,
-            cases: self.cases.into_iter().map(IntoAllocated::into_allocated).collect(),
+            cases: self
+                .cases
+                .into_iter()
+                .map(IntoAllocated::into_allocated)
+                .collect(),
             close_brace: self.close_brace,
         }
     }
@@ -583,10 +631,7 @@ impl<T> Node for SwitchStmt<T> {
 
 /// A single case part of a switch statement
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct SwitchCase<T> {
     pub keyword: SwitchCaseKeyword,
     pub test: Option<Expr<T>>,
@@ -608,14 +653,21 @@ impl<T> Node for SwitchCase<T> {
     }
 }
 
-impl<T> IntoAllocated for SwitchCase<T> where T: ToString {
+impl<T> IntoAllocated for SwitchCase<T>
+where
+    T: ToString,
+{
     type Allocated = SwitchCase<String>;
 
     fn into_allocated(self) -> Self::Allocated {
         SwitchCase {
             keyword: self.keyword,
             colon: self.colon,
-            consequent: self.consequent.into_iter().map(IntoAllocated::into_allocated).collect(),
+            consequent: self
+                .consequent
+                .into_iter()
+                .map(IntoAllocated::into_allocated)
+                .collect(),
             test: self.test.into_allocated(),
         }
     }
@@ -623,23 +675,27 @@ impl<T> IntoAllocated for SwitchCase<T> where T: ToString {
 
 /// A collection of program parts wrapped in curly braces
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct BlockStmt<T> {
     pub open_brace: OpenBrace,
     pub stmts: Vec<ProgramPart<T>>,
     pub close_brace: CloseBrace,
 }
 
-impl<T> IntoAllocated for BlockStmt<T> where T: ToString {
+impl<T> IntoAllocated for BlockStmt<T>
+where
+    T: ToString,
+{
     type Allocated = BlockStmt<String>;
 
     fn into_allocated(self) -> Self::Allocated {
         BlockStmt {
             open_brace: self.open_brace,
-            stmts: self.stmts.into_iter().map(IntoAllocated::into_allocated).collect(),
+            stmts: self
+                .stmts
+                .into_iter()
+                .map(IntoAllocated::into_allocated)
+                .collect(),
             close_brace: self.close_brace,
         }
     }
@@ -665,10 +721,7 @@ impl<T> Node for BlockStmt<T> {
 /// }
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct TryStmt<T> {
     pub keyword: Try,
     pub block: BlockStmt<T>,
@@ -676,7 +729,10 @@ pub struct TryStmt<T> {
     pub finalizer: Option<FinallyClause<T>>,
 }
 
-impl<T> IntoAllocated for TryStmt<T> where T: ToString {
+impl<T> IntoAllocated for TryStmt<T>
+where
+    T: ToString,
+{
     type Allocated = TryStmt<String>;
     fn into_allocated(self) -> Self::Allocated {
         TryStmt {
@@ -706,17 +762,17 @@ impl<T> Node for TryStmt<T> {
 
 /// The error handling part of a `TryStmt`
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct CatchClause<T> {
     pub keyword: Catch,
     pub param: Option<CatchArg<T>>,
     pub body: BlockStmt<T>,
 }
 
-impl<T> IntoAllocated for CatchClause<T> where T: ToString {
+impl<T> IntoAllocated for CatchClause<T>
+where
+    T: ToString,
+{
     type Allocated = CatchClause<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -738,17 +794,17 @@ impl<T> Node for CatchClause<T> {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct CatchArg<T> {
     pub open_paren: OpenParen,
     pub param: Pat<T>,
     pub close_paren: CloseParen,
 }
 
-impl<T> IntoAllocated for CatchArg<T> where T: ToString {
+impl<T> IntoAllocated for CatchArg<T>
+where
+    T: ToString,
+{
     type Allocated = CatchArg<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -770,16 +826,16 @@ impl<T> Node for CatchArg<T> {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct FinallyClause<T> {
     pub keyword: Finally,
     pub body: BlockStmt<T>,
 }
 
-impl<T> IntoAllocated for FinallyClause<T> where T: ToString {
+impl<T> IntoAllocated for FinallyClause<T>
+where
+    T: ToString,
+{
     type Allocated = FinallyClause<String>;
     fn into_allocated(self) -> Self::Allocated {
         FinallyClause {
@@ -813,10 +869,7 @@ impl<T> Node for FinallyClause<T> {
 /// }
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct WhileStmt<T> {
     pub keyword: While,
     pub open_paren: OpenParen,
@@ -825,7 +878,10 @@ pub struct WhileStmt<T> {
     pub body: Box<Stmt<T>>,
 }
 
-impl<T> IntoAllocated for WhileStmt<T> where T: ToString {
+impl<T> IntoAllocated for WhileStmt<T>
+where
+    T: ToString,
+{
     type Allocated = WhileStmt<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -834,7 +890,7 @@ impl<T> IntoAllocated for WhileStmt<T> where T: ToString {
             open_paren: self.open_paren,
             test: self.test.into_allocated(),
             close_paren: self.close_paren,
-            body: self.body.into_allocated()
+            body: self.body.into_allocated(),
         }
     }
 }
@@ -855,10 +911,7 @@ impl<T> Node for WhileStmt<T> {
 /// } while (Math.floor(Math.random() * 100) < 75)
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct DoWhileStmt<T> {
     pub keyword_do: Do,
     pub body: Box<Stmt<T>>,
@@ -869,7 +922,10 @@ pub struct DoWhileStmt<T> {
     pub semi_colon: Option<Semicolon>,
 }
 
-impl<T> IntoAllocated for DoWhileStmt<T> where T: ToString {
+impl<T> IntoAllocated for DoWhileStmt<T>
+where
+    T: ToString,
+{
     type Allocated = DoWhileStmt<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -907,10 +963,7 @@ impl<T> Node for DoWhileStmt<T> {
 /// }
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct ForStmt<T> {
     pub keyword: For,
     pub open_paren: OpenParen,
@@ -923,7 +976,10 @@ pub struct ForStmt<T> {
     pub body: Box<Stmt<T>>,
 }
 
-impl<T> IntoAllocated for ForStmt<T> where T: ToString {
+impl<T> IntoAllocated for ForStmt<T>
+where
+    T: ToString,
+{
     type Allocated = ForStmt<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -955,21 +1011,24 @@ impl<T> Node for ForStmt<T> {
 ///  //  vvvvvvvvv
 /// for (var i = 0;i < 100; i++)
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum LoopInit<T> {
     Variable(VarKind, Vec<ListEntry<VarDecl<T>>>),
     Expr(Expr<T>),
 }
 
-impl<T> IntoAllocated for LoopInit<T> where T: ToString {
+impl<T> IntoAllocated for LoopInit<T>
+where
+    T: ToString,
+{
     type Allocated = LoopInit<String>;
     fn into_allocated(self) -> Self::Allocated {
         match self {
-            LoopInit::Variable(k, v) => LoopInit::Variable(k, v.into_iter().map(IntoAllocated::into_allocated).collect()),
-            LoopInit::Expr(inner) => LoopInit::Expr(inner.into_allocated())
+            LoopInit::Variable(k, v) => LoopInit::Variable(
+                k,
+                v.into_iter().map(IntoAllocated::into_allocated).collect(),
+            ),
+            LoopInit::Expr(inner) => LoopInit::Expr(inner.into_allocated()),
         }
     }
 }
@@ -1005,10 +1064,7 @@ impl<T> Node for LoopInit<T> {
 /// //prints a, b
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct ForInStmt<T> {
     pub keyword_for: For,
     pub open_paren: OpenParen,
@@ -1019,7 +1075,10 @@ pub struct ForInStmt<T> {
     pub body: Box<Stmt<T>>,
 }
 
-impl<T> IntoAllocated for ForInStmt<T> where T: ToString {
+impl<T> IntoAllocated for ForInStmt<T>
+where
+    T: ToString,
+{
     type Allocated = ForInStmt<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -1053,10 +1112,7 @@ impl<T> Node for ForInStmt<T> {
 /// //prints 2, 3, 4, 5, 6
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct ForOfStmt<T> {
     pub keyword_for: For,
     pub open_paren: OpenParen,
@@ -1068,7 +1124,10 @@ pub struct ForOfStmt<T> {
     pub is_await: bool,
 }
 
-impl<T> IntoAllocated for ForOfStmt<T> where T: ToString {
+impl<T> IntoAllocated for ForOfStmt<T>
+where
+    T: ToString,
+{
     type Allocated = ForOfStmt<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -1097,17 +1156,17 @@ impl<T> Node for ForOfStmt<T> {
 /// The values on the left hand side of the keyword
 /// in a for in or for of loop
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum LoopLeft<T> {
     Expr(Expr<T>),
     Variable(VarKind, VarDecl<T>),
     Pat(Pat<T>),
 }
 
-impl<T> IntoAllocated for LoopLeft<T> where T: ToString {
+impl<T> IntoAllocated for LoopLeft<T>
+where
+    T: ToString,
+{
     type Allocated = LoopLeft<String>;
     fn into_allocated(self) -> Self::Allocated {
         match self {
diff --git a/src/spanned/tokens.rs b/src/spanned/tokens.rs
index feb3f8c..72e6da6 100644
--- a/src/spanned/tokens.rs
+++ b/src/spanned/tokens.rs
@@ -2,7 +2,7 @@
 
 use crate::spanned::{Node, Position, SourceLocation};
 #[cfg(feature = "serde")]
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 
 macro_rules! impl_token {
     ($what:ty, $s:expr) => {
@@ -22,9 +22,9 @@ macro_rules! impl_token {
                 Self(other)
             }
         }
-        impl std::convert::Into<Position> for $what {
-            fn into(self) -> Position {
-                self.0
+        impl std::convert::From<$what> for Position {
+            fn from(other: $what) -> Position {
+                other.0
             }
         }
         impl std::cmp::PartialEq<Position> for $what {
@@ -73,10 +73,7 @@ macro_rules! impl_token {
 macro_rules! define_token {
     ($name:ident, $s:expr) => {
         #[derive(Debug, Clone, Copy, PartialEq)]
-        #[cfg_attr(
-            feature = "serde",
-            derive(Deserialize, Serialize)
-        )]
+        #[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
         #[doc = $s]
         pub struct $name(Position);
         impl_token!($name, $s);
@@ -205,10 +202,7 @@ define_token!(TripleGreaterThan, ">>>");
 define_token!(TripleGreaterThanEqual, ">>>=");
 
 #[derive(Debug, Clone, Copy, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum Quote {
     Double(DoubleQuote),
     Single(SingleQuote),
@@ -238,10 +232,7 @@ impl Token for Quote {
 }
 
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum QuasiQuote {
     BackTick(BackTick),
     CloseBrace(CloseBrace),
@@ -276,10 +267,7 @@ impl Token for QuasiQuote {
 
 /// The available operators for assignment Exprs
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum AssignOp {
     Equal(Equal),
     PlusEqual(PlusEqual),
@@ -318,10 +306,7 @@ impl Node for AssignOp {
 
 /// The available logical operators
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum LogicalOp {
     Or(DoublePipe),
     And(DoubleAmpersand),
@@ -338,10 +323,7 @@ impl Node for LogicalOp {
 
 /// The available operations for `Binary` Exprs
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum BinaryOp {
     Equal(DoubleEqual),
     NotEqual(BangEqual),
@@ -399,10 +381,7 @@ define_token!(DoublePlus, "++");
 define_token!(DoubleMinus, "--");
 /// `++` or `--`
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum UpdateOp {
     Increment(DoublePlus),
     Decrement(DoubleMinus),
@@ -420,10 +399,7 @@ impl Node for UpdateOp {
 /// The allowed operators for an Expr
 /// to be `Unary`
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum UnaryOp {
     Minus(Minus),
     Plus(Plus),
@@ -449,10 +425,7 @@ impl Node for UnaryOp {
 }
 
 #[derive(Debug, PartialEq, Clone, Copy)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum SwitchCaseKeyword {
     Case(Case),
     Default(Default),
diff --git a/src/stmt.rs b/src/stmt.rs
index 1c97115..e4e65ba 100644
--- a/src/stmt.rs
+++ b/src/stmt.rs
@@ -1,19 +1,15 @@
 use crate::decl::VarDecl;
 use crate::expr::Expr;
 use crate::pat::Pat;
-use crate::{VarKind, IntoAllocated};
 use crate::{Ident, ProgramPart};
-
+use crate::{IntoAllocated, VarKind};
 
 #[cfg(feature = "serde")]
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 
 /// A slightly more granular part of an es program than ProgramPart
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum Stmt<T> {
     /// Any expression
     Expr(Expr<T>),
@@ -180,7 +176,10 @@ pub enum Stmt<T> {
     Var(Vec<VarDecl<T>>),
 }
 
-impl<T> IntoAllocated for Stmt<T> where T: ToString {
+impl<T> IntoAllocated for Stmt<T>
+where
+    T: ToString,
+{
     type Allocated = Stmt<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -222,16 +221,16 @@ impl<T> IntoAllocated for Stmt<T> where T: ToString {
 /// //rand !== 0
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct WithStmt<T> {
     pub object: Expr<T>,
     pub body: Box<Stmt<T>>,
 }
 
-impl<T> IntoAllocated for WithStmt<T> where T: ToString {
+impl<T> IntoAllocated for WithStmt<T>
+where
+    T: ToString,
+{
     type Allocated = WithStmt<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -252,15 +251,16 @@ impl<T> IntoAllocated for WithStmt<T> where T: ToString {
 /// }
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub struct LabeledStmt<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct LabeledStmt<T> {
     pub label: Ident<T>,
     pub body: Box<Stmt<T>>,
 }
 
-impl<T> IntoAllocated for LabeledStmt<T> where T: ToString {
+impl<T> IntoAllocated for LabeledStmt<T>
+where
+    T: ToString,
+{
     type Allocated = LabeledStmt<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -280,16 +280,17 @@ impl<T> IntoAllocated for LabeledStmt<T> where T: ToString {
 /// }
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub struct IfStmt<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct IfStmt<T> {
     pub test: Expr<T>,
     pub consequent: Box<Stmt<T>>,
     pub alternate: Option<Box<Stmt<T>>>,
 }
 
-impl<T> IntoAllocated for IfStmt<T> where T: ToString {
+impl<T> IntoAllocated for IfStmt<T>
+where
+    T: ToString,
+{
     type Allocated = IfStmt<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -316,15 +317,16 @@ impl<T> IntoAllocated for IfStmt<T> where T: ToString {
 /// }
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub struct SwitchStmt<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct SwitchStmt<T> {
     pub discriminant: Expr<T>,
     pub cases: Vec<SwitchCase<T>>,
 }
 
-impl<T> IntoAllocated for SwitchStmt<T> where T: ToString {
+impl<T> IntoAllocated for SwitchStmt<T>
+where
+    T: ToString,
+{
     type Allocated = SwitchStmt<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -337,35 +339,39 @@ impl<T> IntoAllocated for SwitchStmt<T> where T: ToString {
 
 /// A single case part of a switch statement
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct SwitchCase<T> {
     pub test: Option<Expr<T>>,
     pub consequent: Vec<ProgramPart<T>>,
 }
 
-impl<T> IntoAllocated for SwitchCase<T> where T: ToString {
+impl<T> IntoAllocated for SwitchCase<T>
+where
+    T: ToString,
+{
     type Allocated = SwitchCase<String>;
 
     fn into_allocated(self) -> Self::Allocated {
         SwitchCase {
             test: self.test.map(IntoAllocated::into_allocated),
-            consequent: self.consequent.into_iter().map(|c| c.into_allocated()).collect(),
+            consequent: self
+                .consequent
+                .into_iter()
+                .map(|c| c.into_allocated())
+                .collect(),
         }
     }
 }
 
 /// A collection of program parts wrapped in curly braces
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct BlockStmt<T>(pub Vec<ProgramPart<T>>);
 
-impl<T> IntoAllocated for BlockStmt<T> where T: ToString {
+impl<T> IntoAllocated for BlockStmt<T>
+where
+    T: ToString,
+{
     type Allocated = BlockStmt<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -384,16 +390,17 @@ impl<T> IntoAllocated for BlockStmt<T> where T: ToString {
 /// }
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub struct TryStmt<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct TryStmt<T> {
     pub block: BlockStmt<T>,
     pub handler: Option<CatchClause<T>>,
     pub finalizer: Option<BlockStmt<T>>,
 }
 
-impl<T> IntoAllocated for TryStmt<T> where T: ToString {
+impl<T> IntoAllocated for TryStmt<T>
+where
+    T: ToString,
+{
     type Allocated = TryStmt<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -407,16 +414,16 @@ impl<T> IntoAllocated for TryStmt<T> where T: ToString {
 
 /// The error handling part of a `TryStmt`
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub struct CatchClause<T> {
     pub param: Option<Pat<T>>,
     pub body: BlockStmt<T>,
 }
 
-impl<T> IntoAllocated for CatchClause<T> where T: ToString {
+impl<T> IntoAllocated for CatchClause<T>
+where
+    T: ToString,
+{
     type Allocated = CatchClause<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -442,15 +449,16 @@ impl<T> IntoAllocated for CatchClause<T> where T: ToString {
 /// }
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub struct WhileStmt<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct WhileStmt<T> {
     pub test: Expr<T>,
     pub body: Box<Stmt<T>>,
 }
 
-impl<T> IntoAllocated for WhileStmt<T> where T: ToString {
+impl<T> IntoAllocated for WhileStmt<T>
+where
+    T: ToString,
+{
     type Allocated = WhileStmt<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -468,21 +476,22 @@ impl<T> IntoAllocated for WhileStmt<T> where T: ToString {
 /// } while (Math.floor(Math.random() * 100) < 75)
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub struct DoWhileStmt<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct DoWhileStmt<T> {
     pub test: Expr<T>,
     pub body: Box<Stmt<T>>,
 }
 
-impl<T> IntoAllocated for DoWhileStmt<T> where T: ToString {
+impl<T> IntoAllocated for DoWhileStmt<T>
+where
+    T: ToString,
+{
     type Allocated = DoWhileStmt<String>;
 
     fn into_allocated(self) -> Self::Allocated {
         DoWhileStmt {
             test: self.test.into_allocated(),
-            body: self.body.into_allocated()
+            body: self.body.into_allocated(),
         }
     }
 }
@@ -495,17 +504,18 @@ impl<T> IntoAllocated for DoWhileStmt<T> where T: ToString {
 /// }
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub struct ForStmt<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct ForStmt<T> {
     pub init: Option<LoopInit<T>>,
     pub test: Option<Expr<T>>,
     pub update: Option<Expr<T>>,
     pub body: Box<Stmt<T>>,
 }
 
-impl<T> IntoAllocated for ForStmt<T> where T: ToString {
+impl<T> IntoAllocated for ForStmt<T>
+where
+    T: ToString,
+{
     type Allocated = ForStmt<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -523,21 +533,23 @@ impl<T> IntoAllocated for ForStmt<T> where T: ToString {
 ///  //  vvvvvvvvv
 /// for (var i = 0;i < 100; i++)
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum LoopInit<T> {
     Variable(VarKind, Vec<VarDecl<T>>),
     Expr(Expr<T>),
 }
 
-impl<T> IntoAllocated for LoopInit<T> where T: ToString {
+impl<T> IntoAllocated for LoopInit<T>
+where
+    T: ToString,
+{
     type Allocated = LoopInit<String>;
 
     fn into_allocated(self) -> Self::Allocated {
         match self {
-            LoopInit::Variable(k, v) => LoopInit::Variable(k, v.into_iter().map(|v| v.into_allocated()).collect()),
+            LoopInit::Variable(k, v) => {
+                LoopInit::Variable(k, v.into_iter().map(|v| v.into_allocated()).collect())
+            }
             LoopInit::Expr(inner) => LoopInit::Expr(inner.into_allocated()),
         }
     }
@@ -556,16 +568,17 @@ impl<T> IntoAllocated for LoopInit<T> where T: ToString {
 /// //prints a, b
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub struct ForInStmt<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct ForInStmt<T> {
     pub left: LoopLeft<T>,
     pub right: Expr<T>,
     pub body: Box<Stmt<T>>,
 }
 
-impl<T> IntoAllocated for ForInStmt<T> where T: ToString {
+impl<T> IntoAllocated for ForInStmt<T>
+where
+    T: ToString,
+{
     type Allocated = ForInStmt<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -586,17 +599,18 @@ impl<T> IntoAllocated for ForInStmt<T> where T: ToString {
 /// //prints 2, 3, 4, 5, 6
 /// ```
 #[derive(PartialEq, Debug, Clone)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]pub struct ForOfStmt<T> {
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct ForOfStmt<T> {
     pub left: LoopLeft<T>,
     pub right: Expr<T>,
     pub body: Box<Stmt<T>>,
     pub is_await: bool,
 }
 
-impl<T> IntoAllocated for ForOfStmt<T> where T: ToString {
+impl<T> IntoAllocated for ForOfStmt<T>
+where
+    T: ToString,
+{
     type Allocated = ForOfStmt<String>;
 
     fn into_allocated(self) -> Self::Allocated {
@@ -612,17 +626,17 @@ impl<T> IntoAllocated for ForOfStmt<T> where T: ToString {
 /// The values on the left hand side of the keyword
 /// in a for in or for of loop
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Deserialize, Serialize)
-)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 pub enum LoopLeft<T> {
     Expr(Expr<T>),
     Variable(VarKind, VarDecl<T>),
     Pat(Pat<T>),
 }
 
-impl<T> IntoAllocated for LoopLeft<T> where T: ToString {
+impl<T> IntoAllocated for LoopLeft<T>
+where
+    T: ToString,
+{
     type Allocated = LoopLeft<String>;
 
     fn into_allocated(self) -> Self::Allocated {