remove explicit lifetimes where they can be elided

danieleades · danieleades · commit 4fd00fb0ad9b · 2022-11-11T14:47:27.000Z
diff --git a/capnp-futures/src/serialize.rs b/capnp-futures/src/serialize.rs
@@ -139,18 +139,18 @@ fn parse_segment_table_first(buf: &[u8]) -> Result<(usize, usize)>
 
 /// Something that contains segments ready to be written out.
 pub trait AsOutputSegments {
-    fn as_output_segments<'a>(&'a self) -> OutputSegments<'a>;
+    fn as_output_segments(&self) -> OutputSegments;
 }
 
 
 impl <'a, M> AsOutputSegments for &'a M where M: AsOutputSegments {
-    fn as_output_segments<'b>(&'b self) -> OutputSegments<'b> {
+    fn as_output_segments(&self) -> OutputSegments {
         (*self).as_output_segments()
     }
 }
 
 impl <A> AsOutputSegments for message::Builder<A> where A: message::Allocator {
-    fn as_output_segments<'a>(&'a self) -> OutputSegments<'a> {
+    fn as_output_segments(&self) -> OutputSegments {
         self.get_segments_for_output()
     }
 }
@@ -162,7 +162,7 @@ impl <A> AsOutputSegments for message::Builder<A> where A: message::Allocator {
 }*/
 
 impl <A> AsOutputSegments for ::std::rc::Rc<message::Builder<A>> where A: message::Allocator {
-    fn as_output_segments<'a>(&'a self) -> OutputSegments<'a> {
+    fn as_output_segments(&self) -> OutputSegments {
         self.get_segments_for_output()
     }
 }
@@ -394,7 +394,7 @@ pub mod test {
     }
 
     impl AsOutputSegments for Vec<Vec<capnp::Word>> {
-        fn as_output_segments<'a>(&'a self) -> OutputSegments<'a> {
+        fn as_output_segments(&self) -> OutputSegments {
             if self.is_empty() {
                 OutputSegments::SingleSegment([&[]])
             } else if self.len() == 1 {
diff --git a/capnp-rpc/src/broken.rs b/capnp-rpc/src/broken.rs
@@ -65,7 +65,7 @@ impl Request {
 }
 
 impl RequestHook for Request {
-    fn get<'a>(&'a mut self) -> any_pointer::Builder<'a> {
+    fn get(&mut self) -> any_pointer::Builder {
         let mut result: any_pointer::Builder = self.message.get_root().unwrap();
         result.imbue_mut(&mut self.cap_table);
         result
diff --git a/capnp-rpc/src/lib.rs b/capnp-rpc/src/lib.rs
@@ -106,8 +106,8 @@ mod task_set;
 pub mod twoparty;
 
 pub trait OutgoingMessage {
-    fn get_body<'a>(&'a mut self) -> ::capnp::Result<::capnp::any_pointer::Builder<'a>>;
-    fn get_body_as_reader<'a>(&'a self) -> ::capnp::Result<::capnp::any_pointer::Reader<'a>>;
+    fn get_body(&mut self) -> ::capnp::Result<::capnp::any_pointer::Builder>;
+    fn get_body_as_reader(&self) -> ::capnp::Result<::capnp::any_pointer::Reader>;
 
     /// Sends the message. Returns a promise for the message that resolves once the send has completed.
     /// Dropping the returned promise does *not* cancel the send.
@@ -119,7 +119,7 @@ pub trait OutgoingMessage {
 }
 
 pub trait IncomingMessage {
-    fn get_body<'a>(&'a self) -> ::capnp::Result<::capnp::any_pointer::Reader<'a>>;
+    fn get_body(&self) -> ::capnp::Result<::capnp::any_pointer::Reader>;
 }
 
 pub trait Connection<VatId> {
diff --git a/capnp-rpc/src/local.rs b/capnp-rpc/src/local.rs
@@ -34,7 +34,7 @@ use std::mem;
 
 pub trait ResultsDoneHook {
     fn add_ref(&self) -> Box<dyn ResultsDoneHook>;
-    fn get<'a>(&'a self) -> ::capnp::Result<any_pointer::Reader<'a>>;
+    fn get(&self) -> ::capnp::Result<any_pointer::Reader>;
 }
 
 impl Clone for Box<dyn ResultsDoneHook> {
@@ -56,7 +56,7 @@ impl Response {
 }
 
 impl ResponseHook for Response {
-    fn get<'a>(&'a self) -> ::capnp::Result<any_pointer::Reader<'a>> {
+    fn get(&self) -> ::capnp::Result<any_pointer::Reader> {
         self.results.get()
     }
 }
@@ -79,7 +79,7 @@ impl Params {
 }
 
 impl ParamsHook for Params {
-    fn get<'a>(&'a self) -> ::capnp::Result<any_pointer::Reader<'a>> {
+    fn get(&self) -> ::capnp::Result<any_pointer::Reader> {
         let mut result: any_pointer::Reader = self.request.get_root_as_reader()?;
         result.imbue(&self.cap_table);
         Ok(result)
@@ -114,7 +114,7 @@ impl Drop for Results {
 }
 
 impl ResultsHook for Results {
-    fn get<'a>(&'a mut self) -> ::capnp::Result<any_pointer::Builder<'a>> {
+    fn get(&mut self) -> ::capnp::Result<any_pointer::Builder> {
         match *self {
             Results { message: Some(ref mut message), ref mut cap_table, .. } => {
                 let mut result: any_pointer::Builder = message.get_root()?;
@@ -168,7 +168,7 @@ impl ResultsDoneHook for ResultsDone {
     fn add_ref(&self) -> Box<dyn ResultsDoneHook> {
         Box::new(ResultsDone { inner: self.inner.clone() })
     }
-    fn get<'a>(&'a self) -> ::capnp::Result<any_pointer::Reader<'a>> {
+    fn get(&self) -> ::capnp::Result<any_pointer::Reader> {
         let mut result: any_pointer::Reader = self.inner.message.get_root_as_reader()?;
         result.imbue(&self.inner.cap_table);
         Ok(result)
@@ -201,7 +201,7 @@ impl Request {
 }
 
 impl RequestHook for Request {
-    fn get<'a>(&'a mut self) -> any_pointer::Builder<'a> {
+    fn get(&mut self) -> any_pointer::Builder {
         let mut result: any_pointer::Builder = self.message.get_root().unwrap();
         result.imbue_mut(&mut self.cap_table);
         result
diff --git a/capnp-rpc/src/rpc.rs b/capnp-rpc/src/rpc.rs
@@ -127,7 +127,7 @@ impl <T> ExportTable<T> {
         }
     }
 
-    pub fn find<'a>(&'a mut self, id: u32) -> Option<&'a mut T> {
+    pub fn find(&mut self, id: u32) -> Option<&mut T> {
         let idx = id as usize;
         if idx < self.slots.len() {
             match self.slots[idx] {
@@ -139,7 +139,7 @@ impl <T> ExportTable<T> {
         }
     }
 
-    pub fn iter<'a>(&'a self) -> ExportTableIter<'a, T> {
+    pub fn iter(&self) -> ExportTableIter<T> {
         ExportTableIter {
             table: self,
             idx: 0
@@ -1586,7 +1586,7 @@ impl <VatId> Clone for Response<VatId> {
 }
 
 impl <VatId> ResponseHook for Response<VatId> {
-    fn get<'a>(&'a self) -> ::capnp::Result<any_pointer::Reader<'a>> {
+    fn get(&self) -> ::capnp::Result<any_pointer::Reader> {
         match *self.variant {
             ResponseVariant::Rpc(ref state) => {
                 match state.message.get_body()?.get_as::<message::Reader>()?.which()? {
@@ -1617,8 +1617,8 @@ struct Request<VatId> where VatId: 'static {
     cap_table: Vec<Option<Box<dyn ClientHook>>>,
 }
 
-fn get_call<'a>(message: &'a mut Box<dyn crate::OutgoingMessage>)
-                -> ::capnp::Result<call::Builder<'a>>
+fn get_call(message: &mut Box<dyn crate::OutgoingMessage>)
+                -> ::capnp::Result<call::Builder>
 {
     let message_root: message::Builder = message.get_body()?.get_as()?;
     match message_root.which()? {
@@ -1645,7 +1645,7 @@ impl <VatId> Request<VatId> where VatId: 'static {
         })
     }
 
-    fn init_call<'a>(&'a mut self) -> call::Builder<'a> {
+    fn init_call(&mut self) -> call::Builder {
         let message_root: message::Builder = self.message.get_body().unwrap().get_as().unwrap();
         message_root.init_call()
     }
@@ -1697,7 +1697,7 @@ impl <VatId> Request<VatId> where VatId: 'static {
 }
 
 impl <VatId> RequestHook for Request<VatId> {
-    fn get<'a>(&'a mut self) -> any_pointer::Builder<'a> {
+    fn get(&mut self) -> any_pointer::Builder {
         use ::capnp::traits::ImbueMut;
         let mut builder = get_call(&mut self.message).unwrap().get_params().unwrap().get_content();
         builder.imbue_mut(&mut self.cap_table);
@@ -1964,7 +1964,7 @@ impl Params {
 }
 
 impl ParamsHook for Params {
-    fn get<'a>(&'a self) -> ::capnp::Result<any_pointer::Reader<'a>> {
+    fn get(&self) -> ::capnp::Result<any_pointer::Reader> {
         let root: message::Reader = self.request.get_body()?.get_as()?;
         match root.which()? {
             message::Call(call) => {
@@ -2062,7 +2062,7 @@ impl <VatId> Drop for Results<VatId> {
 }
 
 impl <VatId> ResultsHook for Results<VatId> {
-    fn get<'a>(&'a mut self) -> ::capnp::Result<any_pointer::Builder<'a>> {
+    fn get(&mut self) -> ::capnp::Result<any_pointer::Builder> {
         use ::capnp::traits::ImbueMut;
         if let Some(ref mut inner) = self.inner {
             inner.ensure_initialized();
@@ -2287,7 +2287,7 @@ impl ResultsDoneHook for ResultsDone {
     fn add_ref(&self) -> Box<dyn ResultsDoneHook> {
         Box::new(ResultsDone { inner: self.inner.clone() })
     }
-    fn get<'a>(&'a self) -> ::capnp::Result<any_pointer::Reader<'a>> {
+    fn get(&self) -> ::capnp::Result<any_pointer::Reader> {
         use ::capnp::traits::Imbue;
         match *self.inner {
             ResultsDoneVariant::Rpc(ref message, ref cap_table) => {
diff --git a/capnp-rpc/src/twoparty.rs b/capnp-rpc/src/twoparty.rs
@@ -42,7 +42,7 @@ impl IncomingMessage {
 }
 
 impl crate::IncomingMessage for IncomingMessage {
-    fn get_body<'a>(&'a self) -> ::capnp::Result<::capnp::any_pointer::Reader<'a>> {
+    fn get_body(&self) -> ::capnp::Result<::capnp::any_pointer::Reader> {
         self.message.get_root()
     }
 }
@@ -53,11 +53,11 @@ struct OutgoingMessage {
 }
 
 impl crate::OutgoingMessage for OutgoingMessage {
-    fn get_body<'a>(&'a mut self) -> ::capnp::Result<::capnp::any_pointer::Builder<'a>> {
+    fn get_body(&mut self) -> ::capnp::Result<::capnp::any_pointer::Builder> {
         self.message.get_root()
     }
 
-    fn get_body_as_reader<'a>(&'a self) -> ::capnp::Result<::capnp::any_pointer::Reader<'a>> {
+    fn get_body_as_reader(&self) -> ::capnp::Result<::capnp::any_pointer::Reader> {
         self.message.get_root_as_reader()
     }
 
diff --git a/capnp/src/capability.rs b/capnp/src/capability.rs
@@ -182,7 +182,7 @@ impl <T> Params <T> {
     pub fn new(hook: Box<dyn ParamsHook>) -> Params<T> {
         Params { marker: PhantomData, hook }
     }
-    pub fn get<'a>(&'a self) -> crate::Result<T::Reader<'a>>
+    pub fn get(&self) -> crate::Result<T::Reader<'_>>
         where T: Owned
     {
         self.hook.get()?.get_as()
diff --git a/capnp/src/message.rs b/capnp/src/message.rs
@@ -434,7 +434,7 @@ impl <A> Builder<A> where A: Allocator {
         Ok(())
     }
 
-    pub fn get_segments_for_output(&self) -> OutputSegments<'_> {
+    pub fn get_segments_for_output(&self) -> OutputSegments {
         self.arena.get_segments_for_output()
     }
 
diff --git a/capnp/src/private/arena.rs b/capnp/src/private/arena.rs
@@ -179,7 +179,7 @@ impl <A> BuilderArenaImpl<A> where A: Allocator {
         self.inner.borrow_mut().allocate_segment(minimum_size)
     }
 
-    pub fn get_segments_for_output(&self) -> OutputSegments<'_> {
+    pub fn get_segments_for_output(&self) -> OutputSegments {
         let reff = self.inner.borrow();
         if reff.segments.len() == 1 {
             let seg = &reff.segments[0];
diff --git a/capnpc/src/codegen.rs b/capnpc/src/codegen.rs
@@ -200,7 +200,7 @@ impl <'a> GeneratorContext<'a> {
         Ok(gen)
     }
 
-    fn get_last_name<'b>(&'b self, id: u64) -> ::capnp::Result<&'b str> {
+    fn get_last_name(&self, id: u64) -> ::capnp::Result<&str> {
         match self.scope_map.get(&id) {
             None => Err(Error::failed(format!("node not found: {}", id))),
             Some(v) => match v.last() {

Original file line number	Diff line number	Diff line change
`@@ -139,18 +139,18 @@ fn parse_segment_table_first(buf: &[u8]) -> Result<(usize, usize)>`
`139`	`139`
`140`	`140`	`/// Something that contains segments ready to be written out.`
`141`	`141`	`pub trait AsOutputSegments {`
`142`		`- fn as_output_segments<'a>(&'a self) -> OutputSegments<'a>;`
	`142`	`+ fn as_output_segments(&self) -> OutputSegments;`
`143`	`143`	`}`
`144`	`144`
`145`	`145`
`146`	`146`	`impl <'a, M> AsOutputSegments for &'a M where M: AsOutputSegments {`
`147`		`- fn as_output_segments<'b>(&'b self) -> OutputSegments<'b> {`
	`147`	`+ fn as_output_segments(&self) -> OutputSegments {`
`148`	`148`	`(*self).as_output_segments()`
`149`	`149`	`}`
`150`	`150`	`}`
`151`	`151`
`152`	`152`	`impl <A> AsOutputSegments for message::Builder<A> where A: message::Allocator {`
`153`		`- fn as_output_segments<'a>(&'a self) -> OutputSegments<'a> {`
	`153`	`+ fn as_output_segments(&self) -> OutputSegments {`
`154`	`154`	`self.get_segments_for_output()`
`155`	`155`	`}`
`156`	`156`	`}`
`@@ -162,7 +162,7 @@ impl <A> AsOutputSegments for message::Builder<A> where A: message::Allocator {`
`162`	`162`	`}*/`
`163`	`163`
`164`	`164`	`impl <A> AsOutputSegments for ::std::rc::Rc<message::Builder<A>> where A: message::Allocator {`
`165`		`- fn as_output_segments<'a>(&'a self) -> OutputSegments<'a> {`
	`165`	`+ fn as_output_segments(&self) -> OutputSegments {`
`166`	`166`	`self.get_segments_for_output()`
`167`	`167`	`}`
`168`	`168`	`}`
`@@ -394,7 +394,7 @@ pub mod test {`
`394`	`394`	`}`
`395`	`395`
`396`	`396`	`impl AsOutputSegments for Vec<Vec<capnp::Word>> {`
`397`		`- fn as_output_segments<'a>(&'a self) -> OutputSegments<'a> {`
	`397`	`+ fn as_output_segments(&self) -> OutputSegments {`
`398`	`398`	`if self.is_empty() {`
`399`	`399`	`OutputSegments::SingleSegment([&[]])`
`400`	`400`	`} else if self.len() == 1 {`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ impl Request {`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`impl RequestHook for Request {`
`68`		`- fn get<'a>(&'a mut self) -> any_pointer::Builder<'a> {`
	`68`	`+ fn get(&mut self) -> any_pointer::Builder {`
`69`	`69`	`let mut result: any_pointer::Builder = self.message.get_root().unwrap();`
`70`	`70`	`result.imbue_mut(&mut self.cap_table);`
`71`	`71`	`result`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ use std::mem;`
`34`	`34`
`35`	`35`	`pub trait ResultsDoneHook {`
`36`	`36`	`fn add_ref(&self) -> Box<dyn ResultsDoneHook>;`
`37`		`- fn get<'a>(&'a self) -> ::capnp::Result<any_pointer::Reader<'a>>;`
	`37`	`+ fn get(&self) -> ::capnp::Result<any_pointer::Reader>;`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`impl Clone for Box<dyn ResultsDoneHook> {`
`@@ -56,7 +56,7 @@ impl Response {`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`impl ResponseHook for Response {`
`59`		`- fn get<'a>(&'a self) -> ::capnp::Result<any_pointer::Reader<'a>> {`
	`59`	`+ fn get(&self) -> ::capnp::Result<any_pointer::Reader> {`
`60`	`60`	`self.results.get()`
`61`	`61`	`}`
`62`	`62`	`}`
`@@ -79,7 +79,7 @@ impl Params {`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`impl ParamsHook for Params {`
`82`		`- fn get<'a>(&'a self) -> ::capnp::Result<any_pointer::Reader<'a>> {`
	`82`	`+ fn get(&self) -> ::capnp::Result<any_pointer::Reader> {`
`83`	`83`	`let mut result: any_pointer::Reader = self.request.get_root_as_reader()?;`
`84`	`84`	`result.imbue(&self.cap_table);`
`85`	`85`	`Ok(result)`
`@@ -114,7 +114,7 @@ impl Drop for Results {`
`114`	`114`	`}`
`115`	`115`
`116`	`116`	`impl ResultsHook for Results {`
`117`		`- fn get<'a>(&'a mut self) -> ::capnp::Result<any_pointer::Builder<'a>> {`
	`117`	`+ fn get(&mut self) -> ::capnp::Result<any_pointer::Builder> {`
`118`	`118`	`match *self {`
`119`	`119`	`Results { message: Some(ref mut message), ref mut cap_table, .. } => {`
`120`	`120`	`let mut result: any_pointer::Builder = message.get_root()?;`
`@@ -168,7 +168,7 @@ impl ResultsDoneHook for ResultsDone {`
`168`	`168`	`fn add_ref(&self) -> Box<dyn ResultsDoneHook> {`
`169`	`169`	`Box::new(ResultsDone { inner: self.inner.clone() })`
`170`	`170`	`}`
`171`		`- fn get<'a>(&'a self) -> ::capnp::Result<any_pointer::Reader<'a>> {`
	`171`	`+ fn get(&self) -> ::capnp::Result<any_pointer::Reader> {`
`172`	`172`	`let mut result: any_pointer::Reader = self.inner.message.get_root_as_reader()?;`
`173`	`173`	`result.imbue(&self.inner.cap_table);`
`174`	`174`	`Ok(result)`
`@@ -201,7 +201,7 @@ impl Request {`
`201`	`201`	`}`
`202`	`202`
`203`	`203`	`impl RequestHook for Request {`
`204`		`- fn get<'a>(&'a mut self) -> any_pointer::Builder<'a> {`
	`204`	`+ fn get(&mut self) -> any_pointer::Builder {`
`205`	`205`	`let mut result: any_pointer::Builder = self.message.get_root().unwrap();`
`206`	`206`	`result.imbue_mut(&mut self.cap_table);`
`207`	`207`	`result`
Original file line number	Diff line number	Diff line change
`@@ -127,7 +127,7 @@ impl <T> ExportTable<T> {`
`127`	`127`	`}`
`128`	`128`	`}`
`129`	`129`
`130`		`- pub fn find<'a>(&'a mut self, id: u32) -> Option<&'a mut T> {`
	`130`	`+ pub fn find(&mut self, id: u32) -> Option<&mut T> {`
`131`	`131`	`let idx = id as usize;`
`132`	`132`	`if idx < self.slots.len() {`
`133`	`133`	`match self.slots[idx] {`
`@@ -139,7 +139,7 @@ impl <T> ExportTable<T> {`
`139`	`139`	`}`
`140`	`140`	`}`
`141`	`141`
`142`		`- pub fn iter<'a>(&'a self) -> ExportTableIter<'a, T> {`
	`142`	`+ pub fn iter(&self) -> ExportTableIter<T> {`
`143`	`143`	`ExportTableIter {`
`144`	`144`	`table: self,`
`145`	`145`	`idx: 0`
`@@ -1586,7 +1586,7 @@ impl <VatId> Clone for Response<VatId> {`
`1586`	`1586`	`}`
`1587`	`1587`
`1588`	`1588`	`impl <VatId> ResponseHook for Response<VatId> {`
`1589`		`- fn get<'a>(&'a self) -> ::capnp::Result<any_pointer::Reader<'a>> {`
	`1589`	`+ fn get(&self) -> ::capnp::Result<any_pointer::Reader> {`
`1590`	`1590`	`match *self.variant {`
`1591`	`1591`	`ResponseVariant::Rpc(ref state) => {`
`1592`	`1592`	`match state.message.get_body()?.get_as::<message::Reader>()?.which()? {`
`@@ -1617,8 +1617,8 @@ struct Request<VatId> where VatId: 'static {`
`1617`	`1617`	`cap_table: Vec<Option<Box<dyn ClientHook>>>,`
`1618`	`1618`	`}`
`1619`	`1619`
`1620`		`-fn get_call<'a>(message: &'a mut Box<dyn crate::OutgoingMessage>)`
`1621`		`- -> ::capnp::Result<call::Builder<'a>>`
	`1620`	`+fn get_call(message: &mut Box<dyn crate::OutgoingMessage>)`
	`1621`	`+ -> ::capnp::Result<call::Builder>`
`1622`	`1622`	`{`
`1623`	`1623`	`let message_root: message::Builder = message.get_body()?.get_as()?;`
`1624`	`1624`	`match message_root.which()? {`
`@@ -1645,7 +1645,7 @@ impl <VatId> Request<VatId> where VatId: 'static {`
`1645`	`1645`	`})`
`1646`	`1646`	`}`
`1647`	`1647`
`1648`		`- fn init_call<'a>(&'a mut self) -> call::Builder<'a> {`
	`1648`	`+ fn init_call(&mut self) -> call::Builder {`
`1649`	`1649`	`let message_root: message::Builder = self.message.get_body().unwrap().get_as().unwrap();`
`1650`	`1650`	`message_root.init_call()`
`1651`	`1651`	`}`
`@@ -1697,7 +1697,7 @@ impl <VatId> Request<VatId> where VatId: 'static {`
`1697`	`1697`	`}`
`1698`	`1698`
`1699`	`1699`	`impl <VatId> RequestHook for Request<VatId> {`
`1700`		`- fn get<'a>(&'a mut self) -> any_pointer::Builder<'a> {`
	`1700`	`+ fn get(&mut self) -> any_pointer::Builder {`
`1701`	`1701`	`use ::capnp::traits::ImbueMut;`
`1702`	`1702`	`let mut builder = get_call(&mut self.message).unwrap().get_params().unwrap().get_content();`
`1703`	`1703`	`builder.imbue_mut(&mut self.cap_table);`
`@@ -1964,7 +1964,7 @@ impl Params {`
`1964`	`1964`	`}`
`1965`	`1965`
`1966`	`1966`	`impl ParamsHook for Params {`
`1967`		`- fn get<'a>(&'a self) -> ::capnp::Result<any_pointer::Reader<'a>> {`
	`1967`	`+ fn get(&self) -> ::capnp::Result<any_pointer::Reader> {`
`1968`	`1968`	`let root: message::Reader = self.request.get_body()?.get_as()?;`
`1969`	`1969`	`match root.which()? {`
`1970`	`1970`	`message::Call(call) => {`
`@@ -2062,7 +2062,7 @@ impl <VatId> Drop for Results<VatId> {`
`2062`	`2062`	`}`
`2063`	`2063`
`2064`	`2064`	`impl <VatId> ResultsHook for Results<VatId> {`
`2065`		`- fn get<'a>(&'a mut self) -> ::capnp::Result<any_pointer::Builder<'a>> {`
	`2065`	`+ fn get(&mut self) -> ::capnp::Result<any_pointer::Builder> {`
`2066`	`2066`	`use ::capnp::traits::ImbueMut;`
`2067`	`2067`	`if let Some(ref mut inner) = self.inner {`
`2068`	`2068`	`inner.ensure_initialized();`
`@@ -2287,7 +2287,7 @@ impl ResultsDoneHook for ResultsDone {`
`2287`	`2287`	`fn add_ref(&self) -> Box<dyn ResultsDoneHook> {`
`2288`	`2288`	`Box::new(ResultsDone { inner: self.inner.clone() })`
`2289`	`2289`	`}`
`2290`		`- fn get<'a>(&'a self) -> ::capnp::Result<any_pointer::Reader<'a>> {`
	`2290`	`+ fn get(&self) -> ::capnp::Result<any_pointer::Reader> {`
`2291`	`2291`	`use ::capnp::traits::Imbue;`
`2292`	`2292`	`match *self.inner {`
`2293`	`2293`	`ResultsDoneVariant::Rpc(ref message, ref cap_table) => {`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ impl IncomingMessage {`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`impl crate::IncomingMessage for IncomingMessage {`
`45`		`- fn get_body<'a>(&'a self) -> ::capnp::Result<::capnp::any_pointer::Reader<'a>> {`
	`45`	`+ fn get_body(&self) -> ::capnp::Result<::capnp::any_pointer::Reader> {`
`46`	`46`	`self.message.get_root()`
`47`	`47`	`}`
`48`	`48`	`}`
`@@ -53,11 +53,11 @@ struct OutgoingMessage {`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`impl crate::OutgoingMessage for OutgoingMessage {`
`56`		`- fn get_body<'a>(&'a mut self) -> ::capnp::Result<::capnp::any_pointer::Builder<'a>> {`
	`56`	`+ fn get_body(&mut self) -> ::capnp::Result<::capnp::any_pointer::Builder> {`
`57`	`57`	`self.message.get_root()`
`58`	`58`	`}`
`59`	`59`
`60`		`- fn get_body_as_reader<'a>(&'a self) -> ::capnp::Result<::capnp::any_pointer::Reader<'a>> {`
	`60`	`+ fn get_body_as_reader(&self) -> ::capnp::Result<::capnp::any_pointer::Reader> {`
`61`	`61`	`self.message.get_root_as_reader()`
`62`	`62`	`}`
`63`	`63`
Original file line number	Diff line number	Diff line change
`@@ -182,7 +182,7 @@ impl <T> Params <T> {`
`182`	`182`	`pub fn new(hook: Box<dyn ParamsHook>) -> Params<T> {`
`183`	`183`	`Params { marker: PhantomData, hook }`
`184`	`184`	`}`
`185`		`- pub fn get<'a>(&'a self) -> crate::Result<T::Reader<'a>>`
	`185`	`+ pub fn get(&self) -> crate::Result<T::Reader<'_>>`
`186`	`186`	`where T: Owned`
`187`	`187`	`{`
`188`	`188`	`self.hook.get()?.get_as()`
Original file line number	Diff line number	Diff line change
`@@ -434,7 +434,7 @@ impl <A> Builder<A> where A: Allocator {`
`434`	`434`	`Ok(())`
`435`	`435`	`}`
`436`	`436`
`437`		`- pub fn get_segments_for_output(&self) -> OutputSegments<'_> {`
	`437`	`+ pub fn get_segments_for_output(&self) -> OutputSegments {`
`438`	`438`	`self.arena.get_segments_for_output()`
`439`	`439`	`}`
`440`	`440`
Original file line number	Diff line number	Diff line change
`@@ -179,7 +179,7 @@ impl <A> BuilderArenaImpl<A> where A: Allocator {`
`179`	`179`	`self.inner.borrow_mut().allocate_segment(minimum_size)`
`180`	`180`	`}`
`181`	`181`
`182`		`- pub fn get_segments_for_output(&self) -> OutputSegments<'_> {`
	`182`	`+ pub fn get_segments_for_output(&self) -> OutputSegments {`
`183`	`183`	`let reff = self.inner.borrow();`
`184`	`184`	`if reff.segments.len() == 1 {`
`185`	`185`	`let seg = &reff.segments[0];`
Original file line number	Diff line number	Diff line change
`@@ -200,7 +200,7 @@ impl <'a> GeneratorContext<'a> {`
`200`	`200`	`Ok(gen)`
`201`	`201`	`}`
`202`	`202`
`203`		`- fn get_last_name<'b>(&'b self, id: u64) -> ::capnp::Result<&'b str> {`
	`203`	`+ fn get_last_name(&self, id: u64) -> ::capnp::Result<&str> {`
`204`	`204`	`match self.scope_map.get(&id) {`
`205`	`205`	`None => Err(Error::failed(format!("node not found: {}", id))),`
`206`	`206`	`Some(v) => match v.last() {`