Merge pull request #76111 from tshortli/lazy-typecheck-lazy-var-in-inlinable-func

SILGen: Only skip decls nested in functions when the function is skipped

Author: tshortli

include/swift/AST/DeclContext.h

@@ -496,6 +496,16 @@ class alignas(1 << DeclContextAlignInBits) DeclContext
     return const_cast<DeclContext *>(this)->getTopmostDeclarationDeclContext();
   }
 
+  /// This routine looks through closure, initializer, and local function
+  /// contexts to find the outermost function declaration.
+  ///
+  /// \returns the outermost function, or null if there is no such context.
+  LLVM_READONLY
+  DeclContext *getOutermostFunctionContext();
+  const DeclContext *getOutermostFunctionContext() const {
+    return const_cast<DeclContext *>(this)->getOutermostFunctionContext();
+  }
+
   /// Returns the innermost context that is an AbstractFunctionDecl whose
   /// body has been skipped.
   LLVM_READONLY

include/swift/AST/DeclExportabilityVisitor.h

@@ -33,6 +33,11 @@ class DeclExportabilityVisitor
   DeclExportabilityVisitor(){};
 
   bool visit(const Decl *D) {
+    // Declarations nested in fragile functions are exported.
+    if (D->getDeclContext()->getFragileFunctionKind().kind !=
+        FragileFunctionKind::None)
+      return true;
+
     if (auto value = dyn_cast<ValueDecl>(D)) {
       // A decl is exportable if it has a public access level.
       auto accessScope =
@@ -50,20 +55,6 @@ class DeclExportabilityVisitor
   bool visitDecl(const Decl *D) = delete;
   bool visitValueDecl(const ValueDecl *valueDecl) = delete;
 
-  bool visitAbstractFunctionDecl(const AbstractFunctionDecl *afd) {
-    // If this function is nested within another function that is exportable to
-    // clients then it is also exportable.
-    auto dc = afd->getDeclContext();
-    do {
-      if (auto parent = dyn_cast<AbstractFunctionDecl>(dc)) {
-        if (DeclExportabilityVisitor().visit(parent))
-          return true;
-      }
-    } while ((dc = dc->getParent()));
-
-    return false;
-  }
-
   bool visitExtensionDecl(const ExtensionDecl *ext) {
     // Extensions must extend exportable types to be exportable.
     auto nominalType = ext->getExtendedNominal();
@@ -149,6 +140,7 @@ class DeclExportabilityVisitor
   DEFAULT_TO_ACCESS_LEVEL(TypeAlias);
   DEFAULT_TO_ACCESS_LEVEL(AssociatedType);
   DEFAULT_TO_ACCESS_LEVEL(AbstractStorage);
+  DEFAULT_TO_ACCESS_LEVEL(AbstractFunction);
   DEFAULT_TO_ACCESS_LEVEL(Macro);
   DEFAULT_TO_ACCESS_LEVEL(EnumElement);
 

lib/AST/DeclContext.cpp

@@ -253,6 +253,22 @@ Decl *DeclContext::getTopmostDeclarationDeclContext() {
   return topmost;
 }
 
+DeclContext *DeclContext::getOutermostFunctionContext() {
+  AbstractFunctionDecl *result = nullptr;
+  auto dc = this;
+  do {
+    if (auto afd = dyn_cast<AbstractFunctionDecl>(dc))
+      result = afd;
+
+    // If we've found a non-local context, we don't have to keep walking up
+    // the hierarchy.
+    if (!dc->isLocalContext())
+      break;
+  } while ((dc = dc->getParent()));
+
+  return result;
+}
+
 DeclContext *DeclContext::getInnermostSkippedFunctionContext() {
   auto dc = this;
   do {

lib/SILGen/SILGen.cpp

@@ -807,6 +807,11 @@ bool SILGenModule::shouldSkipDecl(Decl *D) {
   if (!getASTContext().SILOpts.SkipNonExportableDecls)
     return false;
 
+  // Declarations nested in functions should be emitted whenever the function
+  // containing them should also be emitted.
+  if (auto funcContext = D->getDeclContext()->getOutermostFunctionContext())
+    return shouldSkipDecl(funcContext->getAsDecl());
+
   if (D->isExposedToClients())
     return false;
 

test/Inputs/lazy_typecheck.swift

@@ -24,6 +24,13 @@ public func publicFuncWithDefaultArg(_ x: Int = 1) -> Int {
   return NoTypecheck.int
 }
 
+@inlinable public func publicInlinableFunc() -> Int {
+  lazy var x = inlinableFunc()
+  func nestedFunc() {}
+  defer { nestedFunc() }
+  return x
+}
+
 package func packageFunc() -> Int {
   return NoTypecheck.int
 }

test/Inputs/lazy_typecheck_client.swift

@@ -15,6 +15,7 @@ func testGlobalFunctions() {
   let _: Int = publicFunc()
   let _: Int = publicFuncReturnsTypealias()
   let _: Int = publicFuncWithDefaultArg()
+  let _: Int = publicInlinableFunc()
   #if TEST_PACKAGE
   let _: Int = packageFunc()
   #endif

test/SILGen/skip_non_exportable_decls.swift

@@ -28,6 +28,7 @@ internal func internalFunc() {}
 // CHECK-NO-SKIP: sil hidden{{.*}} @$s4Test022internalFuncWithNestedC0yyF : $@convention(thin) () -> () {
 // CHECK-SKIP-NOT: s4Test022internalFuncWithNestedC0yyF
 internal func internalFuncWithNestedFunc() {
+  lazy var x = 1
   defer { internalFunc() }
   func nested() {}
   nested()
@@ -36,6 +37,9 @@ internal func internalFuncWithNestedFunc() {
     internalFunc()
   }()
 }
+// CHECK-NO-SKIP: sil private{{.*}} @$s4Test022internalFuncWithNestedC0yyF1xL_Sivg : $@convention(thin) (@guaranteed { var Optional<Int> }) -> Int
+// CHECK-SKIP-NOT: s4Test022internalFuncWithNestedC0yyF1xL_Sivg
+
 // CHECK-NO-SKIP: sil private{{.*}} @$s4Test022internalFuncWithNestedC0yyF6$deferL_yyF : $@convention(thin) () -> () {
 // CHECK-SKIP-NOT: s4Test022internalFuncWithNestedC0yyF6$deferL_yyF
 
@@ -53,10 +57,12 @@ public func publicFunc() {}
 
 // CHECK: sil{{.*}} @$s4Test25publicFuncWithNestedFuncsyyF : $@convention(thin) () -> () {
 public func publicFuncWithNestedFuncs() {
+  lazy var x = 1
   defer { publicFunc() }
   func nested() {}
   nested()
 }
+// CHECK: sil private{{.*}} @$s4Test25publicFuncWithNestedFuncsyyF1xL_Sivg : $@convention(thin) (@guaranteed { var Optional<Int> }) -> Int
 // CHECK: sil private{{.*}} @$s4Test25publicFuncWithNestedFuncsyyF6$deferL_yyF : $@convention(thin) () -> () {
 // CHECK: sil private{{.*}} @$s4Test25publicFuncWithNestedFuncsyyF6nestedL_yyF : $@convention(thin) () -> () {