[Sema] TypeWrappers: Request type wrapper attribute type eagerly

The type is needed for serialization so it has to be requested
and chached in type wrapper info.

Author: xedin

include/swift/AST/TypeCheckRequests.h

@@ -3546,23 +3546,6 @@ class GetTypeWrapper
   bool isCached() const { return true; }
 };
 
-/// Return a type of the type wrapper (if any) associated with the given
-/// declaration.
-class GetTypeWrapperType
-    : public SimpleRequest<GetTypeWrapperType, Type(NominalTypeDecl *),
-                           RequestFlags::Cached> {
-public:
-  using SimpleRequest::SimpleRequest;
-
-private:
-  friend SimpleRequest;
-
-  Type evaluate(Evaluator &evaluator, NominalTypeDecl *) const;
-
-public:
-  bool isCached() const { return true; }
-};
-
 /// Inject or get `$Storage` type which has all of the stored properties
 /// of the given type with a type wrapper.
 class GetTypeWrapperStorage

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -404,9 +404,6 @@ SWIFT_REQUEST(TypeChecker, GetSourceFileAsyncNode,
 SWIFT_REQUEST(TypeChecker, GetTypeWrapper,
               Optional<TypeWrapperInfo>(NominalTypeDecl *),
               Cached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, GetTypeWrapperType,
-              Type(NominalTypeDecl *),
-              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, GetTypeWrapperStorage,
               TypeDecl *(NominalTypeDecl *),
               Cached, NoLocationInfo)

include/swift/AST/TypeWrappers.h

@@ -21,17 +21,18 @@ namespace swift {
 
 struct TypeWrapperInfo {
   CustomAttr *Attr;
+  Type AttrType;
   NominalTypeDecl *Wrapper;
   NominalTypeDecl *AttachedTo;
   bool IsInferred;
 
-  TypeWrapperInfo(CustomAttr *attr, NominalTypeDecl *wrapperDecl,
+  TypeWrapperInfo(CustomAttr *attr, Type attrType, NominalTypeDecl *wrapperDecl,
                   NominalTypeDecl *attachedTo, bool isInferred)
-      : Attr(attr), Wrapper(wrapperDecl), AttachedTo(attachedTo),
-        IsInferred(isInferred) {}
+      : Attr(attr), AttrType(attrType), Wrapper(wrapperDecl),
+        AttachedTo(attachedTo), IsInferred(isInferred) {}
 
   TypeWrapperInfo asInferred() const {
-    return {Attr, Wrapper, AttachedTo, true};
+    return {Attr, AttrType, Wrapper, AttachedTo, true};
   }
 };
 

lib/Sema/TypeCheckTypeWrapper.cpp

@@ -130,9 +130,19 @@ static void getTypeWrappers(NominalTypeDecl *decl,
       continue;
 
     auto *typeWrapper = nominal->getAttrs().getAttribute<TypeWrapperAttr>();
-    if (typeWrapper && typeWrapper->isValid())
+    if (typeWrapper && typeWrapper->isValid()) {
+      auto attrType = evaluateOrDefault(
+          ctx.evaluator,
+          CustomAttrTypeRequest{mutableAttr, decl,
+                                CustomAttrTypeKind::TypeWrapper},
+          Type());
+
+      if (!attrType || attrType->hasError())
+        continue;
+
       typeWrappers.push_back(
-          {mutableAttr, nominal, decl, /*isInferred=*/false});
+          {mutableAttr, attrType, nominal, decl, /*isInferred=*/false});
+    }
   }
 
   // Do not allow transitive protocol inference between protocols.
@@ -195,24 +205,6 @@ GetTypeWrapper::evaluate(Evaluator &evaluator, NominalTypeDecl *decl) const {
   return typeWrappers.front();
 }
 
-Type GetTypeWrapperType::evaluate(Evaluator &evaluator,
-                                  NominalTypeDecl *decl) const {
-  auto typeWrapperInfo = decl->getTypeWrapper();
-  if (!typeWrapperInfo)
-    return Type();
-
-  auto type = evaluateOrDefault(
-      evaluator,
-      CustomAttrTypeRequest{typeWrapperInfo->Attr, decl->getDeclContext(),
-                            CustomAttrTypeKind::TypeWrapper},
-      Type());
-
-  if (!type || type->hasError()) {
-    return ErrorType::get(decl->getASTContext());
-  }
-  return type;
-}
-
 VarDecl *NominalTypeDecl::getTypeWrapperProperty() const {
   auto *mutableSelf = const_cast<NominalTypeDecl *>(this);
   return evaluateOrDefault(getASTContext().evaluator,
@@ -352,10 +344,7 @@ GetTypeWrapperProperty::evaluate(Evaluator &evaluator,
   auto *storage = parent->getTypeWrapperStorageDecl();
   assert(storage);
 
-  auto *typeWrapperType =
-      evaluateOrDefault(ctx.evaluator, GetTypeWrapperType{parent}, Type())
-          ->castTo<AnyGenericType>();
-  assert(typeWrapperType);
+  auto *typeWrapperType = typeWrapper->AttrType->castTo<AnyGenericType>();
 
   // $storage: Wrapper<<ParentType>, <ParentType>.$Storage>
   auto propertyTy = BoundGenericType::get(