Merge pull request #333 from sdroege/ref-thread-default

Mark MainContext::ref_thread_default() as non-nullable with regards t…

Author: GuillaumeGomez

Gir.toml

@@ -363,6 +363,11 @@ concurrency = "send+sync"
            [object.function.return]
            nullable = false
 
+       [[object.function]]
+       name = "ref_thread_default"
+           [object.function.return]
+           nullable = false
+
 [[object]]
 name = "GLib.MainLoop"
 status = "generate"

src/auto/main_context.rs

@@ -136,7 +136,7 @@ impl MainContext {
         }
     }
 
-    pub fn ref_thread_default() -> Option<MainContext> {
+    pub fn ref_thread_default() -> MainContext {
         unsafe {
             from_glib_full(ffi::g_main_context_ref_thread_default())
         }

src/main_context_futures.rs

@@ -212,6 +212,8 @@ impl TaskSource {
                 from_glib_none(glib_ffi::g_source_get_context(mut_override(source)))
             };
 
+            assert!(executor.is_owner(), "Polling futures only allowed if the thread is owning the MainContext");
+
             // Clone that we store in the task local data so that
             // it can be retrieved as needed
             executor.push_thread_default();

src/source_futures.rs

@@ -52,25 +52,20 @@ where
 
         if let Some(create_source) = create_source.take() {
             let main_context = MainContext::ref_thread_default();
-            match main_context {
-                None => panic!("Polled from an Executor not backed by a GLib main context"),
-                Some(ref main_context) => {
-                    assert!(main_context.is_owner(), "Spawning futures only allowed if the thread is owning the MainContext");
-
-                    // Channel for sending back the Source result to our future here.
-                    //
-                    // In theory we could directly continue polling the
-                    // corresponding task from the Source callback,
-                    // however this would break at the very least
-                    // the g_main_current_source() API.
-                    let (send, recv) = oneshot::channel();
-
-                    let s = create_source(send);
-
-                    s.attach(Some(main_context));
-                    *source = Some((s, recv));
-                }
-            }
+            assert!(main_context.is_owner(), "Spawning futures only allowed if the thread is owning the MainContext");
+
+            // Channel for sending back the Source result to our future here.
+            //
+            // In theory we could directly continue polling the
+            // corresponding task from the Source callback,
+            // however this would break at the very least
+            // the g_main_current_source() API.
+            let (send, recv) = oneshot::channel();
+
+            let s = create_source(send);
+
+            s.attach(Some(&main_context));
+            *source = Some((s, recv));
         }
 
         // At this point we must have a receiver
@@ -224,25 +219,20 @@ where
 
         if let Some(create_source) = create_source.take() {
             let main_context = MainContext::ref_thread_default();
-            match main_context {
-                None => panic!("Polled from an Executor not backed by a GLib main context"),
-                Some(ref main_context) => {
-                    assert!(main_context.is_owner(), "Spawning futures only allowed if the thread is owning the MainContext");
-
-                    // Channel for sending back the Source result to our future here.
-                    //
-                    // In theory we could directly continue polling the
-                    // corresponding task from the Source callback,
-                    // however this would break at the very least
-                    // the g_main_current_source() API.
-                    let (send, recv) = mpsc::unbounded();
-
-                    let s = create_source(send);
-
-                    s.attach(Some(main_context));
-                    *source = Some((s, recv));
-                }
-            }
+            assert!(main_context.is_owner(), "Spawning futures only allowed if the thread is owning the MainContext");
+
+            // Channel for sending back the Source result to our future here.
+            //
+            // In theory we could directly continue polling the
+            // corresponding task from the Source callback,
+            // however this would break at the very least
+            // the g_main_current_source() API.
+            let (send, recv) = mpsc::unbounded();
+
+            let s = create_source(send);
+
+            s.attach(Some(&main_context));
+            *source = Some((s, recv));
         }
 
         // At this point we must have a receiver