API, Rustc: Add AwaitExpr and support async blocks and fns

marker_api/src/ast/expr.rs

@@ -82,6 +82,7 @@ pub enum ExprKind<'ast> {
     For(&'ast ForExpr<'ast>),
     Loop(&'ast LoopExpr<'ast>),
     While(&'ast WhileExpr<'ast>),
+    Await(&'ast AwaitExpr<'ast>),
     Unstable(&'ast UnstableExpr<'ast>),
 }
 
@@ -163,6 +164,7 @@ pub enum ExprPrecedence {
     For = 0x1400_0004,
     Loop = 0x1400_0005,
     While = 0x1400_0006,
+    Await = 0x1400_0007,
 
     Path = 0x1300_0000,
 
@@ -252,6 +254,7 @@ macro_rules! impl_expr_kind_fn {
             Call, Method,
             Array, Tuple, Ctor, Range,
             If, Let, Match, Break, Return, Continue, For, Loop, While,
+            Await,
             Unstable
         );
     };
@@ -376,7 +379,7 @@ mod test {
         assert_eq!(48, size_of::<StrLitExpr<'_>>(), "StrLitExpr<'_>");
         assert_eq!(24, size_of::<CharLitExpr<'_>>(), "CharLitExpr<'_>");
         assert_eq!(24, size_of::<BoolLitExpr<'_>>(), "BoolLitExpr<'_>");
-        assert_eq!(88, size_of::<BlockExpr<'_>>(), "BlockExpr<'_>");
+        assert_eq!(96, size_of::<BlockExpr<'_>>(), "BlockExpr<'_>");
         assert_eq!(72, size_of::<ClosureExpr<'_>>(), "ClosureExpr<'_>");
         assert_eq!(40, size_of::<UnaryOpExpr<'_>>(), "UnaryOpExpr<'_>");
         assert_eq!(40, size_of::<RefExpr<'_>>(), "RefExpr<'_>");

marker_api/src/ast/expr/block_expr.rs

@@ -1,5 +1,5 @@
 use crate::{
-    ast::{pat::PatKind, stmt::StmtKind, ty::SynTyKind, BodyId, Ident, Span, SpanId},
+    ast::{pat::PatKind, stmt::StmtKind, ty::SynTyKind, BodyId, Ident, Safety, Span, SpanId, Syncness},
     context::with_cx,
     ffi::{FfiOption, FfiSlice},
 };
@@ -23,6 +23,9 @@ use super::{CommonExprData, ExprKind};
 ///
 /// //      vvvvvv An optional label to be targeted by break expressions
 /// let _ = 'label: {
+///     let _ = 18;
+/// //  ^^^^^^^^^^^
+/// // A statement in the block
 ///     12
 /// };
 /// ```
@@ -31,14 +34,19 @@ use super::{CommonExprData, ExprKind};
 /// expression at the end of a block is called *block expression*. The meaning
 /// depends on the context. Marker's documentation will try to make the meaning
 /// clear by linking directly to the [`BlockExpr`] struct or calling it a *block*.
+///
+/// This expression also represents async blocks, the internal desugar used by
+/// rustc is resugared for this.
 #[repr(C)]
 #[derive(Debug)]
 pub struct BlockExpr<'ast> {
     data: CommonExprData<'ast>,
     stmts: FfiSlice<'ast, StmtKind<'ast>>,
     expr: FfiOption<ExprKind<'ast>>,
     label: FfiOption<Ident<'ast>>,
-    is_unsafe: bool,
+    safety: Safety,
+    syncness: Syncness,
+    capture_kind: CaptureKind,
 }
 
 impl<'ast> BlockExpr<'ast> {
@@ -58,8 +66,31 @@ impl<'ast> BlockExpr<'ast> {
         self.label.get()
     }
 
-    pub fn is_unsafe(&self) -> bool {
-        self.is_unsafe
+    pub fn safety(&self) -> Safety {
+        self.safety
+    }
+
+    pub fn syncness(&self) -> Syncness {
+        self.syncness
+    }
+
+    /// The capture kind of this block. For normal blocks, this will always be
+    /// [`CaptureKind::Default`], which in this context means no capture at all.
+    /// Async blocks are special, as they can capture values by move, indicated
+    /// by the `move` keyword, like in this:
+    ///
+    /// ```
+    /// # use std::future::Future;
+    /// # fn foo<'a>(x: &'a u8) -> impl Future<Output = u8> + 'a {
+    /// // The whole block expression
+    /// //  vvvvvvvvvvvvvvvvv
+    ///     async move { *x }
+    /// //        ^^^^
+    /// // The move keyword defining the capture kind
+    /// # }
+    /// ```
+    pub fn capture_kind(&self) -> CaptureKind {
+        self.capture_kind
     }
 }
 
@@ -72,14 +103,18 @@ impl<'ast> BlockExpr<'ast> {
         stmts: &'ast [StmtKind<'ast>],
         expr: Option<ExprKind<'ast>>,
         label: Option<Ident<'ast>>,
-        is_unsafe: bool,
+        safety: Safety,
+        syncness: Syncness,
+        capture_kind: CaptureKind,
     ) -> Self {
         Self {
             data,
             stmts: stmts.into(),
             expr: expr.into(),
             label: label.into(),
-            is_unsafe,
+            safety,
+            syncness,
+            capture_kind,
         }
     }
 }

marker_api/src/ast/expr/op_exprs.rs

@@ -302,3 +302,44 @@ impl<'ast> AssignExpr<'ast> {
         }
     }
 }
+
+/// An `.await` expression on a future, like:
+///
+/// ```
+/// # async fn foo() -> u8 {
+/// #     16
+/// # }
+/// # async fn wrapper() {
+/// // The await expression
+/// //  vvvvvvvvvvv
+///     foo().await;
+/// //  ^^^^^
+/// // The future, that will be awaited
+/// # }
+/// ```
+///
+/// Marker specificity hides the desugar of `.await` expressions. The [Rust Reference]
+/// contains more information how rustc desugars `.await` expressions.
+///
+/// [Rust Reference]: <https://doc.rust-lang.org/reference/expressions/await-expr.html>
+#[repr(C)]
+#[derive(Debug)]
+pub struct AwaitExpr<'ast> {
+    data: CommonExprData<'ast>,
+    expr: ExprKind<'ast>,
+}
+
+impl<'ast> AwaitExpr<'ast> {
+    pub fn expr(&self) -> ExprKind<'ast> {
+        self.expr
+    }
+}
+
+super::impl_expr_data!(AwaitExpr<'ast>, Await);
+
+#[cfg(feature = "driver-api")]
+impl<'ast> AwaitExpr<'ast> {
+    pub fn new(data: CommonExprData<'ast>, expr: ExprKind<'ast>) -> Self {
+        Self { data, expr }
+    }
+}

marker_api/src/ast/item/fn_item.rs

@@ -24,8 +24,20 @@ use super::CommonItemData;
 ///     // A function without a body
 ///     fn baz(_: i32);
 /// }
+///
+/// // An async function.
+/// async fn foo_async() -> u8 {
+///     // ...
+///     # 16
+/// }
 /// ```
 ///
+/// Async functions in Rustc actually return a future with the defined output type.
+/// The return type `-> u8` gets desugared to `impl Future<Output = u8>`. Marker will
+/// resugar the type to what the user had originally written. In this case it would
+/// just return `u8`. The semantic return type of an async function can be retrieved
+/// from the expression of the [`Body`][super::Body].
+///
 /// See: <https://doc.rust-lang.org/reference/items/functions.html>
 #[repr(C)]
 #[derive(Debug)]

marker_api/src/prelude.rs

@@ -11,6 +11,10 @@ pub use crate::ast::ty::SynTyData;
 // Common types
 pub use crate::ast::expr::ExprKind;
 pub use crate::ast::item::ItemKind;
+pub use crate::ast::pat::PatKind;
+pub use crate::ast::stmt::StmtKind;
+pub use crate::ast::ty::SemTyKind;
+pub use crate::ast::ty::SynTyKind;
 pub use crate::ast::Ident;
 pub use crate::ast::Span;
 pub use crate::AstContext;

marker_rustc_driver/src/conversion/marker.rs

@@ -204,6 +204,26 @@ impl<'ast, 'tcx> MarkerConverterInner<'ast, 'tcx> {
     {
         self.storage.alloc_slice(iter)
     }
+
+    pub fn with_body<U, F>(&self, rustc_body_id: hir::BodyId, f: F) -> U
+    where
+        F: FnOnce() -> U,
+    {
+        // Body-Translation-Stack push
+        let prev_rustc_body_id = self.rustc_body.replace(Some(rustc_body_id));
+        let prev_rustc_ty_check = self.rustc_ty_check.take();
+        self.fill_rustc_ty_check();
+
+        // Operation
+        let res = f();
+
+        // Body-Translation-Stack pop
+        self.rustc_body.replace(prev_rustc_body_id);
+        self.rustc_ty_check.replace(prev_rustc_ty_check);
+
+        // Return result
+        res
+    }
 }
 
 impl<'ast, 'tcx> MarkerConverterInner<'ast, 'tcx> {
@@ -219,20 +239,3 @@ impl<'ast, 'tcx> MarkerConverterInner<'ast, 'tcx> {
         ))
     }
 }
-
-macro_rules! with_body {
-    ($cx:expr, $id:expr, $with:expr) => {
-        // Body-Translation-Stack push
-        let prev_rustc_body_id = $cx.rustc_body.replace(Some($id));
-        let prev_rustc_ty_check = $cx.rustc_ty_check.take();
-        $cx.fill_rustc_ty_check();
-
-        // Operation
-        $with
-
-        // Body-Translation-Stack pop
-        $cx.rustc_body.replace(prev_rustc_body_id);
-        $cx.rustc_ty_check.replace(prev_rustc_ty_check);
-    };
-}
-use with_body;