Merge pull request #1379 from PolyMeilex/fix/clippy

Address Clippy lints

.github/workflows/lint.yml

@@ -0,0 +1,12 @@
+name: Lint
+on: [push, pull_request]
+jobs:
+  all:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: hecrj/setup-rust-action@v1
+      with:
+        components: clippy
+    - uses: actions/checkout@master
+    - name: Check lints
+      run: cargo clippy --all --all-features --no-deps

clippy.toml

@@ -0,0 +1 @@
+too-many-arguments-threshold = 20

core/src/keyboard/modifiers.rs

@@ -5,7 +5,7 @@ bitflags! {
     #[derive(Default)]
     pub struct Modifiers: u32{
         /// The "shift" key.
-        const SHIFT = 0b100 << 0;
+        const SHIFT = 0b100;
         // const LSHIFT = 0b010 << 0;
         // const RSHIFT = 0b001 << 0;
         //

core/src/lib.rs

@@ -12,11 +12,18 @@
 #![doc(
     html_logo_url = "https://raw.githubusercontent.com/iced-rs/iced/9ab6923e943f784985e9ef9ca28b10278297225d/docs/logo.svg"
 )]
-#![deny(missing_docs)]
+#![deny(
-#![deny(missing_debug_implementations)]
+    missing_debug_implementations,
-#![deny(unused_results)]
+    missing_docs,
-#![forbid(unsafe_code)]
+    unused_results,
-#![forbid(rust_2018_idioms)]
+    clippy::extra_unused_lifetimes,
+    clippy::from_over_into,
+    clippy::needless_borrow,
+    clippy::new_without_default,
+    clippy::useless_conversion
+)]
+#![forbid(unsafe_code, rust_2018_idioms)]
+#![allow(clippy::inherent_to_string, clippy::type_complexity)]
 pub mod alignment;
 pub mod keyboard;
 pub mod mouse;

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
@@ -529,25 +529,25 @@ impl SavedState {
     }
 
     async fn load() -> Result<SavedState, LoadError> {
-        let storage = Self::storage().ok_or(LoadError::FileError)?;
+        let storage = Self::storage().ok_or(LoadError::File)?;
 
         let contents = storage
             .get_item("state")
-            .map_err(|_| LoadError::FileError)?
+            .map_err(|_| LoadError::File)?
-            .ok_or(LoadError::FileError)?;
+            .ok_or(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> {
-        let storage = Self::storage().ok_or(SaveError::FileError)?;
+        let storage = Self::storage().ok_or(SaveError::File)?;
 
         let json = serde_json::to_string_pretty(&self)
-            .map_err(|_| SaveError::FormatError)?;
+            .map_err(|_| SaveError::Format)?;
 
         storage
             .set_item("state", &json)
-            .map_err(|_| SaveError::WriteError)?;
+            .map_err(|_| SaveError::Write)?;
 
         let _ = wasm_timer::Delay::new(std::time::Duration::from_secs(2)).await;
 

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
@@ -576,25 +576,25 @@ impl SavedState {
     }
 
     async fn load() -> Result<SavedState, LoadError> {
-        let storage = Self::storage().ok_or(LoadError::FileError)?;
+        let storage = Self::storage().ok_or(LoadError::File)?;
 
         let contents = storage
             .get_item("state")
-            .map_err(|_| LoadError::FileError)?
+            .map_err(|_| LoadError::File)?
-            .ok_or(LoadError::FileError)?;
+            .ok_or(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> {
-        let storage = Self::storage().ok_or(SaveError::FileError)?;
+        let storage = Self::storage().ok_or(SaveError::File)?;
 
         let json = serde_json::to_string_pretty(&self)
-            .map_err(|_| SaveError::FormatError)?;
+            .map_err(|_| SaveError::Format)?;
 
         storage
             .set_item("state", &json)
-            .map_err(|_| SaveError::WriteError)?;
+            .map_err(|_| SaveError::Write)?;
 
         let _ = wasm_timer::Delay::new(std::time::Duration::from_secs(2)).await;
 

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);
             });
         }

futures/src/lib.rs

@@ -4,13 +4,19 @@
 #![doc(
     html_logo_url = "https://raw.githubusercontent.com/iced-rs/iced/9ab6923e943f784985e9ef9ca28b10278297225d/docs/logo.svg"
 )]
-#![deny(missing_docs)]
+#![deny(
-#![deny(missing_debug_implementations)]
+    missing_debug_implementations,
-#![deny(unused_results)]
+    missing_docs,
-#![forbid(unsafe_code)]
+    unused_results,
-#![forbid(rust_2018_idioms)]
+    clippy::extra_unused_lifetimes,
+    clippy::from_over_into,
+    clippy::needless_borrow,
+    clippy::new_without_default,
+    clippy::useless_conversion
+)]
+#![forbid(unsafe_code, rust_2018_idioms)]
+#![allow(clippy::inherent_to_string, clippy::type_complexity)]
 #![cfg_attr(docsrs, feature(doc_cfg))]
-
 pub use futures;
 
 mod command;

futures/src/runtime.rs

@@ -66,8 +66,6 @@ where
 
         let future = future.then(|message| async move {
             let _ = sender.send(message).await;
-
-            ()
         });
 
         self.executor.spawn(future);

futures/src/subscription.rs

@@ -183,11 +183,7 @@ where
 
         let mapper = self.mapper;
 
-        Box::pin(
+        Box::pin(self.recipe.stream(input).map(mapper))
-            self.recipe
-                .stream(input)
-                .map(move |element| mapper(element)),
-        )
     }
 }
 

futures/src/subscription/tracker.rs

@@ -127,7 +127,7 @@ where
             futures.push(Box::pin(future));
         }
 
-        self.subscriptions.retain(|id, _| alive.contains(&id));
+        self.subscriptions.retain(|id, _| alive.contains(id));
 
         futures
     }
@@ -156,3 +156,13 @@ where
             });
     }
 }
+
+impl<Hasher, Event> Default for Tracker<Hasher, Event>
+where
+    Hasher: std::hash::Hasher + Default,
+    Event: 'static + Send + Clone,
+{
+    fn default() -> Self {
+        Self::new()
+    }
+}

glow/src/backend.rs

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

glow/src/lib.rs

@@ -7,10 +7,18 @@
 #![doc(
     html_logo_url = "https://raw.githubusercontent.com/iced-rs/iced/9ab6923e943f784985e9ef9ca28b10278297225d/docs/logo.svg"
 )]
-#![deny(missing_docs)]
+#![deny(
-#![deny(missing_debug_implementations)]
+    missing_debug_implementations,
-#![deny(unused_results)]
+    missing_docs,
+    unused_results,
+    clippy::extra_unused_lifetimes,
+    clippy::from_over_into,
+    clippy::needless_borrow,
+    clippy::new_without_default,
+    clippy::useless_conversion
+)]
 #![forbid(rust_2018_idioms)]
+#![allow(clippy::inherent_to_string, clippy::type_complexity)]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 
 pub use glow;

glow/src/program.rs

@@ -70,7 +70,7 @@ impl Shader {
         unsafe {
             let shader = gl.create_shader(stage).expect("Cannot create shader");
 
-            gl.shader_source(shader, &content);
+            gl.shader_source(shader, content);
             gl.compile_shader(shader);
 
             if !gl.get_shader_compile_status(shader) {

glow/src/quad/compatibility.rs

@@ -110,22 +110,13 @@ impl Pipeline {
         bounds: Rectangle<u32>,
     ) {
         // TODO: Remove this allocation (probably by changing the shader and removing the need of two `position`)
-        let vertices: Vec<Vertex> = instances
+        let vertices: Vec<Vertex> =
-            .iter()
+            instances.iter().flat_map(Vertex::from_quad).collect();
-            .flat_map(|quad| Vertex::from_quad(quad))
-            .collect();
 
         // 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)
@@ -187,13 +178,13 @@ impl Pipeline {
                 gl.buffer_sub_data_u8_slice(
                     glow::ARRAY_BUFFER,
                     0,
-                    bytemuck::cast_slice(&vertices),
+                    bytemuck::cast_slice(vertices),
                 );
 
                 gl.buffer_sub_data_u8_slice(
                     glow::ELEMENT_ARRAY_BUFFER,
                     0,
-                    bytemuck::cast_slice(&indices),
+                    bytemuck::cast_slice(indices),
                 );
 
                 gl.draw_elements(

glow/src/quad/core.rs

@@ -154,7 +154,7 @@ impl Pipeline {
                 gl.buffer_sub_data_u8_slice(
                     glow::ARRAY_BUFFER,
                     0,
-                    bytemuck::cast_slice(&instances),
+                    bytemuck::cast_slice(instances),
                 );
 
                 gl.draw_arrays_instanced(

glow/src/text.rs

@@ -54,7 +54,7 @@ impl Pipeline {
         #[cfg(target_arch = "wasm32")]
         let draw_brush_builder = draw_brush_builder.draw_cache_align_4x4(true);
 
-        let draw_brush = draw_brush_builder.build(&gl);
+        let draw_brush = draw_brush_builder.build(gl);
 
         let measure_brush =
             glyph_brush::GlyphBrushBuilder::using_font(font).build();
@@ -180,7 +180,8 @@ impl Pipeline {
                 }
                 b_count += utf8_len;
             }
-            return byte_index;
+
+            byte_index
         };
 
         if !nearest_only {

glutin/src/lib.rs

@@ -7,11 +7,20 @@
 #![doc(
     html_logo_url = "https://raw.githubusercontent.com/iced-rs/iced/9ab6923e943f784985e9ef9ca28b10278297225d/docs/logo.svg"
 )]
-#![deny(missing_docs)]
+#![deny(
-#![deny(missing_debug_implementations)]
+    missing_docs,
-#![deny(unused_results)]
+    missing_debug_implementations,
-#![deny(unsafe_code)]
+    unsafe_code,
+    unused_results,
+    clippy::extra_unused_lifetimes,
+    clippy::from_over_into,
+    clippy::needless_borrow,
+    clippy::new_without_default,
+    clippy::useless_conversion
+)]
 #![forbid(rust_2018_idioms)]
+#![allow(clippy::inherent_to_string, clippy::type_complexity)]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 pub use glutin;
 

graphics/src/font/source.rs

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

graphics/src/layer.rs

@@ -202,7 +202,7 @@ impl<'a> Layer<'a> {
                 Self::process_primitive(
                     layers,
                     translation + *new_translation,
-                    &content,
+                    content,
                     current_layer,
                 );
             }
@@ -210,7 +210,7 @@ impl<'a> Layer<'a> {
                 Self::process_primitive(
                     layers,
                     translation,
-                    &cache,
+                    cache,
                     current_layer,
                 );
             }

graphics/src/lib.rs

@@ -7,11 +7,19 @@
 #![doc(
     html_logo_url = "https://raw.githubusercontent.com/iced-rs/iced/9ab6923e943f784985e9ef9ca28b10278297225d/docs/logo.svg"
 )]
-#![deny(missing_docs)]
+#![deny(
-#![deny(missing_debug_implementations)]
+    missing_debug_implementations,
-#![deny(unused_results)]
+    missing_docs,
-#![deny(unsafe_code)]
+    unsafe_code,
+    unused_results,
+    clippy::extra_unused_lifetimes,
+    clippy::from_over_into,
+    clippy::needless_borrow,
+    clippy::new_without_default,
+    clippy::useless_conversion
+)]
 #![forbid(rust_2018_idioms)]
+#![allow(clippy::inherent_to_string, clippy::type_complexity)]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 mod antialiasing;
 mod error;

graphics/src/widget/canvas/path.rs

@@ -73,9 +73,8 @@ impl Path {
 
 pub(super) fn dashed(path: &Path, line_dash: LineDash<'_>) -> Path {
     Path::new(|builder| {
-        let segments_odd = (line_dash.segments.len() % 2 == 1).then(|| {
+        let segments_odd = (line_dash.segments.len() % 2 == 1)
-            [&line_dash.segments[..], &line_dash.segments[..]].concat()
+            .then(|| [line_dash.segments, line_dash.segments].concat());
-        });
 
         let mut draw_line = false;
 
@@ -103,8 +102,7 @@ pub(super) fn dashed(path: &Path, line_dash: LineDash<'_>) -> Path {
                 },
                 index: line_dash.offset,
                 intervals: segments_odd
-                    .as_ref()
+                    .as_deref()
-                    .map(Vec::as_slice)
                     .unwrap_or(line_dash.segments),
             },
         );

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

@@ -53,7 +53,7 @@ impl Builder {
             let _ = self.raw.line_to(a);
         }
 
-        let _ = self.raw.arc_to(
+        self.raw.arc_to(
             math::Vector::new(radius, radius),
             math::Angle::radians(0.0),
             path::ArcFlags::default(),
@@ -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

@@ -67,10 +67,7 @@ where
         let side_length = (self.state.width + 2 * QUIET_ZONE) as f32
             * f32::from(self.cell_size);
 
-        layout::Node::new(Size::new(
+        layout::Node::new(Size::new(side_length, side_length))
-            f32::from(side_length),
-            f32::from(side_length),
-        ))
     }
 
     fn draw(
@@ -128,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

@@ -38,7 +38,7 @@ pub trait Component<Message, Renderer> {
 
     /// Produces the widgets of the [`Component`], which may trigger an [`Event`](Component::Event)
     /// on user interaction.
-    fn view(&mut self) -> Element<Self::Event, Renderer>;
+    fn view(&mut self) -> Element<'_, Self::Event, Renderer>;
 }
 
 /// Turns an implementor of [`Component`] into an [`Element`] that can be
@@ -350,7 +350,7 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
     ) {
-        self.with_overlay_maybe(|overlay| {
+        let _ = self.with_overlay_maybe(|overlay| {
             overlay.draw(renderer, theme, style, layout, cursor_position);
         });
     }
@@ -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

@@ -1,6 +1,21 @@
 #![doc(
     html_logo_url = "https://raw.githubusercontent.com/iced-rs/iced/9ab6923e943f784985e9ef9ca28b10278297225d/docs/logo.svg"
 )]
+#![deny(
+    missing_debug_implementations,
+    unused_results,
+    clippy::extra_unused_lifetimes,
+    clippy::from_over_into,
+    clippy::needless_borrow,
+    clippy::new_without_default,
+    clippy::useless_conversion
+)]
+#![forbid(unsafe_code)]
+#![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

@@ -43,7 +43,7 @@ pub trait Component<Message, Renderer> {
 
     /// Produces the widgets of the [`Component`], which may trigger an [`Event`](Component::Event)
     /// on user interaction.
-    fn view(&self, state: &Self::State) -> Element<Self::Event, Renderer>;
+    fn view(&self, state: &Self::State) -> Element<'_, Self::Event, Renderer>;
 }
 
 /// Turns an implementor of [`Component`] into an [`Element`] that can be
@@ -382,7 +382,7 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
     ) {
-        self.with_overlay_maybe(|overlay| {
+        let _ = self.with_overlay_maybe(|overlay| {
             overlay.draw(renderer, theme, style, layout, cursor_position);
         });
     }
@@ -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

@@ -341,7 +341,7 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
     ) {
-        self.with_overlay_maybe(|overlay| {
+        let _ = self.with_overlay_maybe(|overlay| {
             overlay.draw(renderer, theme, style, layout, cursor_position);
         });
     }
@@ -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)
     }
 }
 
@@ -363,7 +363,7 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
     ) {
-        self.with_overlay_maybe(|overlay| {
+        let _ = self.with_overlay_maybe(|overlay| {
             overlay.draw(renderer, theme, style, layout, cursor_position);
         });
     }
@@ -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,

native/src/debug/null.rs

@@ -1,5 +1,5 @@
 #![allow(missing_docs)]
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct Debug;
 
 impl Debug {

native/src/hasher.rs

@@ -1,13 +1,7 @@
 /// The hasher used to compare layouts.
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct Hasher(twox_hash::XxHash64);
 
-impl Default for Hasher {
-    fn default() -> Self {
-        Hasher(twox_hash::XxHash64::default())
-    }
-}
-
 impl core::hash::Hasher for Hasher {
     fn write(&mut self, bytes: &[u8]) {
         self.0.write(bytes)

native/src/lib.rs

@@ -31,11 +31,19 @@
 #![doc(
     html_logo_url = "https://raw.githubusercontent.com/iced-rs/iced/9ab6923e943f784985e9ef9ca28b10278297225d/docs/logo.svg"
 )]
-#![deny(missing_docs)]
+#![deny(
-#![deny(missing_debug_implementations)]
+    missing_debug_implementations,
-#![deny(unused_results)]
+    missing_docs,
-#![forbid(unsafe_code)]
+    unused_results,
-#![forbid(rust_2018_idioms)]
+    clippy::extra_unused_lifetimes,
+    clippy::from_over_into,
+    clippy::needless_borrow,
+    clippy::new_without_default,
+    clippy::useless_conversion
+)]
+#![forbid(unsafe_code, rust_2018_idioms)]
+#![allow(clippy::inherent_to_string, clippy::type_complexity)]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 pub mod clipboard;
 pub mod command;
 pub mod event;

native/src/overlay/menu.rs

@@ -174,9 +174,9 @@ where
 
         Self {
             container,
-            width: width,
+            width,
             target_height,
-            style: style,
+            style,
         }
     }
 }
@@ -230,7 +230,7 @@ where
         shell: &mut Shell<'_, Message>,
     ) -> event::Status {
         self.container.on_event(
-            event.clone(),
+            event,
             layout,
             cursor_position,
             renderer,
@@ -326,7 +326,8 @@ where
         use std::f32;
 
         let limits = limits.width(Length::Fill).height(Length::Shrink);
-        let text_size = self.text_size.unwrap_or(renderer.default_size());
+        let text_size =
+            self.text_size.unwrap_or_else(|| renderer.default_size());
 
         let size = {
             let intrinsic = Size::new(
@@ -366,8 +367,9 @@ where
                 let bounds = layout.bounds();
 
                 if bounds.contains(cursor_position) {
-                    let text_size =
+                    let text_size = self
-                        self.text_size.unwrap_or(renderer.default_size());
+                        .text_size
+                        .unwrap_or_else(|| renderer.default_size());
 
                     *self.hovered_option = Some(
                         ((cursor_position.y - bounds.y)
@@ -380,8 +382,9 @@ where
                 let bounds = layout.bounds();
 
                 if bounds.contains(cursor_position) {
-                    let text_size =
+                    let text_size = self
-                        self.text_size.unwrap_or(renderer.default_size());
+                        .text_size
+                        .unwrap_or_else(|| renderer.default_size());
 
                     *self.hovered_option = Some(
                         ((cursor_position.y - bounds.y)
@@ -430,7 +433,8 @@ where
         let appearance = theme.appearance(self.style);
         let bounds = layout.bounds();
 
-        let text_size = self.text_size.unwrap_or(renderer.default_size());
+        let text_size =
+            self.text_size.unwrap_or_else(|| renderer.default_size());
         let option_height = (text_size + self.padding.vertical()) as usize;
 
         let offset = viewport.y - bounds.y;
@@ -485,15 +489,15 @@ where
     }
 }
 
-impl<'a, T, Message, Renderer> Into<Element<'a, Message, Renderer>>
+impl<'a, T, Message, Renderer> From<List<'a, T, Renderer>>
-    for List<'a, T, Renderer>
+    for Element<'a, Message, Renderer>
 where
     T: ToString + Clone,
     Message: 'a,
     Renderer: 'a + text::Renderer,
     Renderer::Theme: StyleSheet,
 {
-    fn into(self) -> Element<'a, Message, Renderer> {
+    fn from(list: List<'a, T, Renderer>) -> Self {
-        Element::new(self)
+        Element::new(list)
     }
 }

native/src/program/state.rs

@@ -113,7 +113,7 @@ where
             &mut messages,
         );
 
-        messages.extend(self.queued_messages.drain(..));
+        messages.append(&mut self.queued_messages);
         self.queued_events.clear();
         debug.event_processing_finished();
 

native/src/renderer/null.rs

@@ -5,7 +5,7 @@ use crate::{Background, Font, Point, Rectangle, Size, Theme, Vector};
 /// A renderer that does nothing.
 ///
 /// It can be useful if you are writing tests!
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Default)]
 pub struct Null;
 
 impl Null {

native/src/user_interface.rs

@@ -430,7 +430,7 @@ where
         overlay
             .as_ref()
             .and_then(|layout| {
-                root.overlay(Layout::new(&base), renderer).map(|overlay| {
+                root.overlay(Layout::new(base), renderer).map(|overlay| {
                     let overlay_interaction = overlay.mouse_interaction(
                         Layout::new(layout),
                         cursor_position,

native/src/widget/button.rs

@@ -382,7 +382,7 @@ where
             self.on_press.is_some(),
             theme,
             self.style,
-            || &self.state,
+            || self.state,
         );
 
         self.content.draw(

native/src/widget/checkbox.rs

@@ -158,7 +158,10 @@ where
                 Text::new(&self.label)
                     .font(self.font.clone())
                     .width(self.width)
-                    .size(self.text_size.unwrap_or(renderer.default_size())),
+                    .size(
+                        self.text_size
+                            .unwrap_or_else(|| renderer.default_size()),
+                    ),
             )
             .layout(renderer, limits)
     }

native/src/widget/column.rs

@@ -102,6 +102,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

native/src/widget/pane_grid.rs

@@ -835,8 +835,7 @@ fn hovered_split<'a>(
 ) -> Option<(Split, Axis, Rectangle)> {
     splits
         .filter_map(|(split, (axis, region, ratio))| {
-            let bounds =
+            let bounds = axis.split_line_bounds(*region, *ratio, spacing);
-                axis.split_line_bounds(*region, *ratio, f32::from(spacing));
 
             if bounds.contains(cursor_position) {
                 Some((*split, *axis, bounds))

native/src/widget/pane_grid/node.rs

@@ -36,14 +36,11 @@ impl Node {
 
         std::iter::from_fn(move || {
             while let Some(node) = unvisited_nodes.pop() {
-                match node {
+                if let Node::Split { id, a, b, .. } = node {
-                    Node::Split { id, a, b, .. } => {
+                    unvisited_nodes.push(a);
-                        unvisited_nodes.push(a);
+                    unvisited_nodes.push(b);
-                        unvisited_nodes.push(b);
 
-                        return Some(id);
+                    return Some(id);
-                    }
-                    _ => {}
                 }
             }
 
@@ -124,12 +121,9 @@ impl Node {
     }
 
     pub(crate) fn update(&mut self, f: &impl Fn(&mut Node)) {
-        match self {
+        if let Node::Split { a, b, .. } = self {
-            Node::Split { a, b, .. } => {
+            a.update(f);
-                a.update(f);
+            b.update(f);
-                b.update(f);
-            }
-            _ => {}
         }
 
         f(self);

native/src/widget/pane_grid/state.rs

@@ -66,6 +66,11 @@ impl<T> State<T> {
         self.panes.len()
     }
 
+    /// Returns `true` if the amount of panes in the [`State`] is 0.
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
     /// Returns the internal state of the given [`Pane`], if it exists.
     pub fn get(&self, pane: &Pane) -> Option<&T> {
         self.panes.get(pane)

native/src/widget/pick_list.rs

@@ -160,7 +160,7 @@ where
 
     let limits = limits.width(width).height(Length::Shrink).pad(padding);
 
-    let text_size = text_size.unwrap_or(renderer.default_size());
+    let text_size = text_size.unwrap_or_else(|| renderer.default_size());
 
     let max_width = match width {
         Length::Shrink => {
@@ -407,10 +407,9 @@ pub fn draw<T, Renderer>(
 
     let label = selected.map(ToString::to_string);
 
-    if let Some(label) =
+    if let Some(label) = label.as_deref().or(placeholder) {
-        label.as_ref().map(String::as_str).or_else(|| placeholder)
+        let text_size =
-    {
+            f32::from(text_size.unwrap_or_else(|| renderer.default_size()));
-        let text_size = f32::from(text_size.unwrap_or(renderer.default_size()));
 
         renderer.fill_text(Text {
             content: label,
@@ -460,7 +459,7 @@ where
             self.padding,
             self.text_size,
             &self.font,
-            self.placeholder.as_ref().map(String::as_str),
+            self.placeholder.as_deref(),
             &self.options,
         )
     }
@@ -513,7 +512,7 @@ where
             self.padding,
             self.text_size,
             &self.font,
-            self.placeholder.as_ref().map(String::as_str),
+            self.placeholder.as_deref(),
             self.selected.as_ref(),
             self.style,
         )
@@ -526,7 +525,7 @@ where
     ) -> Option<overlay::Element<'_, Message, Renderer>> {
         overlay(
             layout,
-            &mut self.state,
+            self.state,
             self.padding,
             self.text_size,
             self.font.clone(),
@@ -536,8 +535,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,
     [T]: ToOwned<Owned = Vec<T>>,
@@ -550,7 +549,7 @@ where
     <Renderer::Theme as StyleSheet>::Style:
         Into<<Renderer::Theme as menu::StyleSheet>::Style>,
 {
-    fn into(self) -> Element<'a, Message, Renderer> {
+    fn from(pick_list: PickList<'a, T, Message, Renderer>) -> Self {
-        Element::new(self)
+        Element::new(pick_list)
     }
 }

native/src/widget/progress_bar.rs

@@ -76,7 +76,7 @@ where
     }
 }
 
-impl<'a, Message, Renderer> Widget<Message, Renderer> for ProgressBar<Renderer>
+impl<Message, Renderer> Widget<Message, Renderer> for ProgressBar<Renderer>
 where
     Renderer: crate::Renderer,
     Renderer::Theme: StyleSheet,

native/src/widget/radio.rs

@@ -168,11 +168,9 @@ where
                     .width(Length::Units(self.size))
                     .height(Length::Units(self.size)),
             )
-            .push(
+            .push(Text::new(&self.label).width(self.width).size(
-                Text::new(&self.label)
+                self.text_size.unwrap_or_else(|| renderer.default_size()),
-                    .width(self.width)
+            ))
-                    .size(self.text_size.unwrap_or(renderer.default_size())),
-            )
             .layout(renderer, limits)
     }
 

native/src/widget/row.rs

@@ -102,6 +102,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

native/src/widget/rule.rs

@@ -36,7 +36,7 @@ where
     /// Creates a vertical [`Rule`] with the given width.
     pub fn vertical(width: u16) -> Self {
         Rule {
-            width: Length::from(Length::Units(width)),
+            width: Length::Units(width),
             height: Length::Fill,
             is_horizontal: false,
             style: Default::default(),

native/src/widget/scrollable.rs

@@ -662,7 +662,7 @@ where
         shell: &mut Shell<'_, Message>,
     ) -> event::Status {
         update(
-            &mut self.state,
+            self.state,
             event,
             layout,
             cursor_position,
@@ -693,7 +693,7 @@ where
         renderer: &Renderer,
     ) -> mouse::Interaction {
         mouse_interaction(
-            &self.state,
+            self.state,
             layout,
             cursor_position,
             self.scrollbar_width,
@@ -720,7 +720,7 @@ where
         _viewport: &Rectangle,
     ) {
         draw(
-            &self.state,
+            self.state,
             renderer,
             theme,
             layout,

native/src/widget/slider.rs

@@ -303,7 +303,7 @@ pub fn draw<T, R>(
         HandleShape::Rectangle {
             width,
             border_radius,
-        } => (f32::from(width), f32::from(bounds.height), border_radius),
+        } => (f32::from(width), bounds.height, border_radius),
     };
 
     let value = value.into() as f32;
@@ -410,7 +410,7 @@ where
             layout,
             cursor_position,
             shell,
-            &mut self.state,
+            self.state,
             &mut self.value,
             &self.range,
             self.step,
@@ -432,7 +432,7 @@ where
             renderer,
             layout,
             cursor_position,
-            &self.state,
+            self.state,
             self.value,
             &self.range,
             theme,
@@ -447,7 +447,7 @@ where
         _viewport: &Rectangle,
         _renderer: &Renderer,
     ) -> mouse::Interaction {
-        mouse_interaction(layout, cursor_position, &self.state)
+        mouse_interaction(layout, cursor_position, self.state)
     }
 }
 

native/src/widget/text.rs

@@ -131,7 +131,7 @@ where
     ) -> layout::Node {
         let limits = limits.width(self.width).height(self.height);
 
-        let size = self.size.unwrap_or(renderer.default_size());
+        let size = self.size.unwrap_or_else(|| renderer.default_size());
 
         let bounds = limits.max();
 
@@ -205,7 +205,7 @@ pub fn draw<Renderer>(
 
     renderer.fill_text(crate::text::Text {
         content,
-        size: f32::from(size.unwrap_or(renderer.default_size())),
+        size: f32::from(size.unwrap_or_else(|| renderer.default_size())),
         bounds: Rectangle { x, y, ..bounds },
         color: appearance.color.unwrap_or(style.text_color),
         font,

native/src/widget/text_input.rs

@@ -176,7 +176,7 @@ where
             theme,
             layout,
             cursor_position,
-            &self.state,
+            self.state,
             value.unwrap_or(&self.value),
             &self.placeholder,
             self.size,
@@ -198,7 +198,7 @@ pub fn layout<Renderer>(
 where
     Renderer: text::Renderer,
 {
-    let text_size = size.unwrap_or(renderer.default_size());
+    let text_size = size.unwrap_or_else(|| renderer.default_size());
 
     let limits = limits
         .pad(padding)
@@ -498,7 +498,7 @@ where
                                 None => {
                                     let content: String = clipboard
                                         .read()
-                                        .unwrap_or(String::new())
+                                        .unwrap_or_default()
                                         .chars()
                                         .filter(|c| !c.is_control())
                                         .collect();
@@ -597,7 +597,7 @@ pub fn draw<Renderer>(
     Renderer::Theme: StyleSheet,
 {
     let secure_value = is_secure.then(|| value.secure());
-    let value = secure_value.as_ref().unwrap_or(&value);
+    let value = secure_value.as_ref().unwrap_or(value);
 
     let bounds = layout.bounds();
     let text_bounds = layout.children().next().unwrap().bounds();
@@ -623,16 +623,16 @@ pub fn draw<Renderer>(
     );
 
     let text = value.to_string();
-    let size = size.unwrap_or(renderer.default_size());
+    let size = size.unwrap_or_else(|| renderer.default_size());
 
     let (cursor, offset) = if state.is_focused() {
-        match state.cursor.state(&value) {
+        match state.cursor.state(value) {
             cursor::State::Index(position) => {
                 let (text_value_width, offset) =
                     measure_cursor_and_scroll_offset(
                         renderer,
                         text_bounds,
-                        &value,
+                        value,
                         size,
                         position,
                         font.clone(),
@@ -664,7 +664,7 @@ pub fn draw<Renderer>(
                     measure_cursor_and_scroll_offset(
                         renderer,
                         text_bounds,
-                        &value,
+                        value,
                         size,
                         left,
                         font.clone(),
@@ -674,7 +674,7 @@ pub fn draw<Renderer>(
                     measure_cursor_and_scroll_offset(
                         renderer,
                         text_bounds,
-                        &value,
+                        value,
                         size,
                         right,
                         font.clone(),
@@ -998,16 +998,16 @@ fn find_cursor_position<Renderer>(
 where
     Renderer: text::Renderer,
 {
-    let size = size.unwrap_or(renderer.default_size());
+    let size = size.unwrap_or_else(|| renderer.default_size());
 
     let offset =
-        offset(renderer, text_bounds, font.clone(), size, &value, &state);
+        offset(renderer, text_bounds, font.clone(), size, value, state);
 
     renderer
         .hit_test(
             &value.to_string(),
             size.into(),
-            font.clone(),
+            font,
             Size::INFINITY,
             Point::new(x + offset, text_bounds.height / 2.0),
             true,

native/src/widget/text_input/editor.rs

@@ -15,12 +15,9 @@ impl<'a> Editor<'a> {
     }
 
     pub fn insert(&mut self, character: char) {
-        match self.cursor.selection(self.value) {
+        if let Some((left, right)) = self.cursor.selection(self.value) {
-            Some((left, right)) => {
+            self.cursor.move_left(self.value);
-                self.cursor.move_left(self.value);
+            self.value.remove_many(left, right);
-                self.value.remove_many(left, right);
-            }
-            _ => {}
         }
 
         self.value.insert(self.cursor.end(self.value), character);
@@ -29,13 +26,9 @@ impl<'a> Editor<'a> {
 
     pub fn paste(&mut self, content: Value) {
         let length = content.len();
-
+        if let Some((left, right)) = self.cursor.selection(self.value) {
-        match self.cursor.selection(self.value) {
+            self.cursor.move_left(self.value);
-            Some((left, right)) => {
+            self.value.remove_many(left, right);
-                self.cursor.move_left(self.value);
-                self.value.remove_many(left, right);
-            }
-            _ => {}
         }
 
         self.value.insert_many(self.cursor.end(self.value), content);

native/src/widget/text_input/value.rs

@@ -37,7 +37,7 @@ impl Value {
         let previous_string =
             &self.graphemes[..index.min(self.graphemes.len())].concat();
 
-        UnicodeSegmentation::split_word_bound_indices(&previous_string as &str)
+        UnicodeSegmentation::split_word_bound_indices(previous_string as &str)
             .filter(|(_, word)| !word.trim_start().is_empty())
             .next_back()
             .map(|(i, previous_word)| {
@@ -58,9 +58,8 @@ impl Value {
     pub fn next_end_of_word(&self, index: usize) -> usize {
         let next_string = &self.graphemes[index..].concat();
 
-        UnicodeSegmentation::split_word_bound_indices(&next_string as &str)
+        UnicodeSegmentation::split_word_bound_indices(next_string as &str)
-            .filter(|(_, word)| !word.trim_start().is_empty())
+            .find(|(_, word)| !word.trim_start().is_empty())
-            .next()
             .map(|(i, next_word)| {
                 index
                     + UnicodeSegmentation::graphemes(next_word, true).count()

native/src/widget/toggler.rs

@@ -162,7 +162,10 @@ where
                     .horizontal_alignment(self.text_alignment)
                     .font(self.font.clone())
                     .width(self.width)
-                    .size(self.text_size.unwrap_or(renderer.default_size())),
+                    .size(
+                        self.text_size
+                            .unwrap_or_else(|| renderer.default_size()),
+                    ),
             );
         }
 
@@ -239,7 +242,7 @@ where
                 renderer,
                 style,
                 label_layout,
-                &label,
+                label,
                 self.text_size,
                 self.font.clone(),
                 Default::default(),

pure/src/lib.rs

@@ -82,10 +82,18 @@
 #![doc(
     html_logo_url = "https://raw.githubusercontent.com/iced-rs/iced/9ab6923e943f784985e9ef9ca28b10278297225d/docs/logo.svg"
 )]
-#![deny(missing_docs)]
+#![deny(
-#![deny(unused_results)]
+    missing_docs,
-#![forbid(unsafe_code)]
+    unused_results,
-#![forbid(rust_2018_idioms)]
+    clippy::extra_unused_lifetimes,
+    clippy::from_over_into,
+    clippy::needless_borrow,
+    clippy::new_without_default,
+    clippy::useless_conversion
+)]
+#![forbid(rust_2018_idioms, unsafe_code)]
+#![allow(clippy::inherent_to_string, clippy::type_complexity)]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 pub mod flex;
 pub mod helpers;
@@ -146,7 +154,7 @@ where
         content: impl Into<Element<'a, Message, Renderer>>,
     ) -> Self {
         let element = content.into();
-        let _ = state.diff(&element);
+        state.diff(&element);
 
         Self { state, element }
     }
@@ -272,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

@@ -143,7 +143,7 @@ where
             self.padding,
             self.text_size,
             &self.font,
-            self.placeholder.as_ref().map(String::as_str),
+            self.placeholder.as_deref(),
             &self.options,
         )
     }
@@ -199,7 +199,7 @@ where
             self.padding,
             self.text_size,
             &self.font,
-            self.placeholder.as_ref().map(String::as_str),
+            self.placeholder.as_deref(),
             self.selected.as_ref(),
             self.style,
         )
@@ -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,

src/lib.rs

@@ -174,12 +174,20 @@
 #![doc(
     html_logo_url = "https://raw.githubusercontent.com/iced-rs/iced/9ab6923e943f784985e9ef9ca28b10278297225d/docs/logo.svg"
 )]
-#![deny(missing_docs)]
+#![deny(
-#![deny(missing_debug_implementations)]
+    missing_debug_implementations,
-#![deny(unused_results)]
+    missing_docs,
-#![forbid(unsafe_code)]
+    unused_results,
-#![forbid(rust_2018_idioms)]
+    clippy::extra_unused_lifetimes,
+    clippy::from_over_into,
+    clippy::needless_borrow,
+    clippy::new_without_default,
+    clippy::useless_conversion
+)]
+#![forbid(rust_2018_idioms, unsafe_code)]
+#![allow(clippy::inherent_to_string, clippy::type_complexity)]
 #![cfg_attr(docsrs, feature(doc_cfg))]
+
 mod element;
 mod error;
 mod result;

style/src/lib.rs

@@ -7,6 +7,16 @@
 #![doc(
     html_logo_url = "https://raw.githubusercontent.com/iced-rs/iced/9ab6923e943f784985e9ef9ca28b10278297225d/docs/logo.svg"
 )]
+#![deny(
+    unused_results,
+    clippy::extra_unused_lifetimes,
+    clippy::from_over_into,
+    clippy::needless_borrow,
+    clippy::new_without_default,
+    clippy::useless_conversion
+)]
+#![forbid(unsafe_code, rust_2018_idioms)]
+#![allow(clippy::inherent_to_string, clippy::type_complexity)]
 pub use iced_core::{Background, Color};
 
 pub mod application;

style/src/text.rs

@@ -6,13 +6,7 @@ pub trait StyleSheet {
     fn appearance(&self, style: Self::Style) -> Appearance;
 }
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Default)]
 pub struct Appearance {
     pub color: Option<Color>,
 }
-
-impl Default for Appearance {
-    fn default() -> Self {
-        Self { color: None }
-    }
-}

style/src/theme.rs

@@ -419,7 +419,7 @@ impl radio::StyleSheet for Theme {
 
         radio::Appearance {
             background: Color::TRANSPARENT.into(),
-            dot_color: palette.primary.strong.color.into(),
+            dot_color: palette.primary.strong.color,
             border_width: 1.0,
             border_color: palette.primary.strong.color,
             text_color: None,
@@ -431,7 +431,7 @@ impl radio::StyleSheet for Theme {
         let palette = self.extended_palette();
 
         radio::Appearance {
-            dot_color: palette.primary.strong.color.into(),
+            dot_color: palette.primary.strong.color,
             background: palette.primary.weak.color.into(),
             ..active
         }
@@ -599,7 +599,7 @@ impl scrollable::StyleSheet for Theme {
             border_width: 0.0,
             border_color: Color::TRANSPARENT,
             scroller: scrollable::Scroller {
-                color: palette.background.strong.color.into(),
+                color: palette.background.strong.color,
                 border_radius: 2.0,
                 border_width: 0.0,
                 border_color: Color::TRANSPARENT,
@@ -616,7 +616,7 @@ impl scrollable::StyleSheet for Theme {
             border_width: 0.0,
             border_color: Color::TRANSPARENT,
             scroller: scrollable::Scroller {
-                color: palette.primary.strong.color.into(),
+                color: palette.primary.strong.color,
                 border_radius: 2.0,
                 border_width: 0.0,
                 border_color: Color::TRANSPARENT,

wgpu/src/backend.rs

@@ -93,7 +93,7 @@ impl Backend {
                 &layer,
                 staging_belt,
                 encoder,
-                &frame,
+                frame,
                 target_size.width,
                 target_size.height,
             );
@@ -230,7 +230,6 @@ impl Backend {
                                 wgpu_glyph::VerticalAlign::Bottom
                             }
                         }),
-                    ..Default::default()
                 };
 
                 self.text_pipeline.queue(text);

wgpu/src/image.rs

@@ -236,7 +236,7 @@ impl Pipeline {
             entries: &[wgpu::BindGroupEntry {
                 binding: 0,
                 resource: wgpu::BindingResource::TextureView(
-                    &texture_atlas.view(),
+                    texture_atlas.view(),
                 ),
             }],
         });
@@ -264,7 +264,7 @@ impl Pipeline {
     #[cfg(feature = "image_rs")]
     pub fn dimensions(&self, handle: &image::Handle) -> (u32, u32) {
         let mut cache = self.raster_cache.borrow_mut();
-        let memory = cache.load(&handle);
+        let memory = cache.load(handle);
 
         memory.dimensions()
     }
@@ -272,7 +272,7 @@ impl Pipeline {
     #[cfg(feature = "svg")]
     pub fn viewport_dimensions(&self, handle: &svg::Handle) -> (u32, u32) {
         let mut cache = self.vector_cache.borrow_mut();
-        let svg = cache.load(&handle);
+        let svg = cache.load(handle);
 
         svg.viewport_dimensions()
     }
@@ -358,7 +358,7 @@ impl Pipeline {
                     entries: &[wgpu::BindGroupEntry {
                         binding: 0,
                         resource: wgpu::BindingResource::TextureView(
-                            &self.texture_atlas.view(),
+                            self.texture_atlas.view(),
                         ),
                     }],
                 });