Merge pull request #26282 from slavapestov/storage-impl-info-request

Use a request to compute AbstractStorageDecl::getImplInfo()

Author: slavapestov

include/swift/AST/Decl.h

@@ -4385,6 +4385,7 @@ class AbstractStorageDecl : public ValueDecl {
   friend class IsGetterMutatingRequest;
   friend class IsSetterMutatingRequest;
   friend class OpaqueReadOwnershipRequest;
+  friend class StorageImplInfoRequest;
 
 public:
   static const size_t MaxNumAccessors = 255;
@@ -4487,7 +4488,7 @@ class AbstractStorageDecl : public ValueDecl {
   Type getValueInterfaceType() const;
 
   /// Determine how this storage is implemented.
-  StorageImplInfo getImplInfo() const { return ImplInfo; }
+  StorageImplInfo getImplInfo() const;
 
   /// Overwrite the registered implementation-info.  This should be
   /// used carefully.

include/swift/AST/TypeCheckRequests.h

@@ -29,6 +29,7 @@
 
 namespace swift {
 
+class AbstractStorageDecl;
 class GenericParamList;
 struct PropertyWrapperBackingPropertyInfo;
 class RequirementRepr;
@@ -836,6 +837,27 @@ class StoredPropertiesAndMissingMembersRequest :
   bool isCached() const { return true; }
 };
 
+class StorageImplInfoRequest :
+    public SimpleRequest<StorageImplInfoRequest,
+                         StorageImplInfo(AbstractStorageDecl *),
+                         CacheKind::SeparatelyCached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  llvm::Expected<StorageImplInfo>
+  evaluate(Evaluator &evaluator, AbstractStorageDecl *decl) const;
+
+public:
+  // Separate caching.
+  bool isCached() const { return true; }
+  Optional<StorageImplInfo> getCachedResult() const;
+  void cacheResult(StorageImplInfo value) const;
+};
+
 // Allow AnyValue to compare two Type values, even though Type doesn't
 // support ==.
 template<>

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -46,3 +46,4 @@ SWIFT_TYPEID(LazyStoragePropertyRequest)
 SWIFT_TYPEID(TypeCheckFunctionBodyUntilRequest)
 SWIFT_TYPEID(StoredPropertiesRequest)
 SWIFT_TYPEID(StoredPropertiesAndMissingMembersRequest)
+SWIFT_TYPEID(StorageImplInfoRequest)

include/swift/Basic/Statistics.def

@@ -179,6 +179,12 @@ FRONTEND_STATISTIC(Sema, NumDeclsTypechecked)
 /// Number of declarations finalized.
 FRONTEND_STATISTIC(Sema, NumDeclsFinalized)
 
+/// Number of synthesized accessors.
+FRONTEND_STATISTIC(Sema, NumAccessorsSynthesized)
+
+/// Number of synthesized accessor bodies.
+FRONTEND_STATISTIC(Sema, NumAccessorBodiesSynthesized)
+
 /// Number of full function bodies typechecked.
 FRONTEND_STATISTIC(Sema, NumFunctionsTypechecked)
 

lib/AST/AccessRequests.cpp

@@ -148,12 +148,37 @@ void AccessLevelRequest::cacheResult(AccessLevel value) const {
 // the cycle of computation associated with formal accesses, we give it its own
 // request.
 
+// In a .swiftinterface file, a stored property with an explicit @_hasStorage
+// attribute but no setter is assumed to have originally been a private(set).
+static bool isStoredWithPrivateSetter(VarDecl *VD) {
+  auto *HSA = VD->getAttrs().getAttribute<HasStorageAttr>();
+  if (!HSA || HSA->isImplicit())
+    return false;
+
+  auto *DC = VD->getDeclContext();
+  auto *SF = DC->getParentSourceFile();
+  if (!SF || SF->Kind != SourceFileKind::Interface)
+    return false;
+
+  if (VD->isLet() ||
+      (VD->getSetter() &&
+       !VD->getSetter()->isImplicit()))
+    return false;
+
+  return true;
+}
+
 llvm::Expected<AccessLevel>
 SetterAccessLevelRequest::evaluate(Evaluator &evaluator,
                                    AbstractStorageDecl *ASD) const {
   assert(!ASD->Accessors.getInt().hasValue());
-  if (auto *AA = ASD->getAttrs().getAttribute<SetterAccessAttr>())
-    return AA->getAccess();
+  if (auto *SAA = ASD->getAttrs().getAttribute<SetterAccessAttr>())
+    return SAA->getAccess();
+
+  if (auto *VD = dyn_cast<VarDecl>(ASD))
+    if (isStoredWithPrivateSetter(VD))
+      return AccessLevel::Private;
+
   return ASD->getFormalAccess();
 }
 

lib/AST/Decl.cpp

@@ -4621,6 +4621,14 @@ void ProtocolDecl::computeKnownProtocolKind() const {
   const_cast<ProtocolDecl *>(this)->Bits.ProtocolDecl.KnownProtocol = value;
 }
 
+
+StorageImplInfo AbstractStorageDecl::getImplInfo() const {
+  ASTContext &ctx = getASTContext();
+  return evaluateOrDefault(ctx.evaluator,
+    StorageImplInfoRequest{const_cast<AbstractStorageDecl *>(this)},
+    StorageImplInfo::getSimpleStored(StorageIsMutable));
+}
+
 bool AbstractStorageDecl::hasPrivateAccessor() const {
   for (auto accessor : getAllAccessors()) {
     if (hasPrivateOrFilePrivateFormalAccess(accessor))

lib/AST/TypeCheckRequests.cpp

@@ -659,3 +659,20 @@ void OpaqueReadOwnershipRequest::cacheResult(OpaqueReadOwnership value) const {
   auto *storage = std::get<0>(getStorage());
   storage->setOpaqueReadOwnership(value);
 }
+
+//----------------------------------------------------------------------------//
+// StorageImplInfoRequest computation.
+//----------------------------------------------------------------------------//
+
+Optional<StorageImplInfo>
+StorageImplInfoRequest::getCachedResult() const {
+  auto *storage = std::get<0>(getStorage());
+  if (storage->LazySemanticInfo.ImplInfoComputed)
+    return storage->ImplInfo;
+  return None;
+}
+
+void StorageImplInfoRequest::cacheResult(StorageImplInfo value) const {
+  auto *storage = std::get<0>(getStorage());
+  storage->setImplInfo(value);
+}