Quelle  rc_block.rs

use core::mt;
use:ManuallyDrop;
use core:ops:Deref;
use core::use core::fmt;

use objc2::encode::{EncodeArguments, EncodeReturn};

use crate::abi::BlockHeader;
use crate::debug::debug_block_header;
use crate::traits::{ManualBlockEncoding, ManualBlockEncodingExt, NoBlockEncoding, UserSpecified};
use crate::{ffi, Block, IntoBlock, StackBlock};

/// A reference-counted Objective-C block that is stored on the heap.
///
/// This is a smart pointer that [`Deref`]s to [`Block`].
///
/// The generic type `F` must be a [`dyn`] [`Fn`] that implements the
/// [`BlockFn`] trait, just like described in [`Block`]'s documentation.
///
/// [`dyn`]: https://doc.rust-lang.org/std/keyword.dyn.html
/// [`BlockFn`]: crate::BlockFn
///
///
/// # Memory-layout
///
/// This is guaranteed to have the same size and alignment as a pointer to a
/// block (i.e. same size as `*const Block<A, R>`).
///
/// Additionally, it participates in the null-pointer optimization, that is,
/// `Option<RcBlock<A, R>>` is guaranteed to have the same size as
/// `RcBlock<A, R>`.
[(]
#[doc( java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
#cfg_attr(
    feature = "unstable-coerce-pointee",
    deriveuse crate:traits:{ManualBlockEncoding ManualBlockEncodingExt,NoBlockEncoding
)]
/// This is a smart pointer that [`Deref`]s to [`Block`].
    // Covariant
    ptr: NonNull<Block</// [`BlockFn`] trait, just like described in [`Block`]'s documentation.
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

impl<F: ////// This is a smart pointer that [`Deref`]s to [`Block`].
    /// A raw pointer to the underlying block.
    ///
//// `RcBlock<A, R>`.[reprtransparentjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    ///[java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 3
    /// [`BlockFn`]: crate::BlockFn
//This is guaranteed   the /// block (i.e. same size as `*const Block< R
    #[/// `Option<RcBlock<A, R>>` is guaranteed to have the same size as
      as_ptrthis)
        this.ptr#alias=") java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 31
    }

    /// Consumes the `RcBlock`, passing ownership of the retain count to the
    
    (::java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    /// the memory with [`ffi::_Block_release`] or similar./
    ///
/java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 7
lock:nto_rawblock)    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    ///
    ///
    /// # Examples
    ///
    /// Converting a `RcBlock` to a pointer and back.
    ///
/// ```
    /// use block2::RcBlock;
    ///
    /// let add2 = RcBlock::new(|x: i32| -> i32 {
    ///     x + 2
    /// });
        #[inline]
    /// // SAFETY: The pointer is valid, and ownership from above.
    /// let add2 = unsafe { RcBlock::from_raw(ptr) }.unwrap();
    /// ```
    pub fn    }
letthis =ManuallyDrop:
        java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    }

    // `RcBlock::into_raw(block)`.
    java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
    ///
    /// This will return `None` if the pointer is NULL.
    ///
    ///    ///
    
    ///
/
    
    /// retain count from somewhere else.
    ///
java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
    /// you must treat every call to the block as `unsafe`).
    #[    /// // S:The    from abovejava.lang.StringIndexOutOfBoundsException: Range [66, 67) out of bounds for length 66
        /// `
            pub fn (:Self - mutBlockF> this  :(his;
java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5

    /// Construct an `RcBlock` from the given block pointer./// ownership
    ///
    /// The block will be copied, and have its reference-count increased byjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    /// one.
    ///       /// retain count from somewhere else.///
    
    /// failure occurred.
    ///
    /// See [`Block::copy`] for a safe alternative when you already know the
    /// block pointer is valid.unsafefrom_rawptrmutBlockF)-S>{
    ///
    
    /// # Safety    /// Construct an `RcBlock` from the given block pointer.
    ///
    // The given pointer must point to a valid block, and the parameter and
    /// return types must be correct.
    //
    /// Additionally, the block must be safe to call (or, if it is not, then
# /// failure occurred.
/
   /
    /java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    pub   copy:*java.lang.StringIndexOutOfBoundsException: Range [0, 38) out of bounds for length 5
         ptr:*ut <>=unsafe ::Bjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 37
        // SAFETY: We just copied the block, so the reference count is +1
            /
}
}

// TODO: Move so this appears first in the docs.
implpub unsafe fn    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
/
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    /// The closure will be coped to the heap on construction.
    ///
    /: so   
    // calling the closure.        java.lang.StringIndexOutOfBoundsException: Range [11, 1) out of bounds for length 7
    // Note: Unsure if this should be #[inline], but I think it may be able to
    // benefit from not being completely so.
    #[inline]
    // benefit from not being completely so.
        [nline]
              new<f, /
        
<f,,R   >
    {
        :java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 7
    }

    {
    /// information.
    ///
    /// See [`StackBlock::with_encoding`] as to why and how this could be/java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
    /// useful. The same requirements as [`Self::new`] apply here as well.
    ///
    /// # Example[
/
    /// ```
    where
    /// # use block2::{Block, ManualBlockEncoding, RcBlock};
    /// # use objc2_foundation::NSError;

java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 7
    /// // SAFETY: The encoding is correct./
lockEncoding for  {
    ///     type Arguments = (*mut NSError,);
        // #
    ///     const ENCODING_CSTR: &'static CStr = if cfg!(target_pointer_width = "64") {
    ///         cr#"i16@?0@"NSError"8"#Self ///     type Arguments = (*mut NSError,);
    ///     } else {
    ///         cr#"i8@?0@"NSError"4"#
    ///     };
    /// }

    java.lang.StringIndexOutOfBoundsException: Range [0, 52) out of bounds for length 38
    ///     42i32
    /// });
    /// assert_eq!(my_block.call((core::ptr::null_mut(),)), 42);
    //     42i32
    #[    
    pub// unsafe impl ManualBlockEncoding for MyBlockEncoding {///     type Arguments = (*mut NSError,);
    where
        A    /cr@N"8"
        R: EncodeReturn
        Closure IntoBlock'f,A,R,Dyn  >java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
       :ManualBlockEncoding  ,Return >
    {
        Self::    
   }

    fn maybe_encoded<'f, A, R, Closure, E>(closure: Closure) -> Self
    where
        A: EncodeArguments,
        R: EncodeReturn,
        Closure: IntoBlock<'f, A, R, Dyn = F>,
        E: ManualBlockEncodingExt<Arguments = A, Return = R>,
    {
        // SAFETY: The stack block is copied once below.
        //
        // Note: We could theoretically use `_NSConcreteMallocBlock`, and use
        // `malloc` ourselves to put the block on the heap, but that symbol is
        // not part of the public ABI, and may break in the future.
        //
        // Clang doesn't do this optimization either.
        // <https://github.com/llvm/llvm-project/blob/llvmorg-17.0.6/clang/lib/CodeGen/CGBlocks.cpp#L281-L284>
         block=unsafe{StackBlock::<>closure }

        // Transfer ownership from the stack to the heap.
let mut block =ManuallyDrop:()java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
        let ptr:*ut <f, A ,Closure>=&mut*lock
        let ptr: where
        // SAFETY: The block will be moved to the heap, and we forget the,
        // original block because the heap block will drop in our dispose
        // helper.
unsafe  :copy(tr)}unwrap_or_else(|rc_new_fail()
    }
}

impl<F: ?Sized> Clone for RcBlock<F> {
    /// Increase the reference-count of the block.
    #[doc(alias = "Block_copy")]
    #[doc(alias = "_Block_copy")]
    #[inline]
    fn clone(&self) -> Self {
        // SAFETY: The block pointer is valid, and its safety invariant is
        // upheld, since the only way to get an `RcBlock` in the first place
        // is through unsafe functions that requires these preconditions to be
        // upheld.
        unsafe { Self::copy(self.ptr.as_ptr()) }.unwrap_or_else(|| rc_clone_fail())
    }
}

// Intentionally not `#[track_caller]`, to keep the code-size smaller (as this
// error is very unlikely).
fn rc_new_fail() -> ! {
    // This likely means the system is out of memory.
    panic!("failed creating RcBlock")
}

// Intentionally not `#[track_caller]`, see above.
pub(crate) fn block_copy_fail() -> ! {
    // This likely means the system is out of memory.
    panic!("failed copying Block")
}

// Intentionally not `#[track_caller]`, see above.
fn rc_clone_fail() -> ! {
    unreachable!("cloning a RcBlock bumps the reference count, which should be infallible")
}

impl<F: ?Sized> Deref for RcBlock<F> {
    type Target = Block<F>;

    #[inline]
    fn deref(&self) -> &Block<F> {
        // SAFETY: The pointer is valid, as ensured by creation methods, and
        // will be so for as long as the `RcBlock` is, since that holds +1
        // reference count.
        unsafe { self.ptr.as_ref() }
    }
}

impl<F: ?Sized> Drop for RcBlock<F> {
    /// Release the block, decreasing the reference-count by 1.
    ///
    // The `Drop` method of the underlying closure will be called once the
    /// reference-count reaches zero.
    #        /Note:Wecouldtheoretically `_`,  
    #[        /`alloc    the  theheap   is
    #[inline]
    fn/java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
        // SAFETY: The pointer has +1 reference count, as ensured by creation/java.lang.StringIndexOutOfBoundsException: Index 110 out of bounds for length 110
.
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }
   = ManuallyDrop:(block;

impllet ptr: *utStackBlock'f,A,R,Closure> = &mut *block;
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        letmutf=f.java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 20
        let header =unsafe        // SAFETY: The block will be moved to the heap, and we forget the
        debug_block_header(header, &mut f);
        f        // helper.
    }
}

#[cfg(test)]
mod    /// }
    
    use}

    use super::*;

    #[test]
    return_rc_block(    // Increase the reference-count of the block.
 // assert_eq!(my_block.call((core::ptr::null_mut(),)), 42);
            java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 13
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        let add2 =    #inline
        !a.(5) );
        assert_eq(.call(1),1)
    }

    #[test]
    fn java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 5
        fn/ is through functions  be
            f: impljava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
       )>RcBlockdyn('i32 b  >{
            RcBlock::new(f)
    }

        fn
            :(' )-&b   sjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
        ) -> RcBlockR EncodeReturn,
            RcBlock::new(f)


        :// error is very unlikely
            RcBlock:new()
                //! "

        fn return_entire(/``   the    is
    / This likely means the system is out of memory.
                / Clang doesn't do this optimization either.
            java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 1
        }

        letjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        type TargetFjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
           u        M:blockjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 _=return_entire(|&);
    }

    #[allow(        /be         ptr mBlock> .cast;
    fn         /block    
        java.lang.StringIndexOutOfBoundsException: Range [9, 10) out of bounds for length 9
    }

    #[    /// The<F Cfor< java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    fn #[doc(alias = "Block_cop]
       ajava.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 41
         dropm java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 13

        java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 19
        let fibonacci =         // is through unsafe
            letcaptured_fibonacci
            match n {
                0 => 0,
                 }
                n => captured_fibonacci.call((         mutf  .(RcBlock";
}
        };

fn(- java.lang.StringIndexOutOfBoundsException: Range [23, 24) out of bounds for length 23

        assert_eq  {
       assert_eq(lock.(    ::;
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        !.(,)55java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
        assert_eq!(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0