diff --git a/src/collections/scoped_buffer.rs b/src/collections/scoped_buffer.rs
index 0d5865bd6d7014a443f35c90c53f082ddd838ef8..7f5194cf31bc6ef317490d82f6dc413fb07e2272 100644
--- a/src/collections/scoped_buffer.rs
+++ b/src/collections/scoped_buffer.rs
@@ -7,27 +7,28 @@
 ///
 /// It is unsafe because we're using pointers to circumvent borrowing rules in
 /// the name of code cleanliness. The correctness of use is checked in debug
-/// mode.
+/// mode at runtime.
 
 use std::iter::FromIterator;
 
-pub(crate) struct ScopedBuffer<T: Sized> {
-    pub inner: Vec<T>,
+macro_rules! hide {
+    ($v:block) => {
+        #[cfg(debug_assertions)] $v
+    };
+    ($v:expr) => {
+        #[cfg(debug_assertions)] $v
+    };
 }
 
-/// A section of the buffer. Keeps track of where we started the section. When
-/// done with the section one must call `into_vec` or `forget` to remove the
-/// section from the underlying buffer. This will also be done upon dropping the
-/// ScopedSection in case errors are being handled.
-pub(crate) struct ScopedSection<T: Sized> {
-    inner: *mut Vec<T>,
-    start_size: u32,
-    #[cfg(debug_assertions)] cur_size: u32,
+pub(crate) struct ScopedBuffer<T: Sized> {
+    pub inner: Vec<T>,
 }
 
 impl<T: Sized> ScopedBuffer<T> {
     pub(crate) fn with_capacity(capacity: usize) -> Self {
-        Self { inner: Vec::with_capacity(capacity) }
+        Self {
+            inner: Vec::with_capacity(capacity),
+        }
     }
 
     pub(crate) fn start_section(&mut self) -> ScopedSection<T> {
@@ -35,7 +36,7 @@ impl<T: Sized> ScopedBuffer<T> {
         ScopedSection {
             inner: &mut self.inner,
             start_size,
-            #[cfg(debug_assertions)] cur_size: start_size
+            #[cfg(debug_assertions)] cur_size: start_size,
         }
     }
 }
@@ -61,18 +62,35 @@ impl<T: Sized> Drop for ScopedBuffer<T> {
     }
 }
 
+/// A section of the buffer. Keeps track of where we started the section. When
+/// done with the section one must call `into_vec` or `forget` to remove the
+/// section from the underlying buffer. This will also be done upon dropping the
+/// ScopedSection in case errors are being handled.
+pub(crate) struct ScopedSection<T: Sized> {
+    inner: *mut Vec<T>,
+    start_size: u32,
+    #[cfg(debug_assertions)] cur_size: u32,
+}
+
 impl<T: Sized> ScopedSection<T> {
     #[inline]
     pub(crate) fn push(&mut self, value: T) {
         let vec = unsafe{&mut *self.inner};
-        #[cfg(debug_assertions)] debug_assert_eq!(vec.len(), self.cur_size as usize, "trying to push onto section, but size is larger than expected");
+        hide!(debug_assert_eq!(
+            vec.len(), self.cur_size as usize,
+            "trying to push onto section, but size is larger than expected"
+        ));
         vec.push(value);
-        #[cfg(debug_assertions)] { self.cur_size += 1; }
+        hide!(self.cur_size += 1);
     }
 
+    #[inline]
     pub(crate) fn len(&self) -> usize {
         let vec = unsafe{&mut *self.inner};
-        #[cfg(debug_assertions)] debug_assert_eq!(vec.len(), self.cur_size as usize, "trying to get section length, but size is larger than expected");
+        hide!(debug_assert_eq!(
+            vec.len(), self.cur_size as usize,
+            "trying to get section length, but size is larger than expected"
+        ));
         return vec.len() - self.start_size as usize;
     }
 
@@ -80,13 +98,13 @@ impl<T: Sized> ScopedSection<T> {
     #[allow(unused_mut)] // used in debug mode
     pub(crate) fn forget(mut self) {
         let vec = unsafe{&mut *self.inner};
-        #[cfg(debug_assertions)] {
+        hide!({
             debug_assert_eq!(
                 vec.len(), self.cur_size as usize,
                 "trying to forget section, but size is larger than expected"
             );
             self.cur_size = self.start_size;
-        }
+        });
         vec.truncate(self.start_size as usize);
     }
 
@@ -94,13 +112,13 @@ impl<T: Sized> ScopedSection<T> {
     #[allow(unused_mut)] // used in debug mode
     pub(crate) fn into_vec(mut self) -> Vec<T> {
         let vec = unsafe{&mut *self.inner};
-        #[cfg(debug_assertions)]  {
+        hide!({
             debug_assert_eq!(
                 vec.len(), self.cur_size as usize,
                 "trying to turn section into vec, but size is larger than expected"
             );
             self.cur_size = self.start_size;
-        }
+        });
         let section = Vec::from_iter(vec.drain(self.start_size as usize..));
         section
     }
@@ -116,12 +134,19 @@ impl<T: Copy> ScopedSection<T> {
     }
 }
 
-impl<T: Sized> std::ops::Index<usize> for ScopedSection<T> {
+impl<T> std::ops::Index<usize> for ScopedSection<T> {
     type Output = T;
 
-    fn index(&self, idx: usize) -> &Self::Output {
+    fn index(&self, index: usize) -> &Self::Output {
         let vec = unsafe{&*self.inner};
-        return &vec[self.start_size as usize + idx]
+        return &vec[self.start_size as usize + index]
+    }
+}
+
+impl<T> std::ops::IndexMut<usize> for ScopedSection<T> {
+    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
+        let vec = unsafe{&mut *self.inner};
+        return &mut vec[self.start_size as usize + index]
     }
 }
 
@@ -129,11 +154,14 @@ impl<T: Sized> std::ops::Index<usize> for ScopedSection<T> {
 impl<T: Sized> Drop for ScopedSection<T> {
     fn drop(&mut self) {
         let vec = unsafe{&mut *self.inner};
-        #[cfg(debug_assertions)] debug_assert_eq!(vec.len(), self.cur_size as usize);
+        hide!(debug_assert_eq!(vec.len(), self.cur_size as usize));
         vec.truncate(self.start_size as usize);
     }
 }
 
+/// Small utility for iterating over a section of the buffer. Same conditions as
+/// the buffer apply: each time we retrieve an element the buffer must have the
+/// same size as the moment of creation.
 pub(crate) struct ScopedIter<T: Copy> {
     inner: *mut Vec<T>,
     cur_index: u32,
@@ -144,6 +172,7 @@ impl<T: Copy> Iterator for ScopedIter<T> {
     type Item = T;
 
     fn next(&mut self) -> Option<Self::Item> {
+        hide!(debug_assert_eq!(self.last_index as usize, unsafe { (*self.inner).len() }));
         if self.cur_index >= self.last_index {
             return None;
         }