Add support for delay to signal intention to leave awaitables un-awaited

Summary:
Add `delay` keyword that signals intentions to leave an awaitable unawaited (typically an anti-pattern, but valid in certain cases). Similar to `await`, `delay` is only permitted in async functions, and its operand must be an Awaitable<T>. Unlike await, which unwraps to T, delay preserves the Awaitable<T> type and is a runtime no-op.

This change doesn't impose any restrictions on unawaited awaitables without `delay`, yet. Will build on top of this to typecheck unawaited awaitables (D93179385) after addressing rollout concerns.

TODO: RFC: I still need to add a check that `delay` is only used in assignment (e.g. `$x = delay foo()`, and not `foo(delay $bar)`. The latter isn't dangerous, but it is useless. Should I add an explicit check for this, or just let it be innocuous?

Reviewed By: vassilmladenov

Differential Revision: D93162973

fbshipit-source-id: 6424b937b1f41954863c04a2e4c96b0740461039

Author: jtwarren

hphp/hack/src/annotated_ast/aast_defs.ml

@@ -588,6 +588,11 @@ and ('ex, 'en) expr_ =
       (** Await expression.
        *
        *     await $foo *)
+  | Delay of ('ex, 'en) expr
+      (** Delay expression. Runtime no-op that signals intent not to immediately
+       * await an awaitable.
+       *
+       *     delay $foo *)
   | ReadonlyExpr of ('ex, 'en) expr
       (** Readonly expression.
        *

hphp/hack/src/annotated_ast/aast_utils.ml

@@ -46,6 +46,7 @@ let rec can_be_captured = function
   | Yield _
   | Clone _
   | Await _
+  | Delay _
   | ReadonlyExpr _
   | Cast _
   | Unop _
@@ -166,6 +167,7 @@ let rec is_const_expr (_, _, expr_) =
   | Call _
   | New _
   | Await _
+  | Delay _
   | Assign _
   | ExpressionTree _
   | ET_Splice _

hphp/hack/src/decl/direct_decl_smart_constructors.rs

@@ -1472,14 +1472,15 @@ impl<'o, 't> DirectDeclSmartConstructors<'o, 't> {
                         Unop(box (_, expr)) => expr_to_ty(expr),
                         Hole(box (expr, _, _, _)) => expr_to_ty(expr),
 
-                        ArrayGet(_) | As(_) | Await(_) | Binop(_) | Assign(_) | Call(_)
-                        | Cast(_) | ClassConst(_) | ClassGet(_) | Clone(_) | Collection(_)
-                        | Dollardollar(_) | Efun(_) | Eif(_) | EnumClassLabel(_) | ETSplice(_)
-                        | ExpressionTree(_) | FunctionPointer(_) | Id(_) | Import(_) | Is(_)
-                        | KeyValCollection(_) | Lfun(_) | List(_) | Lplaceholder(_) | Lvar(_)
-                        | MethodCaller(_) | New(_) | ObjGet(_) | Omitted | Pair(_) | Pipe(_)
-                        | ReadonlyExpr(_) | Shape(_) | Tuple(_) | Upcast(_) | ValCollection(_)
-                        | Xml(_) | Yield(_) | Invalid(_) | Package(_) | Nameof(_) => None,
+                        ArrayGet(_) | As(_) | Await(_) | Delay(_) | Binop(_) | Assign(_)
+                        | Call(_) | Cast(_) | ClassConst(_) | ClassGet(_) | Clone(_)
+                        | Collection(_) | Dollardollar(_) | Efun(_) | Eif(_)
+                        | EnumClassLabel(_) | ETSplice(_) | ExpressionTree(_)
+                        | FunctionPointer(_) | Id(_) | Import(_) | Is(_) | KeyValCollection(_)
+                        | Lfun(_) | List(_) | Lplaceholder(_) | Lvar(_) | MethodCaller(_)
+                        | New(_) | ObjGet(_) | Omitted | Pair(_) | Pipe(_) | ReadonlyExpr(_)
+                        | Shape(_) | Tuple(_) | Upcast(_) | ValCollection(_) | Xml(_)
+                        | Yield(_) | Invalid(_) | Package(_) | Nameof(_) => None,
                     }
                 }
                 Some(Ty(
@@ -3034,6 +3035,7 @@ impl<'o, 't> FlattenSmartConstructors for DirectDeclSmartConstructors<'o, 't> {
             | TokenKind::Concurrent
             | TokenKind::Continue
             | TokenKind::Default
+            | TokenKind::Delay
             | TokenKind::Do
             | TokenKind::Echo
             | TokenKind::Else

hphp/hack/src/elab/lift_await.rs

@@ -140,6 +140,7 @@ fn check_await_usage(expr: &Expr) -> AwaitUsage {
         | Expr_::Clone(box expr)
         | Expr_::PrefixedString(box (_, expr))
         | Expr_::ReadonlyExpr(box expr)
+        | Expr_::Delay(box expr)
         | Expr_::Cast(box (_, expr))
         | Expr_::Is(box (expr, _))
         | Expr_::As(box nast::As_ { expr, .. })
@@ -345,6 +346,7 @@ fn extract_subexprs(expr: &mut nast::Expr) -> Vec<&mut nast::Expr> {
         | Expr_::Clone(_)
         | Expr_::PrefixedString(_)
         | Expr_::ReadonlyExpr(_)
+        | Expr_::Delay(_)
         | Expr_::Cast(_)
         | Expr_::Is(_)
         | Expr_::As(_)
@@ -911,6 +913,7 @@ impl LiftAwait {
             | Expr_::Clone(box expr)
             | Expr_::PrefixedString(box (_, expr))
             | Expr_::ReadonlyExpr(box expr)
+            | Expr_::Delay(box expr)
             | Expr_::Cast(box (_, expr))
             | Expr_::Is(box (expr, _))
             | Expr_::As(box nast::As_ { expr, .. })

hphp/hack/src/elab/passes/elab_const_expr.rs

@@ -183,6 +183,7 @@ impl Pass for ElabConstExprPass {
                 | Expr_::Lplaceholder(..)
                 | Expr_::ArrayGet(..)
                 | Expr_::Await(..)
+                | Expr_::Delay(..)
                 | Expr_::Cast(..)
                 | Expr_::ClassGet(..)
                 | Expr_::Clone(..)

hphp/hack/src/elab/passes/elab_dynamic_class_name.rs

@@ -87,7 +87,11 @@ fn is_dynamic(class_id: &ClassId) -> bool {
         | ClassId_::CIexpr(Expr(
             _,
             _,
-            Expr_::Lvar(..) | Expr_::This | Expr_::Dollardollar(..) | Expr_::Await(..),
+            Expr_::Lvar(..)
+            | Expr_::This
+            | Expr_::Dollardollar(..)
+            | Expr_::Await(..)
+            | Expr_::Delay(..),
         )) => false,
         ClassId_::CIexpr(_) => true,
     }

hphp/hack/src/elab/passes/validate_coroutine.rs

@@ -61,6 +61,7 @@ impl Pass for ValidateCoroutinePass {
                 env.emit_error(NastCheckError::AwaitInSyncFunction {
                     pos: exprs.0.clone(),
                     func_pos: None,
+                    keyword: "await".into(),
                 })
             }
             Stmt_::Foreach(box (_, AsExpr::AwaitAsV(pos, _) | AsExpr::AwaitAsKv(pos, _, _), _))
@@ -69,12 +70,14 @@ impl Pass for ValidateCoroutinePass {
                 env.emit_error(NastCheckError::AwaitInSyncFunction {
                     pos: pos.clone(),
                     func_pos: None,
+                    keyword: "await".into(),
                 })
             }
             Stmt_::Awaitall(..) if self.is_sync() => {
                 env.emit_error(NastCheckError::AwaitInSyncFunction {
                     pos: elem.0.clone(),
                     func_pos: None,
+                    keyword: "await".into(),
                 })
             }
             Stmt_::Return(box Some(_)) if self.is_generator() => {
@@ -91,6 +94,14 @@ impl Pass for ValidateCoroutinePass {
                 env.emit_error(NastCheckError::AwaitInSyncFunction {
                     pos: elem.1.clone(),
                     func_pos: self.func_pos.clone(),
+                    keyword: "await".into(),
+                })
+            }
+            Expr_::Delay(..) if self.is_sync() => {
+                env.emit_error(NastCheckError::AwaitInSyncFunction {
+                    pos: elem.1.clone(),
+                    func_pos: self.func_pos.clone(),
+                    keyword: "delay".into(),
                 })
             }
             _ => (),

hphp/hack/src/elab/transform.rs

@@ -3,7 +3,7 @@
 // This source code is licensed under the MIT license found in the
 // LICENSE file in the "hack" directory of this source tree.
 //
-// @generated SignedSource<<025b1d8e377255344caf6a4eb3584dad>>
+// @generated SignedSource<<9bf0fd63ae6ce7d846018264a93cb872>>
 //
 // To regenerate this file, run:
 //   buck run @fbcode//mode/dev-nosan-lg fbcode//hphp/hack/src:oxidized_regen
@@ -748,6 +748,7 @@ impl Transform for Expr_ {
             }
             Expr_::Yield(ref mut __binding_0) => __binding_0.transform(env, &mut pass.clone()),
             Expr_::Await(ref mut __binding_0) => __binding_0.transform(env, &mut pass.clone()),
+            Expr_::Delay(ref mut __binding_0) => __binding_0.transform(env, &mut pass.clone()),
             Expr_::ReadonlyExpr(ref mut __binding_0) => {
                 __binding_0.transform(env, &mut pass.clone())
             }

hphp/hack/src/hackc/compile/closure_convert.rs

@@ -1120,6 +1120,10 @@ impl<'ast, 'a: 'b, 'b> VisitorMut<'ast> for ClosureVisitor<'a, 'b> {
                     x.recurse(scope, self)?;
                     Expr_::Await(x)
                 }
+                Expr_::Delay(mut x) => {
+                    x.recurse(scope, self)?;
+                    Expr_::Delay(x)
+                }
                 Expr_::ReadonlyExpr(mut x) => {
                     x.recurse(scope, self)?;
                     Expr_::ReadonlyExpr(x)

hphp/hack/src/hackc/emitter/emit_expression.rs

@@ -507,6 +507,7 @@ pub fn emit_expr<'a>(
             Expr_::Clone(e) => Ok(emit_pos_then(pos, emit_clone(emitter, env, e)?)),
             Expr_::Shape(e) => Ok(emit_pos_then(pos, emit_shape(emitter, env, expression, e)?)),
             Expr_::Await(e) => emit_await(emitter, env, pos, e),
+            Expr_::Delay(e) => emit_expr(emitter, env, e),
             Expr_::ReadonlyExpr(e) => emit_readonly_expr(emitter, env, pos, e),
             Expr_::Yield(e) => emit_yield(emitter, env, pos, e),
             Expr_::Efun(e) => Ok(emit_pos_then(
@@ -6148,6 +6149,7 @@ fn can_use_as_rhs_in_list_assignment(expr: &ast::Expr_) -> Result<bool> {
         | Expr_::As(_)
         | Expr_::Upcast(_)
         | Expr_::Await(_)
+        | Expr_::Delay(_)
         | Expr_::ReadonlyExpr(_)
         | Expr_::ClassConst(_) => true,
         Expr_::Pipe(p) => can_use_as_rhs_in_list_assignment(&(p.2).2)?,