AST: Convert ValueDecl::getOpaqueResultTypeDecl() into a request

slavapestov · slavapestov · commit e334e5d66f38 · 2019-10-04T22:11:07.000-04:00
Instead of depending on a prior call to setOpaqueResultTypeDecl(),
we can instead just build the decl if we need one.
diff --git a/include/swift/AST/ASTTypeIDZone.def b/include/swift/AST/ASTTypeIDZone.def
@@ -33,6 +33,7 @@ SWIFT_TYPEID_NAMED(InfixOperatorDecl *, InfixOperatorDecl)
 SWIFT_TYPEID_NAMED(IterableDeclContext *, IterableDeclContext)
 SWIFT_TYPEID_NAMED(ModuleDecl *, ModuleDecl)
 SWIFT_TYPEID_NAMED(NominalTypeDecl *, NominalTypeDecl)
+SWIFT_TYPEID_NAMED(OpaqueTypeDecl *, OpaqueTypeDecl)
 SWIFT_TYPEID_NAMED(OperatorDecl *, OperatorDecl)
 SWIFT_TYPEID_NAMED(Optional<PropertyWrapperMutability>,
                    PropertyWrapperMutability)
diff --git a/include/swift/AST/ASTTypeIDs.h b/include/swift/AST/ASTTypeIDs.h
@@ -34,6 +34,7 @@ class IterableDeclContext;
 class ModuleDecl;
 class NominalTypeDecl;
 class OperatorDecl;
+class OpaqueTypeDecl;
 class PrecedenceGroupDecl;
 struct PropertyWrapperBackingPropertyInfo;
 struct PropertyWrapperTypeInfo;
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -2764,12 +2764,6 @@ class ValueDecl : public Decl {
   /// Get the representative for this value's opaque result type, if it has one.
   OpaqueReturnTypeRepr *getOpaqueResultTypeRepr() const;
 
-  /// Set the opaque return type decl for this decl.
-  ///
-  /// `this` must be of a decl type that supports opaque return types, and
-  /// must not have previously had an opaque result type set.
-  void setOpaqueResultTypeDecl(OpaqueTypeDecl *D);
-
   /// Retrieve the attribute associating this declaration with a
   /// function builder, if there is one.
   CustomAttr *getAttachedFunctionBuilder() const;
@@ -4530,8 +4524,6 @@ class AbstractStorageDecl : public ValueDecl {
     Bits.AbstractStorageDecl.IsStatic = IsStatic;
   }
 
-  OpaqueTypeDecl *OpaqueReturn = nullptr;
-
 public:
 
   /// Should this declaration be treated as if annotated with transparent
@@ -4789,14 +4781,6 @@ class AbstractStorageDecl : public ValueDecl {
 
   bool hasAnyDynamicReplacementAccessors() const;
 
-  OpaqueTypeDecl *getOpaqueResultTypeDecl() const {
-    return OpaqueReturn;
-  }
-  void setOpaqueResultTypeDecl(OpaqueTypeDecl *decl) {
-    assert(!OpaqueReturn && "already has opaque type decl");
-    OpaqueReturn = decl;
-  }
-
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) {
     return D->getKind() >= DeclKind::First_AbstractStorageDecl &&
@@ -5982,8 +5966,6 @@ class FuncDecl : public AbstractFunctionDecl {
 
   TypeLoc FnRetType;
 
-  OpaqueTypeDecl *OpaqueReturn = nullptr;
-
 protected:
   FuncDecl(DeclKind Kind,
            SourceLoc StaticLoc, StaticSpellingKind StaticSpelling,
@@ -6129,15 +6111,7 @@ class FuncDecl : public AbstractFunctionDecl {
   }
 
   OperatorDecl *getOperatorDecl() const;
-  
-  OpaqueTypeDecl *getOpaqueResultTypeDecl() const {
-    return OpaqueReturn;
-  }
-  void setOpaqueResultTypeDecl(OpaqueTypeDecl *decl) {
-    assert(!OpaqueReturn && "already has opaque type decl");
-    OpaqueReturn = decl;
-  }
-  
+
   /// Returns true if the function is forced to be statically dispatched.
   bool hasForcedStaticDispatch() const {
     return Bits.FuncDecl.ForcedStaticDispatch;
diff --git a/include/swift/AST/TypeCheckRequests.h b/include/swift/AST/TypeCheckRequests.h
@@ -1188,7 +1188,7 @@ class GenericSignatureRequest :
   void cacheResult(GenericSignature value) const;
 };
 
-/// Compute the interface type of the underlying definition type of a typealias declaration.
+/// Compute the underlying interface type of a typealias.
 class UnderlyingTypeRequest :
     public SimpleRequest<UnderlyingTypeRequest,
                          Type(TypeAliasDecl *),
@@ -1211,6 +1211,7 @@ class UnderlyingTypeRequest :
   void diagnoseCycle(DiagnosticEngine &diags) const;
 };
 
+/// Looks up the precedence group of an operator declaration.
 class OperatorPrecedenceGroupRequest
     : public SimpleRequest<OperatorPrecedenceGroupRequest,
                            PrecedenceGroupDecl *(InfixOperatorDecl *),
@@ -1272,6 +1273,25 @@ class IsABICompatibleOverrideRequest
   bool isCached() const { return true; }
 };
 
+/// Builds an opaque result type for a declaration.
+class OpaqueResultTypeRequest
+    : public SimpleRequest<OpaqueResultTypeRequest,
+                           OpaqueTypeDecl *(ValueDecl *),
+                           CacheKind::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  llvm::Expected<OpaqueTypeDecl *>
+  evaluate(Evaluator &evaluator, ValueDecl *VD) const;
+
+public:
+  // Caching.
+  bool isCached() const { return true; }
+};
+
 // Allow AnyValue to compare two Type values, even though Type doesn't
 // support ==.
 template<>
diff --git a/include/swift/AST/TypeCheckerTypeIDZone.def b/include/swift/AST/TypeCheckerTypeIDZone.def
@@ -88,6 +88,9 @@ SWIFT_REQUEST(TypeChecker, MangleLocalTypeDeclRequest,
 SWIFT_REQUEST(TypeChecker, OpaqueReadOwnershipRequest,
               OpaqueReadOwnership(AbstractStorageDecl *), SeparatelyCached,
               NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, OpaqueResultTypeRequest,
+              OpaqueTypeDecl *(ValueDecl *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, OperatorPrecedenceGroupRequest,
               PrecedenceGroupDecl *(PrecedenceGroupDecl *),
               Cached, NoLocationInfo)
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -2580,7 +2580,22 @@ void ValueDecl::setOverriddenDecls(ArrayRef<ValueDecl *> overridden) {
 OpaqueReturnTypeRepr *ValueDecl::getOpaqueResultTypeRepr() const {
   TypeLoc returnLoc;
   if (auto *VD = dyn_cast<VarDecl>(this)) {
-    returnLoc = VD->getTypeLoc();
+    if (auto *P = VD->getParentPattern()) {
+      while (auto *PP = dyn_cast<ParenPattern>(P))
+        P = PP->getSubPattern();
+
+      if (auto *TP = dyn_cast<TypedPattern>(P)) {
+        P = P->getSemanticsProvidingPattern();
+        if (auto *NP = dyn_cast<NamedPattern>(P)) {
+          assert(NP->getDecl() == VD);
+          (void) NP;
+
+          returnLoc = TP->getTypeLoc();
+        }
+      }
+    } else {
+      returnLoc = VD->getTypeLoc();
+    }
   } else if (auto *FD = dyn_cast<FuncDecl>(this)) {
     returnLoc = FD->getBodyResultTypeLoc();
   } else if (auto *SD = dyn_cast<SubscriptDecl>(this)) {
@@ -2591,23 +2606,12 @@ OpaqueReturnTypeRepr *ValueDecl::getOpaqueResultTypeRepr() const {
 }
 
 OpaqueTypeDecl *ValueDecl::getOpaqueResultTypeDecl() const {
-  if (auto func = dyn_cast<FuncDecl>(this)) {
-    return func->getOpaqueResultTypeDecl();
-  } else if (auto storage = dyn_cast<AbstractStorageDecl>(this)) {
-    return storage->getOpaqueResultTypeDecl();
-  } else {
+  if (getOpaqueResultTypeRepr() == nullptr)
     return nullptr;
-  }
-}
 
-void ValueDecl::setOpaqueResultTypeDecl(OpaqueTypeDecl *D) {
-  if (auto func = dyn_cast<FuncDecl>(this)) {
-    func->setOpaqueResultTypeDecl(D);
-  } else if (auto storage = dyn_cast<AbstractStorageDecl>(this)){
-    storage->setOpaqueResultTypeDecl(D);
-  } else {
-    llvm_unreachable("decl does not support opaque result types");
-  }
+  return evaluateOrDefault(getASTContext().evaluator,
+    OpaqueResultTypeRequest{const_cast<ValueDecl *>(this)},
+    nullptr);
 }
 
 bool ValueDecl::isObjC() const {
diff --git a/lib/Sema/TypeCheckDecl.cpp b/lib/Sema/TypeCheckDecl.cpp
@@ -3793,22 +3793,25 @@ static Type buildAddressorResultType(TypeChecker &TC,
 }
 
 
-static void validateResultType(TypeChecker &TC,
-                               ValueDecl *decl, ParameterList *params,
-                               TypeLoc &resultTyLoc,
-                               TypeResolution resolution) {
+static void validateResultType(ValueDecl *decl,
+                               TypeLoc &resultTyLoc) {
   // Nothing to do if there's no result type loc to set into.
   if (resultTyLoc.isNull())
     return;
 
   // Check the result type. It is allowed to be opaque.
-  if (auto opaqueTy =
-          dyn_cast_or_null<OpaqueReturnTypeRepr>(resultTyLoc.getTypeRepr())) {
-    // Create the decl and type for it.
+  if (decl->getOpaqueResultTypeRepr()) {
+    auto *opaqueDecl = decl->getOpaqueResultTypeDecl();
     resultTyLoc.setType(
-        TC.getOrCreateOpaqueResultType(resolution, decl, opaqueTy));
+        opaqueDecl
+        ? opaqueDecl->getDeclaredInterfaceType()
+        : ErrorType::get(decl->getASTContext()));
   } else {
-    TypeChecker::validateType(TC.Context, resultTyLoc, resolution,
+    auto *dc = decl->getInnermostDeclContext();
+    auto resolution = TypeResolution::forInterface(
+      dc, dc->getGenericSignatureOfContext());
+    TypeChecker::validateType(dc->getASTContext(),
+                              resultTyLoc, resolution,
                               TypeResolverContext::FunctionResult);
   }
 }
@@ -4081,8 +4084,7 @@ void TypeChecker::validateDecl(ValueDecl *D) {
                                                    FD->getGenericSignature());
     typeCheckParameterList(FD->getParameters(), resolution,
                            TypeResolverContext::AbstractFunctionDecl);
-    validateResultType(*this, FD, FD->getParameters(),
-                       FD->getBodyResultTypeLoc(), resolution);
+    validateResultType(FD, FD->getBodyResultTypeLoc());
     // FIXME: Roll all of this interface type computation into a request.
     FD->computeType();
 
@@ -4152,8 +4154,7 @@ void TypeChecker::validateDecl(ValueDecl *D) {
     auto res = TypeResolution::forInterface(SD, SD->getGenericSignature());
     typeCheckParameterList(SD->getIndices(), res,
                            TypeResolverContext::SubscriptDecl);
-    validateResultType(*this, SD, SD->getIndices(),
-                       SD->getElementTypeLoc(), res);
+    validateResultType(SD, SD->getElementTypeLoc());
     SD->computeType();
 
     if (SD->getOpaqueResultTypeDecl()) {
diff --git a/lib/Sema/TypeCheckGeneric.cpp b/lib/Sema/TypeCheckGeneric.cpp
@@ -83,43 +83,47 @@ TypeChecker::gatherGenericParamBindingsText(
 
 /// Get the opaque type representing the return type of a declaration, or
 /// create it if it does not yet exist.
-Type TypeChecker::getOrCreateOpaqueResultType(TypeResolution resolution,
-                                              ValueDecl *originatingDecl,
-                                              OpaqueReturnTypeRepr *repr) {
+llvm::Expected<OpaqueTypeDecl *>
+OpaqueResultTypeRequest::evaluate(Evaluator &evaluator,
+                                  ValueDecl *originatingDecl) const {
+  auto *repr = originatingDecl->getOpaqueResultTypeRepr();
+  assert(repr && "Declaration does not have an opaque result type");
+  auto *dc = originatingDecl->getInnermostDeclContext();
+  auto &ctx = dc->getASTContext();
+
   // Protocol requirements can't have opaque return types.
   //
   // TODO: Maybe one day we could treat this as sugar for an associated type.
   if (isa<ProtocolDecl>(originatingDecl->getDeclContext())
       && originatingDecl->isProtocolRequirement()) {
-    
+
     SourceLoc fixitLoc;
     if (auto vd = dyn_cast<VarDecl>(originatingDecl)) {
       fixitLoc = vd->getParentPatternBinding()->getStartLoc();
     } else {
       fixitLoc = originatingDecl->getStartLoc();
     }
-    
-    diagnose(repr->getLoc(), diag::opaque_type_in_protocol_requirement)
+
+    ctx.Diags.diagnose(repr->getLoc(),
+                       diag::opaque_type_in_protocol_requirement)
       .fixItInsert(fixitLoc, "associatedtype <#AssocType#>\n")
       .fixItReplace(repr->getSourceRange(), "<#AssocType#>");
     
-    return ErrorType::get(Context);
-  }
-  
-  // If the decl already has an opaque type decl for its return type, use it.
-  if (auto existingDecl = originatingDecl->getOpaqueResultTypeDecl()) {
-    return existingDecl->getDeclaredInterfaceType();
+    return nullptr;
   }
   
   // Check the availability of the opaque type runtime support.
-  if (!Context.LangOpts.DisableAvailabilityChecking) {
-    auto runningOS = overApproximateAvailabilityAtLocation(repr->getLoc(),
-                                    originatingDecl->getInnermostDeclContext());
-    auto availability = Context.getOpaqueTypeAvailability();
+  if (!ctx.LangOpts.DisableAvailabilityChecking) {
+    auto runningOS =
+      TypeChecker::overApproximateAvailabilityAtLocation(
+        repr->getLoc(),
+        originatingDecl->getInnermostDeclContext());
+    auto availability = ctx.getOpaqueTypeAvailability();
     if (!runningOS.isContainedIn(availability)) {
-      diagnosePotentialOpaqueTypeUnavailability(repr->getSourceRange(),
-       originatingDecl->getInnermostDeclContext(),
-       UnavailabilityReason::requiresVersionRange(availability.getOSVersion()));
+      TypeChecker::diagnosePotentialOpaqueTypeUnavailability(
+        repr->getSourceRange(),
+        originatingDecl->getInnermostDeclContext(),
+        UnavailabilityReason::requiresVersionRange(availability.getOSVersion()));
     }
   }
   
@@ -128,18 +132,20 @@ Type TypeChecker::getOrCreateOpaqueResultType(TypeResolution resolution,
   TypeResolutionOptions options(TypeResolverContext::GenericRequirement);
   TypeLoc constraintTypeLoc(repr->getConstraint());
   // Pass along the error type if resolving the repr failed.
+  auto resolution = TypeResolution::forInterface(
+    dc, dc->getGenericSignatureOfContext());
   bool validationError
-    = validateType(Context, constraintTypeLoc, resolution, options);
+    = TypeChecker::validateType(ctx, constraintTypeLoc, resolution, options);
   auto constraintType = constraintTypeLoc.getType();
   if (validationError)
-    return constraintType;
+    return nullptr;
   
   // Error out if the constraint type isn't a class or existential type.
   if (!constraintType->getClassOrBoundGenericClass()
       && !constraintType->isExistentialType()) {
-    diagnose(repr->getConstraint()->getLoc(),
-             diag::opaque_type_invalid_constraint);
-    return constraintTypeLoc.getType();
+    ctx.Diags.diagnose(repr->getConstraint()->getLoc(),
+                       diag::opaque_type_invalid_constraint);
+    return nullptr;
   }
   
   if (constraintType->hasArchetype())
@@ -157,8 +163,7 @@ Type TypeChecker::getOrCreateOpaqueResultType(TypeResolution resolution,
                outerGenericSignature->getGenericParams().back()->getDepth() + 1;
   }
   
-  auto returnTypeParam = GenericTypeParamType::get(returnTypeDepth, 0,
-                                                   Context);
+  auto returnTypeParam = GenericTypeParamType::get(returnTypeDepth, 0, ctx);
 
   SmallVector<GenericTypeParamType *, 2> genericParamTypes;
   genericParamTypes.push_back(returnTypeParam);
@@ -184,7 +189,7 @@ Type TypeChecker::getOrCreateOpaqueResultType(TypeResolution resolution,
   }
   
   auto interfaceSignature = evaluateOrDefault(
-      Context.evaluator,
+      ctx.evaluator,
       AbstractGenericSignatureRequest{
         outerGenericSignature.getPointer(),
         std::move(genericParamTypes),
@@ -194,24 +199,21 @@ Type TypeChecker::getOrCreateOpaqueResultType(TypeResolution resolution,
   // Create the OpaqueTypeDecl for the result type.
   // It has the same parent context and generic environment as the originating
   // decl.
-  auto dc = originatingDecl->getDeclContext();
-  
+  auto parentDC = originatingDecl->getDeclContext();
   auto originatingGenericContext = originatingDecl->getAsGenericContext();
   GenericParamList *genericParams = originatingGenericContext
     ? originatingGenericContext->getGenericParams()
     : nullptr;
 
-  auto opaqueDecl = new (Context) OpaqueTypeDecl(originatingDecl,
-                                                 genericParams,
-                                                 dc,
-                                                 interfaceSignature,
-                                                 returnTypeParam);
+  auto opaqueDecl = new (ctx) OpaqueTypeDecl(originatingDecl,
+                                             genericParams,
+                                             parentDC,
+                                             interfaceSignature,
+                                             returnTypeParam);
   opaqueDecl->copyFormalAccessFrom(originatingDecl);
   if (auto originatingSig = originatingDC->getGenericSignatureOfContext()) {
     opaqueDecl->setGenericSignature(originatingSig);
   }
-
-  originatingDecl->setOpaqueResultTypeDecl(opaqueDecl);
   
   // The declared interface type is an opaque ArchetypeType.
   SubstitutionMap subs;
@@ -221,7 +223,7 @@ Type TypeChecker::getOrCreateOpaqueResultType(TypeResolution resolution,
   auto opaqueTy = OpaqueTypeArchetypeType::get(opaqueDecl, subs);
   auto metatype = MetatypeType::get(opaqueTy);
   opaqueDecl->setInterfaceType(metatype);
-  return opaqueTy;
+  return opaqueDecl;
 }
 
 /// Determine whether the given type is \c Self, an associated type of \c Self,
diff --git a/lib/Sema/TypeCheckPattern.cpp b/lib/Sema/TypeCheckPattern.cpp
diff --git a/lib/Sema/TypeChecker.h b/lib/Sema/TypeChecker.h
diff --git a/lib/Serialization/Deserialization.cpp b/lib/Serialization/Deserialization.cpp
