Merge rust-lang#11776

bors[bot] · lnicola · web-flow · commit 6a0b199c8232 · 2022-03-21T09:04:40.000Z
11776: Replace write! with direct `Formatter` calls r=Veykril a=lnicola

The final executable is somehow larger (36 239 296 vs 36 238 336 bytes), but this saves us a bit of `text` and `data`:

```
   text	   data	    bss	    dec	    hex	filename
23719199	1126625	   4377	24850201	17b2f19	rust-analyzer-baseline
23716027	1126377	   4377	24846781	17b21bd	rust-analyzer-pr
```

Co-authored-by: Laurențiu Nicola &lt;lnicola@dend.ro&gt;
diff --git a/crates/base_db/src/input.rs b/crates/base_db/src/input.rs
@@ -105,7 +105,7 @@ impl CrateName {
 
 impl fmt::Display for CrateName {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.0)
+        self.0.fmt(f)
     }
 }
 
@@ -160,7 +160,7 @@ impl From<CrateName> for CrateDisplayName {
 
 impl fmt::Display for CrateDisplayName {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.crate_name)
+        self.crate_name.fmt(f)
     }
 }
 
diff --git a/crates/cfg/src/cfg_expr.rs b/crates/cfg/src/cfg_expr.rs
@@ -43,7 +43,7 @@ impl CfgAtom {
 impl fmt::Display for CfgAtom {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            CfgAtom::Flag(name) => write!(f, "{}", name),
+            CfgAtom::Flag(name) => name.fmt(f),
             CfgAtom::KeyValue { key, value } => write!(f, "{} = {:?}", key, value),
         }
     }
diff --git a/crates/cfg/src/dnf.rs b/crates/cfg/src/dnf.rs
@@ -6,7 +6,7 @@
 //!
 //! This is currently both messy and inefficient. Feel free to improve, there are unit tests.
 
-use std::fmt;
+use std::fmt::{self, Write};
 
 use rustc_hash::FxHashSet;
 
@@ -125,17 +125,17 @@ impl DnfExpr {
 impl fmt::Display for DnfExpr {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         if self.conjunctions.len() != 1 {
-            write!(f, "any(")?;
+            f.write_str("any(")?;
         }
         for (i, conj) in self.conjunctions.iter().enumerate() {
             if i != 0 {
                 f.write_str(", ")?;
             }
 
-            write!(f, "{}", conj)?;
+            conj.fmt(f)?;
         }
         if self.conjunctions.len() != 1 {
-            write!(f, ")")?;
+            f.write_char(')')?;
         }
 
         Ok(())
@@ -165,17 +165,17 @@ impl Conjunction {
 impl fmt::Display for Conjunction {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         if self.literals.len() != 1 {
-            write!(f, "all(")?;
+            f.write_str("all(")?;
         }
         for (i, lit) in self.literals.iter().enumerate() {
             if i != 0 {
                 f.write_str(", ")?;
             }
 
-            write!(f, "{}", lit)?;
+            lit.fmt(f)?;
         }
         if self.literals.len() != 1 {
-            write!(f, ")")?;
+            f.write_str(")")?;
         }
 
         Ok(())
@@ -204,12 +204,12 @@ impl fmt::Display for Literal {
         }
 
         match &self.var {
-            Some(var) => write!(f, "{}", var)?,
+            Some(var) => var.fmt(f)?,
             None => f.write_str("<invalid>")?,
         }
 
         if self.negate {
-            write!(f, ")")?;
+            f.write_char(')')?;
         }
 
         Ok(())
diff --git a/crates/cfg/src/lib.rs b/crates/cfg/src/lib.rs
@@ -128,7 +128,7 @@ impl fmt::Display for CfgDiff {
                 };
                 f.write_str(sep)?;
 
-                write!(f, "{}", atom)?;
+                atom.fmt(f)?;
             }
 
             if !self.disable.is_empty() {
@@ -146,7 +146,7 @@ impl fmt::Display for CfgDiff {
                 };
                 f.write_str(sep)?;
 
-                write!(f, "{}", atom)?;
+                atom.fmt(f)?;
             }
         }
 
@@ -170,7 +170,7 @@ impl fmt::Display for InactiveReason {
                 };
                 f.write_str(sep)?;
 
-                write!(f, "{}", atom)?;
+                atom.fmt(f)?;
             }
             let is_are = if self.enabled.len() == 1 { "is" } else { "are" };
             write!(f, " {} enabled", is_are)?;
@@ -189,7 +189,7 @@ impl fmt::Display for InactiveReason {
                 };
                 f.write_str(sep)?;
 
-                write!(f, "{}", atom)?;
+                atom.fmt(f)?;
             }
             let is_are = if self.disabled.len() == 1 { "is" } else { "are" };
             write!(f, " {} disabled", is_are)?;
diff --git a/crates/hir_def/src/type_ref.rs b/crates/hir_def/src/type_ref.rs
@@ -5,7 +5,7 @@ use hir_expand::{
     name::{AsName, Name},
     AstId, InFile,
 };
-use std::convert::TryInto;
+use std::{convert::TryInto, fmt::Write};
 use syntax::ast::{self, HasName};
 
 use crate::{body::LowerCtx, intern::Interned, path::Path};
@@ -364,8 +364,8 @@ pub enum ConstScalarOrPath {
 impl std::fmt::Display for ConstScalarOrPath {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            ConstScalarOrPath::Scalar(s) => write!(f, "{}", s),
-            ConstScalarOrPath::Path(n) => write!(f, "{}", n),
+            ConstScalarOrPath::Scalar(s) => s.fmt(f),
+            ConstScalarOrPath::Path(n) => n.fmt(f),
         }
     }
 }
@@ -425,10 +425,10 @@ pub enum ConstScalar {
 }
 
 impl std::fmt::Display for ConstScalar {
-    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
         match self {
-            ConstScalar::Usize(us) => write!(fmt, "{}", us),
-            ConstScalar::Unknown => write!(fmt, "_"),
+            ConstScalar::Usize(us) => us.fmt(f),
+            ConstScalar::Unknown => f.write_char('_'),
         }
     }
 }
diff --git a/crates/hir_expand/src/mod_path.rs b/crates/hir_expand/src/mod_path.rs
@@ -121,7 +121,7 @@ impl Display for ModPath {
                 f.write_str("::")?;
             }
             first_segment = false;
-            write!(f, "{}", segment)?;
+            segment.fmt(f)?;
         }
         Ok(())
     }
diff --git a/crates/hir_ty/src/consteval.rs b/crates/hir_ty/src/consteval.rs
@@ -1,6 +1,10 @@
 //! Constant evaluation details
 
-use std::{collections::HashMap, convert::TryInto, fmt::Display};
+use std::{
+    collections::HashMap,
+    convert::TryInto,
+    fmt::{Display, Write},
+};
 
 use chalk_ir::{BoundVar, DebruijnIndex, GenericArgData, IntTy, Scalar};
 use hir_def::{
@@ -79,28 +83,29 @@ impl Display for ComputedExpr {
                     if *x >= 16 {
                         write!(f, "{} ({:#X})", x, x)
                     } else {
-                        write!(f, "{}", x)
+                        x.fmt(f)
                     }
                 }
                 Literal::Uint(x, _) => {
                     if *x >= 16 {
                         write!(f, "{} ({:#X})", x, x)
                     } else {
-                        write!(f, "{}", x)
+                        x.fmt(f)
                     }
                 }
-                Literal::Float(x, _) => write!(f, "{}", x),
-                Literal::Bool(x) => write!(f, "{}", x),
-                Literal::Char(x) => write!(f, "{:?}", x),
-                Literal::String(x) => write!(f, "{:?}", x),
-                Literal::ByteString(x) => write!(f, "{:?}", x),
+                Literal::Float(x, _) => x.fmt(f),
+                Literal::Bool(x) => x.fmt(f),
+                Literal::Char(x) => std::fmt::Debug::fmt(x, f),
+                Literal::String(x) => std::fmt::Debug::fmt(x, f),
+                Literal::ByteString(x) => std::fmt::Debug::fmt(x, f),
             },
             ComputedExpr::Tuple(t) => {
-                write!(f, "(")?;
+                f.write_char('(')?;
                 for x in &**t {
-                    write!(f, "{}, ", x)?;
+                    x.fmt(f)?;
+                    f.write_str(", ")?;
                 }
-                write!(f, ")")
+                f.write_char(')')
             }
         }
     }
diff --git a/crates/hir_ty/src/diagnostics/decl_check.rs b/crates/hir_ty/src/diagnostics/decl_check.rs
@@ -72,7 +72,7 @@ impl fmt::Display for CaseType {
             CaseType::UpperCamelCase => "CamelCase",
         };
 
-        write!(f, "{}", repr)
+        repr.fmt(f)
     }
 }
 
@@ -103,7 +103,7 @@ impl fmt::Display for IdentType {
             IdentType::Variant => "Variant",
         };
 
-        write!(f, "{}", repr)
+        repr.fmt(f)
     }
 }
 
diff --git a/crates/hir_ty/src/tls.rs b/crates/hir_ty/src/tls.rs
@@ -1,5 +1,5 @@
 //! Implementation of Chalk debug helper functions using TLS.
-use std::fmt;
+use std::fmt::{self, Display};
 
 use itertools::Itertools;
 
@@ -24,17 +24,17 @@ impl DebugContext<'_> {
             AdtId::UnionId(it) => self.0.union_data(it).name.clone(),
             AdtId::EnumId(it) => self.0.enum_data(it).name.clone(),
         };
-        write!(f, "{}", name)
+        name.fmt(f)
     }
 
     pub(crate) fn debug_trait_id(
         &self,
         id: chalk_db::TraitId,
-        fmt: &mut fmt::Formatter<'_>,
+        f: &mut fmt::Formatter<'_>,
     ) -> Result<(), fmt::Error> {
         let trait_: hir_def::TraitId = from_chalk_trait_id(id);
         let trait_data = self.0.trait_data(trait_);
-        write!(fmt, "{}", trait_data.name)
+        trait_data.name.fmt(f)
     }
 
     pub(crate) fn debug_assoc_type_id(
diff --git a/crates/ide/src/runnables.rs b/crates/ide/src/runnables.rs
@@ -38,8 +38,8 @@ pub enum TestId {
 impl fmt::Display for TestId {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            TestId::Name(name) => write!(f, "{}", name),
-            TestId::Path(path) => write!(f, "{}", path),
+            TestId::Name(name) => name.fmt(f),
+            TestId::Path(path) => path.fmt(f),
         }
     }
 }
diff --git a/crates/ide/src/syntax_highlighting/tags.rs b/crates/ide/src/syntax_highlighting/tags.rs
@@ -1,7 +1,10 @@
 //! Defines token tags we use for syntax highlighting.
 //! A tag is not unlike a CSS class.
 
-use std::{fmt, ops};
+use std::{
+    fmt::{self, Write},
+    ops,
+};
 
 use ide_db::SymbolKind;
 
@@ -254,9 +257,10 @@ impl fmt::Display for HlMod {
 
 impl fmt::Display for Highlight {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.tag)?;
+        self.tag.fmt(f)?;
         for modifier in self.mods.iter() {
-            write!(f, ".{}", modifier)?
+            f.write_char('.')?;
+            modifier.fmt(f)?;
         }
         Ok(())
     }
diff --git a/crates/proc_macro_api/src/lib.rs b/crates/proc_macro_api/src/lib.rs
@@ -95,9 +95,10 @@ pub struct ServerError {
 
 impl fmt::Display for ServerError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.message)?;
+        self.message.fmt(f)?;
         if let Some(io) = &self.io {
-            write!(f, ": {}", io)?;
+            f.write_str(": ")?;
+            io.fmt(f)?;
         }
         Ok(())
     }
diff --git a/crates/profile/src/memory_usage.rs b/crates/profile/src/memory_usage.rs
@@ -11,8 +11,8 @@ pub struct MemoryUsage {
 }
 
 impl fmt::Display for MemoryUsage {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        write!(fmt, "{}", self.allocated)
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.allocated.fmt(f)
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -105,7 +105,7 @@ impl CrateName {`
`105`	`105`
`106`	`106`	`impl fmt::Display for CrateName {`
`107`	`107`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`108`		`- write!(f, "{}", self.0)`
	`108`	`+ self.0.fmt(f)`
`109`	`109`	`}`
`110`	`110`	`}`
`111`	`111`
`@@ -160,7 +160,7 @@ impl From<CrateName> for CrateDisplayName {`
`160`	`160`
`161`	`161`	`impl fmt::Display for CrateDisplayName {`
`162`	`162`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`163`		`- write!(f, "{}", self.crate_name)`
	`163`	`+ self.crate_name.fmt(f)`
`164`	`164`	`}`
`165`	`165`	`}`
`166`	`166`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ impl CfgAtom {`
`43`	`43`	`impl fmt::Display for CfgAtom {`
`44`	`44`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`45`	`45`	`match self {`
`46`		`- CfgAtom::Flag(name) => write!(f, "{}", name),`
	`46`	`+ CfgAtom::Flag(name) => name.fmt(f),`
`47`	`47`	`CfgAtom::KeyValue { key, value } => write!(f, "{} = {:?}", key, value),`
`48`	`48`	`}`
`49`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@`
`6`	`6`	`//!`
`7`	`7`	`//! This is currently both messy and inefficient. Feel free to improve, there are unit tests.`
`8`	`8`
`9`		`-use std::fmt;`
	`9`	`+use std::fmt::{self, Write};`
`10`	`10`
`11`	`11`	`use rustc_hash::FxHashSet;`
`12`	`12`
`@@ -125,17 +125,17 @@ impl DnfExpr {`
`125`	`125`	`impl fmt::Display for DnfExpr {`
`126`	`126`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`127`	`127`	`if self.conjunctions.len() != 1 {`
`128`		`- write!(f, "any(")?;`
	`128`	`+ f.write_str("any(")?;`
`129`	`129`	`}`
`130`	`130`	`for (i, conj) in self.conjunctions.iter().enumerate() {`
`131`	`131`	`if i != 0 {`
`132`	`132`	`f.write_str(", ")?;`
`133`	`133`	`}`
`134`	`134`
`135`		`- write!(f, "{}", conj)?;`
	`135`	`+ conj.fmt(f)?;`
`136`	`136`	`}`
`137`	`137`	`if self.conjunctions.len() != 1 {`
`138`		`- write!(f, ")")?;`
	`138`	`+ f.write_char(')')?;`
`139`	`139`	`}`
`140`	`140`
`141`	`141`	`Ok(())`
`@@ -165,17 +165,17 @@ impl Conjunction {`
`165`	`165`	`impl fmt::Display for Conjunction {`
`166`	`166`	`fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {`
`167`	`167`	`if self.literals.len() != 1 {`
`168`		`- write!(f, "all(")?;`
	`168`	`+ f.write_str("all(")?;`
`169`	`169`	`}`
`170`	`170`	`for (i, lit) in self.literals.iter().enumerate() {`
`171`	`171`	`if i != 0 {`
`172`	`172`	`f.write_str(", ")?;`
`173`	`173`	`}`
`174`	`174`
`175`		`- write!(f, "{}", lit)?;`
	`175`	`+ lit.fmt(f)?;`
`176`	`176`	`}`
`177`	`177`	`if self.literals.len() != 1 {`
`178`		`- write!(f, ")")?;`
	`178`	`+ f.write_str(")")?;`
`179`	`179`	`}`
`180`	`180`
`181`	`181`	`Ok(())`
`@@ -204,12 +204,12 @@ impl fmt::Display for Literal {`
`204`	`204`	`}`
`205`	`205`
`206`	`206`	`match &self.var {`
`207`		`- Some(var) => write!(f, "{}", var)?,`
	`207`	`+ Some(var) => var.fmt(f)?,`
`208`	`208`	`None => f.write_str("<invalid>")?,`
`209`	`209`	`}`
`210`	`210`
`211`	`211`	`if self.negate {`
`212`		`- write!(f, ")")?;`
	`212`	`+ f.write_char(')')?;`
`213`	`213`	`}`
`214`	`214`
`215`	`215`	`Ok(())`
Original file line number	Diff line number	Diff line change
`@@ -128,7 +128,7 @@ impl fmt::Display for CfgDiff {`
`128`	`128`	`};`
`129`	`129`	`f.write_str(sep)?;`
`130`	`130`
`131`		`- write!(f, "{}", atom)?;`
	`131`	`+ atom.fmt(f)?;`
`132`	`132`	`}`
`133`	`133`
`134`	`134`	`if !self.disable.is_empty() {`
`@@ -146,7 +146,7 @@ impl fmt::Display for CfgDiff {`
`146`	`146`	`};`
`147`	`147`	`f.write_str(sep)?;`
`148`	`148`
`149`		`- write!(f, "{}", atom)?;`
	`149`	`+ atom.fmt(f)?;`
`150`	`150`	`}`
`151`	`151`	`}`
`152`	`152`
`@@ -170,7 +170,7 @@ impl fmt::Display for InactiveReason {`
`170`	`170`	`};`
`171`	`171`	`f.write_str(sep)?;`
`172`	`172`
`173`		`- write!(f, "{}", atom)?;`
	`173`	`+ atom.fmt(f)?;`
`174`	`174`	`}`
`175`	`175`	`let is_are = if self.enabled.len() == 1 { "is" } else { "are" };`
`176`	`176`	`write!(f, " {} enabled", is_are)?;`
`@@ -189,7 +189,7 @@ impl fmt::Display for InactiveReason {`
`189`	`189`	`};`
`190`	`190`	`f.write_str(sep)?;`
`191`	`191`
`192`		`- write!(f, "{}", atom)?;`
	`192`	`+ atom.fmt(f)?;`
`193`	`193`	`}`
`194`	`194`	`let is_are = if self.disabled.len() == 1 { "is" } else { "are" };`
`195`	`195`	`write!(f, " {} disabled", is_are)?;`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ use hir_expand::{`
`5`	`5`	`name::{AsName, Name},`
`6`	`6`	`AstId, InFile,`
`7`	`7`	`};`
`8`		`-use std::convert::TryInto;`
	`8`	`+use std::{convert::TryInto, fmt::Write};`
`9`	`9`	`use syntax::ast::{self, HasName};`
`10`	`10`
`11`	`11`	`use crate::{body::LowerCtx, intern::Interned, path::Path};`
`@@ -364,8 +364,8 @@ pub enum ConstScalarOrPath {`
`364`	`364`	`impl std::fmt::Display for ConstScalarOrPath {`
`365`	`365`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`366`	`366`	`match self {`
`367`		`- ConstScalarOrPath::Scalar(s) => write!(f, "{}", s),`
`368`		`- ConstScalarOrPath::Path(n) => write!(f, "{}", n),`
	`367`	`+ ConstScalarOrPath::Scalar(s) => s.fmt(f),`
	`368`	`+ ConstScalarOrPath::Path(n) => n.fmt(f),`
`369`	`369`	`}`
`370`	`370`	`}`
`371`	`371`	`}`
`@@ -425,10 +425,10 @@ pub enum ConstScalar {`
`425`	`425`	`}`
`426`	`426`
`427`	`427`	`impl std::fmt::Display for ConstScalar {`
`428`		`- fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {`
	`428`	`+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {`
`429`	`429`	`match self {`
`430`		`- ConstScalar::Usize(us) => write!(fmt, "{}", us),`
`431`		`- ConstScalar::Unknown => write!(fmt, "_"),`
	`430`	`+ ConstScalar::Usize(us) => us.fmt(f),`
	`431`	`+ ConstScalar::Unknown => f.write_char('_'),`
`432`	`432`	`}`
`433`	`433`	`}`
`434`	`434`	`}`
Original file line number	Diff line number	Diff line change
`@@ -121,7 +121,7 @@ impl Display for ModPath {`
`121`	`121`	`f.write_str("::")?;`
`122`	`122`	`}`
`123`	`123`	`first_segment = false;`
`124`		`- write!(f, "{}", segment)?;`
	`124`	`+ segment.fmt(f)?;`
`125`	`125`	`}`
`126`	`126`	`Ok(())`
`127`	`127`	`}`
Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,7 @@ impl fmt::Display for CaseType {`
`72`	`72`	`CaseType::UpperCamelCase => "CamelCase",`
`73`	`73`	`};`
`74`	`74`
`75`		`- write!(f, "{}", repr)`
	`75`	`+ repr.fmt(f)`
`76`	`76`	`}`
`77`	`77`	`}`
`78`	`78`
`@@ -103,7 +103,7 @@ impl fmt::Display for IdentType {`
`103`	`103`	`IdentType::Variant => "Variant",`
`104`	`104`	`};`
`105`	`105`
`106`		`- write!(f, "{}", repr)`
	`106`	`+ repr.fmt(f)`
`107`	`107`	`}`
`108`	`108`	`}`
`109`	`109`
Original file line number	Diff line number	Diff line change
`@@ -38,8 +38,8 @@ pub enum TestId {`
`38`	`38`	`impl fmt::Display for TestId {`
`39`	`39`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`40`	`40`	`match self {`
`41`		`- TestId::Name(name) => write!(f, "{}", name),`
`42`		`- TestId::Path(path) => write!(f, "{}", path),`
	`41`	`+ TestId::Name(name) => name.fmt(f),`
	`42`	`+ TestId::Path(path) => path.fmt(f),`
`43`	`43`	`}`
`44`	`44`	`}`
`45`	`45`	`}`