diff --git a/src/expr.rs b/src/expr.rs
index 0f1a6953e2..e6485f9a86 100644
--- a/src/expr.rs
+++ b/src/expr.rs
@@ -1377,7 +1377,7 @@ pub(crate) mod parsing {
             }
             let expr = Box::new(unary_expr(input, allow_struct)?);
             if raw.is_some() {
-                Ok(Expr::Verbatim(verbatim::between(begin, input)))
+                Ok(Expr::Verbatim(verbatim::between(&begin, input)))
             } else {
                 Ok(Expr::Reference(ExprReference {
                     attrs,
@@ -1423,7 +1423,7 @@ pub(crate) mod parsing {
         let mut e = trailer_helper(input, atom)?;
 
         if let Expr::Verbatim(tokens) = &mut e {
-            *tokens = verbatim::between(begin, input);
+            *tokens = verbatim::between(&begin, input);
         } else {
             let inner_attrs = e.replace_attrs(Vec::new());
             attrs.extend(inner_attrs);
@@ -1707,7 +1707,7 @@ pub(crate) mod parsing {
         parenthesized!(args in input);
         args.parse::<TokenStream>()?;
 
-        Ok(Expr::Verbatim(verbatim::between(begin, input)))
+        Ok(Expr::Verbatim(verbatim::between(&begin, input)))
     }
 
     fn path_or_macro_or_struct(
diff --git a/src/generics.rs b/src/generics.rs
index 44a10da7da..2ad913d1da 100644
--- a/src/generics.rs
+++ b/src/generics.rs
@@ -771,7 +771,7 @@ pub(crate) mod parsing {
             bound.paren_token = paren_token;
 
             if is_tilde_const {
-                Ok(TypeParamBound::Verbatim(verbatim::between(begin, input)))
+                Ok(TypeParamBound::Verbatim(verbatim::between(&begin, input)))
             } else {
                 Ok(TypeParamBound::Trait(bound))
             }
diff --git a/src/item.rs b/src/item.rs
index 66ab35b5df..50d7e6ef69 100644
--- a/src/item.rs
+++ b/src/item.rs
@@ -917,7 +917,7 @@ pub(crate) mod parsing {
             let sig: Signature = input.parse()?;
             if input.peek(Token![;]) {
                 input.parse::<Token![;]>()?;
-                Ok(Item::Verbatim(verbatim::between(begin, input)))
+                Ok(Item::Verbatim(verbatim::between(&begin, input)))
             } else {
                 parse_rest_of_fn(input, Vec::new(), vis, sig).map(Item::Fn)
             }
@@ -943,7 +943,7 @@ pub(crate) mod parsing {
             let allow_crate_root_in_path = true;
             match parse_item_use(input, allow_crate_root_in_path)? {
                 Some(item_use) => Ok(Item::Use(item_use)),
-                None => Ok(Item::Verbatim(verbatim::between(begin, input))),
+                None => Ok(Item::Verbatim(verbatim::between(&begin, input))),
             }
         } else if lookahead.peek(Token![static]) {
             let vis = input.parse()?;
@@ -954,13 +954,13 @@ pub(crate) mod parsing {
                 input.parse::<Token![=]>()?;
                 input.parse::<Expr>()?;
                 input.parse::<Token![;]>()?;
-                Ok(Item::Verbatim(verbatim::between(begin, input)))
+                Ok(Item::Verbatim(verbatim::between(&begin, input)))
             } else {
                 let colon_token = input.parse()?;
                 let ty = input.parse()?;
                 if input.peek(Token![;]) {
                     input.parse::<Token![;]>()?;
-                    Ok(Item::Verbatim(verbatim::between(begin, input)))
+                    Ok(Item::Verbatim(verbatim::between(&begin, input)))
                 } else {
                     Ok(Item::Static(ItemStatic {
                         attrs: Vec::new(),
@@ -989,7 +989,7 @@ pub(crate) mod parsing {
             let ty = input.parse()?;
             if input.peek(Token![;]) {
                 input.parse::<Token![;]>()?;
-                Ok(Item::Verbatim(verbatim::between(begin, input)))
+                Ok(Item::Verbatim(verbatim::between(&begin, input)))
             } else {
                 Ok(Item::Const(ItemConst {
                     attrs: Vec::new(),
@@ -1016,7 +1016,7 @@ pub(crate) mod parsing {
                 if let Some(item) = parse_impl(input, allow_verbatim_impl)? {
                     Ok(Item::Impl(item))
                 } else {
-                    Ok(Item::Verbatim(verbatim::between(begin, input)))
+                    Ok(Item::Verbatim(verbatim::between(&begin, input)))
                 }
             } else if lookahead.peek(Token![extern]) {
                 input.parse().map(Item::ForeignMod)
@@ -1046,7 +1046,7 @@ pub(crate) mod parsing {
             if let Some(item) = parse_impl(input, allow_verbatim_impl)? {
                 Ok(Item::Impl(item))
             } else {
-                Ok(Item::Verbatim(verbatim::between(begin, input)))
+                Ok(Item::Verbatim(verbatim::between(&begin, input)))
             }
         } else if lookahead.peek(Token![macro]) {
             input.advance_to(&ahead);
@@ -1227,7 +1227,7 @@ pub(crate) mod parsing {
             return Err(lookahead.error());
         }
 
-        Ok(Item::Verbatim(verbatim::between(begin, input)))
+        Ok(Item::Verbatim(verbatim::between(&begin, input)))
     }
 
     #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
@@ -1767,7 +1767,7 @@ pub(crate) mod parsing {
                     content.call(Attribute::parse_inner)?;
                     content.call(Block::parse_within)?;
 
-                    Ok(ForeignItem::Verbatim(verbatim::between(begin, input)))
+                    Ok(ForeignItem::Verbatim(verbatim::between(&begin, input)))
                 } else {
                     Ok(ForeignItem::Fn(ForeignItemFn {
                         attrs: Vec::new(),
@@ -1787,7 +1787,7 @@ pub(crate) mod parsing {
                     input.parse::<Token![=]>()?;
                     input.parse::<Expr>()?;
                     input.parse::<Token![;]>()?;
-                    Ok(ForeignItem::Verbatim(verbatim::between(begin, input)))
+                    Ok(ForeignItem::Verbatim(verbatim::between(&begin, input)))
                 } else {
                     Ok(ForeignItem::Static(ForeignItemStatic {
                         attrs: Vec::new(),
@@ -1896,7 +1896,7 @@ pub(crate) mod parsing {
         )?;
 
         if colon_token.is_some() || ty.is_some() {
-            Ok(ForeignItem::Verbatim(verbatim::between(begin, input)))
+            Ok(ForeignItem::Verbatim(verbatim::between(&begin, input)))
         } else {
             Ok(ForeignItem::Type(ForeignItemType {
                 attrs: Vec::new(),
@@ -1966,7 +1966,7 @@ pub(crate) mod parsing {
 
         let (eq_token, ty) = match ty {
             Some(ty) if colon_token.is_none() => ty,
-            _ => return Ok(Item::Verbatim(verbatim::between(begin, input))),
+            _ => return Ok(Item::Verbatim(verbatim::between(&begin, input))),
         };
 
         Ok(Item::Type(ItemType {
@@ -2254,7 +2254,7 @@ pub(crate) mod parsing {
 
             match (vis, defaultness) {
                 (Visibility::Inherited, None) => {}
-                _ => return Ok(TraitItem::Verbatim(verbatim::between(begin, input))),
+                _ => return Ok(TraitItem::Verbatim(verbatim::between(&begin, input))),
             }
 
             let item_attrs = match &mut item {
@@ -2372,7 +2372,7 @@ pub(crate) mod parsing {
         )?;
 
         if vis.is_some() {
-            Ok(TraitItem::Verbatim(verbatim::between(begin, input)))
+            Ok(TraitItem::Verbatim(verbatim::between(&begin, input)))
         } else {
             Ok(TraitItem::Type(TraitItemType {
                 attrs: Vec::new(),
@@ -2485,7 +2485,7 @@ pub(crate) mod parsing {
             self_ty = if polarity.is_none() {
                 first_ty
             } else {
-                Type::Verbatim(verbatim::between(begin, input))
+                Type::Verbatim(verbatim::between(&begin, input))
             };
         }
 
@@ -2539,7 +2539,7 @@ pub(crate) mod parsing {
                 if let Some(item) = parse_impl_item_fn(input, allow_omitted_body)? {
                     Ok(ImplItem::Fn(item))
                 } else {
-                    Ok(ImplItem::Verbatim(verbatim::between(begin, input)))
+                    Ok(ImplItem::Verbatim(verbatim::between(&begin, input)))
                 }
             } else if lookahead.peek(Token![const]) {
                 input.advance_to(&ahead);
@@ -2568,7 +2568,7 @@ pub(crate) mod parsing {
                     }));
                 } else {
                     input.parse::<Token![;]>()?;
-                    return Ok(ImplItem::Verbatim(verbatim::between(begin, input)));
+                    return Ok(ImplItem::Verbatim(verbatim::between(&begin, input)));
                 }
             } else if lookahead.peek(Token![type]) {
                 parse_impl_item_type(begin, input)
@@ -2714,7 +2714,7 @@ pub(crate) mod parsing {
 
         let (eq_token, ty) = match ty {
             Some(ty) if colon_token.is_none() => ty,
-            _ => return Ok(ImplItem::Verbatim(verbatim::between(begin, input))),
+            _ => return Ok(ImplItem::Verbatim(verbatim::between(&begin, input))),
         };
 
         Ok(ImplItem::Type(ImplItemType {
diff --git a/src/pat.rs b/src/pat.rs
index 2e6376b2f0..df7da5bbe4 100644
--- a/src/pat.rs
+++ b/src/pat.rs
@@ -422,7 +422,7 @@ pub(crate) mod parsing {
     fn pat_box(begin: ParseBuffer, input: ParseStream) -> Result<Pat> {
         input.parse::<Token![box]>()?;
         Pat::parse_single(input)?;
-        Ok(Pat::Verbatim(verbatim::between(begin, input)))
+        Ok(Pat::Verbatim(verbatim::between(&begin, input)))
     }
 
     fn pat_ident(input: ParseStream) -> Result<PatIdent> {
@@ -544,7 +544,7 @@ pub(crate) mod parsing {
         };
 
         let pat = if boxed.is_some() {
-            Pat::Verbatim(verbatim::between(begin, input))
+            Pat::Verbatim(verbatim::between(&begin, input))
         } else {
             Pat::Ident(PatIdent {
                 attrs: Vec::new(),
@@ -762,7 +762,7 @@ pub(crate) mod parsing {
         content.call(Attribute::parse_inner)?;
         content.call(Block::parse_within)?;
 
-        Ok(verbatim::between(begin, input))
+        Ok(verbatim::between(&begin, input))
     }
 }
 
diff --git a/src/path.rs b/src/path.rs
index e99a3f87d0..a3ab890284 100644
--- a/src/path.rs
+++ b/src/path.rs
@@ -391,7 +391,7 @@ pub(crate) mod parsing {
                 let content;
                 braced!(content in input);
                 content.parse::<Expr>()?;
-                let verbatim = verbatim::between(begin, input);
+                let verbatim = verbatim::between(&begin, input);
                 return Ok(Expr::Verbatim(verbatim));
             }
         }
diff --git a/src/ty.rs b/src/ty.rs
index 9282ba4e61..0f41fe4fa1 100644
--- a/src/ty.rs
+++ b/src/ty.rs
@@ -525,7 +525,7 @@ pub(crate) mod parsing {
             let star_token: Option<Token![*]> = input.parse()?;
             let bounds = TypeTraitObject::parse_bounds(dyn_span, input, allow_plus)?;
             return Ok(if star_token.is_some() {
-                Type::Verbatim(verbatim::between(begin, input))
+                Type::Verbatim(verbatim::between(&begin, input))
             } else {
                 Type::TraitObject(TypeTraitObject {
                     dyn_token: Some(dyn_token),
@@ -947,7 +947,7 @@ pub(crate) mod parsing {
             Some(ty) if !has_mut_self => ty,
             _ => {
                 name = None;
-                Type::Verbatim(verbatim::between(begin, input))
+                Type::Verbatim(verbatim::between(&begin, input))
             }
         };
 
diff --git a/src/verbatim.rs b/src/verbatim.rs
index 436d873437..54dc1cfa0d 100644
--- a/src/verbatim.rs
+++ b/src/verbatim.rs
@@ -1,9 +1,9 @@
-use crate::parse::{ParseBuffer, ParseStream};
+use crate::parse::ParseStream;
 use proc_macro2::{Delimiter, TokenStream};
 use std::cmp::Ordering;
 use std::iter;
 
-pub(crate) fn between<'a>(begin: ParseBuffer<'a>, end: ParseStream<'a>) -> TokenStream {
+pub(crate) fn between<'a>(begin: ParseStream<'a>, end: ParseStream<'a>) -> TokenStream {
     let end = end.cursor();
     let mut cursor = begin.cursor();
     assert!(crate::buffer::same_buffer(end, cursor));