fix: build for macOS

.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/toolchain@v1.0.6
         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/toolchain@v1.0.6
-      #  with:
-      #    toolchain: ${{ matrix.toolchain }}
-      #    target: ${{ matrix.toolchain_target }}
-      #    #override: true
-      #    default: ${{ matrix.default }}
-
       - name: Test
         uses: actions-rs/cargo@v1.0.1
         with:

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"

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
         }
     }

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));
     }
 }
 

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);

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,
             )

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,