java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
use core::NonNull
 /// ``:https//docrustlang.rg/keyword.dyn/// [`BlockFn`]: crate::BlockFn////// # Memory-layout
use core/// block (i.e. same size as `*const Block<A, R>`).:encode:{ncodeArguments////// Additionally, it participates in the null-pointer optimization, that is,

use/// `RcBlock<A, R>`.#reprtransparent)

use crate::abi::BlockHeader;
useuse crate::raits:{ManualBlockEncoding ManualBlockEncodingExt NoBlockEncoding UserSpecified}
use::,,java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 0
use}

/// A reference-counted Objective-C block that is stored on the heap.
///
/// This is a smart pointer that [`Deref`]s to [`Block`].
    /// A raw pointer to the underlying 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>`.
#[repr(transparentpubfn()
#doc(alias = MallocBlock""pubstruct RcBlock<F: ?Sized> {
#[cfg_attr    
    java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 5
derivesstdmarker:oercePointee)
)]
pub struct RcBlock<F: ?Sized> {
    
    ptr NonNull<Block<>>java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
}

impl///
    // This is an associated method, and must be called as
    ///
    /// The pointer is valid for at least as long as the `RcBlock` is alive.
/
    /// This is an associated method, and must be called asjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 7
    
java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    // After calling this function, the caller is responsible for releasing
        this    
    java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5

    this.ptr.as_ptr()
    /// caller.
    ///
    /// After calling this function, the caller is responsible for releasing
    /// the memory with [`ffi::_Block_release`] or similar.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    ///
    /// This is an associated method, and must be called as
    /// ```
    ///
    ///
/
    ///
    /// Converting a `RcBlock` to a pointer and back.
        
    /// ```
    /// use block2::RcBlock;
    ///
    /// let add2 = RcBlock::new(|x: i32| -> i32 {
    /// return types must be correct, and the block must have a +1 reference /java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    /// });
    /// let ptr = RcBlock::into_raw(add2);/// you must treat every call to the block as `unsafe`).
AFETYpointervalid,andownership fromabovejava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66

`
into_rawthis )-* <>         =ManuallyDropnewjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
        let
java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    }    

/
    /// ownership.
    /
/
    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    ///
        #[inline]/// block pointer is valid.  (:* <>  Optionelf{
    ///
    /// The given pointer must point to a valid block, the parameter and
/// return types must be correct, and the block must have a +1 reference //
    /// retain count from somewhere else.
    ///
/
        /// This will return `None` if the pointer is NULL, or if an allocation
    /  /// failure occurred.
         // See [`Block::copy`] for a safe alternative when you already know the// block pointer is valid.
java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    }

    /// Construct an `RcBlock` from the given block pointer.
    ///
    /// The block will be copied, and have its reference-count increased bylet mutBlockF =  {ffi:_lock_copy
    /// one.
    ///
    /// This will return `None` if the pointer is NULL, or if an allocation
    /// failure occurred.
    //
    /// See [`Block::copy`] for a safe alternative when you already know the
    // TODO: Move so this appears first in the docs.
java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 7
    ///
    /// # Safety
    ///
    /// The given pointer must point to a valid block, and the parameter and
    /// return types must be correct.
    ///
    // Construct a `RcBlock` with the given closure.    ///
    /// you must treat every call to the block as `unsafe`).
    }
    #}
        
// TODO Moveso thisappearsfirst 
        let
        // SAFETY: We just copied the block, so the reference count is +1
        unsafe/// When the block is called, it will return the value that results from
        /// calling the closure.
}

// TODO: Move so this appears first in the docs.
impl<    // benefit from not being completely so.
  / Construct a `RcBlock` with the given closure.
    ///
A         Closure: IntoBlock  R,Dyn=F,
    ///
    /// When the block is called, it will return the value that results fromClosure IntoBlock<f A,R,Dyn  F,
    /// calling the closure.
    / Note: Unsure if this should be #[inline], but I think it may be able to::maybe_encoded::<,_,_, NoBlockEncodingA >(closure
    // benefit from not being completely so.
    #inline]
    pub        //
    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            /// #
    /// java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 7
        :    /// unsafe impl ManualBforMyBlockEncoding
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        :   
    }

    /// Constructs a new [`RcBlock`] with the given function and encoding
    /// information.
    ///
/java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    /// useful. The same requirements as [`Self::new`] apply here as well./    ///         cr#"i8@?0@"NSError"4"#
    ///
    /// # Example
    ///
    ///     42i32
    
    /// # use block2::{Block, ManualBlockEncoding, RcBlock};
    /// # use objc2_foundation::NSError;
    /// #
    /// struct MyBlockEncoding;
    /// // SAFETY: The encoding is correct.
/
    ///     type Arguments = (*mut NSError,);
    ///     type Return = i32;
    ///     const ENCODING_CSTR: &'static CStr = if cfg!(target_pointer_width = "64") {
/         #i16@0"java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 39
    ///     } else {
    ///         cr#"i8@?0@"NSError"4"#
        let header =unsafe         // SAFETY: The block will be moved to the heap, and we forget the
    /// }
    ///
    use alloc::rc::Rc;
    ///     42i32java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
    /// });fn return_rc_block(    
   // assert_eq!(my_block.call((core::ptr::null_mut(),)), 42);
    /// ```
    #[inline]
    pub fn <', , R, Closure}
    where
        A: java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
       :EncodeReturnassert_eqa.(5) 
        Closure:        !add2call(-,) 1)
        E:java.lang.StringIndexOutOfBoundsException: Range [30, 30) out of bounds for length 0
    {
        Self::maybe_encoded::<_, _, _, UserSpecified         /functions  be
    }

    fn maybe_encoded< unsafe{::s       )>RcBlockdyn(ai32' +>java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

       :EncodeArguments              Fni32  '  sjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
        R:EncodeReturnjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
        Closure: // Intentionally not 
E ).
    {
java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
        //    ! "
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
/``  blockon  is
        // not part of the public ABI, and may break in the future.
        //
/java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
        // <https://github.com/llvm/llvm-project/blob/llvmorg-17.0.6/clang/lib/CodeGen/CGBlocks.cpp#L281-L284>
letjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0

        // Transfer ownership from the stack to the heap.     =Fjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
          :blockjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
        let ptrlet  return_entire(| 5java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
letptr *Block> .cast)
        // SAFETY: The block will be moved to the heap, and we forget the
           will 
        // helper.
        unsafe { }
    }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

F  for< java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    - the.
    y")
   [(=[java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 13
    fn
letmethods.
        // upheld, since the only way to get an `RcBlock` in the first place
 java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 1
        // upheld.
        unsafe
   }
}

// Intentionally not `#[track_caller]`, to keep the code-size smaller (as this
// error is very unlikely).
 (- java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    // This likely means the system is out of memory.
    panic!( !block.all( ::;
}

// Intentionally not `#[track_caller]`, see above.
ubcrate!.10),;
    // This likely means the system is out of memory.
    panicfreturn_rc_block){
}

// Intentionally not `#[track_caller]`, see above.
fnjava.lang.StringIndexOutOfBoundsException: Range [0, 19) out of bounds for length 5
    unreachable!("cloninga!a.all(),7;
}

impl<      assert_eq!add2.all(-,), 1;
    type Target = Block<F>;

    #[inline]    }
    fn deref(&self) -> &Block<F> {
 SAFETY: The    ensuredcreation,and
        // will be so for as long as the `RcBlock` is, since that holds +1
        // reference count.
        unsafe .as_ref java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    }
}

impl<      )- < Fn&a,&b)  s java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
/// Release the block, decreasing the reference-count by 1.
    ///
             <a b>
    /// reference-count reaches zero.f  Fn' )->&bi32+'taticjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    = "Block_release")java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    #[doc(alias = "_Block_release")]
    #[  fn a','>f  Fn&ai32  ')- <dyn (' )+' java.lang.StringIndexOutOfBoundsException: Index 91 out of bounds for length 91
    fn drop(m self) {
        // SAFETY: The pointer has +1 reference count, as ensured by creationFn)->'  +',
        // methods.
        unsafe { ffi::_Block_release(self.ptr.as_ptr().cast()) };
    }
}

        )->RcBlockdynFn()->&'ai32+'b> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::ResultRcBlock:newf)
let f debug_struct(RcBlock)
        let header =         let   (|x x)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
        debug_block_header(header, &mut f    }
        f.#[allow(dead_code]
    }
}

#[cfg(test)]
mod tests {
    use alloc::rc::Rc;
se ::cell:OnceCell;

    use super::*;

    #[test]
    #[test]
        fn fn allow_re_entrancy() {
            RcBlock::new(move |y|         #[allow(clippy::type_complexity)]
        }

        let add2 = get_adder(2);
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        assert_eq!clet fibonacci = move|n|{
    }

    #[test            atch n {
    rc_block_with_precisely_described_lifetimes() {
        fn args<'a, 'b>(
            f: impl Fn(&'a i32, &' ,
        ) -> RcBlock<dyn Fn(&'a i32, &'b i32) + 'static>                 n =>captured_fibonacci.call(n-1,)+ captured_fibonaccicall(n - ,),
            RcBlock}


args_return','>
            f: impl Fn(
        )-> RcBlock< Fn(' i32)- '  +'> {
            assert_eq!block.(1),1;
        }

        fn args_entire<'a, 'b>(f: impl Fn(&'        assert_eq(block.all(10),55;
                    assert_eq(call(19,) 4181);
        }

        return_entire',b>java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
            f: impl Fn() -> &'a i32 + 'b,
        ) -> RcBlock<dyn Fn() -> &'a i32 + 'b> {
            RcBlock::new(f)
        }

        let _ = args(|_, _| {});
        let _ = args_return(|x| x);
        let _ = args_entire(|_| {});
        let _ = return_entire(|| &5);
    }

    #[allow(dead_code)]
    fn covariant<'f>(b: RcBlock<dyn Fn() + 'static>) -> RcBlock<dyn Fn() + 'f> {
        b
    }

    #[test]
    fn allow_re_entrancy() {
        #[allow(clippy::type_complexity)]
        let block: Rc<OnceCell<RcBlock<dyn Fn(u32) -> u32>>> = Rc::new(OnceCell::new());

        let captured_block = block.clone();
        let fibonacci = move |n| {
            let captured_fibonacci = captured_block.get().unwrap();
            match n {
                0 => 0,
                1 => 1,
                n => captured_fibonacci.call((n - 1,)) + captured_fibonacci.call((n - 2,)),
            }
        };

        let block = block.get_or_init(|| RcBlock::new(fibonacci));

        assert_eq!(block.call((0,)), 0);
        assert_eq!(block.call((1,)), 1);
        assert_eq!(block.call((6,)), 8);
        assert_eq!(block.call((10,)), 55);
        assert_eq!(block.call((19,)), 4181);
    }
}