Collapse infrastructure around DefaultTypeRequest

This can no longer live attached to the request.

Author: CodaFi

include/swift/AST/TypeCheckRequests.h

@@ -507,20 +507,6 @@ class DefaultTypeRequest
   bool isCached() const { return true; }
   Optional<Type> getCachedResult() const;
   void cacheResult(Type value) const;
-
-private:
-  KnownProtocolKind getKnownProtocolKind() const {
-    return std::get<0>(getStorage());
-  }
-  const DeclContext *getDeclContext() const {
-    return std::get<1>(getStorage());
-  }
-
-  static const char *getTypeName(KnownProtocolKind);
-  static bool getPerformLocalLookup(KnownProtocolKind);
-  TypeChecker &getTypeChecker() const;
-  SourceFile *getSourceFile() const;
-  Type &getCache() const;
 };
 
 /// Retrieve information about a property wrapper type.

lib/AST/TypeCheckRequests.cpp

@@ -508,49 +508,20 @@ void swift::simple_display(llvm::raw_ostream &out,
 // DefaultTypeRequest caching.
 //----------------------------------------------------------------------------//
 
-SourceFile *DefaultTypeRequest::getSourceFile() const {
-  return getDeclContext()->getParentSourceFile();
-}
-
-Type &DefaultTypeRequest::getCache() const {
-  return getDeclContext()->getASTContext().getDefaultTypeRequestCache(
-      getSourceFile(), getKnownProtocolKind());
-}
-
 Optional<Type> DefaultTypeRequest::getCachedResult() const {
-  auto const &cachedType = getCache();
+  auto *DC = std::get<1>(getStorage());
+  auto knownProtocolKind = std::get<0>(getStorage());
+  const auto &cachedType = DC->getASTContext().getDefaultTypeRequestCache(
+      DC->getParentSourceFile(), knownProtocolKind);
   return cachedType ? Optional<Type>(cachedType) : None;
 }
 
-void DefaultTypeRequest::cacheResult(Type value) const { getCache() = value; }
-
-const char *
-DefaultTypeRequest::getTypeName(const KnownProtocolKind knownProtocolKind) {
-  switch (knownProtocolKind) {
-
-  // clang-format off
-    # define EXPRESSIBLE_BY_LITERAL_PROTOCOL_WITH_NAME(Id, Name, typeName, performLocalLookup) \
-      case KnownProtocolKind::Id: return typeName;
-    # include "swift/AST/KnownProtocols.def"
-    # undef EXPRESSIBLE_BY_LITERAL_PROTOCOL_WITH_NAME
-    //clang-format on
-      
-    default: return nullptr;
-  }
-}
-
-bool DefaultTypeRequest::getPerformLocalLookup(const KnownProtocolKind knownProtocolKind) {
-  switch (knownProtocolKind) {
-      
-    // clang-format off
-    # define EXPRESSIBLE_BY_LITERAL_PROTOCOL_WITH_NAME(Id, Name, typeName, performLocalLookup) \
-      case KnownProtocolKind::Id: return performLocalLookup;
-    # include "swift/AST/KnownProtocols.def"
-    # undef EXPRESSIBLE_BY_LITERAL_PROTOCOL_WITH_NAME
-    //clang-format on
-      
-    default: return false;
-  }
+void DefaultTypeRequest::cacheResult(Type value) const {
+  auto *DC = std::get<1>(getStorage());
+  auto knownProtocolKind = std::get<0>(getStorage());
+  auto &cacheEntry = DC->getASTContext().getDefaultTypeRequestCache(
+                         DC->getParentSourceFile(), knownProtocolKind);
+  cacheEntry = value;
 }
 
 bool PropertyWrapperTypeInfoRequest::isCached() const {

lib/Sema/TypeCheckExpr.cpp

@@ -663,39 +663,54 @@ static Optional<KnownProtocolKind>
 getKnownProtocolKindIfAny(const ProtocolDecl *protocol) {
   TypeChecker &tc = TypeChecker::createForContext(protocol->getASTContext());
 
-  // clang-format off
-  #define EXPRESSIBLE_BY_LITERAL_PROTOCOL_WITH_NAME(Id, _, __, ___)            \
-    if (protocol == tc.getProtocol(SourceLoc(), KnownProtocolKind::Id))        \
-      return KnownProtocolKind::Id;
-  #include "swift/AST/KnownProtocols.def"
-  #undef EXPRESSIBLE_BY_LITERAL_PROTOCOL_WITH_NAME
-  // clang-format on
+#define EXPRESSIBLE_BY_LITERAL_PROTOCOL_WITH_NAME(Id, _, __, ___)              \
+  if (protocol == tc.getProtocol(SourceLoc(), KnownProtocolKind::Id))          \
+    return KnownProtocolKind::Id;
+#include "swift/AST/KnownProtocols.def"
+#undef EXPRESSIBLE_BY_LITERAL_PROTOCOL_WITH_NAME
 
   return None;
 }
 
 Type TypeChecker::getDefaultType(ProtocolDecl *protocol, DeclContext *dc) {
   if (auto knownProtocolKindIfAny = getKnownProtocolKindIfAny(protocol)) {
-    Type t = evaluateOrDefault(
+    return evaluateOrDefault(
         Context.evaluator,
         DefaultTypeRequest{knownProtocolKindIfAny.getValue(), dc}, nullptr);
-    return t;
   }
-  return nullptr;
+  return Type();
+}
+
+static std::pair<const char *, bool> lookupDefaultTypeInfoForKnownProtocol(
+    const KnownProtocolKind knownProtocolKind) {
+  switch (knownProtocolKind) {
+#define EXPRESSIBLE_BY_LITERAL_PROTOCOL_WITH_NAME(Id, Name, typeName,          \
+                                                  performLocalLookup)          \
+  case KnownProtocolKind::Id:                                                  \
+    return {typeName, performLocalLookup};
+#include "swift/AST/KnownProtocols.def"
+#undef EXPRESSIBLE_BY_LITERAL_PROTOCOL_WITH_NAME
+  default:
+    return {nullptr, false};
+  }
 }
 
 llvm::Expected<Type>
 swift::DefaultTypeRequest::evaluate(Evaluator &evaluator,
                                     KnownProtocolKind knownProtocolKind,
                                     const DeclContext *dc) const {
-  const char *const name = getTypeName(knownProtocolKind);
+  const char *name;
+  bool performLocalLookup;
+  std::tie(name, performLocalLookup) =
+      lookupDefaultTypeInfoForKnownProtocol(knownProtocolKind);
   if (!name)
     return nullptr;
 
-  TypeChecker &tc = getTypeChecker();
+  // FIXME: Creating a whole type checker just to do lookup is unnecessary.
+  TypeChecker &tc = TypeChecker::createForContext(dc->getASTContext());
 
   Type type;
-  if (getPerformLocalLookup(knownProtocolKind))
+  if (performLocalLookup)
     type = lookupDefaultLiteralType(tc, dc, name);
 
   if (!type)
@@ -710,10 +725,6 @@ swift::DefaultTypeRequest::evaluate(Evaluator &evaluator,
   return type;
 }
 
-TypeChecker &DefaultTypeRequest::getTypeChecker() const {
-  return TypeChecker::createForContext(getDeclContext()->getASTContext());
-}
-
 Expr *TypeChecker::foldSequence(SequenceExpr *expr, DeclContext *dc) {
   ArrayRef<Expr*> Elts = expr->getElements();
   assert(Elts.size() > 1 && "inadequate number of elements in sequence");