Make internals of ScopedFuture private

Author: zakstucke

reactive_graph/src/computed/async_derived/mod.rs

@@ -23,10 +23,11 @@ pin_project! {
     #[derive(Clone)]
     #[allow(missing_docs)]
     pub struct ScopedFuture<Fut> {
-        pub owner: Owner,
-        pub observer: Option<AnySubscriber>,
+        owner: Owner,
+        observer: Option<AnySubscriber>,
+        diagnostics: bool,
         #[pin]
-        pub fut: Fut,
+        fut: Fut,
     }
 }
 
@@ -39,61 +40,53 @@ impl<Fut> ScopedFuture<Fut> {
         Self {
             owner,
             observer,
+            diagnostics: true,
             fut,
         }
     }
 
-    #[doc(hidden)]
-    #[track_caller]
-    pub fn new_untracked_with_diagnostics(fut: Fut) -> Self {
+    /// Wraps the given `Future` by taking the current [`Owner`] re-setting it as the
+    /// active owner every time the inner `Future` is polled. Always untracks, i.e., clears
+    /// the active [`Observer`] when polled.
+    pub fn new_untracked(fut: Fut) -> Self {
         let owner = Owner::current().unwrap_or_default();
         Self {
             owner,
             observer: None,
+            diagnostics: false,
             fut,
         }
     }
-}
-
-impl<Fut: Future> Future for ScopedFuture<Fut> {
-    type Output = Fut::Output;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.project();
-        this.owner
-            .with(|| this.observer.with_observer(|| this.fut.poll(cx)))
-    }
-}
 
-pin_project! {
     #[doc(hidden)]
-    pub struct __NonReactiveZoneFut<Fut> {
-        #[pin]
-        fut: Fut,
-    }
-}
-
-impl<Fut> ScopedFuture<__NonReactiveZoneFut<Fut>> {
-    /// Wraps the given `Future` by taking the current [`Owner`] re-setting it as the
-    /// active owner every time the inner `Future` is polled. Always untracks, i.e., clears
-    /// the active [`Observer`] when polled.
-    pub fn new_untracked(fut: Fut) -> Self {
+    #[track_caller]
+    pub fn new_untracked_with_diagnostics(fut: Fut) -> Self {
         let owner = Owner::current().unwrap_or_default();
         Self {
             owner,
             observer: None,
-            fut: __NonReactiveZoneFut { fut },
+            diagnostics: true,
+            fut,
         }
     }
 }
 
-impl<Fut: Future> Future for __NonReactiveZoneFut<Fut> {
+impl<Fut: Future> Future for ScopedFuture<Fut> {
     type Output = Fut::Output;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        #[cfg(debug_assertions)]
-        let _guard = crate::diagnostics::SpecialNonReactiveZone::enter();
-        self.project().fut.poll(cx)
+        let this = self.project();
+        this.owner.with(|| {
+            this.observer.with_observer(|| {
+                #[cfg(debug_assertions)]
+                let _maybe_guard = if *this.diagnostics {
+                    None
+                } else {
+                    Some(crate::diagnostics::SpecialNonReactiveZone::enter())
+                };
+                this.fut.poll(cx)
+            })
+        })
     }
 }