AST: Use VarDecl::isInitExposedToClients() from DeclContext::getFragileFunctionKind()

getFragileFunctionKind() would report that all initializers in
non-resilient public types were inlinable, including static
properties.

This was later patched by VarDecl::isInitExposedToClients(),
which was checked in diagnoseInlinableDeclRefAccess().
However, the latter function only looked at the innermost
DeclContexts, not all parent contexts, so it would incorrectly
diagnose code with a nested DeclContext inside of a static
property initializer.

Fix this by changing getFragileFunctionKind() to call
isInitExposedToClients() and simplifying
diagnoseInlinableDeclRefAccess().

This commit also introduces a new isLayoutExposedToClients()
method, which is similar to isInitExposedToClients(), except
it also returns 'true' if the property does not have an
initializer (and in fact the latter is implemented in terms
of the former).

Author: slavapestov

include/swift/AST/Decl.h

@@ -4763,11 +4763,19 @@ class VarDecl : public AbstractStorageDecl {
 
   /// Determines if this var has an initializer expression that should be
   /// exposed to clients.
+  ///
   /// There's a very narrow case when we would: if the decl is an instance
   /// member with an initializer expression and the parent type is
   /// @frozen and resides in a resilient module.
   bool isInitExposedToClients() const;
-  
+
+  /// Determines if this var is exposed as part of the layout of a
+  /// @frozen struct.
+  ///
+  /// From the standpoint of access control and exportability checking, this
+  /// var will behave as if it was public, even if it is internal or private.
+  bool isLayoutExposedToClients() const;
+
   /// Is this a special debugger variable?
   bool isDebuggerVar() const { return Bits.VarDecl.IsDebuggerVar; }
   void setDebuggerVar(bool IsDebuggerVar) {

lib/AST/Decl.cpp

@@ -1582,12 +1582,27 @@ VarDecl *PatternBindingDecl::getAnchoringVarDecl(unsigned i) const {
 }
 
 bool VarDecl::isInitExposedToClients() const {
+  return hasInitialValue() && isLayoutExposedToClients();
+}
+
+bool VarDecl::isLayoutExposedToClients() const {
   auto parent = dyn_cast<NominalTypeDecl>(getDeclContext());
   if (!parent) return false;
-  if (!hasInitialValue()) return false;
   if (isStatic()) return false;
-  return parent->getAttrs().hasAttribute<FrozenAttr>() ||
-         parent->getAttrs().hasAttribute<FixedLayoutAttr>();
+
+  if (!hasStorage() &&
+      !getAttrs().hasAttribute<LazyAttr>() &&
+      !hasAttachedPropertyWrapper()) {
+    return false;
+  }
+
+  auto nominalAccess =
+    parent->getFormalAccessScope(/*useDC=*/nullptr,
+                                 /*treatUsableFromInlineAsPublic=*/true);
+  if (!nominalAccess.isPublic()) return false;
+
+  return (parent->getAttrs().hasAttribute<FrozenAttr>() ||
+          parent->getAttrs().hasAttribute<FixedLayoutAttr>());
 }
 
 /// Check whether the given type representation will be

lib/AST/DeclContext.cpp

@@ -368,21 +368,17 @@ swift::FragileFunctionKindRequest::evaluate(Evaluator &evaluator,
 
     // Stored property initializer contexts use minimal resilience expansion
     // if the type is formally fixed layout.
-    if (isa<PatternBindingInitializer>(dc)) {
-      if (auto *NTD = dyn_cast<NominalTypeDecl>(dc->getParent())) {
-        auto nominalAccess =
-          NTD->getFormalAccessScope(/*useDC=*/nullptr,
-                                    /*treatUsableFromInlineAsPublic=*/true);
-        if (!nominalAccess.isPublic())
-          return {FragileFunctionKind::None,
-                  /*allowUsableFromInline=*/false};
-
-        if (NTD->isFormallyResilient())
-          return {FragileFunctionKind::None,
-                  /*allowUsableFromInline=*/false};
-
-        return {FragileFunctionKind::PropertyInitializer, true};
+    if (auto *init = dyn_cast <PatternBindingInitializer>(dc)) {
+      auto bindingIndex = init->getBindingIndex();
+      if (auto *varDecl = init->getBinding()->getAnchoringVarDecl(bindingIndex)) {
+        if (varDecl->isInitExposedToClients()) {
+          return {FragileFunctionKind::PropertyInitializer,
+                  /*allowUsableFromInline=*/true};
+        }
       }
+
+      return {FragileFunctionKind::None,
+              /*allowUsableFromInline=*/false};
     }
 
     if (auto *AFD = dyn_cast<AbstractFunctionDecl>(dc)) {
@@ -434,7 +430,8 @@ swift::FragileFunctionKindRequest::evaluate(Evaluator &evaluator,
     }
   }
 
-  return {FragileFunctionKind::None, false};
+  return {FragileFunctionKind::None,
+          /*allowUsableFromInline=*/false};
 }
 
 /// Determine whether the innermost context is generic.

lib/Sema/ResilienceDiagnostics.cpp

@@ -56,14 +56,6 @@ bool TypeChecker::diagnoseInlinableDeclRefAccess(SourceLoc loc,
     return false;
   }
 
-  // Property initializers that are not exposed to clients are OK.
-  if (auto pattern = dyn_cast<PatternBindingInitializer>(DC)) {
-    auto bindingIndex = pattern->getBindingIndex();
-    auto *varDecl = pattern->getBinding()->getAnchoringVarDecl(bindingIndex);
-    if (!varDecl->isInitExposedToClients())
-      return false;
-  }
-
   DowngradeToWarning downgradeToWarning = DowngradeToWarning::No;
 
   // Swift 4.2 did not perform any checks for type aliases.

test/attr/attr_inlinable.swift

@@ -275,8 +275,21 @@ internal func internalIntReturningFunc() -> Int { return 0 }
 public struct PublicFixedStructWithInit {
   var x = internalGlobal // expected-error {{let 'internalGlobal' is internal and cannot be referenced from a property initializer in a '@frozen' type}}
   var y = publicGlobal // OK
+
+  // Static property initializers are not inlinable contexts.
   static var z = privateIntReturningFunc() // OK
   static var a = internalIntReturningFunc() // OK
+
+  // Test the same with a multi-statement closure, which introduces a
+  // new DeclContext.
+  static var zz: Int = {
+    let x = privateIntReturningFunc()
+    return x
+  }()
+  static var aa: Int = {
+    let x = internalIntReturningFunc()
+    return x
+  }()
 }
 
 public struct KeypathStruct {