Rollup merge of #102445 - jmillikin:cstr-is-empty, r=Mark-Simulacrum

[rust.git] / library / core / src / const_closure.rs

diff --git a/library/core/src/const_closure.rs b/library/core/src/const_closure.rs
index 23b3f87e72172faf4edf01b173e1ba6b2733a449..9e9c02093be203d208845880537a6d4a3288c654 100644 (file)
--- a/library/core/src/const_closure.rs
+++ b/library/core/src/const_closure.rs
@@ -23,36 +23,53 @@ pub(crate) struct ConstFnMutClosure<CapturedData, Function> {
     /// The Function of the Closure, must be: Fn(CapturedData, ClosureArgs) -> ClosureReturn
     pub func: Function,
 }
+impl<'a, CapturedData: ?Sized, Function> ConstFnMutClosure<&'a mut CapturedData, Function> {
+    /// Function for creating a new closure.
+    ///
+    /// `data` is the a mutable borrow of data that is captured from the environment.
+    /// If you want Data to be a tuple of mutable Borrows, the struct must be constructed manually.
+    ///
+    /// `func` is the function of the closure, it gets the data and a tuple of the arguments closure
+    ///   and return the return value of the closure.
+    pub(crate) const fn new<ClosureArguments, ClosureReturnValue>(
+        data: &'a mut CapturedData,
+        func: Function,
+    ) -> Self
+    where
+        Function: ~const Fn(&mut CapturedData, ClosureArguments) -> ClosureReturnValue,
+    {
+        Self { data, func }
+    }
+}
 
 macro_rules! impl_fn_mut_tuple {
     ($($var:ident)*) => {
-      #[allow(unused_parens)]
-      impl<'a, $($var,)* ClosureArguments, Function, ClosureReturnValue> const
-        FnOnce<ClosureArguments> for ConstFnMutClosure<($(&'a mut $var),*), Function>
-      where
-        Function: ~const Fn(($(&mut $var),*), ClosureArguments) -> ClosureReturnValue+ ~const Destruct,
-      {
-        type Output = ClosureReturnValue;
+        #[allow(unused_parens)]
+        impl<'a, $($var,)* ClosureArguments, Function, ClosureReturnValue> const
+            FnOnce<ClosureArguments> for ConstFnMutClosure<($(&'a mut $var),*), Function>
+        where
+            Function: ~const Fn(($(&mut $var),*), ClosureArguments) -> ClosureReturnValue+ ~const Destruct,
+        {
+            type Output = ClosureReturnValue;
 
-        extern "rust-call" fn call_once(mut self, args: ClosureArguments) -> Self::Output {
-          self.call_mut(args)
+            extern "rust-call" fn call_once(mut self, args: ClosureArguments) -> Self::Output {
+            self.call_mut(args)
+            }
         }
-      }
-      #[allow(unused_parens)]
-      impl<'a, $($var,)* ClosureArguments, Function, ClosureReturnValue> const
-        FnMut<ClosureArguments> for ConstFnMutClosure<($(&'a mut $var),*), Function>
-      where
-        Function: ~const Fn(($(&mut $var),*), ClosureArguments)-> ClosureReturnValue,
-      {
-        extern "rust-call" fn call_mut(&mut self, args: ClosureArguments) -> Self::Output {
-          #[allow(non_snake_case)]
-          let ($($var),*) = &mut self.data;
-          (self.func)(($($var),*), args)
+        #[allow(unused_parens)]
+        impl<'a, $($var,)* ClosureArguments, Function, ClosureReturnValue> const
+            FnMut<ClosureArguments> for ConstFnMutClosure<($(&'a mut $var),*), Function>
+        where
+            Function: ~const Fn(($(&mut $var),*), ClosureArguments)-> ClosureReturnValue,
+        {
+            extern "rust-call" fn call_mut(&mut self, args: ClosureArguments) -> Self::Output {
+                #[allow(non_snake_case)]
+                let ($($var),*) = &mut self.data;
+                (self.func)(($($var),*), args)
+            }
         }
-      }
-
     };
-  }
+}
 impl_fn_mut_tuple!(A);
 impl_fn_mut_tuple!(A B);
 impl_fn_mut_tuple!(A B C);