Merge pull request #61182 from hamishknight/warranty-void

Author: hamishknight

include/swift/AST/Decl.h

@@ -1049,6 +1049,12 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
 
   bool isAvailableAsSPI() const;
 
+  /// Whether the declaration is considered unavailable through either being
+  /// explicitly marked as such, or has a parent decl that is semantically
+  /// unavailable. This is a broader notion of unavailability than is checked by
+  /// \c AvailableAttr::isUnavailable.
+  bool isSemanticallyUnavailable() const;
+
   // List the SPI groups declared with @_spi or inherited by this decl.
   //
   // SPI groups are inherited from the parent contexts only if the local decl

include/swift/AST/TypeCheckRequests.h

@@ -3489,6 +3489,22 @@ class RenamedDeclRequest
   bool isCached() const { return true; }
 };
 
+class IsSemanticallyUnavailableRequest
+    : public SimpleRequest<IsSemanticallyUnavailableRequest,
+                           bool(const Decl *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  bool evaluate(Evaluator &evaluator, const Decl *decl) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 class ClosureEffectsRequest
     : public SimpleRequest<ClosureEffectsRequest,
                            FunctionType::ExtInfo(ClosureExpr *),

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -395,6 +395,9 @@ SWIFT_REQUEST(TypeChecker, GetImplicitSendableRequest,
 SWIFT_REQUEST(TypeChecker, RenamedDeclRequest,
               ValueDecl *(const ValueDecl *, const AvailableAttr *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, IsSemanticallyUnavailableRequest,
+              bool(const Decl *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ClosureEffectsRequest,
               FunctionType::ExtInfo(ClosureExpr *),
               Cached, NoLocationInfo)

include/swift/SIL/SILDeclRef.h

@@ -300,6 +300,11 @@ struct SILDeclRef {
   /// Retrieves the ASTContext from the underlying AST node being stored.
   ASTContext &getASTContext() const;
 
+  /// Retrieve the innermost declaration context corresponding to the underlying
+  /// node, which will either be the node itself (if it's also a declaration
+  /// context) or its parent context.
+  DeclContext *getInnermostDeclContext() const;
+
   llvm::Optional<AnyFunctionRef> getAnyFunctionRef() const;
 
   SILLocation getAsRegularLocation() const;

include/swift/SIL/SILProfiler.h

@@ -32,7 +32,7 @@ class SILFunction;
 class SILModule;
 
 /// Returns whether the given AST node requires profiling instrumentation.
-bool doesASTRequireProfiling(SILModule &M, ASTNode N);
+bool doesASTRequireProfiling(SILModule &M, ASTNode N, SILDeclRef Constant);
 
 /// SILProfiler - Maps AST nodes to profile counters.
 class SILProfiler : public SILAllocated<SILProfiler> {

lib/AST/Availability.cpp

@@ -20,6 +20,7 @@
 #include "swift/AST/Types.h"
 #include "swift/AST/Availability.h"
 #include "swift/AST/PlatformKind.h"
+#include "swift/AST/TypeCheckRequests.h"
 #include "swift/AST/TypeWalker.h"
 #include <map>
 
@@ -194,6 +195,41 @@ bool Decl::isAvailableAsSPI() const {
     .isAvailableAsSPI();
 }
 
+bool IsSemanticallyUnavailableRequest::evaluate(Evaluator &evaluator,
+                                                const Decl *decl) const {
+  // Directly marked unavailable.
+  if (AvailableAttr::isUnavailable(decl))
+    return true;
+
+  // If this is an extension, it's semantically unavailable if its nominal is,
+  // as there is no way to reference or construct the type.
+  if (auto *ext = dyn_cast<ExtensionDecl>(decl)) {
+    if (auto *nom = ext->getExtendedNominal()) {
+      if (nom->isSemanticallyUnavailable())
+        return true;
+    }
+  }
+
+  // If the parent decl is semantically unavailable, then this decl is too.
+  // For local contexts, this means it's a local decl in e.g an unavailable
+  // function, which cannot be accessed. For non-local contexts, this is a
+  // nested type or a member with an unavailable parent, which cannot be
+  // referenced.
+  // Similar to `AvailableAttr::isUnavailable`, don't apply this logic to
+  // Clang decls, as they may be inaccurately parented.
+  if (!decl->hasClangNode()) {
+    auto *DC = decl->getDeclContext();
+    if (auto *parentDecl = DC->getInnermostDeclarationDeclContext())
+      return parentDecl->isSemanticallyUnavailable();
+  }
+  return false;
+}
+
+bool Decl::isSemanticallyUnavailable() const {
+  auto &eval = getASTContext().evaluator;
+  return evaluateOrDefault(eval, IsSemanticallyUnavailableRequest{this}, false);
+}
+
 AvailabilityContext
 AvailabilityInference::annotatedAvailableRangeForAttr(const SpecializeAttr* attr,
                                                       ASTContext &ctx) {

lib/SIL/IR/SILDeclRef.cpp

@@ -195,18 +195,26 @@ Optional<AnyFunctionRef> SILDeclRef::getAnyFunctionRef() const {
   llvm_unreachable("Unhandled case in switch");
 }
 
-ASTContext &SILDeclRef::getASTContext() const {
+DeclContext *SILDeclRef::getInnermostDeclContext() const {
+  if (!loc)
+    return nullptr;
   switch (getLocKind()) {
   case LocKind::Decl:
-    return getDecl()->getASTContext();
+    return getDecl()->getInnermostDeclContext();
   case LocKind::Closure:
-    return getAbstractClosureExpr()->getASTContext();
+    return getAbstractClosureExpr();
   case LocKind::File:
-    return getFileUnit()->getASTContext();
+    return getFileUnit();
   }
   llvm_unreachable("Unhandled case in switch");
 }
 
+ASTContext &SILDeclRef::getASTContext() const {
+  auto *DC = getInnermostDeclContext();
+  assert(DC && "Must have a decl context");
+  return DC->getASTContext();
+}
+
 Optional<AvailabilityContext> SILDeclRef::getAvailabilityForLinkage() const {
   // Back deployment thunks and fallbacks don't have availability since they
   // are non-ABI.

lib/SIL/IR/SILProfiler.cpp

@@ -42,13 +42,30 @@ static bool doesClosureHaveBody(AbstractClosureExpr *ACE) {
 }
 
 /// Check whether a root AST node should be profiled.
-static bool shouldProfile(ASTNode N) {
+static bool shouldProfile(ASTNode N, SILDeclRef Constant) {
   // Do not profile AST nodes with invalid source locations.
   if (N.getStartLoc().isInvalid() || N.getEndLoc().isInvalid()) {
     LLVM_DEBUG(llvm::dbgs()
                << "Skipping ASTNode: invalid start/end locations\n");
     return false;
   }
+  if (!Constant) {
+    // We should only ever have a null SILDeclRef for top-level code, which is
+    // always user-written, and should always be profiled.
+    // FIXME: Once top-level code is unified under a single SILProfiler, this
+    // case can be eliminated.
+    assert(isa<TopLevelCodeDecl>(N.get<Decl *>()));
+    return true;
+  }
+
+  // Do not profile AST nodes in unavailable contexts.
+  auto *DC = Constant.getInnermostDeclContext();
+  if (auto *D = DC->getInnermostDeclarationDeclContext()) {
+    if (D->isSemanticallyUnavailable()) {
+      LLVM_DEBUG(llvm::dbgs() << "Skipping ASTNode: unavailable context\n");
+      return false;
+    }
+  }
 
   if (auto *E = N.dyn_cast<Expr *>()) {
     if (auto *CE = dyn_cast<AbstractClosureExpr>(E)) {
@@ -96,13 +113,13 @@ static bool shouldProfile(ASTNode N) {
 }
 
 namespace swift {
-bool doesASTRequireProfiling(SILModule &M, ASTNode N) {
+bool doesASTRequireProfiling(SILModule &M, ASTNode N, SILDeclRef Constant) {
   // If profiling isn't enabled, don't profile anything.
   auto &Opts = M.getOptions();
   if (Opts.UseProfile.empty() && !Opts.GenerateProfile)
     return false;
 
-  return shouldProfile(N);
+  return shouldProfile(N, Constant);
 }
 } // namespace swift
 
@@ -157,7 +174,7 @@ static bool canCreateProfilerForAST(ASTNode N, SILDeclRef forDecl) {
 
 SILProfiler *SILProfiler::create(SILModule &M, ASTNode N, SILDeclRef Ref) {
   const auto &Opts = M.getOptions();
-  if (!doesASTRequireProfiling(M, N))
+  if (!doesASTRequireProfiling(M, N, Ref))
     return nullptr;
 
   if (!canCreateProfilerForAST(N, Ref)) {

lib/SILGen/SILGen.cpp

@@ -1436,7 +1436,7 @@ void SILGenModule::emitFunction(FuncDecl *fd) {
 
   if (fd->hasBody()) {
     SILDeclRef constant(decl);
-    bool ForCoverageMapping = doesASTRequireProfiling(M, fd);
+    bool ForCoverageMapping = doesASTRequireProfiling(M, fd, constant);
     emitOrDelayFunction(*this, constant,
                         /*forceEmission=*/ForCoverageMapping);
   }

test/Profiler/unmapped.swift

@@ -22,3 +22,78 @@ struct R : Codable {
 enum E : Int {
   case a
 }
+
+// We don't profile unavailable functions, as they don't provide useful coverage
+// info.
+
+@available(*, unavailable)
+public func unavailableFunction() -> Int {
+  .random() ? 1 : 2
+}
+
+struct TypeWithUnavailableMethods {
+  @available(*, unavailable)
+  func foo() -> Int {
+    .random() ? 1 : 2
+  }
+}
+
+@available(*, unavailable)
+extension TypeWithUnavailableMethods {
+  func bar() -> Int {
+    .random() ? 1 : 2
+  }
+  public func baz() -> Int {
+    .random() ? 1 : 2
+  }
+}
+
+@propertyWrapper
+struct Wrapper<T> {
+  var wrappedValue: T
+}
+
+@available(*, unavailable)
+struct UnavailableType {
+  func foo() -> Int { .random() ? 1 : 2 }
+  public func bar() -> Int { .random() ? 1 : 2 }
+
+  var qux: Int {
+    // The && is here to test autoclosures.
+    .random() && .random() ? 1 : 2
+  }
+
+  var quux: Int {
+    get { .random() ? 1 : 2 }
+    set { _ = newValue }
+  }
+
+  subscript(_ x: Int) -> Int {
+    get { .random() ? 1 : 2 }
+    set { quux = newValue }
+  }
+
+  func baz(_ x: Int = .random() ? 0 : 1) {
+    _ = {
+      struct Nested {
+        func evenMoreNested() -> () -> Int { { .random() ? 1 : 2 } }
+      }
+      func nested() -> () -> Int { { .random() ? 1 : 2 } }
+    }
+  }
+
+  var stored: Int = .random() ? 0 : 1
+
+  var storedClosure: Int = { .random() ? 0 : 1 }()
+
+  @Wrapper
+  var wrappered = .random() ? 0 : 1
+
+  @Wrapper(wrappedValue: .random() ? 0 : 1)
+  var alsoWrappered: Int
+}
+
+@available(*, unavailable)
+class UnavailableClass {
+  deinit {}
+}