Merge pull request swiftlang#34301 from DougGregor/concurrency-actor-constraint-inference

[Concurrency] Propagation and consistency checking for actor constraints.

Author: DougGregor

include/swift/AST/ActorIsolation.h

@@ -16,6 +16,7 @@
 #ifndef SWIFT_AST_ACTORISOLATIONSTATE_H
 #define SWIFT_AST_ACTORISOLATIONSTATE_H
 
+#include "swift/AST/Type.h"
 #include "llvm/ADT/Hashing.h"
 
 namespace llvm {
@@ -24,6 +25,7 @@ class raw_ostream;
 
 namespace swift {
 class ClassDecl;
+class SubstitutionMap;
 class Type;
 
 /// Determine whether the given types are (canonically) equal, declared here
@@ -84,6 +86,8 @@ class ActorIsolation {
 
   operator Kind() const { return getKind(); }
 
+  bool isUnspecified() const { return kind == Unspecified; }
+
   ClassDecl *getActor() const {
     assert(getKind() == ActorInstance);
     return actor;
@@ -94,6 +98,13 @@ class ActorIsolation {
     return globalActor;
   }
 
+  /// Determine whether this isolation will require substitution to be
+  /// evaluated.
+  bool requiresSubstitution() const;
+
+  /// Substitute into types within the actor isolation.
+  ActorIsolation subst(SubstitutionMap subs) const;
+
   friend bool operator==(const ActorIsolation &lhs,
                          const ActorIsolation &rhs) {
     if (lhs.kind != rhs.kind)

include/swift/AST/DiagnosticEngine.h

@@ -18,6 +18,7 @@
 #ifndef SWIFT_BASIC_DIAGNOSTICENGINE_H
 #define SWIFT_BASIC_DIAGNOSTICENGINE_H
 
+#include "swift/AST/ActorIsolation.h"
 #include "swift/AST/DeclNameLoc.h"
 #include "swift/AST/DiagnosticConsumer.h"
 #include "swift/AST/TypeLoc.h"
@@ -93,6 +94,7 @@ namespace swift {
     DeclAttribute,
     VersionTuple,
     LayoutConstraint,
+    ActorIsolation,
   };
 
   namespace diag {
@@ -122,6 +124,7 @@ namespace swift {
       const DeclAttribute *DeclAttributeVal;
       llvm::VersionTuple VersionVal;
       LayoutConstraint LayoutConstraintVal;
+      ActorIsolation ActorIsolationVal;
     };
 
   public:
@@ -209,6 +212,12 @@ namespace swift {
     DiagnosticArgument(LayoutConstraint L)
       : Kind(DiagnosticArgumentKind::LayoutConstraint), LayoutConstraintVal(L) {
     }
+
+    DiagnosticArgument(ActorIsolation AI)
+      : Kind(DiagnosticArgumentKind::ActorIsolation),
+        ActorIsolationVal(AI) {
+    }
+
     /// Initializes a diagnostic argument using the underlying type of the
     /// given enum.
     template<
@@ -299,6 +308,11 @@ namespace swift {
       assert(Kind == DiagnosticArgumentKind::LayoutConstraint);
       return LayoutConstraintVal;
     }
+
+    ActorIsolation getAsActorIsolation() const {
+      assert(Kind == DiagnosticArgumentKind::ActorIsolation);
+      return ActorIsolationVal;
+    }
   };
 
   struct DiagnosticFormatOptions {

include/swift/AST/DiagnosticsSema.def

@@ -4268,6 +4268,10 @@ ERROR(actor_isolation_multiple_attr,none,
       "%0 %1 has multiple actor-isolation attributes ('%2' and '%3')",
       (DescriptiveDeclKind, DeclName, StringRef, StringRef))
 
+ERROR(actor_isolation_override_mismatch,none,
+      "%0 %1 %2 has different actor isolation from %3 overridden declaration",
+      (ActorIsolation, DescriptiveDeclKind, DeclName, ActorIsolation))
+
 //------------------------------------------------------------------------------
 // MARK: Type Check Types
 //------------------------------------------------------------------------------

lib/AST/DiagnosticEngine.cpp

@@ -660,6 +660,26 @@ static void formatDiagnosticArgument(StringRef Modifier,
     Out << FormatOpts.OpeningQuotationMark << Arg.getAsLayoutConstraint()
         << FormatOpts.ClosingQuotationMark;
     break;
+  case DiagnosticArgumentKind::ActorIsolation:
+    switch (auto isolation = Arg.getAsActorIsolation()) {
+    case ActorIsolation::ActorInstance:
+      Out << "actor-isolated";
+      break;
+
+    case ActorIsolation::GlobalActor:
+      Out << "global actor " << FormatOpts.OpeningQuotationMark
+        << isolation.getGlobalActor().getString()
+        << FormatOpts.ClosingQuotationMark << "-isolated";
+      break;
+
+    case ActorIsolation::Independent:
+      Out << "actor-independent";
+      break;
+
+    case ActorIsolation::Unspecified:
+      Out << "non-actor-isolated";
+      break;
+    }
   }
 }
 

lib/AST/TypeCheckRequests.cpp

@@ -1487,6 +1487,29 @@ void CustomAttrTypeRequest::cacheResult(Type value) const {
   attr->setType(value);
 }
 
+bool ActorIsolation::requiresSubstitution() const {
+  switch (kind) {
+  case ActorInstance:
+  case Independent:
+  case Unspecified:
+    return false;
+
+  case GlobalActor:
+    return getGlobalActor()->hasTypeParameter();
+  }
+}
+
+ActorIsolation ActorIsolation::subst(SubstitutionMap subs) const {
+  switch (kind) {
+  case ActorInstance:
+  case Independent:
+  case Unspecified:
+    return *this;
+
+  case GlobalActor:
+    return forGlobalActor(getGlobalActor().subst(subs));
+  }
+}
 
 void swift::simple_display(
     llvm::raw_ostream &out, const ActorIsolation &state) {