allow property/subscript access expressions for actors in typechecker

We now mark some DeclRefExpr and LookupExprs as implicitly async
during typechecking, depending on whether they appear in a context
that is only performing a read / get operation, and whether they
are cross-actor operations.

also resolves rdar://72403401 by improving the error messages
(no more vague "'await' in async context" when its clearly a call!)

Author: kavon

Diff for: include/swift/AST/DiagnosticsSema.def

@@ -4190,8 +4190,12 @@ ERROR(async_call_without_await_in_autoclosure,none,
 ERROR(async_call_without_await_in_async_let,none,
       "call is 'async' in an 'async let' initializer that is not marked "
       "with 'await'", ())
+ERROR(async_prop_access_without_await,none,
+      "property access is 'async' but is not marked with 'await'", ())
+ERROR(async_subscript_access_without_await,none,
+      "subscript access is 'async' but is not marked with 'await'", ())
 WARNING(no_async_in_await,none,
-        "no calls to 'async' functions occur within 'await' expression", ())
+        "no 'async' operations occur within 'await' expression", ())
 ERROR(async_call_in_illegal_context,none,
       "'async' call cannot occur in "
       "%select{<<ERROR>>|a default argument|a property wrapper initializer|a property initializer|a global variable initializer|an enum case raw value|a catch pattern|a catch guard expression|a defer body}0",
@@ -4201,7 +4205,7 @@ ERROR(await_in_illegal_context,none,
       "%select{<<ERROR>>|a default argument|a property wrapper initializer|a property initializer|a global variable initializer|an enum case raw value|a catch pattern|a catch guard expression|a defer body}0",
       (unsigned))
 ERROR(async_in_nonasync_function,none,
-      "%select{'async'|'await'|'async let'}0 in "
+      "%select{'async'|'async' call|'await'|'async let'|'async' property access|'async' subscript access}0 in "
       "%select{a function|an autoclosure}1 that does not support concurrency",
       (unsigned, bool))
 NOTE(note_add_async_to_function,none,
@@ -4279,13 +4283,13 @@ ERROR(actor_with_nonactor_superclass,none,
       "actor class cannot inherit from non-actor class %0", (DeclName))
 
 ERROR(actor_isolated_non_self_reference,none,
-        "actor-isolated %0 %1 can only be referenced "
-        "%select{inside the actor|on 'self'}2",
-        (DescriptiveDeclKind, DeclName, bool))
+        "actor-isolated %0 %1 can only be %select{referenced|mutated|used 'inout'}3 "
+        "%select{from inside the actor|on 'self'}2",
+        (DescriptiveDeclKind, DeclName, bool, unsigned))
 ERROR(actor_isolated_self_independent_context,none,
-        "actor-isolated %0 %1 can not be referenced from an "
+        "actor-isolated %0 %1 can not be %select{referenced|mutated|used 'inout'}2 from an "
         "'@actorIndependent' context",
-        (DescriptiveDeclKind, DeclName))
+        (DescriptiveDeclKind, DeclName, unsigned))
 ERROR(actor_isolated_inout_state,none,
       "actor-isolated %0 %1 cannot be passed 'inout' to"
       "%select{| implicitly}2 'async' function call",
@@ -4298,34 +4302,34 @@ ERROR(actor_isolated_global_actor_context,none,
       "actor %2",
       (DescriptiveDeclKind, DeclName, Type))
 ERROR(global_actor_from_instance_actor_context,none,
-      "%0 %1 isolated to global actor %2 can not be referenced from actor %3",
-      (DescriptiveDeclKind, DeclName, Type, DeclName))
+      "%0 %1 isolated to global actor %2 can not be %select{referenced|mutated|used 'inout'}4 from actor %3",
+      (DescriptiveDeclKind, DeclName, Type, DeclName, unsigned))
 ERROR(global_actor_from_other_global_actor_context,none,
-      "%0 %1 isolated to global actor %2 can not be referenced from "
-      "different global actor %3",
-      (DescriptiveDeclKind, DeclName, Type, Type))
+      "%0 %1 isolated to global actor %2 can not be %select{referenced|mutated|used 'inout'}4"
+      " from different global actor %3",
+      (DescriptiveDeclKind, DeclName, Type, Type, unsigned))
 ERROR(global_actor_from_nonactor_context,none,
-      "%0 %1 isolated to global actor %2 can not be referenced from "
-      "%select{this|an '@actorIndependent'}3 context",
-      (DescriptiveDeclKind, DeclName, Type, bool))
+      "%0 %1 isolated to global actor %2 can not be %select{referenced|mutated|used 'inout'}4"
+      " from %select{this|an '@actorIndependent'}3 context",
+      (DescriptiveDeclKind, DeclName, Type, bool, unsigned))
 ERROR(actor_isolated_partial_apply,none,
         "actor-isolated %0 %1 can not be partially applied",
         (DescriptiveDeclKind, DeclName))
 ERROR(concurrent_access_local,none,
         "use of local %0 %1 in concurrently-executing code",
         (DescriptiveDeclKind, DeclName))
 ERROR(actor_isolated_from_concurrent_closure,none,
-        "actor-isolated %0 %1 cannot be referenced from a concurrent closure",
-        (DescriptiveDeclKind, DeclName))
+        "actor-isolated %0 %1 cannot be %select{referenced|mutated|used 'inout'}2 from a concurrent closure",
+        (DescriptiveDeclKind, DeclName, unsigned))
 ERROR(actor_isolated_from_concurrent_function,none,
-        "actor-isolated %0 %1 cannot be referenced from a concurrent function",
-        (DescriptiveDeclKind, DeclName))
+        "actor-isolated %0 %1 cannot be %select{referenced|mutated|used 'inout'}2 from a concurrent function",
+        (DescriptiveDeclKind, DeclName, unsigned))
 ERROR(actor_isolated_from_async_let,none,
-        "actor-isolated %0 %1 cannot be referenced from 'async let' initializer",
-        (DescriptiveDeclKind, DeclName))
+        "actor-isolated %0 %1 cannot be %select{referenced|mutated|used 'inout'}2 from 'async let' initializer",
+        (DescriptiveDeclKind, DeclName, unsigned))
 ERROR(actor_isolated_from_escaping_closure,none,
-        "actor-isolated %0 %1 cannot be referenced from an '@escaping' closure",
-        (DescriptiveDeclKind, DeclName))
+        "actor-isolated %0 %1 cannot be %select{referenced|mutated|used 'inout'}2 from an '@escaping' closure",
+        (DescriptiveDeclKind, DeclName, unsigned))
 ERROR(local_function_executed_concurrently,none,
       "concurrently-executed %0 %1 must be marked as '@concurrent'",
       (DescriptiveDeclKind, DeclName))
@@ -4338,7 +4342,8 @@ NOTE(actor_isolated_sync_func,none,
      "implicitly asynchronous",
      (DescriptiveDeclKind, DeclName))
 NOTE(actor_mutable_state,none,
-     "mutable state is only available within the actor instance", ())
+     "mutation of this %0 is only permitted within the actor",
+     (DescriptiveDeclKind))
 WARNING(shared_mutable_state_access,none,
         "reference to %0 %1 is not concurrency-safe because it involves "
         "shared mutable state", (DescriptiveDeclKind, DeclName))

Diff for: include/swift/AST/Expr.h

@@ -166,8 +166,9 @@ class alignas(8) Expr {
 
   SWIFT_INLINE_BITFIELD_EMPTY(LiteralExpr, Expr);
   SWIFT_INLINE_BITFIELD_EMPTY(IdentityExpr, Expr);
-  SWIFT_INLINE_BITFIELD(LookupExpr, Expr, 1,
-    IsSuper : 1
+  SWIFT_INLINE_BITFIELD(LookupExpr, Expr, 1+1,
+    IsSuper : 1,
+    IsImplicitlyAsync : 1
   );
   SWIFT_INLINE_BITFIELD_EMPTY(DynamicLookupExpr, LookupExpr);
 
@@ -193,9 +194,10 @@ class alignas(8) Expr {
     LiteralCapacity : 32
   );
 
-  SWIFT_INLINE_BITFIELD(DeclRefExpr, Expr, 2+2,
+  SWIFT_INLINE_BITFIELD(DeclRefExpr, Expr, 2+2+1,
     Semantics : 2, // an AccessSemantics
-    FunctionRefKind : 2
+    FunctionRefKind : 2,
+    IsImplicitlyAsync : 1
   );
 
   SWIFT_INLINE_BITFIELD(UnresolvedDeclRefExpr, Expr, 2+2,
@@ -1190,6 +1192,7 @@ class DeclRefExpr : public Expr {
     Bits.DeclRefExpr.FunctionRefKind =
       static_cast<unsigned>(Loc.isCompound() ? FunctionRefKind::Compound
                                              : FunctionRefKind::Unapplied);
+    Bits.DeclRefExpr.IsImplicitlyAsync = false;
   }
 
   /// Retrieve the declaration to which this expression refers.
@@ -1203,6 +1206,16 @@ class DeclRefExpr : public Expr {
     return (AccessSemantics) Bits.DeclRefExpr.Semantics;
   }
 
+  /// Determine whether this reference needs to happen asynchronously, i.e.,
+  /// guarded by hop_to_executor
+  bool isImplicitlyAsync() const { return Bits.DeclRefExpr.IsImplicitlyAsync; }
+
+  /// Set whether this reference needs to happen asynchronously, i.e.,
+  /// guarded by hop_to_executor
+  void setImplicitlyAsync(bool isImplicitlyAsync) {
+    Bits.DeclRefExpr.IsImplicitlyAsync = isImplicitlyAsync;
+  }
+
   /// Retrieve the concrete declaration reference.
   ConcreteDeclRef getDeclRef() const {
     return D;
@@ -1518,6 +1531,7 @@ class LookupExpr : public Expr {
                           bool Implicit)
       : Expr(Kind, Implicit), Base(base), Member(member) {
     Bits.LookupExpr.IsSuper = false;
+    Bits.LookupExpr.IsImplicitlyAsync = false;
     assert(Base);
   }
 
@@ -1547,6 +1561,16 @@ class LookupExpr : public Expr {
   /// Set whether this reference refers to the superclass's property.
   void setIsSuper(bool isSuper) { Bits.LookupExpr.IsSuper = isSuper; }
 
+  /// Determine whether this reference needs to happen asynchronously, i.e.,
+  /// guarded by hop_to_executor
+  bool isImplicitlyAsync() const { return Bits.LookupExpr.IsImplicitlyAsync; }
+
+  /// Set whether this reference needs to happen asynchronously, i.e.,
+  /// guarded by hop_to_executor
+  void setImplicitlyAsync(bool isImplicitlyAsync) {
+    Bits.LookupExpr.IsImplicitlyAsync = isImplicitlyAsync;
+  }
+
   static bool classof(const Expr *E) {
     return E->getKind() >= ExprKind::First_LookupExpr &&
            E->getKind() <= ExprKind::Last_LookupExpr;
@@ -3118,7 +3142,7 @@ class DestructureTupleExpr final : public ImplicitConversionExpr,
 class LoadExpr : public ImplicitConversionExpr {
 public:
   LoadExpr(Expr *subExpr, Type type)
-    : ImplicitConversionExpr(ExprKind::Load, subExpr, type) {}
+    : ImplicitConversionExpr(ExprKind::Load, subExpr, type) { }
 
   static bool classof(const Expr *E) { return E->getKind() == ExprKind::Load; }
 };
@@ -4398,6 +4422,7 @@ class ApplyExpr : public Expr {
   }
 
   /// Is this application _implicitly_ required to be an async call?
+  /// That is, does it need to be guarded by hop_to_executor.
   /// Note that this is _not_ a check for whether the callee is async!
   /// Only meaningful after complete type-checking.
   ///