Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-07-24 15:50:21 +01:00
Code Issues Projects Releases Packages Wiki Activity

Elide lifetimes where possible after rustup (#34824)

Browse source 
The new version of rust allows us to elide some lifetimes and clippy is
now complaining about this. This change elides them where possible and
removes the clippy exceptions.

Fixes #34804.

Signed-off-by: Martin Robinson <mrobinson@igalia.com>
This commit is contained in:
Martin Robinson 2025-01-03 19:54:44 +01:00 • committed by GitHub
parent 92026cb094
commit 621ddd749c
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
57 changed files with 92 additions and 99 deletions
Download patch file Download diff file Expand all files Collapse all files

6
components/canvas/canvas_data.rs
View file

@ -136,7 +136,7 @@ struct PathBuilderRef<'a> {
transform: Transform2D<f32>, transform: Transform2D<f32>,
} }
impl<'a> PathBuilderRef<'a> { impl PathBuilderRef<'_> {
fn line_to(&mut self, pt: &Point2D<f32>) { fn line_to(&mut self, pt: &Point2D<f32>) {
let pt = self.transform.transform_point(*pt); let pt = self.transform.transform_point(*pt);
self.builder.line_to(pt); self.builder.line_to(pt);
@ -238,7 +238,7 @@ struct UnshapedTextRun<'a> {
string: &'a str, string: &'a str,
} }
impl<'a> UnshapedTextRun<'a> { impl UnshapedTextRun<'_> {
fn script_and_font_compatible(&self, script: Script, other_font: &Option<FontRef>) -> bool { fn script_and_font_compatible(&self, script: Script, other_font: &Option<FontRef>) -> bool {
if self.script != script { if self.script != script {
return false; return false;
@ -1417,7 +1417,7 @@ impl<'a> CanvasData<'a> {
} }
} }
impl<'a> Drop for CanvasData<'a> { impl Drop for CanvasData<'_> {
fn drop(&mut self) { fn drop(&mut self) {
let mut updates = vec![]; let mut updates = vec![];
if let Some(image_key) = self.old_image_key.take() { if let Some(image_key) = self.old_image_key.take() {

1
components/canvas/lib.rs
View file

@ -3,7 +3,6 @@
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
#![deny(unsafe_code)] #![deny(unsafe_code)]
#![allow(clippy::needless_lifetimes)]
mod raqote_backend; mod raqote_backend;

2
components/canvas/raqote_backend.rs
View file

@ -118,7 +118,7 @@ pub enum Pattern<'a> {
Surface(SurfacePattern<'a>), Surface(SurfacePattern<'a>),
} }
impl<'a> Pattern<'a> { impl Pattern<'_> {
fn set_transform(&mut self, transform: Transform2D<f32>) { fn set_transform(&mut self, transform: Transform2D<f32>) {
match self { match self {
Pattern::Surface(pattern) => pattern.set_transform(transform), Pattern::Surface(pattern) => pattern.set_transform(transform),

2
components/canvas/webgl_limits.rs
View file

@ -233,7 +233,7 @@ macro_rules! create_fun {
}; };
} }
impl<'a> GLExt for &'a Gl { impl GLExt for &Gl {
create_fun!( create_fun!(
try_get_integer, try_get_integer,
get_integer, get_integer,

2
components/canvas/webxr.rs
View file

@ -310,7 +310,7 @@ pub(crate) struct WebXRBridgeContexts<'a> {
pub(crate) bound_context_id: &'a mut Option<WebGLContextId>, pub(crate) bound_context_id: &'a mut Option<WebGLContextId>,
} }
impl<'a> WebXRContexts<WebXRSurfman> for WebXRBridgeContexts<'a> { impl WebXRContexts<WebXRSurfman> for WebXRBridgeContexts<'_> {
fn context(&mut self, device: &Device, context_id: WebXRContextId) -> Option<&mut Context> { fn context(&mut self, device: &Device, context_id: WebXRContextId) -> Option<&mut Context> {
let data = WebGLThread::make_current_if_needed_mut( let data = WebGLThread::make_current_if_needed_mut(
device, device,

27
components/hyper_serde/lib.rs
View file

@ -62,7 +62,6 @@
#![deny(missing_docs)] #![deny(missing_docs)]
#![deny(unsafe_code)] #![deny(unsafe_code)]
#![allow(clippy::needless_lifetimes)]
use std::ops::{Deref, DerefMut}; use std::ops::{Deref, DerefMut};
use std::str::FromStr; use std::str::FromStr;
@ -288,7 +287,7 @@ impl<'de> Deserialize<'de> for De<ContentType> {
} }
} }
impl<'a> Serialize for Ser<'a, ContentType> { impl Serialize for Ser<'_, ContentType> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where where
S: Serializer, S: Serializer,
@ -304,7 +303,7 @@ impl<'de> Deserialize<'de> for De<Cookie<'static>> {
{ {
struct CookieVisitor; struct CookieVisitor;
impl<'de> Visitor<'de> for CookieVisitor { impl Visitor<'_> for CookieVisitor {
type Value = De<Cookie<'static>>; type Value = De<Cookie<'static>>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@ -326,7 +325,7 @@ impl<'de> Deserialize<'de> for De<Cookie<'static>> {
} }
} }
impl<'a, 'cookie> Serialize for Ser<'a, Cookie<'cookie>> { impl Serialize for Ser<'_, Cookie<'_>> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where where
S: Serializer, S: Serializer,
@ -418,14 +417,14 @@ impl<'de> Deserialize<'de> for De<HeaderMap> {
} }
} }
impl<'a> Serialize for Ser<'a, HeaderMap> { impl Serialize for Ser<'_, HeaderMap> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where where
S: Serializer, S: Serializer,
{ {
struct Value<'headers>(&'headers [Vec<u8>], bool); struct Value<'headers>(&'headers [Vec<u8>], bool);
impl<'headers> Serialize for Value<'headers> { impl Serialize for Value<'_> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where where
S: Serializer, S: Serializer,
@ -469,7 +468,7 @@ impl<'de> Deserialize<'de> for De<Method> {
{ {
struct MethodVisitor; struct MethodVisitor;
impl<'de> Visitor<'de> for MethodVisitor { impl Visitor<'_> for MethodVisitor {
type Value = De<Method>; type Value = De<Method>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@ -488,7 +487,7 @@ impl<'de> Deserialize<'de> for De<Method> {
} }
} }
impl<'a> Serialize for Ser<'a, Method> { impl Serialize for Ser<'_, Method> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where where
S: Serializer, S: Serializer,
@ -504,7 +503,7 @@ impl<'de> Deserialize<'de> for De<Mime> {
{ {
struct MimeVisitor; struct MimeVisitor;
impl<'de> Visitor<'de> for MimeVisitor { impl Visitor<'_> for MimeVisitor {
type Value = De<Mime>; type Value = De<Mime>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@ -525,7 +524,7 @@ impl<'de> Deserialize<'de> for De<Mime> {
} }
} }
impl<'a> Serialize for Ser<'a, Mime> { impl Serialize for Ser<'_, Mime> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where where
S: Serializer, S: Serializer,
@ -546,7 +545,7 @@ impl<'de> Deserialize<'de> for De<StatusCode> {
} }
} }
impl<'a> Serialize for Ser<'a, StatusCode> { impl Serialize for Ser<'_, StatusCode> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where where
S: Serializer, S: Serializer,
@ -555,7 +554,7 @@ impl<'a> Serialize for Ser<'a, StatusCode> {
} }
} }
impl<'a> Serialize for Ser<'a, (StatusCode, String)> { impl Serialize for Ser<'_, (StatusCode, String)> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where where
S: Serializer, S: Serializer,
@ -610,7 +609,7 @@ impl<'de> Deserialize<'de> for De<Uri> {
{ {
struct UriVisitor; struct UriVisitor;
impl<'de> Visitor<'de> for UriVisitor { impl Visitor<'_> for UriVisitor {
type Value = De<Uri>; type Value = De<Uri>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@ -631,7 +630,7 @@ impl<'de> Deserialize<'de> for De<Uri> {
} }
} }
impl<'a> Serialize for Ser<'a, Uri> { impl Serialize for Ser<'_, Uri> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where where
S: Serializer, S: Serializer,

2
components/layout/block.rs
View file

@ -529,7 +529,7 @@ fn translate_including_floats(cur_b: &mut Au, delta: Au, floats: &mut Floats) {
/// have the Root flow as their CB. /// have the Root flow as their CB.
pub struct AbsoluteAssignBSizesTraversal<'a>(pub &'a SharedStyleContext<'a>); pub struct AbsoluteAssignBSizesTraversal<'a>(pub &'a SharedStyleContext<'a>);
impl<'a> PreorderFlowTraversal for AbsoluteAssignBSizesTraversal<'a> { impl PreorderFlowTraversal for AbsoluteAssignBSizesTraversal<'_> {
#[inline] #[inline]
fn process(&self, flow: &mut dyn Flow) { fn process(&self, flow: &mut dyn Flow) {
if !flow.is_block_like() { if !flow.is_block_like() {

4
components/layout/construct.rs
View file

@ -1802,9 +1802,9 @@ where
} }
} }
impl<'a, 'dom, ConcreteThreadSafeLayoutNode> impl<'dom, ConcreteThreadSafeLayoutNode>
PostorderNodeMutTraversal<'dom, ConcreteThreadSafeLayoutNode> PostorderNodeMutTraversal<'dom, ConcreteThreadSafeLayoutNode>
for FlowConstructor<'a, ConcreteThreadSafeLayoutNode> for FlowConstructor<'_, ConcreteThreadSafeLayoutNode>
where where
ConcreteThreadSafeLayoutNode: ThreadSafeLayoutNode<'dom>, ConcreteThreadSafeLayoutNode: ThreadSafeLayoutNode<'dom>,
{ {

4
components/layout/context.rs
View file

@ -54,7 +54,7 @@ pub struct LayoutContext<'a> {
pub pending_images: Mutex<Vec<PendingImage>>, pub pending_images: Mutex<Vec<PendingImage>>,
} }
impl<'a> Drop for LayoutContext<'a> { impl Drop for LayoutContext<'_> {
fn drop(&mut self) { fn drop(&mut self) {
if !thread::panicking() { if !thread::panicking() {
assert!(self.pending_images.lock().unwrap().is_empty()); assert!(self.pending_images.lock().unwrap().is_empty());
@ -62,7 +62,7 @@ impl<'a> Drop for LayoutContext<'a> {
} }
} }
impl<'a> LayoutContext<'a> { impl LayoutContext<'_> {
#[inline(always)] #[inline(always)]
pub fn shared_context(&self) -> &SharedStyleContext { pub fn shared_context(&self) -> &SharedStyleContext {
&self.style_context &self.style_context

4
components/layout/flow.rs
View file

@ -1231,7 +1231,7 @@ impl BaseFlow {
} }
} }
impl<'a> ImmutableFlowUtils for &'a dyn Flow { impl ImmutableFlowUtils for &dyn Flow {
/// Returns true if this flow is a block flow or subclass thereof. /// Returns true if this flow is a block flow or subclass thereof.
fn is_block_like(self) -> bool { fn is_block_like(self) -> bool {
self.class().is_block_like() self.class().is_block_like()
@ -1332,7 +1332,7 @@ impl<'a> ImmutableFlowUtils for &'a dyn Flow {
} }
} }
impl<'a> MutableFlowUtils for &'a mut dyn Flow { impl MutableFlowUtils for &mut dyn Flow {
/// Calls `repair_style` and `bubble_inline_sizes`. You should use this method instead of /// Calls `repair_style` and `bubble_inline_sizes`. You should use this method instead of
/// calling them individually, since there is no reason not to perform both operations. /// calling them individually, since there is no reason not to perform both operations.
fn repair_style_and_bubble_inline_sizes(self, style: &crate::ServoArc<ComputedValues>) { fn repair_style_and_bubble_inline_sizes(self, style: &crate::ServoArc<ComputedValues>) {

2
components/layout/flow_list.rs
View file

@ -192,7 +192,7 @@ pub struct FlowListRandomAccessMut<'a> {
cache: Vec<FlowRef>, cache: Vec<FlowRef>,
} }
impl<'a> FlowListRandomAccessMut<'a> { impl FlowListRandomAccessMut<'_> {
pub fn get(&mut self, index: usize) -> &mut dyn Flow { pub fn get(&mut self, index: usize) -> &mut dyn Flow {
while index >= self.cache.len() { while index >= self.cache.len() {
match self.iterator.next() { match self.iterator.next() {

2
components/layout/fragment.rs
View file

@ -3353,7 +3353,7 @@ impl<'a> Iterator for InlineStyleIterator<'a> {
} }
} }
impl<'a> InlineStyleIterator<'a> { impl InlineStyleIterator<'_> {
fn new(fragment: &Fragment) -> InlineStyleIterator { fn new(fragment: &Fragment) -> InlineStyleIterator {
InlineStyleIterator { InlineStyleIterator {
fragment, fragment,

4
components/layout/generated_content.rs
View file

@ -133,7 +133,7 @@ impl<'a> ResolveGeneratedContent<'a> {
} }
} }
impl<'a> InorderFlowTraversal for ResolveGeneratedContent<'a> { impl InorderFlowTraversal for ResolveGeneratedContent<'_> {
#[inline] #[inline]
fn process(&mut self, flow: &mut dyn Flow, level: u32) { fn process(&mut self, flow: &mut dyn Flow, level: u32) {
let mut mutator = ResolveGeneratedContentFragmentMutator { let mut mutator = ResolveGeneratedContentFragmentMutator {
@ -168,7 +168,7 @@ struct ResolveGeneratedContentFragmentMutator<'a, 'b: 'a> {
incremented: bool, incremented: bool,
} }
impl<'a, 'b> ResolveGeneratedContentFragmentMutator<'a, 'b> { impl ResolveGeneratedContentFragmentMutator<'_, '_> {
fn mutate_fragment(&mut self, fragment: &mut Fragment) { fn mutate_fragment(&mut self, fragment: &mut Fragment) {
// We only reset and/or increment counters once per flow. This avoids double-incrementing // We only reset and/or increment counters once per flow. This avoids double-incrementing
// counters on list items (once for the main fragment and once for the marker). // counters on list items (once for the main fragment and once for the marker).

2
components/layout/table.rs
View file

@ -1317,7 +1317,7 @@ impl<'table> Iterator for TableCellStyleIterator<'table> {
} }
} }
impl<'table> TableCellStyleInfo<'table> { impl TableCellStyleInfo<'_> {
fn build_display_list(&self, mut state: &mut DisplayListBuildState) { fn build_display_list(&self, mut state: &mut DisplayListBuildState) {
use style::computed_values::visibility::T as Visibility; use style::computed_values::visibility::T as Visibility;

2
components/layout/table_wrapper.rs
View file

@ -669,7 +669,7 @@ impl AutoLayoutCandidateGuess {
} }
} }
impl<'a> Add for &'a AutoLayoutCandidateGuess { impl Add for &AutoLayoutCandidateGuess {
type Output = AutoLayoutCandidateGuess; type Output = AutoLayoutCandidateGuess;
#[inline] #[inline]
fn add(self, other: &AutoLayoutCandidateGuess) -> AutoLayoutCandidateGuess { fn add(self, other: &AutoLayoutCandidateGuess) -> AutoLayoutCandidateGuess {

2
components/layout/text_run.rs
View file

@ -69,7 +69,7 @@ pub struct TextRunSlice<'a> {
pub range: Range<ByteIndex>, pub range: Range<ByteIndex>,
} }
impl<'a> TextRunSlice<'a> { impl TextRunSlice<'_> {
/// Returns the range that these glyphs encompass, relative to the start of the *text run*. /// Returns the range that these glyphs encompass, relative to the start of the *text run*.
#[inline] #[inline]
pub fn text_run_range(&self) -> Range<ByteIndex> { pub fn text_run_range(&self) -> Range<ByteIndex> {

12
components/layout/traversal.rs
View file

@ -43,7 +43,7 @@ impl<'a> RecalcStyleAndConstructFlows<'a> {
} }
#[allow(unsafe_code)] #[allow(unsafe_code)]
impl<'a, 'dom, E> DomTraversal<E> for RecalcStyleAndConstructFlows<'a> impl<'dom, E> DomTraversal<E> for RecalcStyleAndConstructFlows<'_>
where where
E: TElement, E: TElement,
E::ConcreteNode: LayoutNode<'dom>, E::ConcreteNode: LayoutNode<'dom>,
@ -252,7 +252,7 @@ pub struct BubbleISizes<'a> {
pub layout_context: &'a LayoutContext<'a>, pub layout_context: &'a LayoutContext<'a>,
} }
impl<'a> PostorderFlowTraversal for BubbleISizes<'a> { impl PostorderFlowTraversal for BubbleISizes<'_> {
#[inline] #[inline]
fn process(&self, flow: &mut dyn Flow) { fn process(&self, flow: &mut dyn Flow) {
flow.bubble_inline_sizes(); flow.bubble_inline_sizes();
@ -275,7 +275,7 @@ pub struct AssignISizes<'a> {
pub layout_context: &'a LayoutContext<'a>, pub layout_context: &'a LayoutContext<'a>,
} }
impl<'a> PreorderFlowTraversal for AssignISizes<'a> { impl PreorderFlowTraversal for AssignISizes<'_> {
#[inline] #[inline]
fn process(&self, flow: &mut dyn Flow) { fn process(&self, flow: &mut dyn Flow) {
flow.assign_inline_sizes(self.layout_context); flow.assign_inline_sizes(self.layout_context);
@ -297,7 +297,7 @@ pub struct AssignBSizes<'a> {
pub layout_context: &'a LayoutContext<'a>, pub layout_context: &'a LayoutContext<'a>,
} }
impl<'a> PostorderFlowTraversal for AssignBSizes<'a> { impl PostorderFlowTraversal for AssignBSizes<'_> {
#[inline] #[inline]
fn process(&self, flow: &mut dyn Flow) { fn process(&self, flow: &mut dyn Flow) {
// Can't do anything with anything that floats might flow through until we reach their // Can't do anything with anything that floats might flow through until we reach their
@ -326,7 +326,7 @@ pub struct ComputeStackingRelativePositions<'a> {
pub layout_context: &'a LayoutContext<'a>, pub layout_context: &'a LayoutContext<'a>,
} }
impl<'a> PreorderFlowTraversal for ComputeStackingRelativePositions<'a> { impl PreorderFlowTraversal for ComputeStackingRelativePositions<'_> {
#[inline] #[inline]
fn should_process_subtree(&self, flow: &mut dyn Flow) -> bool { fn should_process_subtree(&self, flow: &mut dyn Flow) -> bool {
flow.base() flow.base()
@ -347,7 +347,7 @@ pub struct BuildDisplayList<'a> {
pub state: DisplayListBuildState<'a>, pub state: DisplayListBuildState<'a>,
} }
impl<'a> BuildDisplayList<'a> { impl BuildDisplayList<'_> {
#[inline] #[inline]
pub fn traverse(&mut self, flow: &mut dyn Flow) { pub fn traverse(&mut self, flow: &mut dyn Flow) {
if flow.has_non_invertible_transform_or_zero_scale() { if flow.has_non_invertible_transform_or_zero_scale() {

2
components/layout_2020/construct_modern.rs
View file

@ -71,7 +71,7 @@ pub(crate) struct ModernItem<'dom> {
pub formatting_context: IndependentFormattingContext, pub formatting_context: IndependentFormattingContext,
} }
impl<'a, 'dom, Node: 'dom> TraversalHandler<'dom, Node> for ModernContainerBuilder<'a, 'dom, Node> impl<'dom, Node: 'dom> TraversalHandler<'dom, Node> for ModernContainerBuilder<'_, 'dom, Node>
where where
Node: NodeExt<'dom>, Node: NodeExt<'dom>,
{ {

4
components/layout_2020/context.rs
View file

@ -42,7 +42,7 @@ pub struct LayoutContext<'a> {
Arc<RwLock<FnvHashMap<(ServoUrl, UsePlaceholder), WebRenderImageInfo>>>, Arc<RwLock<FnvHashMap<(ServoUrl, UsePlaceholder), WebRenderImageInfo>>>,
} }
impl<'a> Drop for LayoutContext<'a> { impl Drop for LayoutContext<'_> {
fn drop(&mut self) { fn drop(&mut self) {
if !std::thread::panicking() { if !std::thread::panicking() {
assert!(self.pending_images.lock().is_empty()); assert!(self.pending_images.lock().is_empty());
@ -50,7 +50,7 @@ impl<'a> Drop for LayoutContext<'a> {
} }
} }
impl<'a> LayoutContext<'a> { impl LayoutContext<'_> {
#[inline(always)] #[inline(always)]
pub fn shared_context(&self) -> &SharedStyleContext { pub fn shared_context(&self) -> &SharedStyleContext {
&self.style_context &self.style_context

2
components/layout_2020/display_list/mod.rs
View file

@ -189,7 +189,7 @@ impl DisplayList {
} }
} }
impl<'a> DisplayListBuilder<'a> { impl DisplayListBuilder<'_> {
fn wr(&mut self) -> &mut wr::DisplayListBuilder { fn wr(&mut self) -> &mut wr::DisplayListBuilder {
&mut self.display_list.wr &mut self.display_list.wr
} }

2
components/layout_2020/flexbox/layout.rs
View file

@ -176,7 +176,7 @@ struct FlexLineItem<'a> {
used_main_size: Au, used_main_size: Au,
} }
impl<'a> FlexLineItem<'a> { impl FlexLineItem<'_> {
fn get_or_synthesize_baseline_with_cross_size(&self, cross_size: Au) -> Au { fn get_or_synthesize_baseline_with_cross_size(&self, cross_size: Au) -> Au {
self.layout_result self.layout_result
.baseline_relative_to_margin_box .baseline_relative_to_margin_box

2
components/layout_2020/flow/inline/line.rs
View file

@ -152,7 +152,7 @@ pub(super) struct LineItemLayout<'layout_data, 'layout> {
pub justification_adjustment: Au, pub justification_adjustment: Au,
} }
impl<'layout_data, 'layout> LineItemLayout<'layout_data, 'layout> { impl LineItemLayout<'_, '_> {
pub(super) fn layout_line_items( pub(super) fn layout_line_items(
layout: &mut InlineFormattingContextLayout, layout: &mut InlineFormattingContextLayout,
line_items: Vec<LineItem>, line_items: Vec<LineItem>,

2
components/layout_2020/flow/inline/mod.rs
View file

@ -649,7 +649,7 @@ pub(super) struct InlineFormattingContextLayout<'layout_data> {
baselines: Baselines, baselines: Baselines,
} }
impl<'layout_dta> InlineFormattingContextLayout<'layout_dta> { impl InlineFormattingContextLayout<'_> {
fn current_inline_container_state(&self) -> &InlineContainerState { fn current_inline_container_state(&self) -> &InlineContainerState {
match self.inline_box_state_stack.last() { match self.inline_box_state_stack.last() {
Some(inline_box_state) => &inline_box_state.base, Some(inline_box_state) => &inline_box_state.base,

1
components/layout_2020/lib.rs
View file

@ -3,7 +3,6 @@
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
#![deny(unsafe_code)] #![deny(unsafe_code)]
#![allow(clippy::needless_lifetimes)]
mod cell; mod cell;
pub mod context; pub mod context;

2
components/layout_2020/positioned.rs
View file

@ -749,7 +749,7 @@ struct AbsoluteAxisSolver<'a> {
flip_anchor: bool, flip_anchor: bool,
} }
impl<'a> AbsoluteAxisSolver<'a> { impl AbsoluteAxisSolver<'_> {
/// Returns the amount that we need to subtract from the containing block size in order to /// Returns the amount that we need to subtract from the containing block size in order to
/// obtain the inset-modified containing block that we will use for sizing purposes. /// obtain the inset-modified containing block that we will use for sizing purposes.
/// (Note that for alignment purposes, we may re-resolve auto insets to a different value.) /// (Note that for alignment purposes, we may re-resolve auto insets to a different value.)

10
components/layout_2020/table/construct.rs
View file

@ -39,7 +39,7 @@ pub(super) struct ResolvedSlotAndLocation<'a> {
pub coords: TableSlotCoordinates, pub coords: TableSlotCoordinates,
} }
impl<'a> ResolvedSlotAndLocation<'a> { impl ResolvedSlotAndLocation<'_> {
fn covers_cell_at(&self, coords: TableSlotCoordinates) -> bool { fn covers_cell_at(&self, coords: TableSlotCoordinates) -> bool {
let covered_in_x = let covered_in_x =
coords.x >= self.coords.x && coords.x < self.coords.x + self.cell.colspan; coords.x >= self.coords.x && coords.x < self.coords.x + self.cell.colspan;
@ -59,7 +59,7 @@ pub(crate) enum AnonymousTableContent<'dom, Node> {
}, },
} }
impl<'dom, Node> AnonymousTableContent<'dom, Node> { impl<Node> AnonymousTableContent<'_, Node> {
fn is_whitespace_only(&self) -> bool { fn is_whitespace_only(&self) -> bool {
match self { match self {
Self::Element { .. } => false, Self::Element { .. } => false,
@ -725,8 +725,7 @@ where
} }
} }
impl<'style, 'dom, Node: 'dom> TraversalHandler<'dom, Node> impl<'dom, Node: 'dom> TraversalHandler<'dom, Node> for TableBuilderTraversal<'_, 'dom, Node>
for TableBuilderTraversal<'style, 'dom, Node>
where where
Node: NodeExt<'dom>, Node: NodeExt<'dom>,
{ {
@ -987,8 +986,7 @@ where
} }
} }
impl<'style, 'builder, 'dom, 'a, Node: 'dom> TraversalHandler<'dom, Node> impl<'dom, Node: 'dom> TraversalHandler<'dom, Node> for TableRowBuilder<'_, '_, 'dom, '_, Node>
for TableRowBuilder<'style, 'builder, 'dom, 'a, Node>
where where
Node: NodeExt<'dom>, Node: NodeExt<'dom>,
{ {

2
components/layout_2020/table/layout.rs
View file

@ -2922,7 +2922,7 @@ struct RowspanToDistribute<'a> {
measure: &'a CellOrTrackMeasure, measure: &'a CellOrTrackMeasure,
} }
impl<'a> RowspanToDistribute<'a> { impl RowspanToDistribute<'_> {
fn range(&self) -> Range<usize> { fn range(&self) -> Range<usize> {
self.coordinates.y..self.coordinates.y + self.cell.rowspan self.coordinates.y..self.coordinates.y + self.cell.rowspan
} }

2
components/layout_2020/traversal.rs
View file

@ -30,7 +30,7 @@ impl<'a> RecalcStyle<'a> {
} }
#[allow(unsafe_code)] #[allow(unsafe_code)]
impl<'a, 'dom, E> DomTraversal<E> for RecalcStyle<'a> impl<'dom, E> DomTraversal<E> for RecalcStyle<'_>
where where
E: TElement, E: TElement,
E::ConcreteNode: 'dom + LayoutNode<'dom>, E::ConcreteNode: 'dom + LayoutNode<'dom>,

2
components/script/document_collection.rs
View file

@ -105,7 +105,7 @@ pub struct DocumentsIter<'a> {
iter: hash_map::Iter<'a, PipelineId, Dom<Document>>, iter: hash_map::Iter<'a, PipelineId, Dom<Document>>,
} }
impl<'a> Iterator for DocumentsIter<'a> { impl Iterator for DocumentsIter<'_> {
type Item = (PipelineId, DomRoot<Document>); type Item = (PipelineId, DomRoot<Document>);
fn next(&mut self) -> Option<(PipelineId, DomRoot<Document>)> { fn next(&mut self) -> Option<(PipelineId, DomRoot<Document>)> {

2
components/script/dom/audiocontext.rs
View file

@ -315,7 +315,7 @@ impl Convert<LatencyCategory> for AudioContextLatencyCategory {
} }
} }
impl<'a> Convert<RealTimeAudioContextOptions> for &'a AudioContextOptions { impl Convert<RealTimeAudioContextOptions> for &AudioContextOptions {
fn convert(self) -> RealTimeAudioContextOptions { fn convert(self) -> RealTimeAudioContextOptions {
RealTimeAudioContextOptions { RealTimeAudioContextOptions {
sample_rate: *self.sampleRate.unwrap_or(Finite::wrap(44100.)), sample_rate: *self.sampleRate.unwrap_or(Finite::wrap(44100.)),

2
components/script/dom/bindings/callback.rs
View file

@ -216,7 +216,7 @@ impl<T: DomObject> ThisReflector for T {
} }
} }
impl<'a> ThisReflector for HandleObject<'a> { impl ThisReflector for HandleObject<'_> {
fn jsobject(&self) -> *mut JSObject { fn jsobject(&self) -> *mut JSObject {
self.get() self.get()
} }

4
components/script/dom/bindings/root.rs
View file

@ -260,7 +260,7 @@ impl<'a> ThreadLocalStackRoots<'a> {
} }
} }
impl<'a> Drop for ThreadLocalStackRoots<'a> { impl Drop for ThreadLocalStackRoots<'_> {
fn drop(&mut self) { fn drop(&mut self) {
STACK_ROOTS.with(|r| r.set(None)); STACK_ROOTS.with(|r| r.set(None));
} }
@ -698,7 +698,7 @@ impl<T: DomObject> PartialEq for MutNullableDom<T> {
} }
} }
impl<'a, T: DomObject> PartialEq<Option<&'a T>> for MutNullableDom<T> { impl<T: DomObject> PartialEq<Option<&T>> for MutNullableDom<T> {
fn eq(&self, other: &Option<&T>) -> bool { fn eq(&self, other: &Option<&T>) -> bool {
unsafe { *self.ptr.get() == other.map(Dom::from_ref) } unsafe { *self.ptr.get() == other.map(Dom::from_ref) }
} }

2
components/script/dom/bindings/str.rs
View file

@ -356,7 +356,7 @@ impl From<String> for DOMString {
} }
} }
impl<'a> From<&'a str> for DOMString { impl From<&str> for DOMString {
fn from(contents: &str) -> DOMString { fn from(contents: &str) -> DOMString {
DOMString::from(String::from(contents)) DOMString::from(String::from(contents))
} }

2
components/script/dom/biquadfilternode.rs
View file

@ -187,7 +187,7 @@ impl BiquadFilterNodeMethods<crate::DomTypeHolder> for BiquadFilterNode {
} }
} }
impl<'a> Convert<BiquadFilterNodeOptions> for &'a BiquadFilterOptions { impl Convert<BiquadFilterNodeOptions> for &BiquadFilterOptions {
fn convert(self) -> BiquadFilterNodeOptions { fn convert(self) -> BiquadFilterNodeOptions {
BiquadFilterNodeOptions { BiquadFilterNodeOptions {
gain: *self.gain, gain: *self.gain,

2
components/script/dom/canvasgradient.rs
View file

@ -75,7 +75,7 @@ pub trait ToFillOrStrokeStyle {
fn to_fill_or_stroke_style(self) -> FillOrStrokeStyle; fn to_fill_or_stroke_style(self) -> FillOrStrokeStyle;
} }
impl<'a> ToFillOrStrokeStyle for &'a CanvasGradient { impl ToFillOrStrokeStyle for &CanvasGradient {
fn to_fill_or_stroke_style(self) -> FillOrStrokeStyle { fn to_fill_or_stroke_style(self) -> FillOrStrokeStyle {
let gradient_stops = self.stops.borrow().clone(); let gradient_stops = self.stops.borrow().clone();
match self.style { match self.style {

2
components/script/dom/canvaspattern.rs
View file

@ -70,7 +70,7 @@ impl CanvasPattern {
} }
} }
impl<'a> ToFillOrStrokeStyle for &'a CanvasPattern { impl ToFillOrStrokeStyle for &CanvasPattern {
fn to_fill_or_stroke_style(self) -> FillOrStrokeStyle { fn to_fill_or_stroke_style(self) -> FillOrStrokeStyle {
FillOrStrokeStyle::Surface(SurfaceStyle::new( FillOrStrokeStyle::Surface(SurfaceStyle::new(
self.surface_data.clone(), self.surface_data.clone(),

2
components/script/dom/dedicatedworkerglobalscope.rs
View file

@ -83,7 +83,7 @@ impl<'a> AutoWorkerReset<'a> {
} }
} }
impl<'a> Drop for AutoWorkerReset<'a> { impl Drop for AutoWorkerReset<'_> {
fn drop(&mut self) { fn drop(&mut self) {
self.workerscope self.workerscope
.worker .worker

4
components/script/dom/element.rs
View file

@ -681,7 +681,7 @@ pub trait LayoutElementHelpers<'dom> {
fn get_attr_vals_for_layout(self, name: &LocalName) -> Vec<&'dom AttrValue>; fn get_attr_vals_for_layout(self, name: &LocalName) -> Vec<&'dom AttrValue>;
} }
impl<'dom> LayoutDom<'dom, Element> { impl LayoutDom<'_, Element> {
pub(super) fn focus_state(self) -> bool { pub(super) fn focus_state(self) -> bool {
self.unsafe_get().state.get().contains(ElementState::FOCUS) self.unsafe_get().state.get().contains(ElementState::FOCUS)
} }
@ -4361,7 +4361,7 @@ pub enum AttributeMutation<'a> {
Removed, Removed,
} }
impl<'a> AttributeMutation<'a> { impl AttributeMutation<'_> {
pub fn is_removal(&self) -> bool { pub fn is_removal(&self) -> bool {
match *self { match *self {
AttributeMutation::Removed => true, AttributeMutation::Removed => true,

2
components/script/dom/htmlformelement.rs
View file

@ -1383,7 +1383,7 @@ pub enum FormSubmitterElement<'a> {
// (including custom elements) that can be passed as submitter. // (including custom elements) that can be passed as submitter.
} }
impl<'a> FormSubmitterElement<'a> { impl FormSubmitterElement<'_> {
fn action(&self) -> DOMString { fn action(&self) -> DOMString {
match *self { match *self {
FormSubmitterElement::Form(form) => form.Action(), FormSubmitterElement::Form(form) => form.Action(),

2
components/script/dom/htmlinputelement.rs
View file

@ -195,7 +195,7 @@ impl InputType {
} }
} }
impl<'a> From<&'a Atom> for InputType { impl From<&Atom> for InputType {
fn from(value: &Atom) -> InputType { fn from(value: &Atom) -> InputType {
match value.to_ascii_lowercase() { match value.to_ascii_lowercase() {
atom!("button") => InputType::Button, atom!("button") => InputType::Button,

2
components/script/dom/htmlobjectelement.rs
View file

@ -73,7 +73,7 @@ trait ProcessDataURL {
fn process_data_url(&self); fn process_data_url(&self);
} }
impl<'a> ProcessDataURL for &'a HTMLObjectElement { impl ProcessDataURL for &HTMLObjectElement {
// Makes the local `data` member match the status of the `data` attribute and starts // Makes the local `data` member match the status of the `data` attribute and starts
/// prefetching the image. This method must be called after `data` is changed. /// prefetching the image. This method must be called after `data` is changed.
fn process_data_url(&self) { fn process_data_url(&self) {

2
components/script/dom/oscillatornode.rs
View file

@ -157,7 +157,7 @@ impl OscillatorNodeMethods<crate::DomTypeHolder> for OscillatorNode {
} }
} }
impl<'a> Convert<ServoMediaOscillatorOptions> for &'a OscillatorOptions { impl Convert<ServoMediaOscillatorOptions> for &OscillatorOptions {
fn convert(self) -> ServoMediaOscillatorOptions { fn convert(self) -> ServoMediaOscillatorOptions {
ServoMediaOscillatorOptions { ServoMediaOscillatorOptions {
oscillator_type: self.type_.convert(), oscillator_type: self.type_.convert(),

2
components/script/dom/pannernode.rs
View file

@ -373,7 +373,7 @@ impl PannerNodeMethods<crate::DomTypeHolder> for PannerNode {
} }
} }
impl<'a> Convert<PannerNodeOptions> for &'a PannerOptions { impl Convert<PannerNodeOptions> for &PannerOptions {
fn convert(self) -> PannerNodeOptions { fn convert(self) -> PannerNodeOptions {
PannerNodeOptions { PannerNodeOptions {
panning_model: self.panningModel.convert(), panning_model: self.panningModel.convert(),

2
components/script/dom/rtcpeerconnection.rs
View file

@ -837,7 +837,7 @@ impl Convert<RTCSessionDescriptionInit> for SessionDescription {
} }
} }
impl<'a> Convert<SessionDescription> for &'a RTCSessionDescriptionInit { impl Convert<SessionDescription> for &RTCSessionDescriptionInit {
fn convert(self) -> SessionDescription { fn convert(self) -> SessionDescription {
let type_ = match self.type_ { let type_ = match self.type_ {
RTCSdpType::Answer => SdpType::Answer, RTCSdpType::Answer => SdpType::Answer,

2
components/script/dom/servoparser/html.rs
View file

@ -212,7 +212,7 @@ impl Iterator for SerializationIterator {
} }
} }
impl<'a> Serialize for &'a Node { impl Serialize for &Node {
fn serialize<S: Serializer>( fn serialize<S: Serializer>(
&self, &self,
serializer: &mut S, serializer: &mut S,

2
components/script/dom/treewalker.rs
View file

@ -456,7 +456,7 @@ impl TreeWalker {
} }
} }
impl<'a> Iterator for &'a TreeWalker { impl Iterator for &TreeWalker {
type Item = DomRoot<Node>; type Item = DomRoot<Node>;
fn next(&mut self) -> Option<DomRoot<Node>> { fn next(&mut self) -> Option<DomRoot<Node>> {

12
components/script/dom/webgl_validations/tex_image_2d.rs
View file

@ -107,7 +107,7 @@ pub struct CommonTexImage2DValidatorResult {
pub border: u32, pub border: u32,
} }
impl<'a> WebGLValidator for CommonTexImage2DValidator<'a> { impl WebGLValidator for CommonTexImage2DValidator<'_> {
type Error = TexImageValidationError; type Error = TexImageValidationError;
type ValidatedOutput = CommonTexImage2DValidatorResult; type ValidatedOutput = CommonTexImage2DValidatorResult;
fn validate(self) -> Result<Self::ValidatedOutput, TexImageValidationError> { fn validate(self) -> Result<Self::ValidatedOutput, TexImageValidationError> {
@ -299,7 +299,7 @@ pub struct TexImage2DValidatorResult {
/// TexImage2d validator as per /// TexImage2d validator as per
/// <https://www.khronos.org/opengles/sdk/docs/man/xhtml/glTexImage2D.xml> /// <https://www.khronos.org/opengles/sdk/docs/man/xhtml/glTexImage2D.xml>
impl<'a> WebGLValidator for TexImage2DValidator<'a> { impl WebGLValidator for TexImage2DValidator<'_> {
type ValidatedOutput = TexImage2DValidatorResult; type ValidatedOutput = TexImage2DValidatorResult;
type Error = TexImageValidationError; type Error = TexImageValidationError;
@ -459,7 +459,7 @@ fn is_subimage_blockaligned(
(height % block_height == 0 || yoffset + height == tex_info.height()) (height % block_height == 0 || yoffset + height == tex_info.height())
} }
impl<'a> WebGLValidator for CommonCompressedTexImage2DValidator<'a> { impl WebGLValidator for CommonCompressedTexImage2DValidator<'_> {
type Error = TexImageValidationError; type Error = TexImageValidationError;
type ValidatedOutput = CommonCompressedTexImage2DValidatorResult; type ValidatedOutput = CommonCompressedTexImage2DValidatorResult;
@ -537,7 +537,7 @@ impl<'a> CompressedTexImage2DValidator<'a> {
} }
} }
impl<'a> WebGLValidator for CompressedTexImage2DValidator<'a> { impl WebGLValidator for CompressedTexImage2DValidator<'_> {
type Error = TexImageValidationError; type Error = TexImageValidationError;
type ValidatedOutput = CommonCompressedTexImage2DValidatorResult; type ValidatedOutput = CommonCompressedTexImage2DValidatorResult;
@ -617,7 +617,7 @@ impl<'a> CompressedTexSubImage2DValidator<'a> {
} }
} }
impl<'a> WebGLValidator for CompressedTexSubImage2DValidator<'a> { impl WebGLValidator for CompressedTexSubImage2DValidator<'_> {
type Error = TexImageValidationError; type Error = TexImageValidationError;
type ValidatedOutput = CommonCompressedTexImage2DValidatorResult; type ValidatedOutput = CommonCompressedTexImage2DValidatorResult;
@ -728,7 +728,7 @@ impl<'a> TexStorageValidator<'a> {
} }
} }
impl<'a> WebGLValidator for TexStorageValidator<'a> { impl WebGLValidator for TexStorageValidator<'_> {
type Error = TexImageValidationError; type Error = TexImageValidationError;
type ValidatedOutput = TexStorageValidatorResult; type ValidatedOutput = TexStorageValidatorResult;

4
components/script/layout_dom/element.rs
View file

@ -56,7 +56,7 @@ pub struct ServoLayoutElement<'dom> {
element: LayoutDom<'dom, Element>, element: LayoutDom<'dom, Element>,
} }
impl<'dom> fmt::Debug for ServoLayoutElement<'dom> { impl fmt::Debug for ServoLayoutElement<'_> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "<{}", self.element.local_name())?; write!(f, "<{}", self.element.local_name())?;
if let Some(id) = self.id() { if let Some(id) = self.id() {
@ -800,7 +800,7 @@ impl<'dom> ThreadSafeLayoutElement<'dom> for ServoThreadSafeLayoutElement<'dom>
/// ///
/// Note that the element implementation is needed only for selector matching, /// Note that the element implementation is needed only for selector matching,
/// not for inheritance (styles are inherited appropriately). /// not for inheritance (styles are inherited appropriately).
impl<'dom> ::selectors::Element for ServoThreadSafeLayoutElement<'dom> { impl ::selectors::Element for ServoThreadSafeLayoutElement<'_> {
type Impl = SelectorImpl; type Impl = SelectorImpl;
fn opaque(&self) -> ::selectors::OpaqueElement { fn opaque(&self) -> ::selectors::OpaqueElement {

6
components/script/layout_dom/node.rs
View file

@ -59,7 +59,7 @@ pub struct ServoLayoutNode<'dom> {
unsafe impl Send for ServoLayoutNode<'_> {} unsafe impl Send for ServoLayoutNode<'_> {}
unsafe impl Sync for ServoLayoutNode<'_> {} unsafe impl Sync for ServoLayoutNode<'_> {}
impl<'dom> fmt::Debug for ServoLayoutNode<'dom> { impl fmt::Debug for ServoLayoutNode<'_> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if let Some(el) = self.as_element() { if let Some(el) = self.as_element() {
el.fmt(f) el.fmt(f)
@ -95,7 +95,7 @@ impl<'dom> ServoLayoutNode<'dom> {
} }
} }
impl<'dom> style::dom::NodeInfo for ServoLayoutNode<'dom> { impl style::dom::NodeInfo for ServoLayoutNode<'_> {
fn is_element(&self) -> bool { fn is_element(&self) -> bool {
self.node.is_element_for_layout() self.node.is_element_for_layout()
} }
@ -262,7 +262,7 @@ impl<'dom> ServoThreadSafeLayoutNode<'dom> {
} }
} }
impl<'dom> style::dom::NodeInfo for ServoThreadSafeLayoutNode<'dom> { impl style::dom::NodeInfo for ServoThreadSafeLayoutNode<'_> {
fn is_element(&self) -> bool { fn is_element(&self) -> bool {
self.node.is_element() self.node.is_element()
} }

2
components/script/layout_dom/shadow_root.rs
View file

@ -18,7 +18,7 @@ pub struct ServoShadowRoot<'dom> {
shadow_root: LayoutDom<'dom, ShadowRoot>, shadow_root: LayoutDom<'dom, ShadowRoot>,
} }
impl<'dom> fmt::Debug for ServoShadowRoot<'dom> { impl fmt::Debug for ServoShadowRoot<'_> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.as_node().fmt(f) self.as_node().fmt(f)
} }

1
components/script/lib.rs
View file

@ -11,7 +11,6 @@
#![register_tool(crown)] #![register_tool(crown)]
#![cfg_attr(any(doc, clippy), allow(unknown_lints))] #![cfg_attr(any(doc, clippy), allow(unknown_lints))]
#![deny(crown_is_not_used)] #![deny(crown_is_not_used)]
#![allow(clippy::needless_lifetimes)]
// These are used a lot so let's keep them for now // These are used a lot so let's keep them for now
#[macro_use] #[macro_use]

2
components/script/realms.rs
View file

@ -33,7 +33,7 @@ pub enum InRealm<'a> {
Entered(&'a JSAutoRealm), Entered(&'a JSAutoRealm),
} }
impl<'a> InRealm<'a> { impl InRealm<'_> {
pub fn already(token: &AlreadyInRealm) -> InRealm { pub fn already(token: &AlreadyInRealm) -> InRealm {
InRealm::Already(token) InRealm::Already(token)
} }

2
components/script/script_thread.rs
View file

@ -463,7 +463,7 @@ impl<'a> ScriptMemoryFailsafe<'a> {
} }
} }
impl<'a> Drop for ScriptMemoryFailsafe<'a> { impl Drop for ScriptMemoryFailsafe<'_> {
#[allow(crown::unrooted_must_root)] #[allow(crown::unrooted_must_root)]
fn drop(&mut self) { fn drop(&mut self) {
if let Some(owner) = self.owner { if let Some(owner) = self.owner {

4
components/script/stylesheet_loader.rs
View file

@ -302,7 +302,7 @@ impl<'a> StylesheetLoader<'a> {
} }
} }
impl<'a> StylesheetLoader<'a> { impl StylesheetLoader<'_> {
pub fn load( pub fn load(
&self, &self,
source: StylesheetContextSource, source: StylesheetContextSource,
@ -373,7 +373,7 @@ pub(crate) fn stylesheet_fetch_request(
.integrity_metadata(integrity_metadata) .integrity_metadata(integrity_metadata)
} }
impl<'a> StyleStylesheetLoader for StylesheetLoader<'a> { impl StyleStylesheetLoader for StylesheetLoader<'_> {
/// Request a stylesheet after parsing a given `@import` rule, and return /// Request a stylesheet after parsing a given `@import` rule, and return
/// the constructed `@import` rule. /// the constructed `@import` rule.
fn request_stylesheet( fn request_stylesheet(

2
components/script/stylesheet_set.rs
View file

@ -18,7 +18,7 @@ where
Document(&'a mut DocumentStylesheetSet<S>), Document(&'a mut DocumentStylesheetSet<S>),
} }
impl<'a, S> StylesheetSetRef<'a, S> impl<S> StylesheetSetRef<'_, S>
where where
S: StylesheetInDocument + PartialEq + 'static, S: StylesheetInDocument + PartialEq + 'static,
{ {

2
components/script/xpath/context.rs
View file

@ -78,7 +78,7 @@ pub struct EvalNodesetIter<'a> {
size: usize, size: usize,
} }
impl<'a> Iterator for EvalNodesetIter<'a> { impl Iterator for EvalNodesetIter<'_> {
type Item = EvaluationCtx; type Item = EvaluationCtx;
fn next(&mut self) -> Option<EvaluationCtx> { fn next(&mut self) -> Option<EvaluationCtx> {

3
components/webdriver_server/lib.rs
View file

@ -5,7 +5,6 @@
#![crate_name = "webdriver_server"] #![crate_name = "webdriver_server"]
#![crate_type = "rlib"] #![crate_type = "rlib"]
#![deny(unsafe_code)] #![deny(unsafe_code)]
#![allow(clippy::needless_lifetimes)]
mod actions; mod actions;
mod capabilities; mod capabilities;
@ -313,7 +312,7 @@ impl<'de> Deserialize<'de> for WebDriverPrefValue {
{ {
struct Visitor; struct Visitor;
impl<'de> ::serde::de::Visitor<'de> for Visitor { impl ::serde::de::Visitor<'_> for Visitor {
type Value = WebDriverPrefValue; type Value = WebDriverPrefValue;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {