GCC/MSVC fixes

CMakeLists.txt

@@ -49,7 +49,7 @@ if (MSVC)
     # MSVC:
     add_definitions(-DWIN32_LEAN_AND_MEAN -D_WIN32_WINNT=0x0A00 -DNOMINMAX)
     add_compile_options(
-        /W4         # I think this means 'turn on lots of warnings'
+       # /W4         # I think this means 'turn on lots of warnings'
         /wd4068     # ignore unknown pragma
         /wd4100     # ignore unused fn parameters
         /wd4244     # ignore implicit sign conversion
@@ -76,7 +76,8 @@ else()
         add_compile_options(
             -Wno-gnu-zero-variadic-macro-arguments
             -Wno-gnu-conditional-omitted-operand    # Allow `x ?: y`
-            -Wno-gnu-statement-expression-from-macro-expansion  # Allow `({...})`
+            -Wno-gnu-statement-expression           # Allow `({...})`
+            -Wno-gnu-statement-expression-from-macro-expansion
         )
     endif()
 endif()

include/Awaitable.hh

@@ -19,6 +19,8 @@
 #pragma once
 #include "Result.hh"
 
+#include <functional>
+
 namespace crouton {
 
     /** Pure-virtual interface declaring the coroutine methods needed to support `co_await`

include/Error.hh

@@ -21,7 +21,7 @@
 
 #include <array>
 #include <concepts>
-#include <exception>
+#include <stdexcept>
 #include <type_traits>
 #include <typeinfo>
 
@@ -51,7 +51,7 @@ namespace crouton {
     template <typename T>
     concept ErrorDomain = requires {
         std::is_enum_v<T>;
-        std::same_as<std::underlying_type_t<T>, errorcode_t>;
+        requires std::same_as<std::underlying_type_t<T>, errorcode_t>;
         {ErrorDomainInfo<T>::name} -> std::convertible_to<string_view>;
         {ErrorDomainInfo<T>::description} -> std::convertible_to<ErrorDescriptionFunc>;
     };

include/EventLoop.hh

@@ -20,6 +20,7 @@
 #include "Future.hh"
 
 #include <functional>
+#include <optional>
 
 struct uv_timer_s;
 

include/Future.hh

@@ -61,7 +61,7 @@ namespace crouton {
     template <typename T>
     class Future : public Coroutine<FutureImpl<T>>, public ISelectable {
     public:
-        using nonvoidT = std::conditional<std::is_void_v<T>, std::byte, T>::type;
+        using nonvoidT = typename std::conditional<std::is_void_v<T>, std::byte, T>::type;
 
         /// Creates a Future from a FutureProvider.
         explicit Future(FutureProvider<T> state)        :_state(std::move(state)) {assert(_state);}
@@ -260,7 +260,7 @@ namespace crouton {
     public:
         using super = CoroutineImpl<FutureImpl<T>, true>;
         using handle_type = typename super::handle_type;
-        using nonvoidT = std::conditional<std::is_void_v<T>, std::byte, T>::type;
+        using nonvoidT = typename std::conditional<std::is_void_v<T>, std::byte, T>::type;
 
         FutureImpl() = default;
 

include/LinkedList.hh

@@ -111,6 +111,8 @@ namespace crouton::util {
     protected:
         Link* _begin()                  {return _head._next;}
         Link* _end()                    {return &_head;}
+        Link const* _begin() const      {return _head._next;}
+        Link const* _end() const        {return &_head;}
 
         template <class LINK>
         static LINK& downcast(Link& link)   {return static_cast<LINK&>(link);}

include/Result.hh

@@ -133,6 +133,7 @@ namespace crouton {
 
 
 
+#if 0
     /// Syntactic sugar to handle a `Result<T>`, similar to Swift's `try`.
     /// - If R has a value, evaluates to its value.
     /// - If R has an error, `co_return`s the error from the current coroutine.
@@ -148,4 +149,5 @@ namespace crouton {
     /// - If the future returns a value, evaluates to that value.
     /// - If the future returns an error, `co_return`s the error.
     #define TRY_AWAIT(F)    UNWRAP(AWAIT NoThrow(F))
+#endif
 }

src/io/FileStream.cc

@@ -108,9 +108,10 @@ namespace crouton::io {
             _readBuf = make_unique<Buffer>();
         assert(_readBuf->empty());
         MutableBytes buf(_readBuf->data, Buffer::kCapacity);
-        size_t n = TRY_AWAIT(_preadv(&buf, 1, -1));
-
-        _readBuf->size = uint32_t(n);
+        Result<size_t> n = AWAIT _preadv(&buf, 1, -1);
+        if (auto err = n.error())
+            RETURN err;
+        _readBuf->size = uint32_t(n.value());
         _readBuf->used = 0;
         RETURN _readBuf->bytes();
     }