Use write_str() instead of write!() when possible

Reduces code size

Author: kornelski

compiler/rustc_ast/src/util/literal.rs

@@ -210,7 +210,7 @@ impl fmt::Display for LitKind {
             LitKind::Err => {
                 // This only shows up in places like `-Zunpretty=hir` output, so we
                 // don't bother to produce something useful.
-                write!(f, "<bad-literal>")?;
+                f.write_str("<bad-literal>")?;
             }
         }
 

compiler/rustc_const_eval/src/const_eval/error.rs

@@ -37,9 +37,9 @@ impl fmt::Display for ConstEvalErrKind {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         use self::ConstEvalErrKind::*;
         match self {
-            ConstAccessesStatic => write!(f, "constant accesses static"),
+            ConstAccessesStatic => f.write_str("constant accesses static"),
             ModifiedGlobal => {
-                write!(f, "modifying a static's initial value from another static's initializer")
+                f.write_str("modifying a static's initial value from another static's initializer")
             }
             AssertFailure(msg) => write!(f, "{:?}", msg),
             Panic { msg, line, col, file } => {

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -147,7 +147,7 @@ pub enum MemoryKind {
 impl fmt::Display for MemoryKind {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            MemoryKind::Heap => write!(f, "heap allocation"),
+            MemoryKind::Heap => f.write_str("heap allocation"),
         }
     }
 }

compiler/rustc_const_eval/src/interpret/eval_context.rs

@@ -265,7 +265,7 @@ impl<'tcx> fmt::Display for FrameInfo<'tcx> {
             if tcx.def_key(self.instance.def_id()).disambiguated_data.data
                 == DefPathData::ClosureExpr
             {
-                write!(f, "inside closure")
+                f.write_str("inside closure")
             } else {
                 // Note: this triggers a `good_path_bug` state, which means that if we ever get here
                 // we must emit a diagnostic. We should never display a `FrameInfo` unless we
@@ -987,12 +987,12 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> std::fmt::Debug
                 if frame != self.ecx.frame_idx() {
                     write!(fmt, " ({} frames up)", self.ecx.frame_idx() - frame)?;
                 }
-                write!(fmt, ":")?;
+                fmt.write_str(":")?;
 
                 match self.ecx.stack()[frame].locals[local].value {
-                    LocalValue::Dead => write!(fmt, " is dead")?,
+                    LocalValue::Dead => fmt.write_str(" is dead")?,
                     LocalValue::Live(Operand::Immediate(Immediate::Uninit)) => {
-                        write!(fmt, " is uninitialized")?
+                        fmt.write_str(" is uninitialized")?
                     }
                     LocalValue::Live(Operand::Indirect(mplace)) => {
                         write!(

compiler/rustc_const_eval/src/interpret/memory.rs

@@ -50,8 +50,8 @@ impl<T: MayLeak> MayLeak for MemoryKind<T> {
 impl<T: fmt::Display> fmt::Display for MemoryKind<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            MemoryKind::Stack => write!(f, "stack variable"),
-            MemoryKind::CallerLocation => write!(f, "caller location"),
+            MemoryKind::Stack => f.write_str("stack variable"),
+            MemoryKind::CallerLocation => f.write_str("caller location"),
             MemoryKind::Machine(m) => write!(f, "{}", m),
         }
     }
@@ -893,7 +893,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> std::fmt::Debug for DumpAllocs<'a,
                     // global alloc
                     match self.ecx.tcx.try_get_global_alloc(id) {
                         Some(GlobalAlloc::Memory(alloc)) => {
-                            write!(fmt, " (unchanged global, ")?;
+                            fmt.write_str(" (unchanged global, ")?;
                             write_allocation_track_relocs(
                                 &mut *fmt,
                                 *self.ecx.tcx,
@@ -914,7 +914,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> std::fmt::Debug for DumpAllocs<'a,
                             write!(fmt, " (static: {})", self.ecx.tcx.def_path_str(did))?;
                         }
                         None => {
-                            write!(fmt, " (deallocated)")?;
+                            fmt.write_str(" (deallocated)")?;
                         }
                     }
                 }

compiler/rustc_driver_impl/src/args.rs

@@ -41,7 +41,7 @@ pub enum Error {
 impl fmt::Display for Error {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Error::Utf8Error(None) => write!(fmt, "Utf8 error"),
+            Error::Utf8Error(None) => fmt.write_str("Utf8 error"),
             Error::Utf8Error(Some(path)) => write!(fmt, "Utf8 error in {path}"),
             Error::IOError(path, err) => write!(fmt, "IO Error: {path}: {err}"),
         }

compiler/rustc_error_messages/src/lib.rs

@@ -74,15 +74,15 @@ impl fmt::Display for TranslationBundleError {
                 write!(f, "could not parse ftl file: {}", e)
             }
             TranslationBundleError::AddResource(e) => write!(f, "failed to add resource: {}", e),
-            TranslationBundleError::MissingLocale => write!(f, "missing locale directory"),
+            TranslationBundleError::MissingLocale => f.write_str("missing locale directory"),
             TranslationBundleError::ReadLocalesDir(e) => {
                 write!(f, "could not read locales dir: {}", e)
             }
             TranslationBundleError::ReadLocalesDirEntry(e) => {
                 write!(f, "could not read locales dir entry: {}", e)
             }
             TranslationBundleError::LocaleIsNotDir => {
-                write!(f, "`$sysroot/share/locales/$locale` is not a directory")
+                f.write_str("`$sysroot/share/locales/$locale` is not a directory")
             }
         }
     }

compiler/rustc_expand/src/mbe/macro_parser.rs

@@ -157,7 +157,7 @@ impl Display for MatcherLoc {
                 if let Some(kind) = kind {
                     write!(f, ":{}", kind)?;
                 }
-                write!(f, "`")?;
+                f.write_str("`")?;
                 Ok(())
             }
             MatcherLoc::Eof => f.write_str("end of macro"),

compiler/rustc_feature/src/builtin_attrs.rs

@@ -72,7 +72,7 @@ impl std::fmt::Debug for AttributeGate {
             Self::Gated(ref stab, name, expl, _) => {
                 write!(fmt, "Gated({stab:?}, {name}, {expl})")
             }
-            Self::Ungated => write!(fmt, "Ungated"),
+            Self::Ungated => fmt.write_str("Ungated"),
         }
     }
 }

compiler/rustc_feature/src/lib.rs

@@ -38,10 +38,10 @@ pub enum State {
 impl fmt::Debug for State {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            State::Accepted { .. } => write!(f, "accepted"),
-            State::Active { .. } => write!(f, "active"),
-            State::Removed { .. } => write!(f, "removed"),
-            State::Stabilized { .. } => write!(f, "stabilized"),
+            State::Accepted { .. } => f.write_str("accepted"),
+            State::Active { .. } => f.write_str("active"),
+            State::Removed { .. } => f.write_str("removed"),
+            State::Stabilized { .. } => f.write_str("stabilized"),
         }
     }
 }