Requestify default initializer context creation

This commit adds a request that computes
the initializer context for a parameter with a
default expr or stored property default.

This avoids having to compute them for synthesized
decls and is a step towards requestifying default
argument parsing.

Author: hamishknight

include/swift/AST/ASTTypeIDZone.def

@@ -45,6 +45,7 @@ SWIFT_TYPEID_NAMED(OpaqueTypeDecl *, OpaqueTypeDecl)
 SWIFT_TYPEID_NAMED(OperatorDecl *, OperatorDecl)
 SWIFT_TYPEID_NAMED(Optional<PropertyWrapperMutability>,
                    PropertyWrapperMutability)
+SWIFT_TYPEID_NAMED(ParamDecl *, ParamDecl)
 SWIFT_TYPEID_NAMED(PatternBindingEntry *, PatternBindingEntry)
 SWIFT_TYPEID_NAMED(PrecedenceGroupDecl *, PrecedenceGroupDecl)
 SWIFT_TYPEID_NAMED(ProtocolDecl *, ProtocolDecl)

include/swift/AST/Decl.h

@@ -5175,6 +5175,8 @@ enum class ParamSpecifier : uint8_t {
 
 /// A function parameter declaration.
 class ParamDecl : public VarDecl {
+  friend class DefaultArgumentInitContextRequest;
+
   llvm::PointerIntPair<Identifier, 1, bool> ArgumentNameAndDestructured;
   SourceLoc ParameterNameLoc;
   SourceLoc ArgumentNameLoc;
@@ -5189,6 +5191,10 @@ class ParamDecl : public VarDecl {
     CaptureInfo Captures;
   };
 
+  /// Retrieve the cached initializer context for the parameter's default
+  /// argument without triggering a request.
+  Initializer *getDefaultArgumentInitContextCached() const;
+
   enum class Flags : uint8_t {
     /// Whether or not this parameter is vargs.
     IsVariadic = 1 << 0,
@@ -5262,11 +5268,8 @@ class ParamDecl : public VarDecl {
 
   void setStoredProperty(VarDecl *var);
 
-  Initializer *getDefaultArgumentInitContext() const {
-    if (auto stored = DefaultValueAndFlags.getPointer())
-      return stored->InitContext;
-    return nullptr;
-  }
+  /// Retrieve the initializer context for the parameter's default argument.
+  Initializer *getDefaultArgumentInitContext() const;
 
   void setDefaultArgumentInitContext(Initializer *initContext);
 

include/swift/AST/TypeCheckRequests.h

@@ -1843,6 +1843,28 @@ class HasCircularRawValueRequest
   bool isCached() const { return true; }
 };
 
+/// Computes an initializer context for a parameter with a default argument.
+class DefaultArgumentInitContextRequest
+    : public SimpleRequest<DefaultArgumentInitContextRequest,
+                           Initializer *(ParamDecl *),
+                           CacheKind::SeparatelyCached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  llvm::Expected<Initializer *> evaluate(Evaluator &evaluator,
+                                         ParamDecl *param) const;
+
+public:
+  // Separate caching.
+  bool isCached() const { return true; }
+  Optional<Initializer *> getCachedResult() const;
+  void cacheResult(Initializer *init) const;
+};
+
 // Allow AnyValue to compare two Type values, even though Type doesn't
 // support ==.
 template<>

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -32,6 +32,8 @@ SWIFT_REQUEST(TypeChecker, ClassAncestryFlagsRequest,
 SWIFT_REQUEST(TypeChecker, CompareDeclSpecializationRequest,
               bool (DeclContext *, ValueDecl *, ValueDecl *, bool), Cached,
               NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, DefaultArgumentInitContextRequest,
+              Initializer *(ParamDecl *), SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, DefaultDefinitionTypeRequest,
               Type(AssociatedTypeDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, DefaultTypeRequest,

lib/AST/Decl.cpp

@@ -6046,6 +6046,24 @@ AnyFunctionType::Param ParamDecl::toFunctionParam(Type type) const {
   return AnyFunctionType::Param(type, label, flags);
 }
 
+Initializer *ParamDecl::getDefaultArgumentInitContextCached() const {
+  if (auto *defaultInfo = DefaultValueAndFlags.getPointer())
+      return defaultInfo->InitContext;
+
+  return nullptr;
+}
+
+Initializer *ParamDecl::getDefaultArgumentInitContext() const {
+  // If this param doesn't need a context, don't bother kicking off a request.
+  if (!getDefaultValue() && !getStoredProperty())
+    return nullptr;
+
+  auto &ctx = getASTContext();
+  auto *mutableThis = const_cast<ParamDecl *>(this);
+  return evaluateOrDefault(
+      ctx.evaluator, DefaultArgumentInitContextRequest{mutableThis}, nullptr);
+}
+
 void ParamDecl::setDefaultValue(Expr *E) {
   if (!DefaultValueAndFlags.getPointer()) {
     if (!E) return;
@@ -6093,8 +6111,13 @@ CustomAttr *ValueDecl::getAttachedFunctionBuilder() const {
 }
 
 void ParamDecl::setDefaultArgumentInitContext(Initializer *initContext) {
-  assert(DefaultValueAndFlags.getPointer());
-  DefaultValueAndFlags.getPointer()->InitContext = initContext;
+  auto *oldContext = getDefaultArgumentInitContextCached();
+  assert((!oldContext || oldContext == initContext) &&
+         "Cannot change init context after setting");
+
+  auto *defaultInfo = DefaultValueAndFlags.getPointer();
+  assert(defaultInfo);
+  defaultInfo->InitContext = initContext;
 }
 
 void ParamDecl::setDefaultArgumentCaptureInfo(CaptureInfo captures) {

lib/AST/TypeCheckRequests.cpp

@@ -1181,3 +1181,21 @@ void HasCircularRawValueRequest::noteCycleStep(DiagnosticEngine &diags) const {
   diags.diagnose(decl, diag::kind_declname_declared_here,
                  decl->getDescriptiveKind(), decl->getName());
 }
+
+//----------------------------------------------------------------------------//
+// DefaultArgumentInitContextRequest computation.
+//----------------------------------------------------------------------------//
+
+Optional<Initializer *>
+DefaultArgumentInitContextRequest::getCachedResult() const {
+  auto *param = std::get<0>(getStorage());
+  if (auto *init = param->getDefaultArgumentInitContextCached())
+    return init;
+
+  return None;
+}
+
+void DefaultArgumentInitContextRequest::cacheResult(Initializer *init) const {
+  auto *param = std::get<0>(getStorage());
+  param->setDefaultArgumentInitContext(init);
+}

lib/Sema/CodeSynthesis.cpp

@@ -107,7 +107,6 @@ Expr *swift::buildArgumentForwardingExpr(ArrayRef<ParamDecl*> params,
 }
 
 static void maybeAddMemberwiseDefaultArg(ParamDecl *arg, VarDecl *var,
-                    SmallVectorImpl<DefaultArgumentInitializer *> &defaultInits,
                                          unsigned paramSize, ASTContext &ctx) {
   // First and foremost, if this is a constant don't bother.
   if (var->isLet())
@@ -138,13 +137,6 @@ static void maybeAddMemberwiseDefaultArg(ParamDecl *arg, VarDecl *var,
 
   // We can add a default value now.
 
-  // Give this some bogus context right now, we'll fix it after making
-  // the constructor.
-  auto *initDC = new (ctx) DefaultArgumentInitializer(
-    arg->getDeclContext(), paramSize);
-
-  defaultInits.push_back(initDC);
-
   // If the variable has a type T? and no initial value, return a nil literal
   // default arg. All lazy variables return a nil literal as well. *Note* that
   // the type will always be a sugared T? because we don't default init an
@@ -244,7 +236,7 @@ static ConstructorDecl *createImplicitConstructor(NominalTypeDecl *decl,
       // Don't allow the parameter to accept temporary pointer conversions.
       arg->setNonEphemeralIfPossible();
 
-      maybeAddMemberwiseDefaultArg(arg, var, defaultInits, params.size(), ctx);
+      maybeAddMemberwiseDefaultArg(arg, var, params.size(), ctx);
 
       params.push_back(arg);
     }
@@ -266,11 +258,6 @@ static ConstructorDecl *createImplicitConstructor(NominalTypeDecl *decl,
 
   if (ICK == ImplicitConstructorKind::Memberwise) {
     ctor->setIsMemberwiseInitializer();
-
-    // Fix default argument init contexts now that we have a constructor.
-    for (auto initDC : defaultInits) {
-      initDC->changeFunction(ctor, paramList);
-    }
   }
 
   // If we are defining a default initializer for a class that has a superclass,

lib/Sema/TypeCheckDecl.cpp

@@ -2035,6 +2035,41 @@ static void checkDefaultArguments(ParameterList *params) {
   }
 }
 
+llvm::Expected<Initializer *>
+DefaultArgumentInitContextRequest::evaluate(Evaluator &eval,
+                                            ParamDecl *param) const {
+  auto &ctx = param->getASTContext();
+  auto *parentDC = param->getDeclContext();
+  auto *paramList = getParameterList(cast<ValueDecl>(parentDC->getAsDecl()));
+
+  // In order to compute the initializer context for this parameter, we need to
+  // know its index in the parameter list. Therefore iterate over the parameters
+  // looking for it and fill in the other parameter's contexts while we're here.
+  Initializer *result = nullptr;
+  for (auto idx : indices(*paramList)) {
+    auto *otherParam = paramList->get(idx);
+
+    // If this param doesn't need a context, we're done.
+    if (!otherParam->getDefaultValue() && !otherParam->getStoredProperty())
+      continue;
+
+    // If this param already has a context, continue using it.
+    if (otherParam->getDefaultArgumentInitContextCached())
+      continue;
+
+    // Create a new initializer context. If this is for the parameter that
+    // kicked off the request, make a note of it for when we return. Otherwise
+    // cache the result ourselves.
+    auto *initDC = new (ctx) DefaultArgumentInitializer(parentDC, idx);
+    if (param == otherParam)
+      result = initDC;
+    else
+      eval.cacheOutput(DefaultArgumentInitContextRequest{otherParam}, initDC);
+  }
+  assert(result && "Didn't create init context?");
+  return result;
+}
+
 PrecedenceGroupDecl *TypeChecker::lookupPrecedenceGroup(DeclContext *dc,
                                                         Identifier name,
                                                         SourceLoc nameLoc) {