[NFC] Make EnumRawTypeRequest Cached

Drop the extra bit of state in the AST for the semantic type.

Author: CodaFi

include/swift/AST/Decl.h

@@ -3304,11 +3304,7 @@ class EnumDecl final : public NominalTypeDecl {
   Type getRawType() const;
 
   /// Set the raw type of the enum from its inheritance clause.
-  void setRawType(Type rawType) {
-    auto flags = LazySemanticInfo.RawTypeAndFlags.getInt();
-    LazySemanticInfo.RawTypeAndFlags.setPointerAndInt(
-        rawType, flags | HasComputedRawType);
-  }
+  void setRawType(Type rawType);
 
   /// True if none of the enum cases have associated values.
   ///

include/swift/AST/TypeCheckRequests.h

@@ -126,29 +126,24 @@ class SuperclassTypeRequest
 };
 
 /// Request the raw type of the given enum.
-class EnumRawTypeRequest :
-    public SimpleRequest<EnumRawTypeRequest,
-                         Type(EnumDecl *, TypeResolutionStage),
-                         RequestFlags::SeparatelyCached> {
+class EnumRawTypeRequest
+    : public SimpleRequest<EnumRawTypeRequest, Type(EnumDecl *),
+                           RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
 
 private:
   friend SimpleRequest;
 
   // Evaluation.
-  Type
-  evaluate(Evaluator &evaluator, EnumDecl *enumDecl,
-           TypeResolutionStage stage) const;
+  Type evaluate(Evaluator &evaluator, EnumDecl *enumDecl) const;
 
 public:
   // Cycle handling
   void diagnoseCycle(DiagnosticEngine &diags) const;
+  void noteCycleStep(DiagnosticEngine &diags) const;
 
-  // Separate caching.
-  bool isCached() const;
-  Optional<Type> getCachedResult() const;
-  void cacheResult(Type value) const;
+  bool isCached() const { return true; }
 };
 
 /// Request to determine the set of declarations that were are overridden

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -71,8 +71,7 @@ SWIFT_REQUEST(TypeChecker, EnumRawValuesRequest,
               evaluator::SideEffect (EnumDecl *, TypeResolutionStage),
               SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, EnumRawTypeRequest,
-              Type(EnumDecl *, TypeResolutionStage), SeparatelyCached,
-              NoLocationInfo)
+              Type(EnumDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ExistentialConformsToSelfRequest,
               bool(ProtocolDecl *), SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ExistentialTypeSupportedRequest,

lib/AST/Decl.cpp

@@ -3928,9 +3928,13 @@ EnumDecl::EnumDecl(SourceLoc EnumLoc,
 
 Type EnumDecl::getRawType() const {
   ASTContext &ctx = getASTContext();
-  return evaluateOrDefault(ctx.evaluator,
-    EnumRawTypeRequest{const_cast<EnumDecl *>(this),
-                       TypeResolutionStage::Interface}, Type());
+  return evaluateOrDefault(
+      ctx.evaluator, EnumRawTypeRequest{const_cast<EnumDecl *>(this)}, Type());
+}
+
+void EnumDecl::setRawType(Type rawType) {
+  getASTContext().evaluator.cacheOutput(EnumRawTypeRequest{this},
+                                        std::move(rawType));
 }
 
 StructDecl::StructDecl(SourceLoc StructLoc, Identifier Name, SourceLoc NameLoc,

lib/AST/TypeCheckRequests.cpp

@@ -179,21 +179,10 @@ void EnumRawTypeRequest::diagnoseCycle(DiagnosticEngine &diags) const {
   diags.diagnose(enumDecl, diag::circular_enum_inheritance, enumDecl->getName());
 }
 
-bool EnumRawTypeRequest::isCached() const {
-  return std::get<1>(getStorage()) == TypeResolutionStage::Interface;
-}
-
-Optional<Type> EnumRawTypeRequest::getCachedResult() const {
-  auto enumDecl = std::get<0>(getStorage());
-  if (enumDecl->LazySemanticInfo.hasRawType())
-    return enumDecl->LazySemanticInfo.RawTypeAndFlags.getPointer();
-
-  return None;
-}
-
-void EnumRawTypeRequest::cacheResult(Type value) const {
-  auto enumDecl = std::get<0>(getStorage());
-  enumDecl->LazySemanticInfo.cacheRawType(value);
+void EnumRawTypeRequest::noteCycleStep(DiagnosticEngine &diags) const {
+  auto *decl = std::get<0>(getStorage());
+  diags.diagnose(decl, diag::kind_declname_declared_here,
+                 decl->getDescriptiveKind(), decl->getName());
 }
 
 //----------------------------------------------------------------------------//
@@ -854,17 +843,15 @@ bool EnumRawValuesRequest::isCached() const {
 
 Optional<evaluator::SideEffect> EnumRawValuesRequest::getCachedResult() const {
   auto *ED = std::get<0>(getStorage());
-  if (ED->LazySemanticInfo.hasCheckedRawValues())
+  if (ED->SemanticFlags.contains(EnumDecl::HasFixedRawValuesAndTypes))
     return std::make_tuple<>();
   return None;
 }
 
 void EnumRawValuesRequest::cacheResult(evaluator::SideEffect) const {
   auto *ED = std::get<0>(getStorage());
-  auto flags = ED->LazySemanticInfo.RawTypeAndFlags.getInt() |
-      EnumDecl::HasFixedRawValues |
-      EnumDecl::HasFixedRawValuesAndTypes;
-  ED->LazySemanticInfo.RawTypeAndFlags.setInt(flags);
+  ED->SemanticFlags |= OptionSet<EnumDecl::SemanticInfoFlags>{
+      EnumDecl::HasFixedRawValues | EnumDecl::HasFixedRawValuesAndTypes};
 }
 
 void EnumRawValuesRequest::diagnoseCycle(DiagnosticEngine &diags) const {

lib/Sema/DerivedConformanceRawRepresentable.cpp

@@ -24,6 +24,7 @@
 #include "swift/AST/Types.h"
 #include "llvm/ADT/APInt.h"
 #include "DerivedConformances.h"
+#include "TypeCheckDecl.h"
 
 using namespace swift;
 
@@ -448,7 +449,10 @@ bool DerivedConformance::canDeriveRawRepresentable(DeclContext *DC,
     return false;
 
   Type rawType = enumDecl->getRawType();
-  if (!rawType)
+  if (!rawType || rawType->hasError())
+    return false;
+
+  if (!computeAutomaticEnumValueKind(enumDecl))
     return false;
 
   rawType = DC->mapTypeIntoContext(rawType);

lib/Sema/TypeCheckDecl.cpp

@@ -1162,7 +1162,7 @@ EnumRawValuesRequest::evaluate(Evaluator &eval, EnumDecl *ED,
     if (uncheckedRawValueOf(elt)) {
       if (!uncheckedRawValueOf(elt)->isImplicit())
         lastExplicitValueElt = elt;
-    } else if (!ED->LazySemanticInfo.hasFixedRawValues()) {
+    } else if (!ED->SemanticFlags.contains(EnumDecl::HasFixedRawValues)) {
       // Try to pull out the automatic enum value kind.  If that fails, bail.
       if (!valueKind) {
         valueKind = computeAutomaticEnumValueKind(ED);
@@ -1217,7 +1217,7 @@ EnumRawValuesRequest::evaluate(Evaluator &eval, EnumDecl *ED,
     // to have set things up correctly.  This comes up with imported enums
     // and deserialized @objc enums which always have their raw values setup
     // beforehand.
-    if (ED->LazySemanticInfo.hasFixedRawValues())
+    if (ED->SemanticFlags.contains(EnumDecl::HasFixedRawValues))
       continue;
 
     // Using magic literals like #file as raw value is not supported right now.

lib/Sema/TypeCheckRequestFunctions.cpp

@@ -136,13 +136,12 @@ SuperclassTypeRequest::evaluate(Evaluator &evaluator,
   return Type();
 }
 
-Type
-EnumRawTypeRequest::evaluate(Evaluator &evaluator, EnumDecl *enumDecl,
-                             TypeResolutionStage stage) const {
+Type EnumRawTypeRequest::evaluate(Evaluator &evaluator,
+                                  EnumDecl *enumDecl) const {
   for (unsigned int idx : indices(enumDecl->getInherited())) {
-    auto inheritedTypeResult =
-      evaluator(InheritedTypeRequest{enumDecl, idx, stage});
-    
+    auto inheritedTypeResult = evaluator(
+        InheritedTypeRequest{enumDecl, idx, TypeResolutionStage::Interface});
+
     if (auto err = inheritedTypeResult.takeError()) {
       llvm::handleAllErrors(std::move(err),
         [](const CyclicalRequestError<InheritedTypeRequest> &E) {