[Profiler] Adopt SILDeclRef::hasUserWrittenCode

This replaces some of the existing checks, and
ensures that we don't emit coverage maps for
property wrapper backing initializers that don't
contain user code.

rdar://99931619

Author: hamishknight

lib/SIL/IR/SILDeclRef.cpp

@@ -313,6 +313,25 @@ bool SILDeclRef::hasUserWrittenCode() const {
   // user code into their body.
   switch (kind) {
   case Kind::Func: {
+    if (getAbstractClosureExpr()) {
+      // Auto-closures have user-written code.
+      if (auto *ACE = getAutoClosureExpr()) {
+        // Currently all types of auto-closures can contain user code. Note this
+        // logic does not affect delayed emission, as we eagerly emit all
+        // closure definitions. This does however affect profiling.
+        switch (ACE->getThunkKind()) {
+        case AutoClosureExpr::Kind::None:
+        case AutoClosureExpr::Kind::SingleCurryThunk:
+        case AutoClosureExpr::Kind::DoubleCurryThunk:
+        case AutoClosureExpr::Kind::AsyncLet:
+          return true;
+        }
+        llvm_unreachable("Unhandled case in switch!");
+      }
+      // Otherwise, assume an implicit closure doesn't have user code.
+      return false;
+    }
+
     // Lazy getters splice in the user-written initializer expr.
     if (auto *accessor = dyn_cast<AccessorDecl>(getFuncDecl())) {
       auto *storage = accessor->getStorage();

lib/SIL/IR/SILProfiler.cpp

@@ -67,19 +67,19 @@ static bool shouldProfile(ASTNode N, SILDeclRef Constant) {
     }
   }
 
+  // Do not profile code that hasn't been written by the user.
+  if (!Constant.hasUserWrittenCode()) {
+    LLVM_DEBUG(llvm::dbgs() << "Skipping ASTNode: no user-written code\n");
+    return false;
+  }
+
   if (auto *E = N.dyn_cast<Expr *>()) {
     if (auto *CE = dyn_cast<AbstractClosureExpr>(E)) {
       // Only profile closure expressions with bodies.
       if (!doesClosureHaveBody(CE)) {
         LLVM_DEBUG(llvm::dbgs() << "Skipping ASTNode: closure without body\n");
         return false;
       }
-
-      // Don't profile implicit closures, unless they're autoclosures.
-      if (!isa<AutoClosureExpr>(CE) && CE->isImplicit()) {
-        LLVM_DEBUG(llvm::dbgs() << "Skipping ASTNode: implicit closure expr\n");
-        return false;
-      }
     }
 
     // Profile all other kinds of expressions.
@@ -93,20 +93,6 @@ static bool shouldProfile(ASTNode N, SILDeclRef Constant) {
       LLVM_DEBUG(llvm::dbgs() << "Skipping ASTNode: function without body\n");
       return false;
     }
-
-    // Profile implicit getters for lazy variables.
-    if (auto *accessor = dyn_cast<AccessorDecl>(AFD)) {
-      if (accessor->isImplicit() && accessor->isGetter() &&
-          accessor->getStorage()->getAttrs().hasAttribute<LazyAttr>()) {
-        return true;
-      }
-    }
-  }
-
-  // Skip any remaining implicit, or otherwise unsupported decls.
-  if (D->isImplicit() || isa<EnumCaseDecl>(D)) {
-    LLVM_DEBUG(llvm::dbgs() << "Skipping ASTNode: implicit/unsupported decl\n");
-    return false;
   }
 
   return true;

test/Profiler/Inputs/unmapped_secondary.swift

@@ -0,0 +1,22 @@
+// A secondary file for unmapped.swift that can contain profiled code.
+
+@propertyWrapper
+struct Wrapper<T> {
+  var wrappedValue: T
+}
+
+struct Projected<T> {
+  var value: T
+}
+
+@propertyWrapper
+struct WrapperWithProjectedValue<T> {
+  var wrappedValue: T
+  init(projectedValue: Projected<T>) {
+    self.wrappedValue = projectedValue.value
+  }
+  var projectedValue: Projected<T> {
+    Projected(value: wrappedValue)
+  }
+}
+

test/Profiler/coverage_property_wrapper_backing.swift

@@ -1,4 +1,5 @@
-// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -profile-generate -profile-coverage-mapping -emit-sorted-sil -emit-sil -module-name coverage_property_wrapper_backing %s | %FileCheck %s
+// This uses '-primary-file' to ensure we're conservative with lazy SIL emission.
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -profile-generate -profile-coverage-mapping -emit-sorted-sil -emit-sil -module-name coverage_property_wrapper_backing -primary-file %s | %FileCheck %s
 // RUN: %target-swift-frontend -profile-generate -profile-coverage-mapping -emit-ir %s
 
 @propertyWrapper
@@ -9,6 +10,11 @@ struct Wrapper<T> {
   }
 }
 
+@propertyWrapper
+struct PassThroughWrapper<T> {
+  var wrappedValue: T
+}
+
 // rdar://99931619 – Make sure we emit the profiler increment for the backing
 // initializer.
 
@@ -32,6 +38,20 @@ struct S {
   // CHECK-NEXT: }
 }
 
-// FIXME(rdar://99962285): This is currently needed to SILGen the property
-// initializer for 'i'.
-_ = S().i
+struct T {
+  // The backing initializer for j has no user-written code, so no coverage map needed.
+  // CHECK-NOT: sil_coverage_map {{.*}} "s33coverage_property_wrapper_backing1TV1jSivpfP"
+  @PassThroughWrapper
+  var j = 3
+
+  // FIXME: Ideally the region here would only span the length of the @Wrapper
+  // argument list.
+  // CHECK-LABEL: sil_coverage_map {{.*}} "$s33coverage_property_wrapper_backing1TV1kSivpfP" {{.*}} // property wrapper backing initializer of coverage_property_wrapper_backing.T.k
+  // CHECK-NEXT:  [[@LINE+4]]:4 -> [[@LINE+5]]:30 : 0
+  // CHECK-NEXT:  [[@LINE+4]]:24 -> [[@LINE+4]]:25 : 1
+  // CHECK-NEXT:  [[@LINE+3]]:28 -> [[@LINE+3]]:29 : (0 - 1)
+  // CHECK-NEXT:  }
+  @PassThroughWrapper
+  @Wrapper(.random() ? 1 : 2)
+  var k = 3
+}

test/Profiler/coverage_var_init.swift

@@ -32,14 +32,14 @@ struct S {
 }
 
 final class VarInit {
-  // CHECK: sil_coverage_map {{.*}} "$s17coverage_var_init7VarInitC018initializedWrapperE0SivpfP"
-  // CHECK-NEXT: [[@LINE+1]]:4 -> [[@LINE+1]]:42 : 0
-  @Wrapper var initializedWrapperInit = 2
-
   // CHECK: sil_coverage_map {{.*}} // variable initialization expression of coverage_var_init.VarInit.(_autoclosureWrapperInit
   // CHECK-NEXT: [[@LINE+1]]:52 -> [[@LINE+1]]:53
   @AutoClosureWrapper var autoclosureWrapperInit = 3
 
+  // CHECK: sil_coverage_map {{.*}} "$s17coverage_var_init7VarInitC019_initializedWrapper{{.*}}" {{.*}} // variable initialization expression of coverage_var_init.VarInit.(_initializedWrapperInit
+  // CHECK-NEXT: [[@LINE+1]]:41 -> [[@LINE+1]]:42 : 0
+  @Wrapper var initializedWrapperInit = 2
+
   // CHECK: sil_coverage_map {{.*}} "$s17coverage_var_init7VarInitC04lazydE033_49373CB2DFB47C8DC62FA963604688DFLLSSvgSSyXEfU_"
   // CHECK-NEXT: [[@LINE+1]]:42 -> [[@LINE+3]]:4 : 0
   private lazy var lazyVarInit: String = {

test/Profiler/unmapped.swift

@@ -1,5 +1,6 @@
-// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -suppress-warnings -profile-generate -profile-coverage-mapping -emit-sorted-sil -emit-sil -module-name unmapped %s | %FileCheck %s
-// RUN: %target-swift-frontend -profile-generate -profile-coverage-mapping -emit-ir %s
+// This uses '-primary-file' to ensure we're conservative with lazy SIL emission.
+// RUN: %target-swift-frontend -Xllvm -sil-full-demangle -suppress-warnings -profile-generate -profile-coverage-mapping -emit-sorted-sil -emit-sil -module-name unmapped -primary-file %s %S/Inputs/unmapped_secondary.swift | %FileCheck %s
+// RUN: %target-swift-frontend -profile-generate -profile-coverage-mapping -emit-ir %s %S/Inputs/unmapped_secondary.swift
 
 // This test is exclusively for AST that we should never profile, as there is
 // no interesting user-written code.
@@ -18,11 +19,21 @@ struct R : Codable {
   var y: Int
 }
 
+struct Q {
+  // Don't profile the backing initializer.
+  @Wrapper
+  var x: Int
+}
+
 // Don't profile the implicit rawValue.
 enum E : Int {
   case a
 }
 
+// Don't profile the backing initalizers of the property wrapper.
+@available(*, unavailable)
+func hasExternalPropertyWrapper(@WrapperWithProjectedValue x: Int) {}
+
 // We don't profile unavailable functions, as they don't provide useful coverage
 // info.
 
@@ -48,11 +59,6 @@ extension TypeWithUnavailableMethods {
   }
 }
 
-@propertyWrapper
-struct Wrapper<T> {
-  var wrappedValue: T
-}
-
 @available(*, unavailable)
 struct UnavailableType {
   func foo() -> Int { .random() ? 1 : 2 }