Add support for .await

This uses the new `await` keyword.

Author: harpocrates

src/Language/Rust/Parser/Internal.y

@@ -1029,6 +1029,7 @@ left_gen_expression(lhs,rhs,rhs2) :: { Expr Span }
 --
 postfix_blockexpr(lhs) :: { Expr Span }
   : lhs '?'                          { Try [] $1 ($1 # $>) }
+  | lhs '.' await                    { Await [] $1 ($1 # $>) }
   | lhs '.' ident       %prec FIELD  { FieldAccess [] $1 (unspan $3) ($1 # $>) }
   | lhs '.' ident '(' sep_byT(expr,',') ')'
     { MethodCall [] $1 (unspan $3) Nothing $5 ($1 # $>) }
@@ -1040,44 +1041,6 @@ postfix_blockexpr(lhs) :: { Expr Span }
         _ -> parseError $3
     }
 
--- Postfix expressions that can come after an expression block, in a 'stmt'
---
---  * `{ 1 }[0]` isn't here because it is treated as `{ 1 }; [0]`
---  * `{ 1 }(0)` isn't here because it is treated as `{ 1 }; (0)`
---
-postfix_blockexpr(lhs) :: { Expr Span }
-  : lhs '?'                          { Try [] $1 ($1 # $>) }
-  | lhs '.' ident       %prec FIELD  { FieldAccess [] $1 (unspan $3) ($1 # $>) }
-  | lhs '.' ident '(' sep_byT(expr,',') ')'
-    { MethodCall [] $1 (unspan $3) Nothing $5 ($1 # $>) }
-  | lhs '.' ident '::' '<' sep_byT(ty,',') '>' '(' sep_byT(expr,',') ')'
-    { MethodCall [] $1 (unspan $3) (Just $6) $9 ($1 # $>) }
-  | lhs '.' int                      {%
-      case lit $3 of
-        Int Dec i Unsuffixed _ -> pure (TupField [] $1 (fromIntegral i) ($1 # $3))
-        _ -> parseError $3
-    }
-
--- Postfix expressions that can come after an expression block, in a 'stmt'
---
---  * `{ 1 }[0]` isn't here because it is treated as `{ 1 }; [0]`
---  * `{ 1 }(0)` isn't here because it is treated as `{ 1 }; (0)`
---
-postfix_blockexpr(lhs) :: { Expr Span }
-  : lhs '?'                          { Try [] $1 ($1 # $>) }
-  | lhs '.' ident       %prec FIELD  { FieldAccess [] $1 (unspan $3) ($1 # $>) }
-  | lhs '.' ident '(' sep_byT(expr,',') ')'
-    { MethodCall [] $1 (unspan $3) Nothing $5 ($1 # $>) }
-  | lhs '.' ident '::' '<' sep_byT(ty,',') '>' '(' sep_byT(expr,',') ')'
-    { MethodCall [] $1 (unspan $3) (Just $6) $9 ($1 # $>) }
-  | lhs '.' int                      {%
-      case lit $3 of
-        Int Dec i Unsuffixed _ -> pure (TupField [] $1 (fromIntegral i) ($1 # $3))
-        _ -> parseError $3
-    }
-
-
-
 -- Then, we instantiate this general production into the following families of rules:
 --
 --   ['expr']               Most general class of expressions, no restrictions
@@ -1899,6 +1862,7 @@ addAttrs as (Closure as' c a m f e s) = Closure (as ++ as') c a m f e s
 addAttrs as (BlockExpr as' b s)      = BlockExpr (as ++ as') b s
 addAttrs as (TryBlock as' b s)       = TryBlock (as ++ as') b s
 addAttrs as (Async as' c b s)        = Async (as ++ as') c b s
+addAttrs as (Await as' e s)          = Await (as ++ as') e s
 addAttrs as (Assign as' e1 e2 s)     = Assign (as ++ as') e1 e2 s
 addAttrs as (AssignOp as' b e1 e2 s) = AssignOp (as ++ as') b e1 e2 s
 addAttrs as (FieldAccess as' e i s)  = FieldAccess (as ++ as') e i s

src/Language/Rust/Pretty/Internal.hs

@@ -390,6 +390,7 @@ printExprOuterAttrStyle expr isInline = glue (printEitherAttrs (expressionAttrs
     Async attrs cap blk x       -> annotate x (hsep [ "async"
                                                     , when (cap == Value) "move"
                                                     , printBlockWithAttrs True blk attrs])
+    Await{}                     -> chainedMethodCalls expr False id
     Assign _ lhs rhs x          -> annotate x (hsep [ printExpr lhs, "=", printExpr rhs ])
     AssignOp _ op lhs rhs x     -> annotate x (hsep [ printExpr lhs, printBinOp op <> "=", printExpr rhs ])
     FieldAccess{}               -> chainedMethodCalls expr False id
@@ -442,6 +443,8 @@ printExprOuterAttrStyle expr isInline = glue (printEitherAttrs (expressionAttrs
     = chainedMethodCalls s False (annotate x . (<##> fdoc (indent n (hcat [ ".", printIdent i ]))))
   chainedMethodCalls (Try _ s x) _ fdoc
     = chainedMethodCalls s False (annotate x . (<> fdoc "?"))
+  chainedMethodCalls (Await _ s x) _ fdoc
+    = chainedMethodCalls s False (annotate x . (<##> fdoc (indent n (hcat [ ".", "await" ]))))
   chainedMethodCalls (Index _ s i x) _ fdoc
     = chainedMethodCalls s False (annotate x . (<> fdoc ("[" <> block NoDelim True mempty mempty [printExpr i] <> "]")))
   chainedMethodCalls (TupField _ s i x) t fdoc
@@ -475,6 +478,7 @@ expressionAttrs (Closure as _ _ _ _ _ _) = as
 expressionAttrs (BlockExpr as _ _) = as
 expressionAttrs (TryBlock as _ _) = as
 expressionAttrs (Async as _ _ _) = as
+expressionAttrs (Await as _ _) = as
 expressionAttrs (Assign as _ _ _) = as
 expressionAttrs (AssignOp as _ _ _ _) = as
 expressionAttrs (FieldAccess as _ _ _) = as

src/Language/Rust/Pretty/Resolve.hs

@@ -667,6 +667,7 @@ resolveLhsExprP p SemiExpr l@Try{}         = resolveExprP p AnyExpr l
 resolveLhsExprP p SemiExpr l@FieldAccess{} = resolveExprP p AnyExpr l 
 resolveLhsExprP p SemiExpr l@MethodCall{}  = resolveExprP p AnyExpr l
 resolveLhsExprP p SemiExpr l@TupField{}    = resolveExprP p AnyExpr l
+resolveLhsExprP p SemiExpr l@Await{}       = resolveExprP p AnyExpr l
 resolveLhsExprP _ SemiExpr l | isBlockLike l = parenthesize l
 resolveLhsExprP p t l = resolveExprP p (lhs t) l
   where
@@ -914,11 +915,17 @@ resolveExprP p c f@(FieldAccess as e i x) = scope f $ parenE (p > 17) $ do
   e' <- resolveLhsExprP 17 c e
   i' <- resolveIdent i
   pure (FieldAccess as' e' i' x)
+resolveExprP p SemiExpr a@Await{} = resolveExprP p AnyExpr a
+resolveExprP p c a@(Await as e x) = scope a $ parenE (p > 17) $ do
+  as' <- traverse (resolveAttr OuterAttr) as
+  --e' <- resolveExprP 17 (lhs c) e
+  e' <- resolveLhsExprP 17 c e
+  pure (Await as' e' x)
 -- Immediate expressions
 resolveExprP _ _ v@(Vec as es x) = scope v $ do
   as' <- traverse (resolveAttr EitherAttr) as
   es' <- traverse (resolveExprP 0 AnyExpr) es
-  pure (Vec as' es' x) 
+  pure (Vec as' es' x)
 resolveExprP _ _ p@(PathExpr as Nothing p' x) = scope p $ do
   as' <- traverse (resolveAttr OuterAttr) as
   p'' <- resolvePath ExprPath p'

src/Language/Rust/Syntax/AST.hs

@@ -335,6 +335,8 @@ data Expr a
   | TryBlock [Attribute a] (Block a) a
   -- | an async block (example: @async move { 1 }@)
   | Async [Attribute a] CaptureBy (Block a) a
+  -- | an await expression (example: @foo(1,2,3).await@)
+  | Await [Attribute a] (Expr a) a
   -- | assignment (example: @a = foo()@)
   | Assign [Attribute a] (Expr a) (Expr a) a
   -- | assignment with an operator (example: @a += 1@)
@@ -394,6 +396,7 @@ instance Located a => Located (Expr a) where
   spanOf (BlockExpr _ _ s) = spanOf s
   spanOf (TryBlock _ _ s) = spanOf s
   spanOf (Async _ _ _ s) = spanOf s
+  spanOf (Await _ _ s) = spanOf s
   spanOf (Assign _ _ _ s) = spanOf s
   spanOf (AssignOp _ _ _ _ s) = spanOf s
   spanOf (FieldAccess _ _ _ s) = spanOf s

test/rustc-tests/Diff.hs

@@ -916,6 +916,7 @@ instance Show a => Diffable (Expr a) where
         NullList as === (val ! "attrs" ! "_field0")
         e === (n ! "fields" ! 0)
       ("Async", Async as c e _) -> error "TODO"
+      ("Await", Await as e _) -> error "TODO"
       _ -> diff "differing expressions:" ex val
     where
     n = val ! "node"

test/unit-tests/ParserTest.hs

@@ -603,6 +603,7 @@ parserExpressions = testGroup "parsing expressions"
   , testP ".." (Range [] Nothing Nothing HalfOpen ())
   , testP "x?" (Try [] (PathExpr [] Nothing x ()) ())
   , testP "x.0" (TupField [] (PathExpr [] Nothing x ()) 0 ())
+  , testP "x.await" (Await [] (PathExpr [] Nothing x ()) ())
   , testP "x.foo" (FieldAccess [] (PathExpr [] Nothing x ()) "foo" ())
   , testP "x.foo()" (MethodCall [] (PathExpr [] Nothing x ()) "foo" Nothing [] ())
   , testP "x.foo(1)" (MethodCall [] (PathExpr [] Nothing x ()) "foo" Nothing [Lit [] (Int Dec 1 Unsuffixed ()) ()] ())

test/unit-tests/PrettyTest.hs

@@ -333,6 +333,7 @@ prettyExpressions = testGroup "printing expressions"
   , testFlatten "foo = 1" (printExpr (Assign [] foo _1 ()))
   , testFlatten "foo += 1" (printExpr (AssignOp [] AddOp foo _1 ()))
   , testFlatten "foo <<= 1" (printExpr (AssignOp [] ShlOp foo _1 ()))
+  , testFlatten "foo.await" (printExpr (Await [] foo ()))
   , testFlatten "foo.bar" (printExpr (FieldAccess [] foo (mkIdent "bar") ()))
   , testFlatten "foo.1" (printExpr (TupField [] foo 1 ()))
   , testFlatten "foo[1]" (printExpr (Index [] foo _1 ()))