Inline log format args (#7600)

crates/eframe/src/epi.rs

@@ -916,7 +916,7 @@ pub fn set_value<T: serde::Serialize>(storage: &mut dyn Storage, key: &str, valu
     profiling::function_scope!(key);
     match ron::ser::to_string(value) {
         Ok(string) => storage.set_string(key, string),
-        Err(err) => log::error!("eframe failed to encode data using ron: {}", err),
+        Err(err) => log::error!("eframe failed to encode data using ron: {err}"),
     }
 }
 

crates/eframe/src/native/file_storage.rs

@@ -118,7 +118,7 @@ impl FileStorage {
     pub(crate) fn from_ron_filepath(ron_filepath: impl Into<PathBuf>) -> Self {
         profiling::function_scope!();
         let ron_filepath: PathBuf = ron_filepath.into();
-        log::debug!("Loading app state from {:?}…", ron_filepath);
+        log::debug!("Loading app state from {}…", ron_filepath.display());
         Self {
             kv: read_ron(&ron_filepath).unwrap_or_default(),
             ron_filepath,
@@ -133,9 +133,8 @@ impl FileStorage {
         if let Some(data_dir) = storage_dir(app_id) {
             if let Err(err) = std::fs::create_dir_all(&data_dir) {
                 log::warn!(
-                    "Saving disabled: Failed to create app path at {:?}: {}",
+                    "Saving disabled: Failed to create app path at {}: {err}",
-                    data_dir,
+                    data_dir.display()
-                    err
                 );
                 None
             } else {
@@ -197,7 +196,7 @@ fn save_to_disk(file_path: &PathBuf, kv: &HashMap<String, String>) {
         && !parent_dir.exists()
         && let Err(err) = std::fs::create_dir_all(parent_dir)
     {
-        log::warn!("Failed to create directory {parent_dir:?}: {err}");
+        log::warn!("Failed to create directory {}: {err}", parent_dir.display());
     }
 
     match std::fs::File::create(file_path) {
@@ -210,13 +209,13 @@ fn save_to_disk(file_path: &PathBuf, kv: &HashMap<String, String>) {
                 .to_io_writer_pretty(&mut writer, &kv, config)
                 .and_then(|_| writer.flush().map_err(|err| err.into()))
             {
-                log::warn!("Failed to serialize app state: {}", err);
+                log::warn!("Failed to serialize app state: {err}");
             } else {
-                log::trace!("Persisted to {:?}", file_path);
+                log::trace!("Persisted to {}", file_path.display());
             }
         }
         Err(err) => {
-            log::warn!("Failed to create file {file_path:?}: {err}");
+            log::warn!("Failed to create file {}: {err}", file_path.display());
         }
     }
 }
@@ -234,7 +233,7 @@ where
             match ron::de::from_reader(reader) {
                 Ok(value) => Some(value),
                 Err(err) => {
-                    log::warn!("Failed to parse RON: {}", err);
+                    log::warn!("Failed to parse RON: {err}");
                     None
                 }
             }

crates/eframe/src/web/events.rs

@@ -998,7 +998,10 @@ fn install_drag_and_drop(runner_ref: &WebRunner, target: &EventTarget) -> Result
                                         }
                                     }
                                     Err(err) => {
-                                        log::error!("Failed to read file: {:?}", err);
+                                        log::error!(
+                                            "Failed to read file: {}",
+                                            string_from_js_value(&err)
+                                        );
                                     }
                                 }
                             };

crates/egui-wgpu/src/capture.rs

@@ -198,15 +198,14 @@ impl CaptureState {
             wgpu::TextureFormat::Bgra8Unorm => [2, 1, 0, 3],
             _ => {
                 log::error!(
-                    "Screen can't be captured unless the surface format is Rgba8Unorm or Bgra8Unorm. Current surface format is {:?}",
+                    "Screen can't be captured unless the surface format is Rgba8Unorm or Bgra8Unorm. Current surface format is {format:?}"
-                    format
                 );
                 return;
             }
         };
         buffer_slice.map_async(wgpu::MapMode::Read, move |result| {
             if let Err(err) = result {
-                log::error!("Failed to map buffer for reading: {:?}", err);
+                log::error!("Failed to map buffer for reading: {err}");
                 return;
             }
             let buffer_slice = buffer.slice(..);

crates/egui-wgpu/src/renderer.rs

@@ -344,7 +344,7 @@ impl Renderer {
                 fragment: Some(wgpu::FragmentState {
                     module: &module,
                     entry_point: Some(if output_color_format.is_srgb() {
-                        log::warn!("Detected a linear (sRGBA aware) framebuffer {:?}. egui prefers Rgba8Unorm or Bgra8Unorm", output_color_format);
+                        log::warn!("Detected a linear (sRGBA aware) framebuffer {output_color_format:?}. egui prefers Rgba8Unorm or Bgra8Unorm");
                         "fs_main_linear_framebuffer"
                     } else {
                         "fs_main_gamma_framebuffer" // this is what we prefer

crates/egui-wgpu/src/setup.rs

@@ -64,7 +64,7 @@ impl WgpuSetup {
                     }
                 }
 
-                log::debug!("Creating wgpu instance with backends {:?}", backends);
+                log::debug!("Creating wgpu instance with backends {backends:?}");
                 wgpu::util::new_instance_with_webgpu_detection(&create_new.instance_descriptor)
                     .await
             }

crates/egui-winit/src/lib.rs

@@ -1064,7 +1064,7 @@ pub fn update_viewport_info(
 fn open_url_in_browser(_url: &str) {
     #[cfg(feature = "webbrowser")]
     if let Err(err) = webbrowser::open(_url) {
-        log::warn!("Failed to open url: {}", err);
+        log::warn!("Failed to open url: {err}");
     }
 
     #[cfg(not(feature = "webbrowser"))]

crates/egui_demo_app/src/apps/custom3d_glow.rs

@@ -91,10 +91,7 @@ impl RotatingTriangle {
             let program = gl.create_program().expect("Cannot create program");
 
             if !shader_version.is_new_shader_interface() {
-                log::warn!(
+                log::warn!("Custom 3D painting hasn't been ported to {shader_version:?}");
-                    "Custom 3D painting hasn't been ported to {:?}",
-                    shader_version
-                );
                 return None;
             }
 

crates/egui_glow/examples/pure_glow.rs

@@ -66,7 +66,7 @@ impl GlutinWindowContext {
                 .expect("failed to get window handle")
                 .as_raw()
         });
-        log::debug!("raw window handle: {:?}", raw_window_handle);
+        log::debug!("raw window handle: {raw_window_handle:?}");
         let context_attributes =
             glutin::context::ContextAttributesBuilder::new().build(raw_window_handle);
         // by default, glutin will try to create a core opengl context. but, if it is not available, try to create a gl-es context using this fallback attributes

crates/egui_glow/src/lib.rs

@@ -88,20 +88,11 @@ pub fn check_for_gl_error_impl(gl: &glow::Context, file: &str, line: u32, contex
 
         if context.is_empty() {
             log::error!(
-                "GL error, at {}:{}: {} (0x{:X}). Please file a bug at https://github.com/emilk/egui/issues",
+                "GL error, at {file}:{line}: {error_str} (0x{error_code:X}). Please file a bug at https://github.com/emilk/egui/issues"
-                file,
-                line,
-                error_str,
-                error_code,
             );
         } else {
             log::error!(
-                "GL error, at {}:{} ({}): {} (0x{:X}). Please file a bug at https://github.com/emilk/egui/issues",
+                "GL error, at {file}:{line} ({context}): {error_str} (0x{error_code:X}). Please file a bug at https://github.com/emilk/egui/issues"
-                file,
-                line,
-                context,
-                error_str,
-                error_code,
             );
         }
     }

crates/egui_glow/src/painter.rs

@@ -168,7 +168,7 @@ impl Painter {
         let shader_version = shader_version.unwrap_or_else(|| ShaderVersion::get(&gl));
         let is_webgl_1 = shader_version == ShaderVersion::Es100;
         let shader_version_declaration = shader_version.version_declaration();
-        log::debug!("Shader header: {:?}.", shader_version_declaration);
+        log::debug!("Shader header: {shader_version_declaration:?}.");
 
         let supported_extensions = gl.supported_extensions();
         log::trace!("OpenGL extensions: {supported_extensions:?}");
@@ -179,7 +179,7 @@ impl Painter {
                 // {GL,GLX,WGL}_ARB_framebuffer_sRGB, …
                 extension.ends_with("ARB_framebuffer_sRGB")
             });
-        log::debug!("SRGB framebuffer Support: {:?}", supports_srgb_framebuffer);
+        log::debug!("SRGB framebuffer Support: {supports_srgb_framebuffer}");
 
         unsafe {
             let vert = compile_shader(

crates/egui_glow/src/shader_version.rs

@@ -24,11 +24,7 @@ impl ShaderVersion {
         let shading_lang_string =
             unsafe { gl.get_parameter_string(glow::SHADING_LANGUAGE_VERSION) };
         let shader_version = Self::parse(&shading_lang_string);
-        log::debug!(
+        log::debug!("Shader version: {shader_version:?} ({shading_lang_string:?}).");
-            "Shader version: {:?} ({:?}).",
-            shader_version,
-            shading_lang_string
-        );
         shader_version
     }
 

crates/egui_glow/src/vao.rs

@@ -118,7 +118,7 @@ fn supports_vao(gl: &glow::Context) -> bool {
     const OPENGL_ES_PREFIX: &str = "OpenGL ES ";
 
     let version_string = unsafe { gl.get_parameter_string(glow::VERSION) };
-    log::debug!("GL version: {:?}.", version_string);
+    log::debug!("GL version: {version_string:?}.");
 
     // Examples:
     // * "WebGL 2.0 (OpenGL ES 3.0 Chromium)"
@@ -129,7 +129,7 @@ fn supports_vao(gl: &glow::Context) -> bool {
         if version_str.contains("1.0") {
             // need to test OES_vertex_array_object .
             let supported_extensions = gl.supported_extensions();
-            log::debug!("Supported OpenGL extensions: {:?}", supported_extensions);
+            log::debug!("Supported OpenGL extensions: {supported_extensions:?}");
             supported_extensions.contains("OES_vertex_array_object")
                 || supported_extensions.contains("GL_OES_vertex_array_object")
         } else {
@@ -140,7 +140,7 @@ fn supports_vao(gl: &glow::Context) -> bool {
         if version_string.contains("2.0") {
             // need to test OES_vertex_array_object .
             let supported_extensions = gl.supported_extensions();
-            log::debug!("Supported OpenGL extensions: {:?}", supported_extensions);
+            log::debug!("Supported OpenGL extensions: {supported_extensions:?}");
             supported_extensions.contains("OES_vertex_array_object")
                 || supported_extensions.contains("GL_OES_vertex_array_object")
         } else {
@@ -152,7 +152,7 @@ fn supports_vao(gl: &glow::Context) -> bool {
             // I found APPLE_vertex_array_object , GL_ATI_vertex_array_object ,ARB_vertex_array_object
             // but APPLE's and ATI's very old extension.
             let supported_extensions = gl.supported_extensions();
-            log::debug!("Supported OpenGL extensions: {:?}", supported_extensions);
+            log::debug!("Supported OpenGL extensions: {supported_extensions:?}");
             supported_extensions.contains("ARB_vertex_array_object")
                 || supported_extensions.contains("GL_ARB_vertex_array_object")
         } else {

crates/egui_glow/src/winit.rs

@@ -89,7 +89,7 @@ impl EguiGlow {
                 &mut actions_requested,
             );
             for action in actions_requested {
-                log::warn!("{:?} not yet supported by EguiGlow", action);
+                log::warn!("{action:?} not yet supported by EguiGlow");
             }
         }
 

crates/egui_kittest/src/snapshot.rs

@@ -520,7 +520,7 @@ pub fn image_snapshot_options(
     match try_image_snapshot_options(current, name, options) {
         Ok(_) => {}
         Err(err) => {
-            panic!("{}", err);
+            panic!("{err}");
         }
     }
 }
@@ -539,7 +539,7 @@ pub fn image_snapshot(current: &image::RgbaImage, name: impl Into<String>) {
     match try_image_snapshot(current, name) {
         Ok(_) => {}
         Err(err) => {
-            panic!("{}", err);
+            panic!("{err}");
         }
     }
 }
@@ -613,7 +613,7 @@ impl<State> Harness<'_, State> {
         match self.try_snapshot_options(name, options) {
             Ok(_) => {}
             Err(err) => {
-                panic!("{}", err);
+                panic!("{err}");
             }
         }
     }
@@ -631,7 +631,7 @@ impl<State> Harness<'_, State> {
         match self.try_snapshot(name) {
             Ok(_) => {}
             Err(err) => {
-                panic!("{}", err);
+                panic!("{err}");
             }
         }
     }