Fix clippy lints for all crates and features

... and check those in CI as well!

.github/workflows/lint.yml

@@ -9,4 +9,4 @@ jobs:
         components: clippy
     - uses: actions/checkout@master
     - name: Check lints
-      run: cargo clippy --all --no-deps
+      run: cargo clippy --all --all-features --no-deps

examples/color_palette/src/main.rs

@@ -84,7 +84,7 @@ impl Sandbox for ColorPalette {
 }
 
 #[derive(Debug)]
-pub struct Theme {
+struct Theme {
     lower: Vec<Color>,
     base: Color,
     higher: Vec<Color>,

examples/component/src/main.rs

@@ -150,8 +150,7 @@ mod numeric_input {
                     self.value
                         .as_ref()
                         .map(u32::to_string)
-                        .as_ref()
+                        .as_deref()
-                        .map(String::as_str)
                         .unwrap_or(""),
                     Event::InputChanged,
                 )

examples/custom_widget/src/main.rs

@@ -64,12 +64,12 @@ mod circle {
         }
     }
 
-    impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>> for Circle
+    impl<'a, Message, Renderer> From<Circle> for Element<'a, Message, Renderer>
     where
         Renderer: renderer::Renderer,
     {
-        fn into(self) -> Element<'a, Message, Renderer> {
+        fn from(circle: Circle) -> Self {
-            Element::new(self)
+            Self::new(circle)
         }
     }
 }

examples/download_progress/src/main.rs

@@ -49,7 +49,7 @@ impl Application for Example {
     fn update(&mut self, message: Message) -> Command<Message> {
         match message {
             Message::Add => {
-                self.last_id = self.last_id + 1;
+                self.last_id += 1;
 
                 self.downloads.push(Download::new(self.last_id));
             }
@@ -134,8 +134,8 @@ impl Download {
     }
 
     pub fn progress(&mut self, new_progress: download::Progress) {
-        match &mut self.state {
+        if let State::Downloading { progress } = &mut self.state {
-            State::Downloading { progress } => match new_progress {
+            match new_progress {
                 download::Progress::Started => {
                     *progress = 0.0;
                 }
@@ -152,8 +152,7 @@ impl Download {
                         button: button::State::new(),
                     };
                 }
-            },
+            }
-            _ => {}
         }
     }
 

examples/game_of_life/src/main.rs

@@ -280,7 +280,7 @@ mod grid {
             }
         }
 
-        pub fn view<'a>(&'a mut self) -> Element<'a, Message> {
+        pub fn view(&mut self) -> Element<Message> {
             Canvas::new(self)
                 .width(Length::Fill)
                 .height(Length::Fill)
@@ -328,7 +328,7 @@ mod grid {
         }
     }
 
-    impl<'a> canvas::Program<Message> for Grid {
+    impl canvas::Program<Message> for Grid {
         fn update(
             &mut self,
             event: Event,
@@ -826,13 +826,13 @@ struct Controls {
 }
 
 impl Controls {
-    fn view<'a>(
+    fn view(
-        &'a mut self,
+        &mut self,
         is_playing: bool,
         is_grid_enabled: bool,
         speed: usize,
         preset: Preset,
-    ) -> Element<'a, Message> {
+    ) -> Element<Message> {
         let playback_controls = Row::new()
             .spacing(10)
             .push(

examples/game_of_life/src/preset.rs

@@ -1,7 +1,7 @@
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Preset {
     Custom,
-    XKCD,
+    Xkcd,
     Glider,
     SmallExploder,
     Exploder,
@@ -14,7 +14,7 @@ pub enum Preset {
 
 pub static ALL: &[Preset] = &[
     Preset::Custom,
-    Preset::XKCD,
+    Preset::Xkcd,
     Preset::Glider,
     Preset::SmallExploder,
     Preset::Exploder,
@@ -30,7 +30,7 @@ impl Preset {
         #[rustfmt::skip]
         let cells = match self {
             Preset::Custom => vec![],
-            Preset::XKCD => vec![
+            Preset::Xkcd => vec![
                 "  xxx  ",
                 "  x x  ",
                 "  x x  ",
@@ -116,7 +116,7 @@ impl Preset {
 
 impl Default for Preset {
     fn default() -> Preset {
-        Preset::XKCD
+        Preset::Xkcd
     }
 }
 
@@ -127,7 +127,7 @@ impl std::fmt::Display for Preset {
             "{}",
             match self {
                 Preset::Custom => "Custom",
-                Preset::XKCD => "xkcd #2293",
+                Preset::Xkcd => "xkcd #2293",
                 Preset::Glider => "Glider",
                 Preset::SmallExploder => "Small Exploder",
                 Preset::Exploder => "Exploder",

examples/geometry/src/main.rs

@@ -17,6 +17,7 @@ mod rainbow {
         layout, Element, Layout, Length, Point, Rectangle, Size, Vector, Widget,
     };
 
+    #[derive(Default)]
     pub struct Rainbow;
 
     impl Rainbow {
@@ -148,12 +149,12 @@ mod rainbow {
         }
     }
 
-    impl<'a, Message, B, T> Into<Element<'a, Message, Renderer<B, T>>> for Rainbow
+    impl<'a, Message, B, T> From<Rainbow> for Element<'a, Message, Renderer<B, T>>
     where
         B: Backend,
     {
-        fn into(self) -> Element<'a, Message, Renderer<B, T>> {
+        fn from(rainbow: Rainbow) -> Self {
-            Element::new(self)
+            Self::new(rainbow)
         }
     }
 }

examples/integration_opengl/src/main.rs

@@ -58,7 +58,7 @@ pub fn main() {
 
     let mut cursor_position = PhysicalPosition::new(-1.0, -1.0);
     let mut modifiers = ModifiersState::default();
-    let mut clipboard = Clipboard::connect(&windowed_context.window());
+    let mut clipboard = Clipboard::connect(windowed_context.window());
 
     let mut renderer = Renderer::new(Backend::new(&gl, Settings::default()));
 
@@ -73,13 +73,12 @@ pub fn main() {
     );
     let mut resized = false;
 
-    let scene = Scene::new(&gl, &shader_version);
+    let scene = Scene::new(&gl, shader_version);
 
     event_loop.run(move |event, _, control_flow| {
         *control_flow = ControlFlow::Wait;
 
         match event {
-            Event::LoopDestroyed => return,
             Event::WindowEvent { event, .. } => {
                 match event {
                     WindowEvent::CursorMoved { position, .. } => {

examples/integration_wgpu/src/controls.rs

@@ -112,7 +112,7 @@ impl Program for Controls {
                                 t,
                                 "Placeholder",
                                 text,
-                                move |text| Message::TextChanged(text),
+                                Message::TextChanged,
                             )),
                     ),
             )

examples/integration_wgpu/src/main.rs

@@ -73,7 +73,7 @@ pub fn main() {
     let instance = wgpu::Instance::new(backend);
     let surface = unsafe { instance.create_surface(&window) };
 
-    let (format, (mut device, queue)) = futures::executor::block_on(async {
+    let (format, (device, queue)) = futures::executor::block_on(async {
         let adapter = wgpu::util::initialize_adapter_from_env_or_default(
             &instance,
             backend,
@@ -128,13 +128,13 @@ pub fn main() {
     let mut staging_belt = wgpu::util::StagingBelt::new(5 * 1024);
 
     // Initialize scene and GUI controls
-    let scene = Scene::new(&mut device, format);
+    let scene = Scene::new(&device, format);
     let controls = Controls::new();
 
     // Initialize iced
     let mut debug = Debug::new();
     let mut renderer =
-        Renderer::new(Backend::new(&mut device, Settings::default(), format));
+        Renderer::new(Backend::new(&device, Settings::default(), format));
 
     let mut state = program::State::new(
         controls,
@@ -208,8 +208,8 @@ pub fn main() {
                     surface.configure(
                         &device,
                         &wgpu::SurfaceConfiguration {
+                            format,
                             usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
-                            format: format,
                             width: size.width,
                             height: size.height,
                             present_mode: wgpu::PresentMode::AutoVsync,
@@ -244,7 +244,7 @@ pub fn main() {
                         // And then iced on top
                         renderer.with_primitives(|backend, primitive| {
                             backend.present(
-                                &mut device,
+                                &device,
                                 &mut staging_belt,
                                 &mut encoder,
                                 &view,

examples/integration_wgpu/src/scene.rs

@@ -66,40 +66,37 @@ fn build_pipeline(
             bind_group_layouts: &[],
         });
 
-    let pipeline =
+    device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-        device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+        label: None,
-            label: None,
+        layout: Some(&pipeline_layout),
-            layout: Some(&pipeline_layout),
+        vertex: wgpu::VertexState {
-            vertex: wgpu::VertexState {
+            module: &vs_module,
-                module: &vs_module,
+            entry_point: "main",
-                entry_point: "main",
+            buffers: &[],
-                buffers: &[],
+        },
-            },
+        fragment: Some(wgpu::FragmentState {
-            fragment: Some(wgpu::FragmentState {
+            module: &fs_module,
-                module: &fs_module,
+            entry_point: "main",
-                entry_point: "main",
+            targets: &[Some(wgpu::ColorTargetState {
-                targets: &[Some(wgpu::ColorTargetState {
+                format: texture_format,
-                    format: texture_format,
+                blend: Some(wgpu::BlendState {
-                    blend: Some(wgpu::BlendState {
+                    color: wgpu::BlendComponent::REPLACE,
-                        color: wgpu::BlendComponent::REPLACE,
+                    alpha: wgpu::BlendComponent::REPLACE,
-                        alpha: wgpu::BlendComponent::REPLACE,
+                }),
-                    }),
+                write_mask: wgpu::ColorWrites::ALL,
-                    write_mask: wgpu::ColorWrites::ALL,
+            })],
-                })],
+        }),
-            }),
+        primitive: wgpu::PrimitiveState {
-            primitive: wgpu::PrimitiveState {
+            topology: wgpu::PrimitiveTopology::TriangleList,
-                topology: wgpu::PrimitiveTopology::TriangleList,
+            front_face: wgpu::FrontFace::Ccw,
-                front_face: wgpu::FrontFace::Ccw,
+            ..Default::default()
-                ..Default::default()
+        },
-            },
+        depth_stencil: None,
-            depth_stencil: None,
+        multisample: wgpu::MultisampleState {
-            multisample: wgpu::MultisampleState {
+            count: 1,
-                count: 1,
+            mask: !0,
-                mask: !0,
+            alpha_to_coverage_enabled: false,
-                alpha_to_coverage_enabled: false,
+        },
-            },
+        multiview: None,
-            multiview: None,
+    })
-        });
-
-    pipeline
 }

examples/pokedex/src/main.rs

@@ -192,8 +192,7 @@ impl Pokemon {
         let description = entry
             .flavor_text_entries
             .iter()
-            .filter(|text| text.language.name == "en")
+            .find(|text| text.language.name == "en")
-            .next()
             .ok_or(Error::LanguageError)?;
 
         Ok(Pokemon {

examples/pure/component/src/main.rs

@@ -143,8 +143,7 @@ mod numeric_input {
                         self.value
                             .as_ref()
                             .map(u32::to_string)
-                            .as_ref()
+                            .as_deref()
-                            .map(String::as_str)
                             .unwrap_or(""),
                         Event::InputChanged,
                     )

examples/pure/game_of_life/src/main.rs

@@ -350,7 +350,7 @@ mod grid {
             }
         }
 
-        pub fn view<'a>(&'a self) -> Element<'a, Message> {
+        pub fn view(&self) -> Element<Message> {
             Canvas::new(self)
                 .width(Length::Fill)
                 .height(Length::Fill)

examples/pure/game_of_life/src/preset.rs

@@ -1,7 +1,7 @@
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Preset {
     Custom,
-    XKCD,
+    Xkcd,
     Glider,
     SmallExploder,
     Exploder,
@@ -14,7 +14,7 @@ pub enum Preset {
 
 pub static ALL: &[Preset] = &[
     Preset::Custom,
-    Preset::XKCD,
+    Preset::Xkcd,
     Preset::Glider,
     Preset::SmallExploder,
     Preset::Exploder,
@@ -30,7 +30,7 @@ impl Preset {
         #[rustfmt::skip]
         let cells = match self {
             Preset::Custom => vec![],
-            Preset::XKCD => vec![
+            Preset::Xkcd => vec![
                 "  xxx  ",
                 "  x x  ",
                 "  x x  ",
@@ -116,7 +116,7 @@ impl Preset {
 
 impl Default for Preset {
     fn default() -> Preset {
-        Preset::XKCD
+        Preset::Xkcd
     }
 }
 
@@ -127,7 +127,7 @@ impl std::fmt::Display for Preset {
             "{}",
             match self {
                 Preset::Custom => "Custom",
-                Preset::XKCD => "xkcd #2293",
+                Preset::Xkcd => "xkcd #2293",
                 Preset::Glider => "Glider",
                 Preset::SmallExploder => "Small Exploder",
                 Preset::Exploder => "Exploder",

examples/pure/todos/src/main.rs

@@ -167,7 +167,7 @@ impl Application for Todos {
                 .size(30)
                 .on_submit(Message::CreateTask);
 
-                let controls = view_controls(&tasks, *filter);
+                let controls = view_controls(tasks, *filter);
                 let filtered_tasks =
                     tasks.iter().filter(|task| filter.matches(task));
 
@@ -446,15 +446,15 @@ struct SavedState {
 
 #[derive(Debug, Clone)]
 enum LoadError {
-    FileError,
+    File,
-    FormatError,
+    Format,
 }
 
 #[derive(Debug, Clone)]
 enum SaveError {
-    FileError,
+    File,
-    WriteError,
+    Write,
-    FormatError,
+    Format,
 }
 
 #[cfg(not(target_arch = "wasm32"))]
@@ -465,7 +465,7 @@ impl SavedState {
         {
             project_dirs.data_dir().into()
         } else {
-            std::env::current_dir().unwrap_or(std::path::PathBuf::new())
+            std::env::current_dir().unwrap_or_default()
         };
 
         path.push("todos.json");
@@ -480,37 +480,37 @@ impl SavedState {
 
         let mut file = async_std::fs::File::open(Self::path())
             .await
-            .map_err(|_| LoadError::FileError)?;
+            .map_err(|_| LoadError::File)?;
 
         file.read_to_string(&mut contents)
             .await
-            .map_err(|_| LoadError::FileError)?;
+            .map_err(|_| LoadError::File)?;
 
-        serde_json::from_str(&contents).map_err(|_| LoadError::FormatError)
+        serde_json::from_str(&contents).map_err(|_| LoadError::Format)
     }
 
     async fn save(self) -> Result<(), SaveError> {
         use async_std::prelude::*;
 
         let json = serde_json::to_string_pretty(&self)
-            .map_err(|_| SaveError::FormatError)?;
+            .map_err(|_| SaveError::Format)?;
 
         let path = Self::path();
 
         if let Some(dir) = path.parent() {
             async_std::fs::create_dir_all(dir)
                 .await
-                .map_err(|_| SaveError::FileError)?;
+                .map_err(|_| SaveError::File)?;
         }
 
         {
             let mut file = async_std::fs::File::create(path)
                 .await
-                .map_err(|_| SaveError::FileError)?;
+                .map_err(|_| SaveError::File)?;
 
             file.write_all(json.as_bytes())
                 .await
-                .map_err(|_| SaveError::WriteError)?;
+                .map_err(|_| SaveError::Write)?;
         }
 
         // This is a simple way to save at most once every couple seconds

examples/pure/tour/src/main.rs

@@ -78,14 +78,6 @@ impl Sandbox for Tour {
             .push(controls)
             .into();
 
-        let content = if self.debug {
-            // TODO
-            //content.explain(Color::BLACK)
-            content
-        } else {
-            content
-        };
-
         let scrollable =
             scrollable(container(content).width(Length::Fill).center_x());
 
@@ -494,7 +486,7 @@ impl<'a> Step {
             .push(ferris(width))
             .push(slider(100..=500, width, StepMessage::ImageWidthChanged))
             .push(
-                text(format!("Width: {} px", width.to_string()))
+                text(format!("Width: {} px", width))
                     .width(Length::Fill)
                     .horizontal_alignment(alignment::Horizontal::Center),
             )

examples/solar_system/src/main.rs

@@ -65,8 +65,7 @@ impl Application for SolarSystem {
     }
 
     fn subscription(&self) -> Subscription<Message> {
-        time::every(std::time::Duration::from_millis(10))
+        time::every(std::time::Duration::from_millis(10)).map(Message::Tick)
-            .map(|instant| Message::Tick(instant))
     }
 
     fn view(&mut self) -> Element<Message> {

examples/stopwatch/src/main.rs

@@ -67,13 +67,12 @@ impl Application for Stopwatch {
                     self.state = State::Idle;
                 }
             },
-            Message::Tick(now) => match &mut self.state {
+            Message::Tick(now) => {
-                State::Ticking { last_tick } => {
+                if let State::Ticking { last_tick } = &mut self.state {
                     self.duration += now - *last_tick;
                     *last_tick = now;
                 }
-                _ => {}
+            }
-            },
             Message::Reset => {
                 self.duration = Duration::default();
             }

examples/system_information/src/main.rs

@@ -107,11 +107,8 @@ impl Application for Example {
                     ByteSize::kb(information.memory_total).to_string();
 
                 let memory_total = Text::new(format!(
-                    "Memory (total): {}",
+                    "Memory (total): {} kb ({})",
-                    format!(
+                    information.memory_total, memory_readable
-                        "{} kb ({})",
-                        information.memory_total, memory_readable
-                    )
                 ));
 
                 let memory_text = if let Some(memory_used) =

examples/todos/src/main.rs

@@ -168,7 +168,7 @@ impl Application for Todos {
                 .size(30)
                 .on_submit(Message::CreateTask);
 
-                let controls = controls.view(&tasks, *filter);
+                let controls = controls.view(tasks, *filter);
                 let filtered_tasks =
                     tasks.iter().filter(|task| filter.matches(task));
 
@@ -493,15 +493,15 @@ struct SavedState {
 
 #[derive(Debug, Clone)]
 enum LoadError {
-    FileError,
+    File,
-    FormatError,
+    Format,
 }
 
 #[derive(Debug, Clone)]
 enum SaveError {
-    FileError,
+    File,
-    WriteError,
+    Write,
-    FormatError,
+    Format,
 }
 
 #[cfg(not(target_arch = "wasm32"))]
@@ -512,7 +512,7 @@ impl SavedState {
         {
             project_dirs.data_dir().into()
         } else {
-            std::env::current_dir().unwrap_or(std::path::PathBuf::new())
+            std::env::current_dir().unwrap_or_default()
         };
 
         path.push("todos.json");
@@ -527,37 +527,37 @@ impl SavedState {
 
         let mut file = async_std::fs::File::open(Self::path())
             .await
-            .map_err(|_| LoadError::FileError)?;
+            .map_err(|_| LoadError::File)?;
 
         file.read_to_string(&mut contents)
             .await
-            .map_err(|_| LoadError::FileError)?;
+            .map_err(|_| LoadError::File)?;
 
-        serde_json::from_str(&contents).map_err(|_| LoadError::FormatError)
+        serde_json::from_str(&contents).map_err(|_| LoadError::Format)
     }
 
     async fn save(self) -> Result<(), SaveError> {
         use async_std::prelude::*;
 
         let json = serde_json::to_string_pretty(&self)
-            .map_err(|_| SaveError::FormatError)?;
+            .map_err(|_| SaveError::Format)?;
 
         let path = Self::path();
 
         if let Some(dir) = path.parent() {
             async_std::fs::create_dir_all(dir)
                 .await
-                .map_err(|_| SaveError::FileError)?;
+                .map_err(|_| SaveError::File)?;
         }
 
         {
             let mut file = async_std::fs::File::create(path)
                 .await
-                .map_err(|_| SaveError::FileError)?;
+                .map_err(|_| SaveError::File)?;
 
             file.write_all(json.as_bytes())
                 .await
-                .map_err(|_| SaveError::WriteError)?;
+                .map_err(|_| SaveError::Write)?;
         }
 
         // This is a simple way to save at most once every couple seconds

examples/tooltip/src/main.rs

@@ -54,16 +54,11 @@ impl Sandbox for Example {
             tooltip::Position::Right,
         );
 
-        let fixed_tooltips = Row::with_children(vec![
+        let fixed_tooltips = Row::with_children(vec![top, bottom, left, right])
-            top.into(),
+            .width(Length::Fill)
-            bottom.into(),
+            .height(Length::Fill)
-            left.into(),
+            .align_items(Alignment::Center)
-            right.into(),
+            .spacing(50);
-        ])
-        .width(Length::Fill)
-        .height(Length::Fill)
-        .align_items(Alignment::Center)
-        .spacing(50);
 
         let follow_cursor = tooltip(
             "Tooltip follows cursor",
@@ -78,7 +73,7 @@ impl Sandbox for Example {
                 .center_x()
                 .center_y()
                 .into(),
-            follow_cursor.into(),
+            follow_cursor,
         ])
         .width(Length::Fill)
         .height(Length::Fill)

examples/url_handler/src/main.rs

@@ -57,7 +57,7 @@ impl Application for App {
 
     fn view(&mut self) -> Element<Message> {
         let content = match &self.url {
-            Some(url) => Text::new(format!("{}", url)),
+            Some(url) => Text::new(url),
             None => Text::new("No URL received yet!"),
         };
 

examples/websocket/src/echo.rs

@@ -32,7 +32,7 @@ pub fn connect() -> Subscription<Event> {
                             )
                         }
                         Err(_) => {
-                            let _ = tokio::time::sleep(
+                            tokio::time::sleep(
                                 tokio::time::Duration::from_secs(1),
                             )
                             .await;
@@ -79,6 +79,7 @@ pub fn connect() -> Subscription<Event> {
 }
 
 #[derive(Debug)]
+#[allow(clippy::large_enum_variant)]
 enum State {
     Disconnected,
     Connected(
@@ -101,8 +102,7 @@ pub struct Connection(mpsc::Sender<Message>);
 
 impl Connection {
     pub fn send(&mut self, message: Message) {
-        let _ = self
+        self.0
-            .0
             .try_send(message)
             .expect("Send message to echo server");
     }

examples/websocket/src/echo/server.rs

@@ -27,9 +27,9 @@ use warp::Filter;
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 pub async fn run() {
-    let routes = warp::path::end().and(warp::ws()).map(|ws: warp::ws::Ws| {
+    let routes = warp::path::end()
-        ws.on_upgrade(move |socket| user_connected(socket))
+        .and(warp::ws())
-    });
+        .map(|ws: warp::ws::Ws| ws.on_upgrade(user_connected));
 
     warp::serve(routes).run(([127, 0, 0, 1], 3030)).await;
 }
@@ -40,7 +40,7 @@ async fn user_connected(ws: WebSocket) {
 
     tokio::task::spawn(async move {
         while let Some(message) = rx.next().await {
-            let _ = user_ws_tx.send(message).await.unwrap_or_else(|e| {
+            user_ws_tx.send(message).await.unwrap_or_else(|e| {
                 eprintln!("websocket send error: {}", e);
             });
         }

glow/src/backend.rs

@@ -173,7 +173,6 @@ impl Backend {
                                 glow_glyph::VerticalAlign::Bottom
                             }
                         }),
-                    ..Default::default()
                 };
 
                 self.text_pipeline.queue(text);

glow/src/quad/compatibility.rs

@@ -116,14 +116,7 @@ impl Pipeline {
         // TODO: Remove this allocation (or allocate only when needed)
         let indices: Vec<i32> = (0..instances.len().min(MAX_QUADS) as i32)
             .flat_map(|i| {
-                [
+                [i * 4, 1 + i * 4, 2 + i * 4, 2 + i * 4, 1 + i * 4, 3 + i * 4]
-                    0 + i * 4,
-                    1 + i * 4,
-                    2 + i * 4,
-                    2 + i * 4,
-                    1 + i * 4,
-                    3 + i * 4,
-                ]
             })
             .cycle()
             .take(instances.len() * 6)

graphics/src/font/source.rs

@@ -37,3 +37,9 @@ impl Source {
         }
     }
 }
+
+impl Default for Source {
+    fn default() -> Self {
+        Self::new()
+    }
+}

graphics/src/widget/canvas/path/builder.rs

@@ -151,3 +151,9 @@ impl Builder {
         }
     }
 }
+
+impl Default for Builder {
+    fn default() -> Self {
+        Self::new()
+    }
+}

graphics/src/widget/pure/qr_code.rs

@@ -53,12 +53,12 @@ where
     }
 }
 
-impl<'a, Message, B, T> Into<Element<'a, Message, Renderer<B, T>>>
+impl<'a, Message, B, T> From<QRCode<'a>>
-    for QRCode<'a>
+    for Element<'a, Message, Renderer<B, T>>
 where
     B: Backend,
 {
-    fn into(self) -> Element<'a, Message, Renderer<B, T>> {
+    fn from(qr_code: QRCode<'a>) -> Self {
-        Element::new(self)
+        Self::new(qr_code)
     }
 }

graphics/src/widget/qr_code.rs

@@ -125,13 +125,13 @@ where
     }
 }
 
-impl<'a, Message, B, T> Into<Element<'a, Message, Renderer<B, T>>>
+impl<'a, Message, B, T> From<QRCode<'a>>
-    for QRCode<'a>
+    for Element<'a, Message, Renderer<B, T>>
 where
     B: Backend,
 {
-    fn into(self) -> Element<'a, Message, Renderer<B, T>> {
+    fn from(qr_code: QRCode<'a>) -> Self {
-        Element::new(self)
+        Self::new(qr_code)
     }
 }
 

graphics/src/window/gl_compositor.rs

@@ -35,6 +35,9 @@ pub trait GLCompositor: Sized {
     /// Creates a new [`GLCompositor`] and [`Renderer`] with the given
     /// [`Settings`] and an OpenGL address loader function.
     ///
+    /// # Safety
+    /// The `loader_function` should resolve to valid OpenGL bindings.
+    ///
     /// [`Renderer`]: crate::Renderer
     /// [`Backend`]: crate::Backend
     /// [`Settings`]: Self::Settings

lazy/src/component.rs

@@ -396,7 +396,7 @@ where
                     &mut local_shell,
                 )
             })
-            .unwrap_or_else(|| iced_native::event::Status::Ignored);
+            .unwrap_or(iced_native::event::Status::Ignored);
 
         local_shell.revalidate_layout(|| shell.invalidate_layout());
 

lazy/src/lib.rs

@@ -11,7 +11,11 @@
     clippy::useless_conversion
 )]
 #![forbid(unsafe_code)]
-#![allow(clippy::inherent_to_string, clippy::type_complexity)]
+#![allow(
+    clippy::await_holding_refcell_ref,
+    clippy::inherent_to_string,
+    clippy::type_complexity
+)]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 pub mod component;
 pub mod responsive;

lazy/src/pure/component.rs

@@ -428,7 +428,7 @@ where
                     &mut local_shell,
                 )
             })
-            .unwrap_or_else(|| iced_native::event::Status::Ignored);
+            .unwrap_or(iced_native::event::Status::Ignored);
 
         local_shell.revalidate_layout(|| shell.invalidate_layout());
 

lazy/src/pure/responsive.rs

@@ -383,6 +383,6 @@ where
                 shell,
             )
         })
-        .unwrap_or_else(|| iced_native::event::Status::Ignored)
+        .unwrap_or(iced_native::event::Status::Ignored)
     }
 }

lazy/src/responsive.rs

@@ -224,7 +224,7 @@ where
     where
         R: Deref<Target = Renderer>,
     {
-        self.content.resolve(&mut self.state, renderer, f)
+        self.content.resolve(self.state, renderer, f)
     }
 }
 
@@ -405,6 +405,6 @@ where
                 shell,
             )
         })
-        .unwrap_or_else(|| iced_native::event::Status::Ignored)
+        .unwrap_or(iced_native::event::Status::Ignored)
     }
 }

native/src/debug/basic.rs

@@ -186,6 +186,12 @@ impl Debug {
     }
 }
 
+impl Default for Debug {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 #[derive(Debug)]
 struct TimeBuffer {
     head: usize,

pure/src/lib.rs

@@ -280,13 +280,13 @@ where
     }
 }
 
-impl<'a, Message, Renderer> Into<iced_native::Element<'a, Message, Renderer>>
+impl<'a, Message, Renderer> From<Pure<'a, Message, Renderer>>
-    for Pure<'a, Message, Renderer>
+    for iced_native::Element<'a, Message, Renderer>
 where
     Message: 'a,
     Renderer: iced_native::Renderer + 'a,
 {
-    fn into(self) -> iced_native::Element<'a, Message, Renderer> {
+    fn from(pure: Pure<'a, Message, Renderer>) -> Self {
-        iced_native::Element::new(self)
+        Self::new(pure)
     }
 }

pure/src/widget/button.rs

@@ -159,7 +159,7 @@ where
             self.height,
             self.padding,
             |renderer, limits| {
-                self.content.as_widget().layout(renderer, &limits)
+                self.content.as_widget().layout(renderer, limits)
             },
         )
     }
@@ -261,14 +261,14 @@ where
     }
 }
 
-impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>>
+impl<'a, Message, Renderer> From<Button<'a, Message, Renderer>>
-    for Button<'a, Message, Renderer>
+    for Element<'a, Message, Renderer>
 where
     Message: Clone + 'a,
     Renderer: iced_native::Renderer + 'a,
     Renderer::Theme: StyleSheet,
 {
-    fn into(self) -> Element<'a, Message, Renderer> {
+    fn from(button: Button<'a, Message, Renderer>) -> Self {
-        Element::new(self)
+        Self::new(button)
     }
 }

pure/src/widget/checkbox.rs

@@ -96,14 +96,14 @@ where
     }
 }
 
-impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>>
+impl<'a, Message, Renderer> From<Checkbox<'a, Message, Renderer>>
-    for Checkbox<'a, Message, Renderer>
+    for Element<'a, Message, Renderer>
 where
     Message: 'a,
     Renderer: text::Renderer + 'a,
     Renderer::Theme: StyleSheet + widget::text::StyleSheet,
 {
-    fn into(self) -> Element<'a, Message, Renderer> {
+    fn from(checkbox: Checkbox<'a, Message, Renderer>) -> Self {
-        Element::new(self)
+        Self::new(checkbox)
     }
 }

pure/src/widget/column.rs

@@ -95,6 +95,12 @@ impl<'a, Message, Renderer> Column<'a, Message, Renderer> {
     }
 }
 
+impl<'a, Message, Renderer> Default for Column<'a, Message, Renderer> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl<'a, Message, Renderer> Widget<Message, Renderer>
     for Column<'a, Message, Renderer>
 where
@@ -228,13 +234,13 @@ where
     }
 }
 
-impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>>
+impl<'a, Message, Renderer> From<Column<'a, Message, Renderer>>
-    for Column<'a, Message, Renderer>
+    for Element<'a, Message, Renderer>
 where
     Message: 'a,
     Renderer: iced_native::Renderer + 'a,
 {
-    fn into(self) -> Element<'a, Message, Renderer> {
+    fn from(column: Column<'a, Message, Renderer>) -> Self {
-        Element::new(self)
+        Self::new(column)
     }
 }

pure/src/widget/image.rs

@@ -56,14 +56,14 @@ where
     }
 }
 
-impl<'a, Message, Renderer, Handle> Into<Element<'a, Message, Renderer>>
+impl<'a, Message, Renderer, Handle> From<Image<Handle>>
-    for Image<Handle>
+    for Element<'a, Message, Renderer>
 where
     Message: Clone + 'a,
     Renderer: iced_native::image::Renderer<Handle = Handle> + 'a,
     Handle: Clone + Hash + 'a,
 {
-    fn into(self) -> Element<'a, Message, Renderer> {
+    fn from(image: Image<Handle>) -> Self {
-        Element::new(self)
+        Self::new(image)
     }
 }

pure/src/widget/pick_list.rs

@@ -225,8 +225,8 @@ where
     }
 }
 
-impl<'a, T: 'a, Message, Renderer> Into<Element<'a, Message, Renderer>>
+impl<'a, T: 'a, Message, Renderer> From<PickList<'a, T, Message, Renderer>>
-    for PickList<'a, T, Message, Renderer>
+    for Element<'a, Message, Renderer>
 where
     T: Clone + ToString + Eq + 'static,
     [T]: ToOwned<Owned = Vec<T>>,
@@ -234,7 +234,7 @@ where
     Renderer: text::Renderer + 'a,
     Renderer::Theme: StyleSheet,
 {
-    fn into(self) -> Element<'a, Message, Renderer> {
+    fn from(pick_list: PickList<'a, T, Message, Renderer>) -> Self {
-        Element::new(self)
+        Self::new(pick_list)
     }
 }

pure/src/widget/progress_bar.rs

@@ -10,7 +10,7 @@ use iced_native::{Clipboard, Length, Point, Rectangle, Shell};
 
 pub use iced_native::widget::progress_bar::*;
 
-impl<'a, Message, Renderer> Widget<Message, Renderer> for ProgressBar<Renderer>
+impl<Message, Renderer> Widget<Message, Renderer> for ProgressBar<Renderer>
 where
     Renderer: iced_native::Renderer,
     Renderer::Theme: StyleSheet,
@@ -93,13 +93,13 @@ where
     }
 }
 
-impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>>
+impl<'a, Message, Renderer> From<ProgressBar<Renderer>>
-    for ProgressBar<Renderer>
+    for Element<'a, Message, Renderer>
 where
     Renderer: iced_native::Renderer + 'a,
     Renderer::Theme: StyleSheet,
 {
-    fn into(self) -> Element<'a, Message, Renderer> {
+    fn from(progress_bar: ProgressBar<Renderer>) -> Self {
-        Element::new(self)
+        Self::new(progress_bar)
     }
 }

pure/src/widget/radio.rs

@@ -96,14 +96,14 @@ where
     }
 }
 
-impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>>
+impl<'a, Message, Renderer> From<Radio<Message, Renderer>>
-    for Radio<Message, Renderer>
+    for Element<'a, Message, Renderer>
 where
     Message: 'a + Clone,
     Renderer: text::Renderer + 'a,
     Renderer::Theme: StyleSheet + widget::text::StyleSheet,
 {
-    fn into(self) -> Element<'a, Message, Renderer> {
+    fn from(radio: Radio<Message, Renderer>) -> Self {
-        Element::new(self)
+        Self::new(radio)
     }
 }

pure/src/widget/row.rs

@@ -85,6 +85,12 @@ impl<'a, Message, Renderer> Row<'a, Message, Renderer> {
     }
 }
 
+impl<'a, Message, Renderer> Default for Row<'a, Message, Renderer> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl<'a, Message, Renderer> Widget<Message, Renderer>
     for Row<'a, Message, Renderer>
 where
@@ -215,13 +221,13 @@ where
     }
 }
 
-impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>>
+impl<'a, Message, Renderer> From<Row<'a, Message, Renderer>>
-    for Row<'a, Message, Renderer>
+    for Element<'a, Message, Renderer>
 where
     Message: 'a,
     Renderer: iced_native::Renderer + 'a,
 {
-    fn into(self) -> Element<'a, Message, Renderer> {
+    fn from(row: Row<'a, Message, Renderer>) -> Self {
-        Element::new(self)
+        Self::new(row)
     }
 }

pure/src/widget/rule.rs

@@ -10,7 +10,7 @@ use iced_native::{Clipboard, Length, Point, Rectangle, Shell};
 
 pub use iced_native::widget::rule::*;
 
-impl<'a, Message, Renderer> Widget<Message, Renderer> for Rule<Renderer>
+impl<Message, Renderer> Widget<Message, Renderer> for Rule<Renderer>
 where
     Renderer: iced_native::Renderer,
     Renderer::Theme: StyleSheet,
@@ -93,13 +93,13 @@ where
     }
 }
 
-impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>>
+impl<'a, Message, Renderer> From<Rule<Renderer>>
-    for Rule<Renderer>
+    for Element<'a, Message, Renderer>
 where
     Renderer: iced_native::Renderer + 'a,
     Renderer::Theme: StyleSheet,
 {
-    fn into(self) -> Element<'a, Message, Renderer> {
+    fn from(rule: Rule<Renderer>) -> Self {
-        Element::new(self)
+        Self::new(rule)
     }
 }

pure/src/widget/space.rs

@@ -9,7 +9,7 @@ use iced_native::{Clipboard, Length, Point, Rectangle, Shell};
 
 pub use iced_native::widget::Space;
 
-impl<'a, Message, Renderer> Widget<Message, Renderer> for Space
+impl<Message, Renderer> Widget<Message, Renderer> for Space
 where
     Renderer: iced_native::Renderer,
 {
@@ -91,11 +91,11 @@ where
     }
 }
 
-impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>> for Space
+impl<'a, Message, Renderer> From<Space> for Element<'a, Message, Renderer>
 where
     Renderer: iced_native::Renderer + 'a,
 {
-    fn into(self) -> Element<'a, Message, Renderer> {
+    fn from(space: Space) -> Self {
-        Element::new(self)
+        Self::new(space)
     }
 }

pure/src/widget/svg.rs

@@ -54,12 +54,12 @@ where
     }
 }
 
-impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>> for Svg
+impl<'a, Message, Renderer> From<Svg> for Element<'a, Message, Renderer>
 where
     Message: Clone + 'a,
     Renderer: iced_native::svg::Renderer + 'a,
 {
-    fn into(self) -> Element<'a, Message, Renderer> {
+    fn from(svg: Svg) -> Self {
-        Element::new(self)
+        Self::new(svg)
     }
 }

pure/src/widget/text.rs

@@ -55,23 +55,23 @@ where
     }
 }
 
-impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>>
+impl<'a, Message, Renderer> From<Text<Renderer>>
-    for Text<Renderer>
+    for Element<'a, Message, Renderer>
 where
     Renderer: text::Renderer + 'a,
     Renderer::Theme: widget::text::StyleSheet,
 {
-    fn into(self) -> Element<'a, Message, Renderer> {
+    fn from(text: Text<Renderer>) -> Self {
-        Element::new(self)
+        Self::new(text)
     }
 }
 
-impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>> for &'a str
+impl<'a, Message, Renderer> From<&'a str> for Element<'a, Message, Renderer>
 where
     Renderer: text::Renderer + 'a,
     Renderer::Theme: widget::text::StyleSheet,
 {
-    fn into(self) -> Element<'a, Message, Renderer> {
+    fn from(contents: &'a str) -> Self {
-        Text::new(self).into()
+        Text::new(contents).into()
     }
 }

pure/src/widget/toggler.rs

@@ -96,14 +96,14 @@ where
     }
 }
 
-impl<'a, Message, Renderer> Into<Element<'a, Message, Renderer>>
+impl<'a, Message, Renderer> From<Toggler<'a, Message, Renderer>>
-    for Toggler<'a, Message, Renderer>
+    for Element<'a, Message, Renderer>
 where
     Message: 'a,
     Renderer: text::Renderer + 'a,
     Renderer::Theme: StyleSheet + widget::text::StyleSheet,
 {
-    fn into(self) -> Element<'a, Message, Renderer> {
+    fn from(toggler: Toggler<'a, Message, Renderer>) -> Self {
-        Element::new(self)
+        Self::new(toggler)
     }
 }

src/application.rs

@@ -215,6 +215,7 @@ pub trait Application: Sized {
     where
         Self: 'static,
     {
+        #[allow(clippy::needless_update)]
         let renderer_settings = crate::renderer::Settings {
             default_font: settings.default_font,
             default_text_size: settings.default_text_size,

wgpu/src/image/raster.rs

@@ -103,7 +103,7 @@ impl Cache {
         if let Memory::Host(image) = memory {
             let (width, height) = image.dimensions();
 
-            let entry = atlas.upload(width, height, &image, device, encoder)?;
+            let entry = atlas.upload(width, height, image, device, encoder)?;
 
             *memory = Memory::Device(entry);
         }