Merge pull request swiftlang#35112 from slavapestov/request-evaluator-caching-optimization

Hacks to avoid request evaluator caching overhead

Author: slavapestov

include/swift/AST/Decl.h

@@ -418,7 +418,7 @@ class alignas(1 << DeclAlignInBits) Decl {
     HasNestedTypeDeclarations : 1
   );
 
-  SWIFT_INLINE_BITFIELD(FuncDecl, AbstractFunctionDecl, 1+1+2+1+1+2+1,
+  SWIFT_INLINE_BITFIELD(FuncDecl, AbstractFunctionDecl, 1+1+2+1+1+2+1+1+1,
     /// Whether we've computed the 'static' flag yet.
     IsStaticComputed : 1,
 
@@ -437,21 +437,28 @@ class alignas(1 << DeclAlignInBits) Decl {
     /// Backing bits for 'self' access kind.
     SelfAccess : 2,
 
+    /// Whether we've computed the IsAsyncHandlerRequest.
+    IsAsyncHandlerComputed : 1,
+
+    /// The value of IsAsyncHandlerRequest.
+    IsAsyncHandler : 1,
+
     /// Whether this is a top-level function which should be treated
     /// as if it were in local context for the purposes of capture
     /// analysis.
     HasTopLevelLocalContextCaptures : 1
   );
 
   SWIFT_INLINE_BITFIELD(AccessorDecl, FuncDecl, 4 + 1 + 1,
-                        /// The kind of accessor this is.
-                        AccessorKind : 4,
+    /// The kind of accessor this is.
+    AccessorKind : 4,
 
-                        /// Whether the accessor is transparent.
-                        IsTransparent : 1,
+    /// Whether the accessor is transparent.
+    IsTransparent : 1,
 
-                        /// Whether we have computed the above.
-                        IsTransparentComputed : 1);
+    /// Whether we have computed the above.
+    IsTransparentComputed : 1
+  );
 
   SWIFT_INLINE_BITFIELD(ConstructorDecl, AbstractFunctionDecl, 1+1,
     /// Whether this constructor can fail, by building an Optional type.
@@ -5926,6 +5933,7 @@ class FuncDecl : public AbstractFunctionDecl {
   friend class SelfAccessKindRequest;
   friend class IsStaticRequest;
   friend class ResultTypeRequest;
+  friend class IsAsyncHandlerRequest;
 
   SourceLoc StaticLoc;  // Location of the 'static' token or invalid.
   SourceLoc FuncLoc;    // Location of the 'func' token.
@@ -5957,6 +5965,8 @@ class FuncDecl : public AbstractFunctionDecl {
     Bits.FuncDecl.SelfAccessComputed = false;
     Bits.FuncDecl.IsStaticComputed = false;
     Bits.FuncDecl.IsStatic = false;
+    Bits.FuncDecl.IsAsyncHandlerComputed = false;
+    Bits.FuncDecl.IsAsyncHandler = false;
     Bits.FuncDecl.HasTopLevelLocalContextCaptures = false;
   }
 
@@ -5987,6 +5997,18 @@ class FuncDecl : public AbstractFunctionDecl {
     return None;
   }
 
+  Optional<bool> getCachedIsAsyncHandler() const {
+    if (Bits.FuncDecl.IsAsyncHandlerComputed)
+      return Bits.FuncDecl.IsAsyncHandler;
+
+    return None;
+  }
+
+  void setIsAsyncHandler(bool value) {
+    Bits.FuncDecl.IsAsyncHandlerComputed = true;
+    Bits.FuncDecl.IsAsyncHandler = value;
+  }
+
 public:
   /// Factory function only for use by deserialization.
   static FuncDecl *createDeserialized(ASTContext &Context,

include/swift/AST/TypeCheckRequests.h

@@ -802,7 +802,7 @@ class SelfAccessKindRequest :
 class IsAsyncHandlerRequest :
     public SimpleRequest<IsAsyncHandlerRequest,
                          bool(FuncDecl *),
-                         RequestFlags::Cached> {
+                         RequestFlags::SeparatelyCached> {
 public:
   using SimpleRequest::SimpleRequest;
 
@@ -812,8 +812,10 @@ class IsAsyncHandlerRequest :
   bool evaluate(Evaluator &evaluator, FuncDecl *func) const;
 
 public:
-  // Caching
+  // Separate caching.
   bool isCached() const { return true; }
+  Optional<bool> getCachedResult() const;
+  void cacheResult(bool value) const;
 };
 
 /// Determine whether the given function can be an @asyncHandler, without

lib/AST/Decl.cpp

@@ -5910,6 +5910,11 @@ void VarDecl::visitAuxiliaryDecls(llvm::function_ref<void(VarDecl *)> visit) con
   if (getDeclContext()->isTypeContext())
     return;
 
+  // Avoid request evaluator overhead in the common case where there's
+  // no wrapper.
+  if (!getAttrs().hasAttribute<CustomAttr>())
+    return;
+
   if (auto *backingVar = getPropertyWrapperBackingProperty())
     visit(backingVar);
 

lib/AST/TypeCheckRequests.cpp

@@ -616,6 +616,20 @@ void SelfAccessKindRequest::cacheResult(SelfAccessKind value) const {
   funcDecl->setSelfAccessKind(value);
 }
 
+//----------------------------------------------------------------------------//
+// IsAsyncHandlerRequest computation.
+//----------------------------------------------------------------------------//
+
+Optional<bool> IsAsyncHandlerRequest::getCachedResult() const {
+  auto *funcDecl = std::get<0>(getStorage());
+  return funcDecl->getCachedIsAsyncHandler();
+}
+
+void IsAsyncHandlerRequest::cacheResult(bool value) const {
+  auto *funcDecl = std::get<0>(getStorage());
+  funcDecl->setIsAsyncHandler(value);
+}
+
 //----------------------------------------------------------------------------//
 // IsGetterMutatingRequest computation.
 //----------------------------------------------------------------------------//

lib/SILGen/SILGenDecl.cpp

@@ -1220,17 +1220,21 @@ void SILGenFunction::visitPatternBindingDecl(PatternBindingDecl *PBD) {
 void SILGenFunction::visitVarDecl(VarDecl *D) {
   // We handle emitting the variable storage when we see the pattern binding.
 
-  // Emit the property wrapper backing initializer if necessary.
-  auto wrapperInfo = D->getPropertyWrapperBackingPropertyInfo();
-  if (wrapperInfo && wrapperInfo.initializeFromOriginal)
-    SGM.emitPropertyWrapperBackingInitializer(D);
+  // Avoid request evaluator overhead in the common case where there's
+  // no wrapper.
+  if (D->getAttrs().hasAttribute<CustomAttr>()) {
+    // Emit the property wrapper backing initializer if necessary.
+    auto wrapperInfo = D->getPropertyWrapperBackingPropertyInfo();
+    if (wrapperInfo && wrapperInfo.initializeFromOriginal)
+      SGM.emitPropertyWrapperBackingInitializer(D);
 
-  D->visitAuxiliaryDecls([&](VarDecl *var) {
-    if (auto *patternBinding = var->getParentPatternBinding())
-      visitPatternBindingDecl(patternBinding);
+    D->visitAuxiliaryDecls([&](VarDecl *var) {
+      if (auto *patternBinding = var->getParentPatternBinding())
+        visitPatternBindingDecl(patternBinding);
 
-    visit(var);
-  });
+      visit(var);
+    });
+  }
 
   // Emit the variable's accessors.
   D->visitEmittedAccessors([&](AccessorDecl *accessor) {

lib/Sema/ConstraintSystem.cpp

@@ -2144,14 +2144,6 @@ std::pair<Type, bool> ConstraintSystem::adjustTypeOfOverloadReference(
   llvm_unreachable("Unhandled OverloadChoiceKind in switch.");
 }
 
-/// Whether the declaration is considered 'async'.
-static bool isDeclAsync(ValueDecl *value) {
-  if (auto func = dyn_cast<AbstractFunctionDecl>(value))
-    return func->isAsyncContext();
-
-  return false;
-}
-
 /// Walk a closure AST to determine its effects.
 ///
 /// \returns a function's extended info describing the effects, as
@@ -2374,7 +2366,7 @@ FunctionType::ExtInfo ConstraintSystem::closureEffects(ClosureExpr *expr) {
 
 bool ConstraintSystem::isAsynchronousContext(DeclContext *dc) {
   if (auto func = dyn_cast<AbstractFunctionDecl>(dc))
-    return isDeclAsync(func);
+    return func->isAsyncContext();
 
   if (auto closure = dyn_cast<ClosureExpr>(dc))
     return closureEffects(closure).isAsync();
@@ -2708,8 +2700,10 @@ void ConstraintSystem::resolveOverload(ConstraintLocator *locator,
   if (auto *decl = choice.getDeclOrNull()) {
     // If we're choosing an asynchronous declaration within a synchronous
     // context, or vice-versa, increase the async/async mismatch score.
-    if (isAsynchronousContext(useDC) != isDeclAsync(decl))
-      increaseScore(SK_AsyncSyncMismatch);
+    if (auto func = dyn_cast<AbstractFunctionDecl>(decl)) {
+      if (func->isAsyncContext() != isAsynchronousContext(useDC))
+        increaseScore(SK_AsyncSyncMismatch);
+    }
 
     // If we're binding to an init member, the 'throws' need to line up
     // between the bound and reference types.

lib/Sema/PreCheckExpr.cpp

@@ -1926,6 +1926,9 @@ Expr *PreCheckExpression::simplifyTypeConstructionWithLiteralArg(Expr *E) {
 /// expression and folding sequence expressions.
 bool ConstraintSystem::preCheckExpression(Expr *&expr, DeclContext *dc,
                                           bool replaceInvalidRefsWithErrors) {
+  auto &ctx = dc->getASTContext();
+  FrontendStatsTracer StatsTracer(ctx.Stats, "precheck-expr", expr);
+
   PreCheckExpression preCheck(dc, expr, replaceInvalidRefsWithErrors);
   // Perform the pre-check.
   if (auto result = expr->walk(preCheck)) {