Satisfy mismatched_lifetime_syntaxes rustc lint on nightly

tyranron · tyranron · commit 09cef7762d9b · 2025-06-09T18:03:19.000+02:00
diff --git a/juniper/src/ast.rs b/juniper/src/ast.rs
@@ -626,11 +626,11 @@ impl<'a, S> Arguments<'a, S> {
         self.items.into_iter()
     }
 
-    pub fn iter(&self) -> slice::Iter<(Spanning<&'a str>, Spanning<InputValue<S>>)> {
+    pub fn iter(&self) -> slice::Iter<'_, (Spanning<&'a str>, Spanning<InputValue<S>>)> {
         self.items.iter()
     }
 
-    pub fn iter_mut(&mut self) -> slice::IterMut<(Spanning<&'a str>, Spanning<InputValue<S>>)> {
+    pub fn iter_mut(&mut self) -> slice::IterMut<'_, (Spanning<&'a str>, Spanning<InputValue<S>>)> {
         self.items.iter_mut()
     }
 
@@ -648,7 +648,7 @@ impl<'a, S> Arguments<'a, S> {
 }
 
 impl<'a, S> VariableDefinitions<'a, S> {
-    pub fn iter(&self) -> slice::Iter<(Spanning<&'a str>, VariableDefinition<'a, S>)> {
+    pub fn iter(&self) -> slice::Iter<'_, (Spanning<&'a str>, VariableDefinition<'a, S>)> {
         self.items.iter()
     }
 }
diff --git a/juniper/src/executor/look_ahead.rs b/juniper/src/executor/look_ahead.rs
@@ -819,7 +819,7 @@ mod tests {
 
     use super::*;
 
-    fn parse_document_source<S>(q: &str) -> UnlocatedParseResult<OwnedDocument<S>>
+    fn parse_document_source<S>(q: &str) -> UnlocatedParseResult<OwnedDocument<'_, S>>
     where
         S: ScalarValue,
     {
diff --git a/juniper/src/parser/tests/document.rs b/juniper/src/parser/tests/document.rs
@@ -8,7 +8,7 @@ use crate::{
     value::{DefaultScalarValue, ScalarValue},
 };
 
-fn parse_document<S>(s: &str) -> OwnedDocument<S>
+fn parse_document<S>(s: &str) -> OwnedDocument<'_, S>
 where
     S: ScalarValue,
 {
@@ -33,46 +33,44 @@ fn parse_document_error<S: ScalarValue>(s: &str) -> Spanning<ParseError> {
 fn simple_ast() {
     assert_eq!(
         parse_document::<DefaultScalarValue>(
-            r#"
-            {
+            r#"{
                 node(id: 4) {
                     id
                     name
                 }
-            }
-        "#
+            }"#,
         ),
         vec![Definition::Operation(Spanning::start_end(
-            &SourcePosition::new(13, 1, 12),
-            &SourcePosition::new(124, 6, 13),
+            &SourcePosition::new(0, 0, 0),
+            &SourcePosition::new(111, 5, 13),
             Operation {
                 operation_type: OperationType::Query,
                 name: None,
                 variable_definitions: None,
                 directives: None,
                 selection_set: vec![Selection::Field(Spanning::start_end(
-                    &SourcePosition::new(31, 2, 16),
-                    &SourcePosition::new(110, 5, 17),
+                    &SourcePosition::new(18, 1, 16),
+                    &SourcePosition::new(97, 4, 17),
                     Field {
                         alias: None,
                         name: Spanning::start_end(
-                            &SourcePosition::new(31, 2, 16),
-                            &SourcePosition::new(35, 2, 20),
+                            &SourcePosition::new(18, 1, 16),
+                            &SourcePosition::new(22, 1, 20),
                             "node",
                         ),
                         arguments: Some(Spanning::start_end(
-                            &SourcePosition::new(35, 2, 20),
-                            &SourcePosition::new(42, 2, 27),
+                            &SourcePosition::new(22, 1, 20),
+                            &SourcePosition::new(29, 1, 27),
                             Arguments {
                                 items: vec![(
                                     Spanning::start_end(
-                                        &SourcePosition::new(36, 2, 21),
-                                        &SourcePosition::new(38, 2, 23),
+                                        &SourcePosition::new(23, 1, 21),
+                                        &SourcePosition::new(25, 1, 23),
                                         "id",
                                     ),
                                     Spanning::start_end(
-                                        &SourcePosition::new(40, 2, 25),
-                                        &SourcePosition::new(41, 2, 26),
+                                        &SourcePosition::new(27, 1, 25),
+                                        &SourcePosition::new(28, 1, 26),
                                         graphql_input_value!(4),
                                     ),
                                 )],
@@ -81,13 +79,13 @@ fn simple_ast() {
                         directives: None,
                         selection_set: Some(vec![
                             Selection::Field(Spanning::start_end(
-                                &SourcePosition::new(65, 3, 20),
-                                &SourcePosition::new(67, 3, 22),
+                                &SourcePosition::new(52, 2, 20),
+                                &SourcePosition::new(54, 2, 22),
                                 Field {
                                     alias: None,
                                     name: Spanning::start_end(
-                                        &SourcePosition::new(65, 3, 20),
-                                        &SourcePosition::new(67, 3, 22),
+                                        &SourcePosition::new(52, 2, 20),
+                                        &SourcePosition::new(54, 2, 22),
                                         "id",
                                     ),
                                     arguments: None,
@@ -96,13 +94,13 @@ fn simple_ast() {
                                 },
                             )),
                             Selection::Field(Spanning::start_end(
-                                &SourcePosition::new(88, 4, 20),
-                                &SourcePosition::new(92, 4, 24),
+                                &SourcePosition::new(75, 3, 20),
+                                &SourcePosition::new(79, 3, 24),
                                 Field {
                                     alias: None,
                                     name: Spanning::start_end(
-                                        &SourcePosition::new(88, 4, 20),
-                                        &SourcePosition::new(92, 4, 24),
+                                        &SourcePosition::new(75, 3, 20),
+                                        &SourcePosition::new(79, 3, 24),
                                         "name",
                                     ),
                                     arguments: None,
diff --git a/juniper/src/schema/model.rs b/juniper/src/schema/model.rs
@@ -310,7 +310,7 @@ impl<S> SchemaType<S> {
     }
 
     /// Get a type by name.
-    pub fn type_by_name(&self, name: impl AsRef<str>) -> Option<TypeType<S>> {
+    pub fn type_by_name(&self, name: impl AsRef<str>) -> Option<TypeType<'_, S>> {
         self.types.get(name.as_ref()).map(|t| TypeType::Concrete(t))
     }
 
@@ -329,7 +329,7 @@ impl<S> SchemaType<S> {
     }
 
     /// Get the query type from the schema.
-    pub fn query_type(&self) -> TypeType<S> {
+    pub fn query_type(&self) -> TypeType<'_, S> {
         TypeType::Concrete(
             self.types
                 .get(self.query_type_name.as_str())
@@ -345,7 +345,7 @@ impl<S> SchemaType<S> {
     }
 
     /// Get the mutation type from the schema.
-    pub fn mutation_type(&self) -> Option<TypeType<S>> {
+    pub fn mutation_type(&self) -> Option<TypeType<'_, S>> {
         self.mutation_type_name.as_ref().map(|name| {
             self.type_by_name(name)
                 .expect("Mutation type does not exist in schema")
@@ -361,7 +361,7 @@ impl<S> SchemaType<S> {
     }
 
     /// Get the subscription type.
-    pub fn subscription_type(&self) -> Option<TypeType<S>> {
+    pub fn subscription_type(&self) -> Option<TypeType<'_, S>> {
         self.subscription_type_name.as_ref().map(|name| {
             self.type_by_name(name)
                 .expect("Subscription type does not exist in schema")
@@ -377,7 +377,7 @@ impl<S> SchemaType<S> {
     }
 
     /// Get a list of types.
-    pub fn type_list(&self) -> Vec<TypeType<S>> {
+    pub fn type_list(&self) -> Vec<TypeType<'_, S>> {
         let mut types = self
             .types
             .values()
@@ -393,7 +393,7 @@ impl<S> SchemaType<S> {
     }
 
     /// Make a type.
-    pub fn make_type(&self, ty: &Type<impl AsRef<str>>) -> TypeType<S> {
+    pub fn make_type(&self, ty: &Type<impl AsRef<str>>) -> TypeType<'_, S> {
         match ty {
             Type::List(inner, expected_size) => {
                 TypeType::List(Box::new(self.make_type(inner)), *expected_size)
diff --git a/juniper/src/schema/schema.rs b/juniper/src/schema/schema.rs
@@ -142,7 +142,7 @@ impl<S: ScalarValue> SchemaType<S> {
         self.description.as_ref()
     }
 
-    fn types(&self) -> Vec<TypeType<S>> {
+    fn types(&self) -> Vec<TypeType<'_, S>> {
         self.type_list()
             .into_iter()
             .filter(|t| {
@@ -157,17 +157,17 @@ impl<S: ScalarValue> SchemaType<S> {
     }
 
     #[graphql(name = "queryType")]
-    fn query_type_(&self) -> TypeType<S> {
+    fn query_type_(&self) -> TypeType<'_, S> {
         self.query_type()
     }
 
     #[graphql(name = "mutationType")]
-    fn mutation_type_(&self) -> Option<TypeType<S>> {
+    fn mutation_type_(&self) -> Option<TypeType<'_, S>> {
         self.mutation_type()
     }
 
     #[graphql(name = "subscriptionType")]
-    fn subscription_type_(&self) -> Option<TypeType<S>> {
+    fn subscription_type_(&self) -> Option<TypeType<'_, S>> {
         self.subscription_type()
     }
 
diff --git a/juniper/src/validation/rules/overlapping_fields_can_be_merged.rs b/juniper/src/validation/rules/overlapping_fields_can_be_merged.rs
@@ -56,7 +56,7 @@ impl<K: Eq + Hash + Clone, V> OrderedMap<K, V> {
         }
     }
 
-    fn iter(&self) -> OrderedMapIter<K, V> {
+    fn iter(&self) -> OrderedMapIter<'_, K, V> {
         OrderedMapIter {
             map: &self.data,
             inner: self.insert_order.iter(),

Original file line number	Diff line number	Diff line change
`@@ -626,11 +626,11 @@ impl<'a, S> Arguments<'a, S> {`
`626`	`626`	`self.items.into_iter()`
`627`	`627`	`}`
`628`	`628`
`629`		`- pub fn iter(&self) -> slice::Iter<(Spanning<&'a str>, Spanning<InputValue<S>>)> {`
	`629`	`+ pub fn iter(&self) -> slice::Iter<'_, (Spanning<&'a str>, Spanning<InputValue<S>>)> {`
`630`	`630`	`self.items.iter()`
`631`	`631`	`}`
`632`	`632`
`633`		`- pub fn iter_mut(&mut self) -> slice::IterMut<(Spanning<&'a str>, Spanning<InputValue<S>>)> {`
	`633`	`+ pub fn iter_mut(&mut self) -> slice::IterMut<'_, (Spanning<&'a str>, Spanning<InputValue<S>>)> {`
`634`	`634`	`self.items.iter_mut()`
`635`	`635`	`}`
`636`	`636`
`@@ -648,7 +648,7 @@ impl<'a, S> Arguments<'a, S> {`
`648`	`648`	`}`
`649`	`649`
`650`	`650`	`impl<'a, S> VariableDefinitions<'a, S> {`
`651`		`- pub fn iter(&self) -> slice::Iter<(Spanning<&'a str>, VariableDefinition<'a, S>)> {`
	`651`	`+ pub fn iter(&self) -> slice::Iter<'_, (Spanning<&'a str>, VariableDefinition<'a, S>)> {`
`652`	`652`	`self.items.iter()`
`653`	`653`	`}`
`654`	`654`	`}`
Original file line number	Diff line number	Diff line change
`@@ -819,7 +819,7 @@ mod tests {`
`819`	`819`
`820`	`820`	`use super::*;`
`821`	`821`
`822`		`- fn parse_document_source<S>(q: &str) -> UnlocatedParseResult<OwnedDocument<S>>`
	`822`	`+ fn parse_document_source<S>(q: &str) -> UnlocatedParseResult<OwnedDocument<'_, S>>`
`823`	`823`	`where`
`824`	`824`	`S: ScalarValue,`
`825`	`825`	`{`
Original file line number	Diff line number	Diff line change
`@@ -142,7 +142,7 @@ impl<S: ScalarValue> SchemaType<S> {`
`142`	`142`	`self.description.as_ref()`
`143`	`143`	`}`
`144`	`144`
`145`		`- fn types(&self) -> Vec<TypeType<S>> {`
	`145`	`+ fn types(&self) -> Vec<TypeType<'_, S>> {`
`146`	`146`	`self.type_list()`
`147`	`147`	`.into_iter()`
`148`	`148`	`.filter(\|t\| {`
`@@ -157,17 +157,17 @@ impl<S: ScalarValue> SchemaType<S> {`
`157`	`157`	`}`
`158`	`158`
`159`	`159`	`#[graphql(name = "queryType")]`
`160`		`- fn query_type_(&self) -> TypeType<S> {`
	`160`	`+ fn query_type_(&self) -> TypeType<'_, S> {`
`161`	`161`	`self.query_type()`
`162`	`162`	`}`
`163`	`163`
`164`	`164`	`#[graphql(name = "mutationType")]`
`165`		`- fn mutation_type_(&self) -> Option<TypeType<S>> {`
	`165`	`+ fn mutation_type_(&self) -> Option<TypeType<'_, S>> {`
`166`	`166`	`self.mutation_type()`
`167`	`167`	`}`
`168`	`168`
`169`	`169`	`#[graphql(name = "subscriptionType")]`
`170`		`- fn subscription_type_(&self) -> Option<TypeType<S>> {`
	`170`	`+ fn subscription_type_(&self) -> Option<TypeType<'_, S>> {`
`171`	`171`	`self.subscription_type()`
`172`	`172`	`}`
`173`	`173`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ impl<K: Eq + Hash + Clone, V> OrderedMap<K, V> {`
`56`	`56`	`}`
`57`	`57`	`}`
`58`	`58`
`59`		`- fn iter(&self) -> OrderedMapIter<K, V> {`
	`59`	`+ fn iter(&self) -> OrderedMapIter<'_, K, V> {`
`60`	`60`	`OrderedMapIter {`
`61`	`61`	`map: &self.data,`
`62`	`62`	`inner: self.insert_order.iter(),`