carllerche · andrewleverette · Oct 14, 2020 · Sep 1, 2020 · Sep 1, 2020
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,3 +1,8 @@
+# <future version>
+
+### Changed
+- updated the crate to rust 2018 edition
+
 # 0.1.3 (May 9, 2020)
 
 ### Added

diff --git a/Cargo.toml b/Cargo.toml
@@ -13,6 +13,7 @@ documentation = "https://docs.rs/codegen/0.1.3/codegen"
 homepage = "https://github.com/carllerche/codegen"
 repository = "https://github.com/carllerche/codegen"
 readme = "README.md"
+edition = "2018"
 
 [dependencies]
 indexmap = "1.0.2"
diff --git a/src/associated_type.rs b/src/associated_type.rs
@@ -1,13 +1,10 @@
-use bound::Bound;
-
-use r#type::Type;
-
+use crate::bound::Bound;
+use crate::r#type::Type;
 
 /// Defines an associated type.
 #[derive(Debug, Clone)]
 pub struct AssociatedType(pub Bound);
 
-
 impl AssociatedType {
     /// Add a bound to the associated type.
     pub fn bound<T>(&mut self, ty: T) -> &mut Self

diff --git a/src/block.rs b/src/block.rs
@@ -1,8 +1,7 @@
 use std::fmt::{self, Write};
 
-use body::Body;
-use formatter::Formatter;
-
+use crate::body::Body;
+use crate::formatter::Formatter;
 
 /// Defines a code block. This is used to define a function body.
 #[derive(Debug, Clone)]
@@ -12,7 +11,6 @@ pub struct Block {
     body: Vec<Body>,
 }
 
-
 impl Block {
     /// Returns an empty code block.
     pub fn new(before: &str) -> Self {
@@ -45,7 +43,7 @@ impl Block {
     }
 
     /// Formats the block using the given formatter.
-    pub fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
+    pub fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
         if let Some(ref before) = self.before {
             write!(fmt, "{}", before)?;
         }

diff --git a/src/body.rs b/src/body.rs
@@ -1,21 +1,19 @@
 use std::fmt::{self, Write};
 
-use block::Block;
-use formatter::Formatter;
-
+use crate::block::Block;
+use crate::formatter::Formatter;
 
 #[derive(Debug, Clone)]
 pub enum Body {
     String(String),
     Block(Block),
 }
 
-
 impl Body {
-    pub fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
-        match *self {
-            Body::String(ref s) => write!(fmt, "{}\n", s),
-            Body::Block(ref b) => b.fmt(fmt),
+    pub fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
+        match &self {
+            Body::String(s) => write!(fmt, "{}\n", s),
+            Body::Block(b) => b.fmt(fmt),
         }
     }
 }
diff --git a/src/bound.rs b/src/bound.rs
@@ -1,5 +1,4 @@
-use r#type::Type;
-
+use crate::r#type::Type;
 
 #[derive(Debug, Clone)]
 pub struct Bound {

diff --git a/src/docs.rs b/src/docs.rs
@@ -1,22 +1,20 @@
 use std::fmt::{self, Write};
 
-use formatter::Formatter;
-
+use crate::formatter::Formatter;
 
 #[derive(Debug, Clone)]
 pub struct Docs {
     docs: String,
 }
 
-
 impl Docs {
     pub fn new(docs: &str) -> Self {
         Docs {
             docs: docs.to_string(),
         }
     }
 
-    pub fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
+    pub fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
         for line in self.docs.lines() {
             write!(fmt, "/// {}\n", line)?;
         }

diff --git a/src/enum.rs b/src/enum.rs
@@ -1,11 +1,10 @@
 use std::fmt;
 
-use formatter::Formatter;
-use type_def::TypeDef;
-use variant::Variant;
-
-use r#type::Type;
+use crate::formatter::Formatter;
+use crate::type_def::TypeDef;
+use crate::variant::Variant;
 
+use crate::r#type::Type;
 
 /// Defines an enumeration.
 #[derive(Debug, Clone)]
@@ -14,7 +13,6 @@ pub struct Enum {
     variants: Vec<Variant>,
 }
 
-
 impl Enum {
     /// Return a enum definition with the provided name.
     pub fn new(name: &str) -> Self {
@@ -87,7 +85,7 @@ impl Enum {
     }
 
     /// Formats the enum using the given formatter.
-    pub fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
+    pub fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
         self.type_def.fmt_head("enum", &[], fmt)?;
 
         fmt.block(|fmt| {

diff --git a/src/field.rs b/src/field.rs
@@ -1,5 +1,4 @@
-use r#type::Type;
-
+use crate::r#type::Type;
 
 /// Defines a struct field.
 #[derive(Debug, Clone)]
@@ -17,11 +16,11 @@ pub struct Field {
     pub annotation: Vec<String>,
 }
 
-
 impl Field {
     /// Return a field definition with the provided name and type
     pub fn new<T>(name: &str, ty: T) -> Self
-    where T: Into<Type>,
+    where
+        T: Into<Type>,
     {
         Field {
             name: name.into(),

diff --git a/src/fields.rs b/src/fields.rs
@@ -1,10 +1,9 @@
 use std::fmt::{self, Write};
 
-use field::Field;
-use formatter::Formatter;
-
-use r#type::Type;
+use crate::field::Field;
+use crate::formatter::Formatter;
 
+use crate::r#type::Type;
 
 /// Defines a set of fields.
 #[derive(Debug, Clone)]
@@ -14,10 +13,8 @@ pub enum Fields {
     Named(Vec<Field>),
 }
 
-
 impl Fields {
-    pub fn push_named(&mut self, field: Field) -> &mut Self
-    {
+    pub fn push_named(&mut self, field: Field) -> &mut Self {
         match *self {
             Fields::Empty => {
                 *self = Fields::Named(vec![field]);
@@ -32,7 +29,8 @@ impl Fields {
     }
 
     pub fn named<T>(&mut self, name: &str, ty: T) -> &mut Self
-    where T: Into<Type>,
+    where
+        T: Into<Type>,
     {
         self.push_named(Field {
             name: name.to_string(),
@@ -59,7 +57,7 @@ impl Fields {
         self
     }
 
-    pub fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
+    pub fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
         match *self {
             Fields::Named(ref fields) => {
                 assert!(!fields.is_empty());

diff --git a/src/formatter.rs b/src/formatter.rs
@@ -1,13 +1,11 @@
 use std::fmt::{self, Write};
 
-use bound::Bound;
-
-use r#type::Type;
+use crate::bound::Bound;
 
+use crate::r#type::Type;
 
 const DEFAULT_INDENT: usize = 4;
 
-
 /// Configures how a scope is formatted.
 #[derive(Debug)]
 pub struct Formatter<'a> {
@@ -21,7 +19,6 @@ pub struct Formatter<'a> {
     indent: usize,
 }
 
-
 impl<'a> Formatter<'a> {
     /// Return a new formatter that writes to the given string.
     pub fn new(dst: &'a mut String) -> Self {
@@ -102,9 +99,8 @@ impl<'a> fmt::Write for Formatter<'a> {
     }
 }
 
-
 /// Format generics.
-pub fn fmt_generics(generics: &[String], fmt: &mut Formatter) -> fmt::Result {
+pub fn fmt_generics(generics: &[String], fmt: &mut Formatter<'_>) -> fmt::Result {
     if !generics.is_empty() {
         write!(fmt, "<")?;
 
@@ -122,7 +118,7 @@ pub fn fmt_generics(generics: &[String], fmt: &mut Formatter) -> fmt::Result {
 }
 
 /// Format generic bounds.
-pub fn fmt_bounds(bounds: &[Bound], fmt: &mut Formatter) -> fmt::Result {
+pub fn fmt_bounds(bounds: &[Bound], fmt: &mut Formatter<'_>) -> fmt::Result {
     if !bounds.is_empty() {
         write!(fmt, "\n")?;
 
@@ -142,7 +138,7 @@ pub fn fmt_bounds(bounds: &[Bound], fmt: &mut Formatter) -> fmt::Result {
 }
 
 /// Format multiple generic bounds.
-pub fn fmt_bound_rhs(tys: &[Type], fmt: &mut Formatter) -> fmt::Result {
+pub fn fmt_bound_rhs(tys: &[Type], fmt: &mut Formatter<'_>) -> fmt::Result {
     for (i, ty) in tys.iter().enumerate() {
         if i != 0 {
             write!(fmt, " + ")?

diff --git a/src/function.rs b/src/function.rs
@@ -1,15 +1,14 @@
 use std::fmt::{self, Write};
 
-use block::Block;
-use body::Body;
-use bound::Bound;
-use docs::Docs;
-use field::Field;
-use formatter::{fmt_bounds, fmt_generics};
-use formatter::Formatter;
-
-use r#type::Type;
+use crate::block::Block;
+use crate::body::Body;
+use crate::bound::Bound;
+use crate::docs::Docs;
+use crate::field::Field;
+use crate::formatter::Formatter;
+use crate::formatter::{fmt_bounds, fmt_generics};
 
+use crate::r#type::Type;
 
 /// Defines a function.
 #[derive(Debug, Clone)]
@@ -54,7 +53,6 @@ pub struct Function {
     r#async: bool,
 }
 
-
 impl Function {
     /// Return a new function definition.
     pub fn new(name: &str) -> Self {
@@ -211,7 +209,7 @@ impl Function {
     }
 
     /// Formats the function using the given formatter.
-    pub fn fmt(&self, is_trait: bool, fmt: &mut Formatter) -> fmt::Result {
+    pub fn fmt(&self, is_trait: bool, fmt: &mut Formatter<'_>) -> fmt::Result {
         if let Some(ref docs) = self.docs {
             docs.fmt(fmt)?;
         }

diff --git a/src/impl.rs b/src/impl.rs
@@ -1,12 +1,11 @@
 use std::fmt::{self, Write};
 
-use bound::Bound;
-use field::Field;
-use formatter::{Formatter, fmt_bounds, fmt_generics};
-use function::Function;
-
-use r#type::Type;
+use crate::bound::Bound;
+use crate::field::Field;
+use crate::formatter::{fmt_bounds, fmt_generics, Formatter};
+use crate::function::Function;
 
+use crate::r#type::Type;
 
 /// Defines an impl block.
 #[derive(Debug, Clone)]
@@ -31,7 +30,6 @@ pub struct Impl {
     macros: Vec<String>,
 }
 
-
 impl Impl {
     /// Return a new impl definition
     pub fn new<T>(target: T) -> Self
@@ -121,7 +119,7 @@ impl Impl {
     }
 
     /// Formats the impl block using the given formatter.
-    pub fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
+    pub fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
         for m in self.macros.iter() {
             write!(fmt, "{}\n", m)?;
         }

diff --git a/src/import.rs b/src/import.rs
@@ -7,7 +7,6 @@ pub struct Import {
     pub vis: Option<String>,
 }
 
-
 impl Import {
     /// Return a new import.
     pub fn new(path: &str, ty: &str) -> Self {

diff --git a/src/item.rs b/src/item.rs
@@ -1,11 +1,10 @@
-use function::Function;
-use module::Module;
-
-use r#enum::Enum;
-use r#impl::Impl;
-use r#struct::Struct;
-use r#trait::Trait;
+use crate::function::Function;
+use crate::module::Module;
 
+use crate::r#enum::Enum;
+use crate::r#impl::Impl;
+use crate::r#struct::Struct;
+use crate::r#trait::Trait;
 
 #[derive(Debug, Clone)]
 pub enum Item {

diff --git a/src/lib.rs b/src/lib.rs
@@ -1,5 +1,6 @@
-#![deny(warnings, missing_debug_implementations, missing_docs)]
+#![deny(missing_debug_implementations, missing_docs)]
 #![doc(html_root_url = "https://docs.rs/codegen/0.1.1")]
+#![warn(rust_2018_idioms)]
 
 //! Provides a builder API for generating Rust code.
 //!