feat: Make tokio an optional dependency

Closes #843

Author: Marwes

Cargo.lock

@@ -39,17 +39,17 @@ quick-error = "1.0.0"
 collect-mac = "0.1.0"
 either = "1.0.0"
 itertools = "0.9"
-futures = { version = "0.3.1", features = ["thread-pool"] }
+futures = { version = "0.3.1", default-features = false }
 codespan = "0.9"
 codespan-reporting = "0.9"
-pin-project = "0.4"
+pin-project-lite = { version = "0.1", optional = true }
 salsa = { version = "0.14.0", package = "gluon-salsa" }
 
 serde = { version = "1.0.0", optional = true }
 serde_state = { version = "0.4", optional = true }
 serde_derive_state = { version = "0.4.7", optional = true }
 
-tokio = { version = "0.2", features = ["stream", "sync", "rt-core"] }
+tokio = { version = "0.2", features = ["stream", "sync", "rt-core"], optional = true }
 
 # Binding crates
 regex = { version = "1", optional = true }
@@ -100,10 +100,11 @@ gluon_completion = { path = "completion", version = "0.15.1" } # GLUON
 gluon_codegen = { path = "codegen", version = "0.15.1" } # GLUON
 
 [features]
-default = ["regex", "random"]
+default = ["async", "regex", "random"]
+async = ["tokio"]
 random = ["rand", "rand_xorshift"]
 serialization = ["serde", "serde_state", "serde_derive_state", "gluon_vm/serialization"]
-web = ["hyper", "http", "tower-service", "native-tls", "tokio/net", "tokio-tls"]
+web = ["async", "hyper", "http", "tower-service", "native-tls", "tokio/net", "tokio-tls", "pin-project-lite"]
 
 docs_rs = ["serialization"]
 

Cargo.toml

@@ -17,6 +17,9 @@ use std::{
 use either::Either;
 use salsa::ParallelDatabase;
 
+#[cfg(feature = "serde")]
+use crate::ThreadExt;
+
 use crate::{
     base::{
         ast::{self, OwnedExpr, RootExpr, SpannedExpr, Typed},
@@ -35,7 +38,7 @@ use crate::{
         macros::MacroExpander,
         thread::{RootedThread, RootedValue, Thread, ThreadInternal, VmRoot},
     },
-    Error, ModuleCompiler, Result, ThreadExt,
+    Error, ModuleCompiler, Result,
 };
 
 pub type BoxFuture<'vm, T, E> =

src/compiler_pipeline.rs

@@ -16,7 +16,6 @@ use {
     futures::{
         future::{self},
         prelude::*,
-        task::SpawnExt,
     },
     itertools::Itertools,
     salsa::{debug::DebugQueryTable, Database},
@@ -573,7 +572,10 @@ where
 
         let span = args[0].span;
 
+        #[cfg(feature = "tokio")]
         if let Some(spawn) = macros.spawn {
+            use futures::task::SpawnExt;
+
             let (tx, rx) = tokio::sync::oneshot::channel();
             spawn
                 .spawn(Box::pin(async move {
@@ -585,28 +587,28 @@ where
                     let _ = tx.send(result);
                 }))
                 .unwrap();
-            Box::pin(async move {
+            return Box::pin(async move {
                 Ok(From::from(move || {
                     rx.map(move |r| {
                         r.unwrap_or_else(|err| Err(MacroError::new(Error::String(err.to_string()))))
                             .map(move |id| pos::spanned(span, Expr::Ident(id)).into())
                     })
                     .boxed()
                 }))
-            })
-        } else {
-            Box::pin(async move {
-                Ok(From::from(move || {
-                    async move {
-                        db.import(modulename)
-                            .await
-                            .map_err(|err| MacroError::message(err.to_string()))
-                            .map(move |id| pos::spanned(span, Expr::Ident(id)))
-                    }
-                    .boxed()
-                }))
-            })
+            });
         }
+
+        Box::pin(async move {
+            Ok(From::from(move || {
+                async move {
+                    db.import(modulename)
+                        .await
+                        .map_err(|err| MacroError::message(err.to_string()))
+                        .map(move |id| pos::spanned(span, Expr::Ident(id)))
+                }
+                .boxed()
+            }))
+        })
     }
 }
 

src/import.rs

@@ -888,18 +888,25 @@ impl VmBuilder {
     }
 
     pub async fn build_async(self) -> RootedThread {
-        struct TokioSpawn;
-        impl futures::task::Spawn for TokioSpawn {
-            fn spawn_obj(
-                &self,
-                future: futures::task::FutureObj<'static, ()>,
-            ) -> StdResult<(), futures::task::SpawnError> {
-                tokio::spawn(future);
-                Ok(())
+        #[allow(unused_mut, unused_assignments)]
+        let mut spawner = None;
+
+        #[cfg(feature = "tokio")]
+        {
+            struct TokioSpawn;
+            impl futures::task::Spawn for TokioSpawn {
+                fn spawn_obj(
+                    &self,
+                    future: futures::task::FutureObj<'static, ()>,
+                ) -> StdResult<(), futures::task::SpawnError> {
+                    tokio::spawn(future);
+                    Ok(())
+                }
             }
+            spawner = Some(Box::new(TokioSpawn) as Box<dyn futures::task::Spawn + Send + Sync>);
         }
 
-        self.build_inner(Some(Box::new(TokioSpawn))).await
+        self.build_inner(spawner).await
     }
 
     async fn build_inner(

src/lib.rs

@@ -18,7 +18,7 @@ use {
         StatusCode,
     },
     hyper::{body::Bytes, Server},
-    pin_project::pin_project,
+    pin_project_lite::pin_project,
 };
 
 use crate::base::types::{ArcType, Type};
@@ -360,8 +360,9 @@ async fn listen_(
             })
         });
 
-        #[pin_project]
-        struct Acceptor<S>(#[pin] S);
+        pin_project! {
+            struct Acceptor<S>(#[pin] S);
+        }
         impl<S, T, E> hyper::server::accept::Accept for Acceptor<S>
         where
             S: Stream<Item = Result<T, E>>,