Introduce strongly-typed system primitives (#1561)

* Introduce strongly-typed system primitives

This commit does a lot of reshuffling and even some more. It introduces
strongly-typed system primitives which are: `OsFile`, `OsDir`, `Stdio`,
and `OsOther`. Those primitives are separate structs now, each implementing
a subset of `Handle` methods, rather than all being an enumeration of some
supertype such as `OsHandle`. To summarise the structs:

* `OsFile` represents a regular file, and implements fd-ops
  of `Handle` trait
* `OsDir` represents a directory, and primarily implements path-ops, plus
  `readdir` and some common fd-ops such as `fdstat`, etc.
* `Stdio` represents a stdio handle, and implements a subset of fd-ops
  such as `fdstat` _and_ `read_` and `write_vectored` calls
* `OsOther` currently represents anything else and implements a set similar
  to that implemented by `Stdio`

This commit is effectively an experiment and an excercise into better
understanding what's going on for each OS resource/type under-the-hood.
It's meant to give us some intuition in order to move on with the idea
of having strongly-typed handles in WASI both in the syscall impl as well
as at the libc level.

Some more minor changes include making `OsHandle` represent an OS-specific
wrapper for a raw OS handle (Unix fd or Windows handle). Also, since `OsDir`
is tricky across OSes, we also have a supertype of `OsHandle` called
`OsDirHandle` which may store a `DIR*` stream pointer (mainly BSD). Last but not
least, the `Filetype` and `Rights` are now computed when the resource is created,
rather than every time we call `Handle::get_file_type` and `Handle::get_rights`.
Finally, in order to facilitate the latter, I've converted `EntryRights` into
`HandleRights` and pushed them into each `Handle` implementor.

* Do not adjust rights on Stdio

* Clean up testing for TTY and escaping writes

* Implement AsFile for dyn Handle

This cleans up a lot of repeating boilerplate code todo with
dynamic dispatch.

* Delegate definition of OsDir to OS-specific modules

Delegates defining `OsDir` struct to OS-specific modules (BSD, Linux,
Emscripten, Windows). This way, `OsDir` can safely re-use `OsHandle`
for raw OS handle storage, and can store some aux data such as an
initialized stream ptr in case of BSD. As a result, we can safely
get rid of `OsDirHandle` which IMHO was causing unnecessary noise and
overcomplicating the design. On the other hand, delegating definition
of `OsDir` to OS-specific modules isn't super clean in and of itself
either. Perhaps there's a better way of handling this?

* Check if filetype of OS handle matches WASI filetype when creating

It seems prudent to check if the passed in `File` instance is of
type matching that of the requested WASI filetype. In other words,
we'd like to avoid situations where `OsFile` is created from a
pipe.

* Make AsFile fallible

Return `EBADF` in `AsFile` in case a `Handle` cannot be made into
a `std::fs::File`.

* Remove unnecessary as_file conversion

* Remove unnecessary check for TTY for Stdio handle type

* Fix incorrect stdio ctors on Unix

* Split Stdio into three separate types: Stdin, Stdout, Stderr

* Rename PendingEntry::File to PendingEntry::OsHandle to avoid confusion

* Rename OsHandle to RawOsHandle

Also, since `RawOsHandle` on *nix doesn't need interior mutability
wrt the inner raw file descriptor, we can safely swap the `RawFd`
for `File` instance.

* Add docs explaining what OsOther is

* Allow for stdio to be non-character-device (e.g., piped)

* Return error on bad preopen rather than panic

crates/wasi-common/src/handle.rs

@@ -1,20 +1,74 @@
-use crate::entry::EntryRights;
-use crate::wasi::{types, Errno, Result};
+use crate::wasi::types::{self, Rights};
+use crate::wasi::{Errno, Result};
 use std::any::Any;
+use std::fmt;
 use std::io::{self, SeekFrom};
 
+/// Represents rights of a `Handle`, either already held or required.
+#[derive(Debug, Copy, Clone)]
+pub(crate) struct HandleRights {
+    pub(crate) base: Rights,
+    pub(crate) inheriting: Rights,
+}
+
+impl HandleRights {
+    pub(crate) fn new(base: Rights, inheriting: Rights) -> Self {
+        Self { base, inheriting }
+    }
+
+    /// Create new `HandleRights` instance from `base` rights only, keeping
+    /// `inheriting` set to none.
+    pub(crate) fn from_base(base: Rights) -> Self {
+        Self {
+            base,
+            inheriting: Rights::empty(),
+        }
+    }
+
+    /// Create new `HandleRights` instance with both `base` and `inheriting`
+    /// rights set to none.
+    pub(crate) fn empty() -> Self {
+        Self {
+            base: Rights::empty(),
+            inheriting: Rights::empty(),
+        }
+    }
+
+    /// Check if `other` is a subset of those rights.
+    pub(crate) fn contains(&self, other: &Self) -> bool {
+        self.base.contains(&other.base) && self.inheriting.contains(&other.inheriting)
+    }
+}
+
+impl fmt::Display for HandleRights {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "HandleRights {{ base: {}, inheriting: {} }}",
+            self.base, self.inheriting
+        )
+    }
+}
+
 pub(crate) trait Handle {
     fn as_any(&self) -> &dyn Any;
     fn try_clone(&self) -> io::Result<Box<dyn Handle>>;
-    fn get_file_type(&self) -> io::Result<types::Filetype>;
-    fn get_rights(&self) -> io::Result<EntryRights> {
-        Ok(EntryRights::empty())
+    fn get_file_type(&self) -> types::Filetype;
+    fn get_rights(&self) -> HandleRights {
+        HandleRights::empty()
     }
+    fn set_rights(&self, rights: HandleRights);
     fn is_directory(&self) -> bool {
-        if let Ok(ft) = self.get_file_type() {
-            return ft == types::Filetype::Directory;
-        }
-        false
+        self.get_file_type() == types::Filetype::Directory
+    }
+    /// Test whether this descriptor is considered a tty within WASI.
+    /// Note that since WASI itself lacks an `isatty` syscall and relies
+    /// on a conservative approximation, we use the same approximation here.
+    fn is_tty(&self) -> bool {
+        let file_type = self.get_file_type();
+        let rights = self.get_rights();
+        let required_rights = HandleRights::from_base(Rights::FD_SEEK | Rights::FD_TELL);
+        file_type == types::Filetype::CharacterDevice && rights.contains(&required_rights)
     }
     // TODO perhaps should be a separate trait?
     // FdOps
@@ -73,7 +127,7 @@ pub(crate) trait Handle {
     fn sync(&self) -> Result<()> {
         Ok(())
     }
-    fn write_vectored(&self, _iovs: &[io::IoSlice], _isatty: bool) -> Result<usize> {
+    fn write_vectored(&self, _iovs: &[io::IoSlice]) -> Result<usize> {
         Err(Errno::Badf)
     }
     // TODO perhaps should be a separate trait?