Sema: Use a request to compute AbstractStorageDecl::getImplInfo()

This just moves the code from the parser into a request. Sema will
still overwrite the ImplInfo field for lazy properties and
property wrappers; refactoring that is next.

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;
@@ -810,6 +811,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

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

lib/AST/Decl.cpp

@@ -4659,6 +4659,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

@@ -634,3 +634,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);
+}

lib/Parse/ParseDecl.cpp

@@ -4470,12 +4470,9 @@ struct Parser::ParsedAccessors {
 #include "swift/AST/AccessorKinds.def"
 
   void record(Parser &P, AbstractStorageDecl *storage, bool invalid,
-              const DeclAttributes &attrs,
               SmallVectorImpl<Decl *> &decls);
 
-  StorageImplInfo
-  classify(Parser &P, AbstractStorageDecl *storage, bool invalid,
-           const DeclAttributes &attrs);
+  void classify(Parser &P, AbstractStorageDecl *storage, bool invalid);
 
   /// Add an accessor.  If there's an existing accessor of this kind,
   /// return it.  The new accessor is still remembered but will be
@@ -4908,7 +4905,7 @@ Parser::parseDeclVarGetSet(Pattern *pattern, ParseDeclOptions Flags,
       accessors.Set->setInvalid();
   }
 
-  accessors.record(*this, PrimaryVar, Invalid, Attributes, Decls);
+  accessors.record(*this, PrimaryVar, Invalid, Decls);
 
   return makeParserResult(PrimaryVar);
 }
@@ -4936,10 +4933,8 @@ AccessorDecl *Parser::ParsedAccessors::add(AccessorDecl *accessor) {
 /// Record a bunch of parsed accessors into the given abstract storage decl.
 void Parser::ParsedAccessors::record(Parser &P, AbstractStorageDecl *storage,
                                      bool invalid,
-                                     const DeclAttributes &attrs,
                                      SmallVectorImpl<Decl *> &decls) {
-  auto storageKind = classify(P, storage, invalid, attrs);
-  storage->setImplInfo(storageKind);
+  classify(P, storage, invalid);
 
   decls.append(Accessors.begin(), Accessors.end());
   storage->setAccessors(LBLoc, Accessors, RBLoc);
@@ -4979,53 +4974,8 @@ static void diagnoseAndIgnoreObservers(Parser &P,
   }
 }
 
-/// Gets the storage info of the provided storage decl if it has the
-/// @_hasStorage attribute and it's not in SIL mode.
-///
-/// In this case, we say the decl is:
-///
-/// Read:
-///   - Stored, always
-/// Write:
-///   - Stored, if the decl is a 'var'.
-///   - StoredWithObservers, if the decl has a setter
-///     - This indicates that the original decl had a 'didSet' and/or 'willSet'
-///   - InheritedWithObservers, if the decl has a setter and is an overridde.
-///   - Immutable, if the decl is a 'let' or it does not have a setter.
-/// ReadWrite:
-///   - Stored, if the decl has no accessors listed.
-///   - Immutable, if the decl is a 'let' or it does not have a setter.
-///   - MaterializeToTemporary, if the decl has a setter.
-static StorageImplInfo classifyWithHasStorageAttr(
-  Parser::ParsedAccessors &accessors, ASTContext &ctx,
-  VarDecl *var, const DeclAttributes &attrs) {
-
-  WriteImplKind writeImpl;
-  ReadWriteImplKind readWriteImpl;
-
-  if (accessors.Get && accessors.Set) {
-    // If we see `@_hasStorage var x: T { get set }`, then our property has
-    // willSet/didSet observers.
-    writeImpl = attrs.hasAttribute<OverrideAttr>() ?
-      WriteImplKind::InheritedWithObservers :
-      WriteImplKind::StoredWithObservers;
-    readWriteImpl = ReadWriteImplKind::MaterializeToTemporary;
-  } else if (var->isLet()) {
-    writeImpl = WriteImplKind::Immutable;
-    readWriteImpl = ReadWriteImplKind::Immutable;
-  } else {
-    // Default to stored writes.
-    writeImpl = WriteImplKind::Stored;
-    readWriteImpl = ReadWriteImplKind::Stored;
-  }
-
-  // Always force Stored reads if @_hasStorage is present.
-  return StorageImplInfo(ReadImplKind::Stored, writeImpl, readWriteImpl);
-}
-
-StorageImplInfo
-Parser::ParsedAccessors::classify(Parser &P, AbstractStorageDecl *storage,
-                                  bool invalid, const DeclAttributes &attrs) {
+void Parser::ParsedAccessors::classify(Parser &P, AbstractStorageDecl *storage,
+                                       bool invalid) {
   // If there was a problem parsing accessors, mark all parsed accessors
   // as invalid to avoid tripping up later invariants.
   // We also want to avoid diagnose missing accessors if something
@@ -5092,102 +5042,6 @@ Parser::ParsedAccessors::classify(Parser &P, AbstractStorageDecl *storage,
   } else if (Modify) {
     diagnoseConflictingAccessors(P, Modify, MutableAddress);
   }
-
-  if (auto *var = dyn_cast<VarDecl>(storage)) {
-    // Allow the @_hasStorage attribute to override all the accessors we parsed
-    // when making the final classification.
-    if (attrs.hasAttribute<HasStorageAttr>()) {
-      // The SIL rules for @_hasStorage are slightly different from the non-SIL
-      // rules. In SIL mode, @_hasStorage marks that the type is simply stored,
-      // and the only thing that determines mutability is the existence of the
-      // setter.
-      //
-      // FIXME: SIL should not be special cased here. The behavior should be
-      //        consistent between SIL and non-SIL.
-      //        The strategy here should be to keep track of all opaque accessors
-      //        along with enough information to access the storage trivially
-      //        if allowed. This could be a representational change to
-      //        StorageImplInfo such that it keeps a bitset of listed accessors
-      //        and dynamically determines the access strategy from that.
-      if (P.isInSILMode())
-        return StorageImplInfo::getSimpleStored(
-          StorageIsMutable_t(Set != nullptr));
-
-      return classifyWithHasStorageAttr(*this, P.Context, var, attrs);
-    }
-  }
-
-  // 'get', 'read', and a non-mutable addressor are all exclusive.
-  ReadImplKind readImpl;
-  if (Get) {
-    readImpl = ReadImplKind::Get;
-  } else if (Read) {
-    readImpl = ReadImplKind::Read;
-  } else if (Address) {
-    readImpl = ReadImplKind::Address;
-
-  // If there's a writing accessor of any sort, there must also be a
-  // reading accessor.
-  } else if (auto mutator = findFirstMutator()) {
-    readImpl = ReadImplKind::Get;
-
-  // Subscripts always have to have some sort of accessor; they can't be
-  // purely stored.
-  } else if (isa<SubscriptDecl>(storage)) {
-    readImpl = ReadImplKind::Get;
-
-  // Check if we have observers.
-  } else if (WillSet || DidSet) {
-    if (attrs.hasAttribute<OverrideAttr>()) {
-      readImpl = ReadImplKind::Inherited;
-    } else {
-      readImpl = ReadImplKind::Stored;
-    }
-
-  // Otherwise, it's stored.
-  } else {
-    readImpl = ReadImplKind::Stored;
-  }
-
-  // Prefer using 'set' and 'modify' over a mutable addressor.
-  WriteImplKind writeImpl;
-  ReadWriteImplKind readWriteImpl;
-  if (Set) {
-    writeImpl = WriteImplKind::Set;
-    if (Modify) {
-      readWriteImpl = ReadWriteImplKind::Modify;
-    } else {
-      readWriteImpl = ReadWriteImplKind::MaterializeToTemporary;
-    }
-  } else if (Modify) {
-    writeImpl = WriteImplKind::Modify;
-    readWriteImpl = ReadWriteImplKind::Modify;
-  } else if (MutableAddress) {
-    writeImpl = WriteImplKind::MutableAddress;
-    readWriteImpl = ReadWriteImplKind::MutableAddress;
-
-  // Check if we have observers.
-  } else if (readImpl == ReadImplKind::Inherited) {
-    writeImpl = WriteImplKind::InheritedWithObservers;
-    readWriteImpl = ReadWriteImplKind::MaterializeToTemporary;
-
-  // Otherwise, it's stored.
-  } else if (readImpl == ReadImplKind::Stored) {
-    if (WillSet || DidSet) {
-      writeImpl = WriteImplKind::StoredWithObservers;
-      readWriteImpl = ReadWriteImplKind::MaterializeToTemporary;
-    } else {
-      writeImpl = WriteImplKind::Stored;
-      readWriteImpl = ReadWriteImplKind::Stored;
-    }
-
-  // Otherwise, it's immutable.
-  } else {
-    writeImpl = WriteImplKind::Immutable;
-    readWriteImpl = ReadWriteImplKind::Immutable;
-  }
-
-  return StorageImplInfo(readImpl, writeImpl, readWriteImpl);
 }
 
 
@@ -6598,8 +6452,7 @@ Parser::parseDeclSubscript(SourceLoc StaticLoc,
     Invalid = true;
   }
 
-  accessors.record(*this, Subscript, (Invalid || !Status.isSuccess()),
-                   Attributes, Decls);
+  accessors.record(*this, Subscript, (Invalid || !Status.isSuccess()), Decls);
 
   // No need to setLocalDiscriminator because subscripts cannot
   // validly appear outside of type decls.