Stop eliding lifetimes

It's arguably confusing to see a definition such as
```rust
  impl<'a> OpenTproxySkel<'a> {
      pub fn maps(&self) -> OpenTproxyMaps {
          OpenTproxyMaps { inner: &self.obj }
      }
  }
```
because it omits the fact that the OpenTproxyMaps type actually has a
lifetimes associated with it.
Let's make sure to make lifetimes explicit to prevent such confusion
from the start.

Signed-off-by: Daniel Müller <[email protected]>

Author: d-e-s-o

libbpf-cargo/src/gen/btf.rs

@@ -192,7 +192,7 @@ impl<'s> GenBtf<'s> {
 
         // All the non-bitfield fields have to be naturally aligned
         for m in composite.iter() {
-            let align = self.type_by_id::<BtfType>(m.ty).unwrap().alignment()?;
+            let align = self.type_by_id::<BtfType<'_>>(m.ty).unwrap().alignment()?;
 
             if let MemberAttr::Normal { offset } = m.attr {
                 if offset as usize % (align.get() * 8) != 0 {
@@ -250,7 +250,7 @@ impl<'s> GenBtf<'s> {
     ///
     /// `ty` must be a struct, union, enum, or datasec type.
     pub fn type_definition(&self, ty: BtfType<'s>) -> Result<String> {
-        let is_terminal = |ty: BtfType| -> bool {
+        let is_terminal = |ty: BtfType<'_>| -> bool {
             matches!(
                 ty.kind(),
                 BtfKind::Void
@@ -308,7 +308,7 @@ impl<'s> GenBtf<'s> {
         &'a self,
         def: &mut String,
         dependent_types: &mut Vec<BtfType<'a>>,
-        t: types::Composite,
+        t: types::Composite<'_>,
     ) -> Result<()> {
         let packed = self.is_struct_packed(&t)?;
 
@@ -328,7 +328,7 @@ impl<'s> GenBtf<'s> {
             };
 
             let field_ty = self
-                .type_by_id::<BtfType>(member.ty)
+                .type_by_id::<BtfType<'_>>(member.ty)
                 .unwrap()
                 .skip_mods_and_typedefs();
             if let Some(next_ty_id) = next_type(field_ty)? {
@@ -340,7 +340,7 @@ impl<'s> GenBtf<'s> {
                 let padding = self.required_padding(
                     offset,
                     member_offset as usize / 8,
-                    &self.type_by_id::<BtfType>(member.ty).unwrap(),
+                    &self.type_by_id::<BtfType<'_>>(member.ty).unwrap(),
                     packed,
                 )?;
 
@@ -352,7 +352,7 @@ impl<'s> GenBtf<'s> {
                     ));
                 }
 
-                if let Some(ft) = self.type_by_id::<types::Array>(field_ty.type_id()) {
+                if let Some(ft) = self.type_by_id::<types::Array<'_>>(field_ty.type_id()) {
                     if ft.capacity() > 32 {
                         gen_impl_default = true
                     }
@@ -480,7 +480,7 @@ impl<'s> GenBtf<'s> {
         Ok(())
     }
 
-    fn type_definition_for_enums(&self, def: &mut String, t: types::Enum) -> Result<()> {
+    fn type_definition_for_enums(&self, def: &mut String, t: types::Enum<'_>) -> Result<()> {
         let repr_size = match t.size() {
             1 => "8",
             2 => "16",
@@ -529,7 +529,7 @@ impl<'s> GenBtf<'s> {
         &'a self,
         def: &mut String,
         dependent_types: &mut Vec<BtfType<'a>>,
-        t: types::DataSec,
+        t: types::DataSec<'_>,
     ) -> Result<()> {
         let mut sec_name = match t.name().map(|s| s.to_string_lossy()) {
             None => bail!("Datasec name is empty"),
@@ -545,7 +545,7 @@ impl<'s> GenBtf<'s> {
         let mut offset: u32 = 0;
         for datasec_var in t.iter() {
             let var = self
-                .type_by_id::<types::Var>(datasec_var.ty)
+                .type_by_id::<types::Var<'_>>(datasec_var.ty)
                 .ok_or_else(|| anyhow!("BTF is invalid! Datasec var does not point to a var"))?;
 
             if var.linkage() == Linkage::Static {

libbpf-cargo/src/gen/mod.rs

@@ -300,7 +300,7 @@ fn gen_skel_map_defs(
             inner: &'a {mut_prefix}{inner_ty},
         }}
 
-        impl<'a> {struct_name}<'a> {{
+        impl {struct_name}<'_> {{
         "#,
     )?;
 
@@ -368,7 +368,7 @@ fn gen_skel_prog_defs(
             inner: &'a {mut_prefix}{inner_ty},
         }}
 
-        impl<'a> {struct_name}<'a> {{
+        impl {struct_name}<'_> {{
         "#,
     )?;
 
@@ -399,7 +399,7 @@ fn gen_skel_datasec_defs(skel: &mut String, obj_name: &str, object: &[u8]) -> Re
     };
     let btf = GenBtf::from(btf);
 
-    for ty in btf.type_by_kind::<types::DataSec>() {
+    for ty in btf.type_by_kind::<types::DataSec<'_>>() {
         let name = match ty.name() {
             Some(s) => s.to_str()?,
             None => "",
@@ -451,7 +451,7 @@ fn gen_skel_map_getter(
     write!(
         skel,
         r#"
-        pub fn {map_fn}(&{mut_prefix}self) -> {return_ty} {{
+        pub fn {map_fn}(&{mut_prefix}self) -> {return_ty}<'_> {{
             {return_ty} {{
                 inner: &{mut_prefix}self.obj,
             }}
@@ -488,7 +488,7 @@ fn gen_skel_prog_getter(
     write!(
         skel,
         r#"
-        pub fn {prog_fn}(&{mut_prefix}self) -> {return_ty} {{
+        pub fn {prog_fn}(&{mut_prefix}self) -> {return_ty}<'_> {{
             {return_ty} {{
                 inner: &{mut_prefix}self.obj,
             }}
@@ -524,9 +524,9 @@ fn gen_skel_datasec_getters(
         write!(
             skel,
             r#"
-            pub fn {name}(&mut self) -> &'a {mutability} {struct_name} {{
+            pub fn {name}(&mut self) -> &'_ {mutability} {struct_name} {{
                 unsafe {{
-                    std::mem::transmute::<*mut std::ffi::c_void, &'a {mutability} {struct_name}>(
+                    std::mem::transmute::<*mut std::ffi::c_void, &'_ {mutability} {struct_name}>(
                         self.skel_config.map_mmap_ptr({idx}).unwrap()
                     )
                 }}
@@ -661,6 +661,7 @@ fn gen_skel_contents(_debug: bool, raw_obj_name: &str, obj_file_path: &Path) ->
            #[allow(non_camel_case_types)]
            #[allow(clippy::transmute_ptr_to_ref)]
            #[allow(clippy::upper_case_acronyms)]
+           #[warn(single_use_lifetimes)]
            mod imp {{
            use libbpf_rs::libbpf_sys;
            use libbpf_rs::skel::OpenSkel;
@@ -785,7 +786,7 @@ fn gen_skel_contents(_debug: bool, raw_obj_name: &str, obj_file_path: &Path) ->
         }
     )?;
     writeln!(skel, "}}")?;
-    writeln!(skel, "impl<'a> Open{name}Skel<'a> {{", name = &obj_name)?;
+    writeln!(skel, "impl Open{name}Skel<'_> {{", name = &obj_name)?;
 
     gen_skel_prog_getter(&mut skel, &mut object, &obj_name, true, false)?;
     gen_skel_prog_getter(&mut skel, &mut object, &obj_name, true, true)?;
@@ -815,10 +816,10 @@ fn gen_skel_contents(_debug: bool, raw_obj_name: &str, obj_file_path: &Path) ->
         r#"
         }}
 
-        unsafe impl<'a> Send for {name}Skel<'a> {{}}
-        unsafe impl<'a> Sync for {name}Skel<'a> {{}}
+        unsafe impl Send for {name}Skel<'_> {{}}
+        unsafe impl Sync for {name}Skel<'_> {{}}
 
-        impl<'a> Skel for {name}Skel<'a> {{
+        impl Skel for {name}Skel<'_> {{
             fn object(&self) -> &libbpf_rs::Object {{
                 &self.obj
             }}
@@ -832,7 +833,7 @@ fn gen_skel_contents(_debug: bool, raw_obj_name: &str, obj_file_path: &Path) ->
     gen_skel_attach(&mut skel, &mut object, &obj_name)?;
     writeln!(skel, "}}")?;
 
-    write!(skel, "impl<'a> {name}Skel<'a> {{", name = &obj_name)?;
+    write!(skel, "impl {name}Skel<'_> {{", name = &obj_name)?;
     gen_skel_prog_getter(&mut skel, &mut object, &obj_name, false, false)?;
     gen_skel_prog_getter(&mut skel, &mut object, &obj_name, false, true)?;
     gen_skel_map_getter(&mut skel, &mut object, &obj_name, false, false)?;
@@ -859,7 +860,7 @@ fn gen_skel(
     debug: bool,
     name: &str,
     obj: &Path,
-    out: OutputDest,
+    out: OutputDest<'_>,
     rustfmt_path: Option<&PathBuf>,
 ) -> Result<()> {
     ensure!(!name.is_empty(), "Object file has no name");
@@ -936,7 +937,7 @@ pub fn gen_mods(objs: &[UnprocessedObj], rustfmt_path: Option<&PathBuf>) -> Resu
 pub fn gen_single(
     debug: bool,
     obj_file: &Path,
-    output: OutputDest,
+    output: OutputDest<'_>,
     rustfmt_path: Option<&PathBuf>,
 ) -> Result<()> {
     let filename = match obj_file.file_name() {

libbpf-cargo/src/lib.rs

@@ -55,7 +55,11 @@
 //! build`. This is a convenience command so you don't forget any steps. Alternatively, you could
 //! write a Makefile for your project.
 
-#![warn(clippy::wildcard_imports)]
+#![warn(
+    elided_lifetimes_in_paths,
+    single_use_lifetimes,
+    clippy::wildcard_imports
+)]
 #![deny(unsafe_op_in_unsafe_fn)]
 
 use std::path::Path;