rust-bio · johanneskoester · May 10, 2024 · May 3, 2024 · May 3, 2024 · May 6, 2024
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
@@ -125,29 +125,28 @@ jobs:
     strategy:
       matrix:
         target:
-          - intel-catalina
-          - intel-bigsur
-          - m1-bigsur
+          - intel-monterey
+          - intel-ventura
+          - silicon-sonoma
         include:
-          - target: intel-catalina
-            os: macOS-10.15
+          - target: intel-monterey
+            os: macOS-12.0
             toolchain_target: x86_64-apple-darwin
             toolchain: stable
-            aux_args: ""
-            default: false
-          - target: intel-bigsur
-            os: macOS-11.0
+            aux_args: --target x86_64-apple-darwin
+            default: true
+          - target: intel-ventura
+            os: macOS-13.0
             toolchain_target: x86_64-apple-darwin
             toolchain: stable
+            aux_args: --target x86_64-apple-darwin
+            default: true
+          - target: silicon-sonoma
+            os: macOS-14.0
+            toolchain_target: aarch64-apple-darwin
+            toolchain: stable
             aux_args: ""
             default: false
-          # TODO enable again and try to find out why this fails
-          # - target: m1-bigsur
-          #   os: macOS-11.0
-          #   toolchain_target: aarch64-apple-darwin
-          #   toolchain: nightly
-          #   aux_args: --target aarch64-apple-darwin
-          #   default: true
 
     steps:
       - name: Checkout repository
@@ -158,19 +157,14 @@ jobs:
       - name: Install stable toolchain
         uses: actions-rs/[email protected]
         with:
-          toolchain: stable
+          toolchain: ${{ matrix.toolchain }}
+          target: ${{ matrix.toolchain_target }}
           override: true
+          default: ${{ matrix.default }}
 
       - name: Install htslib dependencies
         run: brew install bzip2 zlib xz curl-openssl
 
-      #- uses: actions-rs/[email protected]
-      #  with:
-      #    toolchain: ${{ matrix.toolchain }}
-      #    target: ${{ matrix.toolchain_target }}
-      #    #override: true
-      #    default: ${{ matrix.default }}
-
       - name: Test
         uses: actions-rs/[email protected]
         with:

diff --git a/Cargo.toml b/Cargo.toml
@@ -21,7 +21,7 @@ bio-types = ">=0.9"
 byteorder = "1.3"
 custom_derive = "0.1"
 derive-new = "0.5"
-hts-sys = {version = "2.1.1", default-features = false}
+hts-sys = {version = "2.1.4", default-features = false, features = ["bindgen"]}
 ieee754 = "0.2"
 lazy_static = "1.4"
 libc = "0.2"

diff --git a/src/bam/mod.rs b/src/bam/mod.rs
@@ -1122,12 +1122,12 @@

            //println!("{}", str::from_utf8(&header_string).unwrap());
            let rec = htslib::sam_hdr_parse(
                ((l_text + 1) as usize).try_into().unwrap(),
                text as *const c_char,
             );
 
             (*rec).text = text as *mut c_char;
-            (*rec).l_text = l_text as u64;
+            (*rec).l_text = l_text;
             rec
         };
 
@@ -1288,7 +1288,7 @@
            }
        };

        match self.reader.read(&mut record) {
            None => None,
            Some(Ok(_)) => Some(Ok(Rc::clone(&self.record))),
            Some(Err(err)) => Some(Err(err)),
@@ -1392,9 +1392,9 @@
                 header_string.len(),
             );
 
-            let rec = htslib::sam_hdr_parse((l_text + 1) as u64, text as *const c_char);
+            let rec = htslib::sam_hdr_parse((l_text + 1), text as *const c_char);
             (*rec).text = text as *mut c_char;
-            (*rec).l_text = l_text as u64;
+            (*rec).l_text = l_text;
             rec
         };
 
@@ -1580,7 +1580,7 @@
             assert_eq!(c1.inner().core.l_qname, b1.inner().core.l_qname);
             assert_eq!(c1.inner().core.n_cigar, b1.inner().core.n_cigar);
             assert_eq!(c1.inner().core.l_qseq, b1.inner().core.l_qseq);
-            assert_eq!(c1.inner().core.isize, b1.inner().core.isize);
+            assert_eq!(c1.inner().core.isize_, b1.inner().core.isize_);
             //... except m_data
         }
     }

diff --git a/src/bam/record.rs b/src/bam/record.rs
@@ -126,7 +126,7 @@
        Record {
            inner: {
                #[allow(clippy::uninit_assumed_init)]
                let mut inner = unsafe { MaybeUninit::uninit().assume_init() };
                unsafe {
                    ::libc::memcpy(
                        &mut inner as *mut htslib::bam1_t as *mut ::libc::c_void,
@@ -152,8 +152,8 @@
 
         let mut sam_string = htslib::kstring_t {
             s: sam_copy.as_ptr() as *mut c_char,
-            l: sam_copy.len() as u64,
-            m: sam_copy.len() as u64,
+            l: sam_copy.len(),
+            m: sam_copy.len(),
         };
 
         let succ = unsafe {
@@ -286,12 +286,12 @@
 
     /// Get insert size.
     pub fn insert_size(&self) -> i64 {
-        self.inner().core.isize
+        self.inner().core.isize_
     }
 
     /// Set insert size.
     pub fn set_insert_size(&mut self, insert_size: i64) {
-        self.inner_mut().core.isize = insert_size;
+        self.inner_mut().core.isize_ = insert_size;
     }
 
     fn qname_capacity(&self) -> usize {
@@ -800,7 +800,7 @@
                    ctag,
                    b'A' as c_char,
                    size_of::<u8>() as i32,
                    [v].as_mut_ptr() as *mut u8,
                ),
                Aux::I8(v) => htslib::bam_aux_append(
                    self.inner_ptr_mut(),
@@ -814,7 +814,7 @@
                    ctag,
                    b'C' as c_char,
                    size_of::<u8>() as i32,
                    [v].as_mut_ptr() as *mut u8,
                ),
                Aux::I16(v) => htslib::bam_aux_append(
                    self.inner_ptr_mut(),
@@ -1609,7 +1609,7 @@

    /// Return encoded base. Complexity: O(1).
    #[inline]
    pub unsafe fn encoded_base_unchecked(&self, i: usize) -> u8 {
        encoded_base_unchecked(self.encoded, i)
    }

@@ -1617,7 +1617,7 @@
    /// Use index based access seq()[i], for checked, safe access.
    /// Complexity: O(1).
    #[inline]
    pub unsafe fn decoded_base_unchecked(&self, i: usize) -> u8 {
        *decode_base_unchecked(self.encoded_base_unchecked(i))
    }

@@ -2234,7 +2234,7 @@
    /// This function allocates memory for the state structure
    /// and initializes the iterator to the start of the modification
    /// records.
    fn new<'a>(r: &'a Record) -> Result<BaseModificationState<'a>> {
        let mut bm = unsafe {
            BaseModificationState {
                record: r,
@@ -2258,7 +2258,7 @@

        let types = bm.recorded();
        bm.buffer.reserve(types.len());
        return Ok(bm);
    }

    pub fn buffer_next_mods(&mut self) -> Result<usize> {
@@ -2286,7 +2286,7 @@
            // not update the length so needs to be manually set
            self.buffer.set_len(ret as usize);

            return Ok(ret as usize);
        }
    }

@@ -2311,7 +2311,7 @@
    /// and the ascii code for the canonical base.
    /// If there are multiple modifications with the same code this will return the data
    /// for the first mod.  See https://github.com/samtools/htslib/issues/1635
    pub fn query_type<'a>(&self, code: i32) -> Result<BaseModificationMetadata> {
        unsafe {
            let mut strand: i32 = 0;
            let mut implicit: i32 = 0;
@@ -2326,13 +2326,13 @@
                &mut canonical,
            );
            if ret == -1 {
                return Err(Error::BamBaseModificationTypeNotFound);
            } else {
                return Ok(BaseModificationMetadata {
                    strand,
                    implicit,
                    canonical: canonical.try_into().unwrap(),
                });
            }
        }
    }
@@ -2353,7 +2353,7 @@
 }

 impl BaseModificationsPositionIter<'_> {
    fn new<'a>(r: &'a Record) -> Result<BaseModificationsPositionIter<'a>> {
        let state = BaseModificationState::new(r)?;
        Ok(BaseModificationsPositionIter { mod_state: state })
    }
@@ -2362,8 +2362,8 @@
        return self.mod_state.recorded();
    }

    pub fn query_type<'a>(&self, code: i32) -> Result<BaseModificationMetadata> {
        return self.mod_state.query_type(code);
    }
 }

@@ -2380,13 +2380,13 @@
        match ret {
            Ok(num_mods) => {
                if num_mods == 0 {
                    return None;
                } else {
                    let data = (self.mod_state.buffer_pos, self.mod_state.buffer.clone());
                    return Some(Ok(data));
                }
            }
            Err(e) => return Some(Err(e)),
        }
    }
 }
@@ -2399,7 +2399,7 @@
 }

 impl BaseModificationsIter<'_> {
    fn new<'a>(r: &'a Record) -> Result<BaseModificationsIter<'a>> {
        let state = BaseModificationState::new(r)?;
        Ok(BaseModificationsIter {
            mod_state: state,
@@ -2411,8 +2411,8 @@
        return self.mod_state.recorded();
    }

    pub fn query_type<'a>(&self, code: i32) -> Result<BaseModificationMetadata> {
        return self.mod_state.query_type(code);
    }
 }

@@ -2446,7 +2446,7 @@
            self.mod_state.buffer[self.buffer_idx],
        );
        self.buffer_idx += 1;
        return Some(Ok(data));
    }
 }


diff --git a/src/bam/record_serde.rs b/src/bam/record_serde.rs
@@ -29,7 +29,7 @@ impl Serialize for Record {
         state.serialize_field("seq_len", &core.l_qseq)?;
         state.serialize_field("mtid", &core.mtid)?;
         state.serialize_field("mpos", &core.mpos)?;
-        state.serialize_field("isize", &core.isize)?;
+        state.serialize_field("isize", &core.isize_)?;
         state.serialize_field("data", Bytes::new(self.data()))?;
         state.end()
     }
@@ -138,7 +138,7 @@ impl<'de> Deserialize<'de> for Record {
                 let mpos = seq
                     .next_element()?
                     .ok_or_else(|| de::Error::invalid_length(0, &self))?;
-                let isize = seq
+                let isize_ = seq
                     .next_element()?
                     .ok_or_else(|| de::Error::invalid_length(0, &self))?;
                 let data = seq
@@ -159,7 +159,7 @@ impl<'de> Deserialize<'de> for Record {
                     m.l_qseq = seq_len;
                     m.mtid = mtid;
                     m.mpos = mpos;
-                    m.isize = isize;
+                    m.isize_ = isize_;
                 }
 
                 rec.set_data(&data);
@@ -271,7 +271,7 @@ impl<'de> Deserialize<'de> for Record {
                 let seq_len = seq_len.ok_or_else(|| de::Error::missing_field("seq_len"))?;
                 let mtid = mtid.ok_or_else(|| de::Error::missing_field("mtid"))?;
                 let mpos = mpos.ok_or_else(|| de::Error::missing_field("mpos"))?;
-                let isize = isize.ok_or_else(|| de::Error::missing_field("isize"))?;
+                let isize_ = isize.ok_or_else(|| de::Error::missing_field("isize"))?;
                 let data = data
                     .ok_or_else(|| de::Error::missing_field("data"))?
                     .into_vec();
@@ -289,7 +289,7 @@ impl<'de> Deserialize<'de> for Record {
                     m.l_qseq = seq_len;
                     m.mtid = mtid;
                     m.mpos = mpos;
-                    m.isize = isize;
+                    m.isize_ = isize_;
                 }
 
                 rec.set_data(&data);

diff --git a/src/bcf/record.rs b/src/bcf/record.rs
@@ -112,18 +112,18 @@
 }

 impl Buffer {
    pub fn new() -> Self {
        Buffer {
            inner: ptr::null_mut(),
            len: 0,
        }
    }
 }

 impl Drop for Buffer {
    fn drop(&mut self) {
        unsafe {
            ::libc::free(self.inner as *mut ::libc::c_void);
        }
    }
 }
@@ -131,7 +131,7 @@
 #[derive(new, Debug)]
 pub struct BufferBacked<'a, T: 'a + fmt::Debug, B: Borrow<Buffer> + 'a> {
    value: T,
    buffer: B,
    #[new(default)]
    phantom: PhantomData<&'a B>,
 }
@@ -1008,7 +1008,7 @@
     }
 
     pub fn remove_alleles(&mut self, remove: &[bool]) -> Result<()> {
-        let rm_set = unsafe { htslib::kbs_init(remove.len() as u64) };
+        let rm_set = unsafe { htslib::kbs_init(remove.len()) };
 
         for (i, &r) in remove.iter().enumerate() {
             if r {
@@ -1094,7 +1094,7 @@
    fn clone(&self) -> Self {
        let inner = unsafe {
            let inner = htslib::bcf_dup(self.inner);
            inner
        };
        Record {
            inner,
@@ -1193,7 +1193,7 @@

 impl fmt::Display for Genotype {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let &Genotype(ref alleles) = self;
        write!(f, "{}", alleles[0])?;
        for a in &alleles[1..] {
            let sep = match a {
@@ -1326,7 +1326,7 @@
    /// as along as the data is accessed. If parts of the data are accessed while
    /// the BufferBacked object is already dropped, you will access unallocated
    /// memory.
    pub fn string(mut self) -> Result<Option<BufferBacked<'b, Vec<&'b [u8]>, B>>> {
        self.data(htslib::BCF_HT_STR).map(|data| {
            data.map(|ret| {
                BufferBacked::new(
@@ -1445,7 +1445,7 @@
                    )
                }
                .chunks(self.values_per_sample())
                .map(|s| trim_slice(s))
                .collect(),
                self.buffer,
            )
@@ -1468,7 +1468,7 @@
                    )
                }
                .chunks(self.values_per_sample())
                .map(|s| trim_slice(s))
                .collect(),
                self.buffer,
            )

diff --git a/src/bgzf/mod.rs b/src/bgzf/mod.rs
@@ -112,11 +112,7 @@
 impl std::io::Read for Reader {
     fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
         let nbytes = unsafe {
-            htslib::bgzf_read(
-                self.inner,
-                buf.as_mut_ptr() as *mut libc::c_void,
-                buf.len() as u64,
-            )
+            htslib::bgzf_read(self.inner, buf.as_mut_ptr() as *mut libc::c_void, buf.len())
         };
         if nbytes < 0 {
             Err(std::io::Error::new(
@@ -232,7 +228,7 @@
            // This should be unreachable
            Ok(i) => return Err(Error::BgzfInvalidCompressionLevel { level: i }),
        };
        return Ok(ffi::CString::new(write_string).unwrap());
    }

    /// Set the thread pool to use for parallel compression.
@@ -257,13 +253,8 @@
 
 impl std::io::Write for Writer {
     fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
-        let nbytes = unsafe {
-            htslib::bgzf_write(
-                self.inner,
-                buf.as_ptr() as *mut libc::c_void,
-                buf.len() as u64,
-            )
-        };
+        let nbytes =
+            unsafe { htslib::bgzf_write(self.inner, buf.as_ptr() as *mut libc::c_void, buf.len()) };
         if nbytes < 0 {
             Err(std::io::Error::new(
                 std::io::ErrorKind::Other,