Add async blocks & try blocks

In Rust 1.37, `catch`, `yield`, and `dyn` ceased to be "weak" keywords.
This simplifies the grammar a bit \o/.

`do catch { ... }` has turned into `try { ... }` and `async`-prefixed
blocks are now a thing.

Author: harpocrates

src/Language/Rust/Parser/Internal.y

@@ -171,11 +171,15 @@ import qualified Data.List.NonEmpty as N
 
   -- Strict keywords used in the language
   as             { Spanned (IdentTok "as") _ }
+  async          { Spanned (IdentTok "async") _ }
+  await          { Spanned (IdentTok "await") _ }
   box            { Spanned (IdentTok "box") _ }
   break          { Spanned (IdentTok "break") _ }
   const          { Spanned (IdentTok "const") _ }
   continue       { Spanned (IdentTok "continue") _ }
   crate          { Spanned (IdentTok "crate") _ }
+  do             { Spanned (IdentTok "do") _ }
+  dyn            { Spanned (IdentTok "dyn") _ }
   else           { Spanned (IdentTok "else") _ }
   enum           { Spanned (IdentTok "enum") _ }
   extern         { Spanned (IdentTok "extern") _ }
@@ -201,12 +205,13 @@ import qualified Data.List.NonEmpty as N
   super          { Spanned (IdentTok "super") _ }
   trait          { Spanned (IdentTok "trait") _ }
   true           { Spanned (IdentTok "true") _ }
+  try            { Spanned (IdentTok "try") _ }
   type           { Spanned (IdentTok "type") _ }
   unsafe         { Spanned (IdentTok "unsafe") _ }
   use            { Spanned (IdentTok "use") _ }
   where          { Spanned (IdentTok "where") _ }
   while          { Spanned (IdentTok "while") _ }
-  do             { Spanned (IdentTok "do") _ }
+  yield          { Spanned (IdentTok "yield") _ }
 
   -- Keywords reserved for future use
   abstract       { Spanned (IdentTok "abstract") _ }
@@ -227,10 +232,7 @@ import qualified Data.List.NonEmpty as N
   -- Weak keywords, have special meaning only in specific contexts.
   default        { Spanned (IdentTok "default") _ }
   union          { Spanned (IdentTok "union") _ }
-  catch          { Spanned (IdentTok "catch") _ }
   auto           { Spanned (IdentTok "auto") _ }
-  yield          { Spanned (IdentTok "yield") _ }
-  dyn            { Spanned (IdentTok "dyn") _ }
 
   -- Comments
   outerDoc       { Spanned (Doc _ Outer _) _ }
@@ -277,7 +279,7 @@ import qualified Data.List.NonEmpty as N
 %nonassoc mut DEF EQ '::'
 
 -- These are all identifiers of sorts ('union' and 'default' are "weak" keywords)
-%nonassoc IDENT ntIdent default union catch self Self super auto dyn crate
+%nonassoc IDENT ntIdent default union self Self super auto crate
 
 -- These are all very low precedence unary operators
 %nonassoc box return yield break continue for IMPLTRAIT LAMBDA
@@ -325,17 +327,15 @@ import qualified Data.List.NonEmpty as N
 %%
 
 -- Unwraps the IdentTok into just an Ident
--- For questionable reasons of backwards compatibility, 'union', 'default', and 'catch' can be used
+-- For questionable reasons of backwards compatibility, 'union', and 'default' can be used
 -- as identifiers, even if they are also keywords. They are "contextual" keywords.
 --
 -- Union's RFC: https://github.com/rust-lang/rfcs/blob/master/text/1444-union.md
 ident :: { Spanned Ident }
   : ntIdent                       { fmap (\(Interpolated (NtIdent i)) -> i) $1 }
   | union                         { toIdent $1 }
   | default                       { toIdent $1 }
-  | catch                         { toIdent $1 }
   | auto                          { toIdent $1 }
-  | dyn                           { toIdent $1 }
   | IDENT                         { toIdent $1 }
 
 -- This should precede any '>' token which could be absorbed in a '>>', '>=', or '>>=' token. Its
@@ -554,7 +554,7 @@ path_segments_with_colons :: { Reversed NonEmpty (PathSegment Span) }
       case (unsnoc $1, unspan $3) of
         ((rst, PathSegment i Nothing x), (lts, tys, bds)) ->
           let seg = PathSegment i (Just (AngleBracketed lts tys bds (spanOf $3))) (x # $3)
-          in pure $ snoc rst seg 
+          in pure $ snoc rst seg
         _ -> fail "invalid path segment in expression path"
     }
 
@@ -1002,7 +1002,6 @@ left_gen_expression(lhs,rhs,rhs2) :: { Expr Span }
   | lhs '...' rhs2  %prec INFIXRNG   { Range [] (Just $1) (Just $3) Closed ($1 # $>) }
   | lhs '..=' rhs2  %prec INFIXRNG   { Range [] (Just $1) (Just $3) Closed ($1 # $>) }
   -- assignment expressions
-  | lhs '<-' rhs                     { InPlace [] $1 $3 ($1 # $>) }
   | lhs '=' rhs                      { Assign [] $1 $3 ($1 # $>) }
   | lhs '>>=' rhs                    { AssignOp [] ShrOp $1 $3 ($1 # $>) }
   | lhs '<<=' rhs                    { AssignOp [] ShlOp $1 $3 ($1 # $>) }
@@ -1155,11 +1154,13 @@ block_like_expr :: { Expr Span }
   | match nostruct_expr '{'             arms '}'                 { Match [] $2 $4 ($1 # $>) }
   | match nostruct_expr '{' inner_attrs arms '}'                 { Match (toList $4) $2 $5 ($1 # $>) }
   | expr_path '!' '{' token_stream '}'                           { MacExpr [] (Mac $1 $4 ($1 # $>)) ($1 # $>) }
-  | do catch inner_attrs_block                                   { let (as,b) = $> in Catch as b ($1 # b) }
+  | try inner_attrs_block                                        { let (as,b) = $> in TryBlock as b ($1 # b) }
+  | async      inner_attrs_block                                 { let (as,b) = $> in Async as Ref b ($1 # b) }
+  | async move inner_attrs_block                                 { let (as,b) = $> in Async as Value b ($1 # b) }
 
 -- 'if' expressions are a bit special since they can have an arbitrary number of 'else if' chains.
 if_expr :: { Expr Span }
-  : if             nostruct_expr block else_expr        { If [] $2 $3 $4 ($1 # $3 # $>) }
+  : if              nostruct_expr block else_expr       { If [] $2 $3 $4 ($1 # $3 # $>) }
   | if let pats '=' nostruct_expr block else_expr       { IfLet [] $3 $5 $6 $7 ($1 # $6 # $>) }
 
 else_expr :: { Maybe (Expr Span) }
@@ -1631,6 +1632,7 @@ token :: { Spanned Token }
   | const      { $1 }
   | continue   { $1 }
   | crate      { $1 }
+  | dyn        { $1 }
   | else       { $1 }
   | enum       { $1 }
   | extern     { $1 }
@@ -1656,11 +1658,13 @@ token :: { Spanned Token }
   | super      { $1 }
   | trait      { $1 }
   | true       { $1 }
+  | try        { $1 }
   | type       { $1 }
   | unsafe     { $1 }
   | use        { $1 }
   | where      { $1 }
   | while      { $1 }
+  | yield      { $1 }
   -- Keywords reserved for future use
   | abstract   { $1 }
   | alignof    { $1 }
@@ -1680,10 +1684,7 @@ token :: { Spanned Token }
   -- Weak keywords, have special meaning only in specific contexts.
   | default    { $1 }
   | union      { $1 }
-  | catch      { $1 }
   | auto       { $1 }
-  | yield      { $1 }
-  | dyn        { $1 }
   -- Comments
   | outerDoc   { $1 }
   | innerDoc   { $1 }
@@ -1808,7 +1809,7 @@ expParseError (Spanned t _, exps) = fail $ "Syntax error: unexpected `" ++ show
          words "'||' '&&' '<<' '(' '[' '{' box break continue" ++
          words "for if loop match move return Self self      " ++
          words "static super unsafe while do default union   " ++
-         words "catch auto yield dyn"
+         words "auto yield try async"
 
   lit = boolLit ++ byteLit ++ charLit ++ intLit ++ floatLit ++ strLit ++
         byteStrLit ++ rawStrLit ++ rawByteStrLit
@@ -1862,7 +1863,6 @@ macroItem as i mac x = MacItem as i mac x
 -- | Add attributes to an expression
 addAttrs :: [Attribute Span] -> Expr Span -> Expr Span
 addAttrs as (Box as' e s)            = Box (as ++ as') e s
-addAttrs as (InPlace as' e1 e2 s)    = InPlace (as ++ as') e1 e2 s
 addAttrs as (Vec as' e s)            = Vec (as ++ as') e s
 addAttrs as (Call as' f es s)        = Call (as ++ as') f es s
 addAttrs as (MethodCall as' i s tys es s') = MethodCall (as ++ as') i s tys es s'
@@ -1881,7 +1881,8 @@ addAttrs as (Loop as' b l s)         = Loop (as ++ as') b l s
 addAttrs as (Match as' e a s)        = Match (as ++ as') e a s
 addAttrs as (Closure as' m c f e s)  = Closure (as ++ as') m c f e s
 addAttrs as (BlockExpr as' b s)      = BlockExpr (as ++ as') b s
-addAttrs as (Catch as' b s)          = Catch (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 (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

@@ -362,7 +362,6 @@ printExprOuterAttrStyle :: Expr a -> Bool -> Doc a
 printExprOuterAttrStyle expr isInline = glue (printEitherAttrs (expressionAttrs expr) Outer isInline) $
   case expr of
     Box _ e x                   -> annotate x ("box" <+> printExpr e)
-    InPlace _ place e x         -> annotate x (hsep [ printExpr place, "<-", printExpr e ])
     Vec as exprs x              -> annotate x (block Bracket True "," (printInnerAttrs as) (printExpr <$> exprs))
     Call _ func [arg] x         -> annotate x (printExpr func <> parens (printExpr arg))
     Call _ func args x          -> annotate x (printExpr func <> block Paren True "," mempty (printExpr <$> args))
@@ -386,7 +385,10 @@ printExprOuterAttrStyle expr isInline = glue (printEitherAttrs (expressionAttrs
                                                     , when (cap == Value) "move"
                                                     , printFnBlockArgs decl <+> printExpr body])
     BlockExpr attrs blk x       -> annotate x (printBlockWithAttrs True blk attrs)
-    Catch attrs blk x           -> annotate x ("do catch" <+> printBlockWithAttrs True blk attrs)
+    TryBlock attrs blk x        -> annotate x ("try" <+> printBlockWithAttrs True blk attrs)
+    Async attrs cap blk x       -> annotate x (hsep [ "async"
+                                                    , when (cap == Value) "move"
+                                                    , printBlockWithAttrs True blk attrs])
     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
@@ -452,7 +454,6 @@ printStr sty str = unAnnotate (printLit (Str str sty Unsuffixed ()))
 -- | Extract from an expression its attributes
 expressionAttrs :: Expr a -> [Attribute a]
 expressionAttrs (Box as _ _) = as
-expressionAttrs (InPlace as _  _ _) = as
 expressionAttrs (Vec as _ _) = as
 expressionAttrs (Call as _  _ _) = as
 expressionAttrs (MethodCall as _ _  _ _ _) = as
@@ -471,7 +472,8 @@ expressionAttrs (Loop as _ _ _) = as
 expressionAttrs (Match as _ _ _) = as
 expressionAttrs (Closure as _ _ _ _ _) = as
 expressionAttrs (BlockExpr as _ _) = as
-expressionAttrs (Catch as _ _) = as
+expressionAttrs (TryBlock as _ _) = as
+expressionAttrs (Async as _ _ _) = as
 expressionAttrs (Assign as _ _ _) = as
 expressionAttrs (AssignOp as _ _ _ _) = as
 expressionAttrs (FieldAccess as _ _ _) = as

src/Language/Rust/Pretty/Resolve.hs

@@ -800,12 +800,6 @@ resolveExprP p c a@(AssignOp as o l r x) = scope a $ parenE (p > 1) $ do
   l' <- resolveLhsExprP 2 c l
   r' <- resolveExprP 1 (rhs c) r
   pure (AssignOp as' o l' r' x)
-resolveExprP p c i@(InPlace as l r x) = scope i $ parenE (p > 2) $ do
-  as' <- traverse (resolveAttr OuterAttr) as
-  --l' <- resolveExprP 3 (lhs c) l 
-  l' <- resolveLhsExprP 3 c l
-  r' <- resolveExprP 2 (rhs c) r 
-  pure (InPlace as' l' r' x)
 -- Range expressions
 resolveExprP _ _ r@(Range _ _ Nothing Closed _) = scope r (err r "inclusive ranges must be bounded at the end")
 resolveExprP _ _ r@(Range as Nothing Nothing rl x) = scope r $ do
@@ -1034,10 +1028,14 @@ resolveExprP _ _ m@(Match as e ar x) = scope m $ do
   e' <- resolveExprP 0 AnyExpr e
   ar' <- traverse resolveArm ar
   pure (Match as' e' ar' x)
-resolveExprP _ _ c@(Catch as b x) = scope c $ do
+resolveExprP _ _ c@(TryBlock as b x) = scope c $ do
+  as' <- traverse (resolveAttr EitherAttr) as
+  b' <- resolveBlock b
+  pure (TryBlock as' b' x)
+resolveExprP _ _ c@(Async as c' b x) = scope c $ do
   as' <- traverse (resolveAttr EitherAttr) as
   b' <- resolveBlock b
-  pure (Catch as' b' x) 
+  pure (Async as' c' b' x)
 
 isBlockLike :: Expr a -> Bool
 isBlockLike If{} = True

src/Language/Rust/Syntax/AST.hs

@@ -154,7 +154,7 @@ data Abi
 -- trait Foo {
 --   // Regular argument
 --   fn new(x: usize) -> Foo;
---   
+--
 --   // Self argument, by value
 --   fn foo(self) -> i32;
 --   fn bar(mut self);
@@ -252,7 +252,7 @@ data BinOp
   deriving (Eq, Ord, Enum, Bounded, Show, Typeable, Data, Generic, NFData)
 
 -- | Describes how a value bound to an identifier in a pattern is going to be borrowed
--- (@syntax::ast::BindingMode@). 
+-- (@syntax::ast::BindingMode@).
 --
 -- Example: @&mut@ in @|&mut x: i32| -> { x += 1 }@
 data BindingMode
@@ -268,7 +268,7 @@ data Block a = Block [Stmt a] Unsafety a
   deriving (Eq, Ord, Show, Functor, Typeable, Data, Generic, Generic1, NFData)
 
 instance Located a => Located (Block a) where spanOf (Block _ _ s) = spanOf s
- 
+
 -- | Describes how a 'Closure' should close over its free variables (@syntax::ast::CaptureBy@).
 data CaptureBy
   = Value -- ^ make copies of free variables closed over (@move@ closures)
@@ -277,21 +277,19 @@ data CaptureBy
 
 -- | Const annotation to specify if a function or method is allowed to be called in constants
 -- context with constant arguments (@syntax::ast::Constness@). [Relevant
--- RFC](https://github.com/rust-lang/rfcs/blob/master/text/0911-const-fn.md) 
+-- RFC](https://github.com/rust-lang/rfcs/blob/master/text/0911-const-fn.md)
 --
 -- Example: @const@ in @const fn inc(x: i32) -> i32 { x + 1 }@
 data Constness = Const | NotConst deriving (Eq, Ord, Enum, Bounded, Show, Typeable, Data, Generic, NFData)
 
--- | An 'ImplItem' can be marked @default@ (@syntax::ast::Defaultness@).  
+-- | An 'ImplItem' can be marked @default@ (@syntax::ast::Defaultness@).
 data Defaultness = Default | Final deriving (Eq, Ord, Enum, Bounded, Show, Typeable, Data, Generic, NFData)
 
 -- | Expression (@syntax::ast::Expr@). Note that Rust pushes into expressions an unusual number
 -- of constructs including @if@, @while@, @match@, etc.
 data Expr a
   -- | box expression (example:  @box x@)
   = Box [Attribute a] (Expr a) a
-  -- | in-place expression - first 'Expr' is the place, second one is the value (example: @x <- y@)
-  | InPlace [Attribute a] (Expr a) (Expr a) a
   -- | array literal (example: @[a, b, c, d]@)
   | Vec [Attribute a] [Expr a] a
   -- | function call where the first 'Expr' is the function itself, and the @['Expr']@ is the list of
@@ -311,7 +309,7 @@ data Expr a
   | Lit [Attribute a] (Lit a) a
   -- | cast (example: @foo as f64@)
   | Cast [Attribute a] (Expr a) (Ty a) a
-  -- | type annotation (example: @x: i32@) 
+  -- | type annotation (example: @x: i32@)
   | TypeAscription [Attribute a] (Expr a) (Ty a) a
   -- | if expression, with an optional @else@ block. In the case the @else@ block is missing, the
   -- type of the @if@ is inferred to be @()@. (example: @if 1 == 2 { (1,1) } else { (2,2) }@
@@ -332,8 +330,10 @@ data Expr a
   | Closure [Attribute a] Movability CaptureBy (FnDecl a) (Expr a) a
   -- | (possibly unsafe) block (example: @unsafe { 1 }@)
   | BlockExpr [Attribute a] (Block a) a
-  -- | a catch block (example: @do catch { 1 }@)
-  | Catch [Attribute a] (Block a) a
+  -- | a try block (example: @try { 1 }@)
+  | TryBlock [Attribute a] (Block a) a
+  -- | an async block (example: @async move { 1 }@)
+  | Async [Attribute a] CaptureBy (Block a) a
   -- | assignment (example: @a = foo()@)
   | Assign [Attribute a] (Expr a) (Expr a) a
   -- | assignment with an operator (example: @a += 1@)
@@ -346,12 +346,12 @@ data Expr a
   | Index [Attribute a] (Expr a) (Expr a) a
   -- | range (examples: @1..2@, @1..@, @..2@, @1...2@, @1...@, @...2@)
   | Range [Attribute a] (Maybe (Expr a)) (Maybe (Expr a)) RangeLimits a
-  -- | variable reference 
+  -- | variable reference
   | PathExpr [Attribute a] (Maybe (QSelf a)) (Path a) a
   -- | referencing operation (example: @&a or &mut a@)
   | AddrOf [Attribute a] Mutability (Expr a) a
   -- | @break@ with an optional label and expression denoting what to break out of and what to
-  -- return (example: @break 'lbl 1@) 
+  -- return (example: @break 'lbl 1@)
   | Break [Attribute a] (Maybe (Label a)) (Maybe (Expr a)) a
   -- | @continue@ with an optional label (example: @continue@)
   | Continue [Attribute a] (Maybe (Label a)) a
@@ -373,7 +373,6 @@ data Expr a
 
 instance Located a => Located (Expr a) where
   spanOf (Box _ _ s) = spanOf s
-  spanOf (InPlace _ _ _ s) = spanOf s
   spanOf (Vec _ _ s) = spanOf s
   spanOf (Call _ _ _ s) = spanOf s
   spanOf (MethodCall _ _ _ _ _ s) = spanOf s
@@ -392,7 +391,8 @@ instance Located a => Located (Expr a) where
   spanOf (Match _ _ _ s) = spanOf s
   spanOf (Closure _ _ _ _ _ s) = spanOf s
   spanOf (BlockExpr _ _ s) = spanOf s
-  spanOf (Catch _ _ s) = spanOf s
+  spanOf (TryBlock _ _ s) = spanOf s
+  spanOf (Async _ _ _ s) = spanOf s
   spanOf (Assign _ _ _ s) = spanOf s
   spanOf (AssignOp _ _ _ _ s) = spanOf s
   spanOf (FieldAccess _ _ _ s) = spanOf s
@@ -705,11 +705,11 @@ byteStr s = ByteStr (map (fromIntegral . ord) s)
 suffix :: Lit a -> Suffix
 suffix (Str _ _ s _) = s
 suffix (ByteStr _ _ s _) = s
-suffix (Char _ s _) = s 
-suffix (Byte _ s _) = s 
-suffix (Int _ _ s _) = s 
+suffix (Char _ s _) = s
+suffix (Byte _ s _) = s
+suffix (Int _ _ s _) = s
 suffix (Float _ s _) = s
-suffix (Bool _ s _) = s 
+suffix (Bool _ s _) = s
 
 -- | The base of the number in an @Int@ literal can be binary (e.g. @0b1100@), octal (e.g. @0o14@),
 -- decimal (e.g. @12@), or hexadecimal (e.g. @0xc@).