Align isolated conformances with the current proposal

include/swift/AST/ASTContext.h

@@ -279,6 +279,14 @@ class ASTContext final {
   struct Implementation;
   Implementation &getImpl() const;
 
+  struct GlobalCache;
+
+  /// Retrieve a reference to the global cache within this ASTContext,
+  /// which is a place where we can stash side tables without having to
+  /// recompile the world every time we add a side table. See
+  /// "swift/AST/ASTContextGlobalCache.h"
+  GlobalCache &getGlobalCache() const;
+
   friend ConstraintCheckerArenaRAII;
 
   void operator delete(void *Data) throw();

include/swift/AST/ASTContextGlobalCache.h

@@ -0,0 +1,34 @@
+//===--- ASTContextGlobalCache.h - AST Context Cache ------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the ASTContext::GlobalCache type. DO NOT include this
+// header from any other header: it should only be included in those .cpp
+// files that need to access the side tables. There are no include guards to
+// force the issue.
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/AST/ASTContext.h"
+
+namespace swift {
+
+/// A collection of side tables associated with the ASTContext itself, meant
+// as
+struct ASTContext::GlobalCache {
+  /// Mapping from normal protocol conformances to the explicitly-specified
+  /// global actor isolations, e.g., when the conformance was spelled
+  /// `@MainActor P` or similar.
+  llvm::DenseMap<const NormalProtocolConformance *, TypeExpr *>
+      conformanceExplicitGlobalActorIsolation;
+};
+
+} // end namespace 

include/swift/AST/ConformanceAttributes.h

@@ -17,6 +17,8 @@
 
 namespace swift {
 
+class TypeExpr;
+
 /// Describes all of the attributes that can occur on a conformance.
 struct ConformanceAttributes {
   /// The location of the "unchecked" attribute, if present.
@@ -28,9 +30,15 @@ struct ConformanceAttributes {
   /// The location of the "unsafe" attribute if present.
   SourceLoc unsafeLoc;
 
-  /// The location of the "@isolated" attribute if present.
-  SourceLoc isolatedLoc;
-
+  /// The location of the "nonisolated" modifier, if present.
+  SourceLoc nonisolatedLoc;
+
+  /// The location of the '@' prior to the global actor type.
+  SourceLoc globalActorAtLoc;
+
+  /// The global actor type to which this conformance is isolated.
+  TypeExpr *globalActorType = nullptr;
+
   /// Merge other conformance attributes into this set.
   ConformanceAttributes &
   operator |=(const ConformanceAttributes &other) {
@@ -40,8 +48,12 @@ struct ConformanceAttributes {
       preconcurrencyLoc = other.preconcurrencyLoc;
     if (other.unsafeLoc.isValid())
       unsafeLoc = other.unsafeLoc;
-    if (other.isolatedLoc.isValid())
-      isolatedLoc = other.isolatedLoc;
+    if (other.nonisolatedLoc.isValid())
+      nonisolatedLoc = other.nonisolatedLoc;
+    if (other.globalActorType && !globalActorType) {
+      globalActorAtLoc = other.globalActorAtLoc;
+      globalActorType = other.globalActorType;
+    }
     return *this;
   }
 };

include/swift/AST/Decl.h

@@ -1806,16 +1806,20 @@ struct InheritedEntry : public TypeLoc {
   /// This is true in cases like ~Copyable but not (P & ~Copyable).
   bool IsSuppressed : 1;
 
+  /// The global actor isolation provided (for a conformance).
+  TypeExpr *globalActorIsolationType = nullptr;
+
 public:
   InheritedEntry(const TypeLoc &typeLoc);
 
   InheritedEntry(const TypeLoc &typeLoc, ProtocolConformanceOptions options,
                  bool isSuppressed = false)
       : TypeLoc(typeLoc), RawOptions(options.toRaw()),
-        IsSuppressed(isSuppressed) {}
+        IsSuppressed(isSuppressed),
+        globalActorIsolationType(options.getGlobalActorIsolationType()) {}
 
   ProtocolConformanceOptions getOptions() const {
-    return ProtocolConformanceOptions(RawOptions);
+    return ProtocolConformanceOptions(RawOptions, globalActorIsolationType);
   }
 
   bool isUnchecked() const {
@@ -1827,8 +1831,12 @@ struct InheritedEntry : public TypeLoc {
   bool isPreconcurrency() const {
     return getOptions().contains(ProtocolConformanceFlags::Preconcurrency);
   }
-  bool isIsolated() const {
-    return getOptions().contains(ProtocolConformanceFlags::Isolated);
+  bool isNonisolated() const {
+    return getOptions().contains(ProtocolConformanceFlags::Nonisolated);
+  }
+
+  TypeExpr *getGlobalActorIsolationType() const {
+    return globalActorIsolationType;
   }
 
   ExplicitSafety getExplicitSafety() const {

include/swift/AST/DiagnosticsSema.def

@@ -8319,31 +8319,28 @@ ERROR(attr_abi_incompatible_with_silgen_name,none,
 //===----------------------------------------------------------------------===//
 // MARK: Isolated conformances
 //===----------------------------------------------------------------------===//
-ERROR(isolated_conformance_not_global_actor_isolated,none,
-      "isolated conformance is only permitted on global-actor-isolated types",
-      ())
 ERROR(isolated_conformance_experimental_feature,none,
       "isolated conformances require experimental feature "
       " 'IsolatedConformances'", ())
 ERROR(nonisolated_conformance_depends_on_isolated_conformance,none,
-      "conformance of %0 to %1 depends on %2 conformance of %3 to %4; mark it as 'isolated'",
-      (Type, DeclName, ActorIsolation, Type, DeclName))
+      "conformance of %0 to %1 depends on %2 conformance of %3 to %4; mark it as '%5'",
+      (Type, DeclName, ActorIsolation, Type, DeclName, StringRef))
 ERROR(isolated_conformance_mismatch_with_associated_isolation,none,
       "%0 conformance of %1 to %2 cannot depend on %3 conformance of %4 to %5",
       (ActorIsolation, Type, DeclName, ActorIsolation, Type, DeclName))
 NOTE(add_isolated_to_conformance,none,
-     "add 'isolated' to the %0 conformance to restrict it to %1 code",
-    (DeclName, ActorIsolation))
+     "add '%0' to the %1 conformance to restrict it to %2 code",
+    (StringRef, DeclName, ActorIsolation))
 ERROR(isolated_conformance_with_sendable,none,
-      "isolated conformance of %0 to %1 cannot be used to satisfy conformance "
+      "%4 conformance of %0 to %1 cannot be used to satisfy conformance "
       "requirement for a %select{`Sendable`|`SendableMetatype`}2 type "
-      "parameter %3", (Type, DeclName, bool, Type))
+      "parameter %3", (Type, DeclName, bool, Type, ActorIsolation))
 ERROR(isolated_conformance_with_sendable_simple,none,
-      "isolated conformance of %0 to %1 cannot be used to satisfy conformance "
-      "requirement for a `Sendable` type parameter ",
-      (Type, DeclName))
+      "%2 conformance of %0 to %1 cannot be used to satisfy "
+      "conformance requirement for a `Sendable` type parameter ",
+      (Type, DeclName, ActorIsolation))
 ERROR(isolated_conformance_wrong_domain,none,
-      "%0 isolated conformance of %1 to %2 cannot be used in %3 context",
+      "%0 conformance of %1 to %2 cannot be used in %3 context",
       (ActorIsolation, Type, DeclName, ActorIsolation))
 
 //===----------------------------------------------------------------------===//

include/swift/AST/ProtocolConformance.h

@@ -147,7 +147,7 @@ class alignas(1 << DeclAlignInBits) ProtocolConformance
     SWIFT_INLINE_BITFIELD_EMPTY(RootProtocolConformance, ProtocolConformance);
 
     SWIFT_INLINE_BITFIELD_FULL(NormalProtocolConformance, RootProtocolConformance,
-                               1+1+1+
+                               1+1+1+1+1+
                                bitmax(NumProtocolConformanceOptions,8)+
                                bitmax(NumProtocolConformanceStateBits,8)+
                                bitmax(NumConformanceEntryKindBits,8),
@@ -161,6 +161,12 @@ class alignas(1 << DeclAlignInBits) ProtocolConformance
       /// this conformance.
       IsPreconcurrencyEffectful : 1,
 
+      /// Whether the computed actor isolation is nonisolated.
+      IsComputedNonisolated : 1,
+
+      /// Whether there is an explicit global actor specified for this
+      /// conformance.
+      HasExplicitGlobalActor : 1,
       : NumPadBits,
 
       /// Options.
@@ -240,6 +246,14 @@ class alignas(1 << DeclAlignInBits) ProtocolConformance
   /// Otherwise a new conformance will be created.
   ProtocolConformance *getCanonicalConformance();
 
+  /// Determine the actor isolation of this conformance.
+  ActorIsolation getIsolation() const;
+
+  /// Determine whether this conformance is isolated to an actor.
+  bool isIsolated() const {
+    return getIsolation().isActorIsolated();
+  }
+
   /// Return true if the conformance has a witness for the given associated
   /// type.
   bool hasTypeWitness(AssociatedTypeDecl *assocType) const;
@@ -529,6 +543,7 @@ class NormalProtocolConformance : public RootProtocolConformance,
 {
   friend class ValueWitnessRequest;
   friend class TypeWitnessRequest;
+  friend class ConformanceIsolationRequest;
 
   /// The protocol being conformed to.
   ProtocolDecl *Protocol;
@@ -570,6 +585,20 @@ class NormalProtocolConformance : public RootProtocolConformance,
 
   void resolveLazyInfo() const;
 
+  /// Retrieve the explicitly-specified global actor isolation.
+  TypeExpr *getExplicitGlobalActorIsolation() const;
+
+  // Record the explicitly-specified global actor isolation.
+  void setExplicitGlobalActorIsolation(TypeExpr *typeExpr);
+
+  bool isComputedNonisolated() const {
+    return Bits.NormalProtocolConformance.IsComputedNonisolated;
+  }
+
+  void setComputedNonnisolated(bool value = true) {
+    Bits.NormalProtocolConformance.IsComputedNonisolated = value;
+  }
+
 public:
   NormalProtocolConformance(Type conformingType, ProtocolDecl *protocol,
                             SourceLoc loc, DeclContext *dc,
@@ -593,6 +622,9 @@ class NormalProtocolConformance : public RootProtocolConformance,
     Bits.NormalProtocolConformance.HasComputedAssociatedConformances = false;
     Bits.NormalProtocolConformance.SourceKind =
         unsigned(ConformanceEntryKind::Explicit);
+    Bits.NormalProtocolConformance.IsComputedNonisolated = false;
+    Bits.NormalProtocolConformance.HasExplicitGlobalActor = false;
+    setExplicitGlobalActorIsolation(options.getGlobalActorIsolationType());
   }
 
   /// Get the protocol being conformed to.
@@ -634,7 +666,8 @@ class NormalProtocolConformance : public RootProtocolConformance,
   void setInvalid() { Bits.NormalProtocolConformance.IsInvalid = true; }
 
   ProtocolConformanceOptions getOptions() const {
-    return ProtocolConformanceOptions(Bits.NormalProtocolConformance.Options);
+    return ProtocolConformanceOptions(Bits.NormalProtocolConformance.Options,
+                                      getExplicitGlobalActorIsolation());
   }
 
   /// Whether this is an "unchecked" conformance.
@@ -669,11 +702,6 @@ class NormalProtocolConformance : public RootProtocolConformance,
     return getOptions().contains(ProtocolConformanceFlags::Preconcurrency);
   }
 
-  /// Whether this is an isolated conformance.
-  bool isIsolated() const {
-    return getOptions().contains(ProtocolConformanceFlags::Isolated);
-  }
-
   /// Retrieve the location of `@preconcurrency`, if there is one and it is
   /// known.
   SourceLoc getPreconcurrencyLoc() const { return PreconcurrencyLoc; }