Drop the "allows unsafe" modeling as availability

With the move to unsafe effects, we no longer model `unsafe` as an
availability problem. Remove all of that supporting code.

Author: DougGregor

include/swift/AST/AvailabilityContext.h

@@ -87,10 +87,6 @@ class AvailabilityContext {
   /// Returns true if this context is `@_unavailableInEmbedded`.
   bool isUnavailableInEmbedded() const;
 
-  /// Returns true if this context allows the use of unsafe constructs inside
-  /// it.
-  bool allowsUnsafe() const;
-
   /// Constrain with another `AvailabilityContext`.
   void constrainWithContext(const AvailabilityContext &other, ASTContext &ctx);
 
@@ -107,9 +103,6 @@ class AvailabilityContext {
   constrainWithDeclAndPlatformRange(const Decl *decl,
                                     const AvailabilityRange &platformRange);
 
-  /// Constrain to allow unsafe code.
-  void constrainWithAllowsUnsafe(ASTContext &ctx);
-
   /// Returns true if `other` is as available or is more available.
   bool isContainedIn(const AvailabilityContext other) const;
 

include/swift/AST/AvailabilityContextStorage.h

@@ -43,10 +43,6 @@ struct AvailabilityContext::PlatformInfo {
   /// platform.
   unsigned IsDeprecated : 1;
 
-  /// Whether or not the context allows unsafe code within it, e.g., via the
-  /// `@unsafe` attribute.
-  unsigned AllowsUnsafe: 1;
-
   /// Sets each field to the value of the corresponding field in `other` if the
   /// other is more restrictive. Returns true if any field changed as a result
   /// of adding this constraint.
@@ -67,7 +63,6 @@ struct AvailabilityContext::PlatformInfo {
     ID.AddBoolean(IsUnavailableInEmbedded);
     ID.AddInteger(static_cast<uint8_t>(UnavailablePlatform));
     ID.AddBoolean(IsDeprecated);
-    ID.AddBoolean(AllowsUnsafe);
   }
 };
 

include/swift/AST/Decl.h

@@ -1207,10 +1207,6 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl>, public Swi
   /// used in a "safe" dialect.
   bool isUnsafe() const;
 
-  /// Whether this declaration explicitly states that it is allowed to contain
-  /// unsafe code.
-  bool allowsUnsafe() const;
-
 private:
   bool isUnsafeComputed() const {
     return Bits.Decl.IsUnsafeComputed;
@@ -1957,7 +1953,6 @@ class ExtensionDecl final : public GenericContext, public Decl,
   friend class Decl;
 public:
   using Decl::getASTContext;
-  using Decl::allowsUnsafe;
 
   /// Create a new extension declaration.
   static ExtensionDecl *create(ASTContext &ctx, SourceLoc extensionLoc,
@@ -3435,7 +3430,6 @@ class GenericTypeDecl : public GenericContext, public TypeDecl {
   using DeclContext::operator new;
   using DeclContext::operator delete;
   using TypeDecl::getDeclaredInterfaceType;
-  using Decl::allowsUnsafe;
 
   static bool classof(const DeclContext *C) {
     if (auto D = C->getAsDecl())

include/swift/AST/DeclContext.h

@@ -718,10 +718,6 @@ class alignas(1 << DeclContextAlignInBits) DeclContext
   /// target. Used for conformance lookup disambiguation.
   bool isAlwaysAvailableConformanceContext() const;
 
-  /// Determines whether this context is explicitly allowed to use unsafe
-  /// constructs.
-  bool allowsUnsafe() const;
-
   /// \returns true if traversal was aborted, false otherwise.
   bool walkContext(ASTWalker &Walker);
 

lib/AST/AvailabilityContext.cpp

@@ -47,7 +47,6 @@ bool AvailabilityContext::PlatformInfo::constrainWith(
         CONSTRAIN_BOOL(IsUnavailableInEmbedded, other.IsUnavailableInEmbedded);
   }
   isConstrained |= CONSTRAIN_BOOL(IsDeprecated, other.IsDeprecated);
-  isConstrained |= CONSTRAIN_BOOL(AllowsUnsafe, other.AllowsUnsafe);
 
   return isConstrained;
 }
@@ -65,7 +64,6 @@ bool AvailabilityContext::PlatformInfo::constrainWith(const Decl *decl) {
   }
 
   isConstrained |= CONSTRAIN_BOOL(IsDeprecated, decl->isDeprecated());
-  isConstrained |= CONSTRAIN_BOOL(AllowsUnsafe, decl->allowsUnsafe());
 
   return isConstrained;
 }
@@ -131,8 +129,7 @@ AvailabilityContext::forPlatformRange(const AvailabilityRange &range,
   PlatformInfo platformInfo{range, PlatformKind::none,
                             /*IsUnavailable*/ false,
                             /*IsUnavailableInEmbedded*/ false,
-                            /*IsDeprecated*/ false,
-                            /*AllowsUnsafe*/ false};
+                            /*IsDeprecated*/ false};
   return AvailabilityContext(Storage::get(platformInfo, ctx));
 }
 
@@ -155,8 +152,7 @@ AvailabilityContext::get(const AvailabilityRange &platformAvailability,
                                 ? *unavailablePlatform
                                 : PlatformKind::none,
                             unavailablePlatform.has_value(),
-                            /*IsUnavailableInEmbedded*/ false, deprecated,
-                            /*AllowsUnsafe*/ false};
+                            /*IsUnavailableInEmbedded*/ false, deprecated};
   return AvailabilityContext(Storage::get(platformInfo, ctx));
 }
 
@@ -175,10 +171,6 @@ bool AvailabilityContext::isUnavailableInEmbedded() const {
   return Info->Platform.IsUnavailableInEmbedded;
 }
 
-bool AvailabilityContext::allowsUnsafe() const {
-  return Info->Platform.AllowsUnsafe;
-}
-
 bool AvailabilityContext::isDeprecated() const {
   return Info->Platform.IsDeprecated;
 }
@@ -195,15 +187,6 @@ void AvailabilityContext::constrainWithDecl(const Decl *decl) {
   constrainWithDeclAndPlatformRange(decl, AvailabilityRange::alwaysAvailable());
 }
 
-void AvailabilityContext::constrainWithAllowsUnsafe(ASTContext &ctx) {
-  if (allowsUnsafe())
-    return;
-
-  PlatformInfo platformInfo{Info->Platform};
-  platformInfo.AllowsUnsafe = true;
-  Info = Storage::get(platformInfo, ctx);
-}
-
 void AvailabilityContext::constrainWithPlatformRange(
     const AvailabilityRange &platformRange, ASTContext &ctx) {
   PlatformInfo platformAvailability{Info->Platform};
@@ -251,9 +234,6 @@ void AvailabilityContext::print(llvm::raw_ostream &os) const {
 
   if (isDeprecated())
     os << " deprecated";
-
-  if (allowsUnsafe())
-    os << " allows_unsafe";
 }
 
 void AvailabilityContext::dump() const { print(llvm::errs()); }

lib/AST/Decl.cpp

@@ -1094,10 +1094,6 @@ bool Decl::isUnsafe() const {
       false);
 }
 
-bool Decl::allowsUnsafe() const {
-  return isUnsafe();
-}
-
 Type AbstractFunctionDecl::getThrownInterfaceType() const {
   if (!getThrownTypeRepr())
     return ThrownType.getType();

lib/AST/DeclContext.cpp

@@ -1554,10 +1554,3 @@ bool DeclContext::isAlwaysAvailableConformanceContext() const {
 
   return deploymentTarget.isContainedIn(conformanceAvailability);
 }
-
-bool DeclContext::allowsUnsafe() const {
-  if (auto decl = getAsDecl())
-    return decl->allowsUnsafe();
-
-  return false;
-}

lib/Sema/TypeCheckAvailability.cpp

@@ -964,8 +964,7 @@ class AvailabilityScopeBuilder : private ASTWalker {
     // Are we already constrained by the deployment target and the declaration
     // doesn't explicitly allow unsafe constructs in its definition, adding
     // new contexts won't change availability.
-    bool allowsUnsafe = declHasSafeAttr(D);
-    if (isCurrentScopeContainedByDeploymentTarget() && !allowsUnsafe)
+    if (isCurrentScopeContainedByDeploymentTarget())
       return;
 
     // Enumerate all of the body scopes to apply availability.
@@ -981,11 +980,6 @@ class AvailabilityScopeBuilder : private ASTWalker {
              AvailabilityRange::forDeploymentTarget(Context), Context);
       }
 
-      // Allow unsafe if appropriate for this body.
-      if (allowsUnsafe) {
-        availability.constrainWithAllowsUnsafe(Context);
-      }
-
       nodesAndScopes.push_back({
           body,
           AvailabilityScope::createForDeclImplicit(

lib/Sema/TypeCheckDeclOverride.cpp

@@ -2261,7 +2261,7 @@ static bool checkSingleOverride(ValueDecl *override, ValueDecl *base) {
     if (isUnsafe(overrideRef) && !isUnsafe(baseRef)) {
       // Don't diagnose @unsafe overrides if the subclass is @unsafe.
       auto overridingClass = override->getDeclContext()->getSelfClassDecl();
-      bool shouldDiagnose = !overridingClass || !overridingClass->allowsUnsafe();
+      bool shouldDiagnose = !overridingClass || !overridingClass->isUnsafe();
 
       if (shouldDiagnose) {
         diagnoseUnsafeUse(UnsafeUse::forOverride(override, base));