AST/SILGen: Requestify function body skipping.

Function bodies are skipped during typechecking when one of the
-experimental-skip-*-function-bodies flags is passed to the frontend. This was
implemented by setting the "body kind" of an `AbstractFunctionDecl` during decl
checking in `TypeCheckDeclPrimary`. This approach had a couple of issues:
- It is incompatible with skipping function bodies during lazy typechecking,
  since the skipping is only evaluated during a phase of eager typechecking.
- It prevents skipped function bodies from being parsed on-demand ("skipped" is
  a state that is distinct from "parsed", when they ought to be orthogonal).
  This needlessly prevented complete module interfaces from being emitted with
  -experimental-skip-all-function-bodies.

Storing the skipped status of a function separately from body kind and
requestifying the determination of whether to skip a function solves these
problems.

Resolves rdar://116020403

Author: tshortli

include/swift/AST/Decl.h

@@ -450,10 +450,13 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
   SWIFT_INLINE_BITFIELD(SubscriptDecl, VarDecl, 2,
     StaticSpelling : 2
   );
-  SWIFT_INLINE_BITFIELD(AbstractFunctionDecl, ValueDecl, 3+2+8+1+1+1+1+1+1+1,
+  SWIFT_INLINE_BITFIELD(AbstractFunctionDecl, ValueDecl, 3+2+2+8+1+1+1+1+1+1+1,
     /// \see AbstractFunctionDecl::BodyKind
     BodyKind : 3,
 
+    /// \see AbstractFunctionDecl::BodySkippedStatus
+    BodySkippedStatus : 2,
+
     /// \see AbstractFunctionDecl::SILSynthesizeKind
     SILSynthesizeKind : 2,
 
@@ -6856,9 +6859,6 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
     /// Function body is parsed and available as an AST subtree.
     Parsed,
 
-    /// Function body is not available, although it was written in the source.
-    Skipped,
-
     /// Function body will be synthesized on demand.
     Synthesize,
 
@@ -6874,6 +6874,14 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
     // This enum currently needs to fit in a 3-bit bitfield.
   };
 
+  enum class BodySkippedStatus {
+    Unknown,
+    Skipped,
+    NotSkipped,
+
+    // This enum needs to fit in a 2-bit bitfield.
+  };
+
   BodyKind getBodyKind() const {
     return BodyKind(Bits.AbstractFunctionDecl.BodyKind);
   }
@@ -6925,13 +6933,13 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
 
     /// The location of the function body when the body is delayed or skipped.
     ///
-    /// This enum member is active if getBodyKind() is BodyKind::Unparsed or
-    /// BodyKind::Skipped.
+    /// This enum member is active if getBodyKind() is BodyKind::Unparsed.
     SourceRange BodyRange;
   };
 
   friend class ParseAbstractFunctionBodyRequest;
   friend class TypeCheckFunctionBodyRequest;
+  friend class IsFunctionBodySkippedRequest;
 
   CaptureInfo Captures;
 
@@ -6969,6 +6977,15 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
     Bits.AbstractFunctionDecl.BodyKind = unsigned(K);
   }
 
+  BodySkippedStatus getBodySkippedStatus() const {
+    return static_cast<BodySkippedStatus>(
+        Bits.AbstractFunctionDecl.BodySkippedStatus);
+  }
+
+  void setBodySkippedStatus(BodySkippedStatus status) {
+    Bits.AbstractFunctionDecl.BodySkippedStatus = unsigned(status);
+  }
+
   void setSILSynthesizeKind(SILSynthesizeKind K) {
     Bits.AbstractFunctionDecl.SILSynthesizeKind = unsigned(K);
   }
@@ -7087,10 +7104,7 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   ///
   /// Note that a true return value does not imply that the body was actually
   /// parsed.
-  bool hasBody() const {
-    return getBodyKind() != BodyKind::None &&
-           getBodyKind() != BodyKind::Skipped;
-  }
+  bool hasBody() const { return getBodyKind() != BodyKind::None; }
 
   /// Returns true if the text of this function's body can be retrieved either
   /// by extracting the text from the source buffer or reading the inlinable
@@ -7112,21 +7126,6 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// Set a new body for the function.
   void setBody(BraceStmt *S, BodyKind NewBodyKind);
 
-  /// Note that the body was skipped for this function. Function body
-  /// cannot be attached after this call.
-  void setBodySkipped(SourceRange bodyRange) {
-    // FIXME: Remove 'Parsed' from this list once we can always delay
-    //        parsing bodies. The -experimental-skip-*-function-bodies options
-    //        do currently skip parsing, unless disabled through other means in
-    //        SourceFile::hasDelayedBodyParsing.
-    assert(getBodyKind() == BodyKind::None ||
-           getBodyKind() == BodyKind::Unparsed ||
-           getBodyKind() == BodyKind::Parsed);
-    assert(bodyRange.isValid());
-    BodyRange = bodyRange;
-    setBodyKind(BodyKind::Skipped);
-  }
-
   /// Note that parsing for the body was delayed.
   void setBodyDelayed(SourceRange bodyRange) {
     assert(getBodyKind() == BodyKind::None);
@@ -7204,9 +7203,9 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
     return getBodyKind() == BodyKind::SILSynthesize;
   }
 
-  bool isBodySkipped() const {
-    return getBodyKind() == BodyKind::Skipped;
-  }
+  /// Indicates whether the body of this function is skipped during
+  /// typechecking.
+  bool isBodySkipped() const;
 
   bool isMemberwiseInitializer() const {
     return getBodyKind() == BodyKind::SILSynthesize

include/swift/AST/TypeCheckRequests.h

@@ -4423,6 +4423,25 @@ class SerializeAttrGenericSignatureRequest
   void cacheResult(GenericSignature signature) const;
 };
 
+class IsFunctionBodySkippedRequest
+    : public SimpleRequest<IsFunctionBodySkippedRequest,
+                           bool(const AbstractFunctionDecl *),
+                           RequestFlags::SeparatelyCached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  bool evaluate(Evaluator &evaluator, const AbstractFunctionDecl *) const;
+
+public:
+  // Separate caching.
+  bool isCached() const { return true; }
+  llvm::Optional<bool> getCachedResult() const;
+  void cacheResult(bool isSkipped) const;
+};
+
 #define SWIFT_TYPEID_ZONE TypeChecker
 #define SWIFT_TYPEID_HEADER "swift/AST/TypeCheckerTypeIDZone.def"
 #include "swift/Basic/DefineTypeIDZone.h"

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -503,3 +503,6 @@ SWIFT_REQUEST(TypeChecker, ExpandChildTypeRefinementContextsRequest,
 SWIFT_REQUEST(TypeChecker, SerializeAttrGenericSignatureRequest,
               bool(Decl *, SpecializeAttr *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, IsFunctionBodySkippedRequest,
+              bool(const AbstractFunctionDecl *),
+              SeparatelyCached, NoLocationInfo)

lib/AST/ASTVerifier.cpp

@@ -496,7 +496,6 @@ class Verifier : public ASTWalker {
       switch (afd->getBodyKind()) {
       case AbstractFunctionDecl::BodyKind::None:
       case AbstractFunctionDecl::BodyKind::TypeChecked:
-      case AbstractFunctionDecl::BodyKind::Skipped:
       case AbstractFunctionDecl::BodyKind::SILSynthesize:
       case AbstractFunctionDecl::BodyKind::Deserialized:
         return true;

lib/AST/Decl.cpp

@@ -8934,9 +8934,6 @@ BraceStmt *AbstractFunctionDecl::getTypecheckedBody() const {
 }
 
 void AbstractFunctionDecl::setBody(BraceStmt *S, BodyKind NewBodyKind) {
-  assert(getBodyKind() != BodyKind::Skipped &&
-         "cannot set a body if it was skipped");
-
   llvm::Optional<Fingerprint> fp = llvm::None;
   if (getBodyKind() == BodyKind::TypeChecked ||
       getBodyKind() == BodyKind::Parsed) {
@@ -8952,6 +8949,52 @@ void AbstractFunctionDecl::setBody(BraceStmt *S, BodyKind NewBodyKind) {
   }
 }
 
+bool AbstractFunctionDecl::isBodySkipped() const {
+  return evaluateOrDefault(getASTContext().evaluator, IsFunctionBodySkippedRequest{this}, false);
+}
+
+bool IsFunctionBodySkippedRequest::evaluate(
+    Evaluator &evaluator, const AbstractFunctionDecl *afd) const {
+  auto &Ctx = afd->getASTContext();
+  // Make sure we're in a mode that's skipping function bodies.
+  if (Ctx.TypeCheckerOpts.SkipFunctionBodies == FunctionBodySkipping::None)
+    return false;
+
+  if (auto *AD = dyn_cast<AccessorDecl>(afd)) {
+    // didSet needs to be checked to determine whether to keep its parameter,
+    // so never try to skip.
+    if (AD->getAccessorKind() == AccessorKind::DidSet)
+      return false;
+
+    // Synthesized accessors (like implicit _read or _modify accessors) need to
+    // be typechecked because they get serialized.
+    if (AD->isSynthesized())
+      return false;
+  }
+
+  // Do not skip the body of an actor initializer. They are checked to determine
+  // delegation status.
+  if (auto *ctor = dyn_cast<ConstructorDecl>(afd))
+    if (auto *nom = ctor->getParent()->getSelfNominalTypeDecl())
+      if (nom->isAnyActor())
+        return false;
+
+  // Skipping all bodies won't serialize anything, so we can skip regardless.
+  if (Ctx.TypeCheckerOpts.SkipFunctionBodies == FunctionBodySkipping::All)
+    return true;
+
+  // If we want all types (for LLDB) we can't skip functions with nested
+  // types. We could probably improve upon this and type-check only the
+  // nested types instead for better performances.
+  if (afd->hasNestedTypeDeclarations() &&
+      Ctx.TypeCheckerOpts.SkipFunctionBodies ==
+          FunctionBodySkipping::NonInlinableWithoutTypes)
+    return false;
+
+  // Only skip functions where their body won't be serialized
+  return afd->getResilienceExpansion() != ResilienceExpansion::Minimal;
+}
+
 void AbstractFunctionDecl::setBodyToBeReparsed(SourceRange bodyRange) {
   assert(bodyRange.isValid());
   assert(getBodyKind() == BodyKind::Unparsed ||
@@ -8986,7 +9029,6 @@ SourceRange AbstractFunctionDecl::getBodySourceRange() const {
 
     return SourceRange();
 
-  case BodyKind::Skipped:
   case BodyKind::Unparsed:
     return BodyRange;
   }
@@ -9396,7 +9438,6 @@ bool AbstractFunctionDecl::hasInlinableBodyText() const {
 
   case BodyKind::None:
   case BodyKind::Synthesize:
-  case BodyKind::Skipped:
   case BodyKind::SILSynthesize:
     return false;
   }
@@ -9847,8 +9888,7 @@ SourceRange FuncDecl::getSourceRange() const {
   if (StartLoc.isInvalid())
     return SourceRange();
 
-  if (getBodyKind() == BodyKind::Unparsed ||
-      getBodyKind() == BodyKind::Skipped)
+  if (getBodyKind() == BodyKind::Unparsed)
     return { StartLoc, BodyRange.End };
 
   SourceLoc RBraceLoc = getOriginalBodySourceRange().End;
@@ -10530,7 +10570,6 @@ ParseAbstractFunctionBodyRequest::getCachedResult() const {
   case BodyKind::Deserialized:
   case BodyKind::SILSynthesize:
   case BodyKind::None:
-  case BodyKind::Skipped:
     return BodyAndFingerprint{};
 
   case BodyKind::TypeChecked:
@@ -10552,7 +10591,6 @@ void ParseAbstractFunctionBodyRequest::cacheResult(
   case BodyKind::Deserialized:
   case BodyKind::SILSynthesize:
   case BodyKind::None:
-  case BodyKind::Skipped:
     // The body is always empty, so don't cache anything.
     assert(!value.getFingerprint().has_value() && value.getBody() == nullptr);
     return;
@@ -10569,6 +10607,27 @@ void ParseAbstractFunctionBodyRequest::cacheResult(
   }
 }
 
+llvm::Optional<bool> IsFunctionBodySkippedRequest::getCachedResult() const {
+  using BodySkippedStatus = AbstractFunctionDecl::BodySkippedStatus;
+  auto afd = std::get<0>(getStorage());
+  switch (afd->getBodySkippedStatus()) {
+  case BodySkippedStatus::Unknown:
+    return llvm::None;
+  case BodySkippedStatus::Skipped:
+    return true;
+  case BodySkippedStatus::NotSkipped:
+    return false;
+  }
+  llvm_unreachable("bad BodySkippedStatus");
+}
+
+void IsFunctionBodySkippedRequest::cacheResult(bool isSkipped) const {
+  using BodySkippedStatus = AbstractFunctionDecl::BodySkippedStatus;
+  auto afd = std::get<0>(getStorage());
+  const_cast<AbstractFunctionDecl *>(afd)->setBodySkippedStatus(
+      isSkipped ? BodySkippedStatus::Skipped : BodySkippedStatus::NotSkipped);
+}
+
 void swift::simple_display(llvm::raw_ostream &out, BodyAndFingerprint value) {
   out << "(";
   simple_display(out, value.getBody());

lib/AST/TypeCheckRequests.cpp

@@ -1457,11 +1457,13 @@ llvm::Optional<BraceStmt *>
 TypeCheckFunctionBodyRequest::getCachedResult() const {
   using BodyKind = AbstractFunctionDecl::BodyKind;
   auto *afd = std::get<0>(getStorage());
+  if (afd->isBodySkipped())
+    return nullptr;
+
   switch (afd->getBodyKind()) {
   case BodyKind::Deserialized:
   case BodyKind::SILSynthesize:
   case BodyKind::None:
-  case BodyKind::Skipped:
     // These cases don't have any body available.
     return nullptr;
 

lib/Parse/ParseRequests.cpp

@@ -91,7 +91,6 @@ ParseAbstractFunctionBodyRequest::evaluate(Evaluator &evaluator,
   case BodyKind::Deserialized:
   case BodyKind::SILSynthesize:
   case BodyKind::None:
-  case BodyKind::Skipped:
     return {};
 
   case BodyKind::TypeChecked:

lib/SIL/IR/Linker.cpp

@@ -61,6 +61,7 @@
 #include "swift/AST/SubstitutionMap.h"
 #include "swift/ClangImporter/ClangModule.h"
 #include "swift/SIL/FormalLinkage.h"
+#include "swift/SIL/PrettyStackTrace.h"
 #include "swift/Serialization/SerializedSILLoader.h"
 #include <functional>
 
@@ -100,6 +101,8 @@ void SILLinkerVisitor::deserializeAndPushToWorklist(SILFunction *F) {
 /// Deserialize a function and add it to the worklist for processing.
 void SILLinkerVisitor::maybeAddFunctionToWorklist(SILFunction *F,
                                                   bool setToSerializable) {
+  PrettyStackTraceSILFunction stackTrace("adding to linker worklist", F);
+
   SILLinkage linkage = F->getLinkage();
   assert((!setToSerializable || F->hasValidLinkageForFragileRef() ||
          hasSharedVisibility(linkage)) &&

lib/SIL/Verifier/SILVerifier.cpp

@@ -6676,13 +6676,20 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     SILModule &mod = F->getModule();
     bool embedded = mod.getASTContext().LangOpts.hasFeature(Feature::Embedded);
 
+    bool isBodySkipped = false;
+    if (auto DC = F->getDeclContext()) {
+      if (auto AFD = dyn_cast<AbstractFunctionDecl>(DC)) {
+        isBodySkipped = AFD->isBodySkipped();
+      }
+    }
+
     require(!F->isSerialized() || !mod.isSerialized() || mod.isParsedAsSerializedSIL(),
             "cannot have a serialized function after the module has been serialized");
 
     switch (F->getLinkage()) {
     case SILLinkage::Public:
     case SILLinkage::Shared:
-      require(F->isDefinition() || F->hasForeignBody(),
+      require(isBodySkipped || F->isDefinition() || F->hasForeignBody(),
               "public/shared function must have a body");
       break;
     case SILLinkage::PublicNonABI:
@@ -6711,13 +6718,8 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
 
     // Don't verify functions that were skipped. We are likely to see them in
     // FunctionBodySkipping::NonInlinableWithoutTypes mode.
-    auto Ctx = F->getDeclContext();
-    if (Ctx) {
-      if (auto AFD = dyn_cast<AbstractFunctionDecl>(Ctx)) {
-        if (AFD->isBodySkipped())
-          return;
-      }
-    }
+    if (isBodySkipped)
+      return;
 
     if (F->isExternalDeclaration()) {
       if (F->hasForeignBody())