ParamDecl: Defend against default argument kind overwrites

Author: AnthonyLatsis

include/swift/AST/Decl.h

@@ -6670,8 +6670,15 @@ class ParamDecl : public VarDecl {
             Identifier argumentName, SourceLoc parameterNameLoc,
             Identifier parameterName, DeclContext *dc);
 
-  /// Create a new ParamDecl identical to the first except without the interface type.
-  static ParamDecl *cloneWithoutType(const ASTContext &Ctx, ParamDecl *PD);
+  /// Create a new `ParamDecl` identical to the given one except without the
+  /// interface type.
+  ///
+  /// \param PD The parameter to clone.
+  /// \param defaultArgKind The default argument kind for the cloned parameter.
+  ///        If \c std::nullopt, use the default argument kind of \p PD.
+  static ParamDecl *cloneWithoutType(
+      const ASTContext &Ctx, ParamDecl *PD,
+      std::optional<DefaultArgumentKind> defaultArgKind = std::nullopt);
 
   /// Create a an identical copy of this ParamDecl.
   static ParamDecl *clone(const ASTContext &Ctx, ParamDecl *PD);
@@ -6736,9 +6743,8 @@ class ParamDecl : public VarDecl {
   bool isDefaultArgument() const {
     return getDefaultArgumentKind() != DefaultArgumentKind::None;
   }
-  void setDefaultArgumentKind(DefaultArgumentKind K) {
-    Bits.ParamDecl.defaultArgumentKind = static_cast<unsigned>(K);
-  }
+
+  void setDefaultArgumentKind(DefaultArgumentKind K);
 
   void setDefaultArgumentKind(ArgumentAttrs K) {
     setDefaultArgumentKind(K.argumentKind);

lib/AST/Decl.cpp

@@ -8253,13 +8253,19 @@ ParamDecl::ParamDecl(SourceLoc specifierLoc, SourceLoc argumentNameLoc,
     static_cast<unsigned>(DefaultArgumentKind::None);
 }
 
-ParamDecl *ParamDecl::cloneWithoutType(const ASTContext &Ctx, ParamDecl *PD) {
+ParamDecl *
+ParamDecl::cloneWithoutType(const ASTContext &Ctx, ParamDecl *PD,
+                            std::optional<DefaultArgumentKind> defaultArgKind) {
   auto *Clone = new (Ctx) ParamDecl(
       SourceLoc(), SourceLoc(), PD->getArgumentName(),
       SourceLoc(), PD->getParameterName(), PD->getDeclContext());
   Clone->setOptionsAndPointers(nullptr, nullptr, PD->getOptions());
-  Clone->Bits.ParamDecl.defaultArgumentKind =
-      PD->Bits.ParamDecl.defaultArgumentKind;
+
+  if (defaultArgKind) {
+    Clone->setDefaultArgumentKind(*defaultArgKind);
+  } else {
+    Clone->setDefaultArgumentKind(PD->getDefaultArgumentKind());
+  }
 
   Clone->setSpecifier(PD->getSpecifier());
   Clone->setImplicitlyUnwrappedOptional(PD->isImplicitlyUnwrappedOptional());
@@ -8367,6 +8373,12 @@ ParamDecl *ParamDecl::createParsed(ASTContext &Context, SourceLoc specifierLoc,
   return decl;
 }
 
+void ParamDecl::setDefaultArgumentKind(DefaultArgumentKind K) {
+  assert(getDefaultArgumentKind() == DefaultArgumentKind::None &&
+         "Overwrite of default argument kind");
+  Bits.ParamDecl.defaultArgumentKind = static_cast<unsigned>(K);
+}
+
 /// Retrieve the type of 'self' for the given context.
 Type DeclContext::getSelfTypeInContext() const {
   return mapTypeIntoContext(getSelfInterfaceType());

lib/AST/Parameter.cpp

@@ -64,32 +64,32 @@ ParameterList *ParameterList::clone(const ASTContext &C,
   for (auto &decl : params) {
     auto defaultArgKind = decl->getDefaultArgumentKind();
 
-    decl = ParamDecl::cloneWithoutType(C, decl);
-    if (options & Implicit)
-      decl->setImplicit();
-
-    // If the argument isn't named, give the parameter a name so that
-    // silgen will produce a value for it.
-    if (decl->getName().empty() && (options & NamedArguments)) {
-      llvm::SmallString<16> s;
-      { llvm::raw_svector_ostream(s) << "__argument" << ++i; }
-      decl->setName(C.getIdentifier(s));
-    }
-    
     // If we're inheriting a default argument, mark it as such.
     // FIXME: Figure out how to clone default arguments as well.
     if (options & Inherited) {
       switch (defaultArgKind) {
       case DefaultArgumentKind::Normal:
       case DefaultArgumentKind::StoredProperty:
-        decl->setDefaultArgumentKind(DefaultArgumentKind::Inherited);
+        defaultArgKind = DefaultArgumentKind::Inherited;
         break;
 
       default:
         break;
       }
     } else {
-      decl->setDefaultArgumentKind(DefaultArgumentKind::None);
+      defaultArgKind = DefaultArgumentKind::None;
+    }
+
+    decl = ParamDecl::cloneWithoutType(C, decl, defaultArgKind);
+    if (options & Implicit)
+      decl->setImplicit();
+
+    // If the argument isn't named, give the parameter a name so that
+    // silgen will produce a value for it.
+    if (decl->getName().empty() && (options & NamedArguments)) {
+      llvm::SmallString<16> s;
+      { llvm::raw_svector_ostream(s) << "__argument" << ++i; }
+      decl->setName(C.getIdentifier(s));
     }
   }