Merge pull request #70044 from apple/egorzhdan/default-arguments

[cxx-interop] Support C++ default arguments

Author: egorzhdan

include/swift/AST/ClangModuleLoader.h

@@ -283,6 +283,8 @@ class ClangModuleLoader : public ModuleLoader {
 
   virtual bool isUnsafeCXXMethod(const FuncDecl *func) = 0;
 
+  virtual FuncDecl *getDefaultArgGenerator(const clang::ParmVarDecl *param) = 0;
+
   virtual llvm::Optional<Type>
   importFunctionReturnType(const clang::FunctionDecl *clangDecl,
                            DeclContext *dc) = 0;

include/swift/ClangImporter/ClangImporter.h

@@ -587,6 +587,8 @@ class ClangImporter final : public ClangModuleLoader {
 
   bool isUnsafeCXXMethod(const FuncDecl *func) override;
 
+  FuncDecl *getDefaultArgGenerator(const clang::ParmVarDecl *param) override;
+
   bool isAnnotatedWith(const clang::CXXMethodDecl *method, StringRef attr);
 
   /// Find the lookup table that corresponds to the given Clang module.

lib/ClangImporter/ClangImporter.cpp

@@ -4199,14 +4199,20 @@ void ClangModuleUnit::getImportedModulesForLookup(
 void ClangImporter::getMangledName(raw_ostream &os,
                                    const clang::NamedDecl *clangDecl) const {
   if (!Impl.Mangler)
-    Impl.Mangler.reset(Impl.getClangASTContext().createMangleContext());
+    Impl.Mangler.reset(getClangASTContext().createMangleContext());
 
+  return Impl.getMangledName(Impl.Mangler.get(), clangDecl, os);
+}
+
+void ClangImporter::Implementation::getMangledName(
+    clang::MangleContext *mangler, const clang::NamedDecl *clangDecl,
+    raw_ostream &os) {
   if (auto ctor = dyn_cast<clang::CXXConstructorDecl>(clangDecl)) {
     auto ctorGlobalDecl =
         clang::GlobalDecl(ctor, clang::CXXCtorType::Ctor_Complete);
-    Impl.Mangler->mangleCXXName(ctorGlobalDecl, os);
+    mangler->mangleCXXName(ctorGlobalDecl, os);
   } else {
-    Impl.Mangler->mangleName(clangDecl, os);
+    mangler->mangleName(clangDecl, os);
   }
 }
 
@@ -7044,6 +7050,14 @@ bool ClangImporter::isAnnotatedWith(const clang::CXXMethodDecl *method,
          });
 }
 
+FuncDecl *
+ClangImporter::getDefaultArgGenerator(const clang::ParmVarDecl *param) {
+  auto it = Impl.defaultArgGenerators.find(param);
+  if (it != Impl.defaultArgGenerators.end())
+    return it->second;
+  return nullptr;
+}
+
 SwiftLookupTable *
 ClangImporter::findLookupTable(const clang::Module *clangModule) {
   return Impl.findLookupTable(clangModule);
@@ -7190,7 +7204,7 @@ static bool hasOwnedValueAttr(const clang::RecordDecl *decl) {
          });
 }
 
-static bool hasUnsafeAPIAttr(const clang::Decl *decl) {
+bool importer::hasUnsafeAPIAttr(const clang::Decl *decl) {
   return decl->hasAttrs() && llvm::any_of(decl->getAttrs(), [](auto *attr) {
            if (auto swiftAttr = dyn_cast<clang::SwiftAttrAttr>(attr))
              return swiftAttr->getAttribute() == "import_unsafe";
@@ -7256,6 +7270,10 @@ static bool hasPointerInSubobjects(const clang::CXXRecordDecl *decl) {
   return false;
 }
 
+bool importer::isViewType(const clang::CXXRecordDecl *decl) {
+  return !hasOwnedValueAttr(decl) && hasPointerInSubobjects(decl);
+}
+
 static bool copyConstructorIsDefaulted(const clang::CXXRecordDecl *decl) {
   auto ctor = llvm::find_if(decl->ctors(), [](clang::CXXConstructorDecl *ctor) {
     return ctor->isCopyConstructor();
@@ -7581,8 +7599,7 @@ bool IsSafeUseOfCxxDecl::evaluate(Evaluator &evaluator,
         // A projection of a view type (such as a string_view) from a self
         // contained parent is a proejction (unsafe).
         if (!anySubobjectsSelfContained(cxxRecordReturnType) &&
-            !hasOwnedValueAttr(cxxRecordReturnType) &&
-            hasPointerInSubobjects(cxxRecordReturnType)) {
+            isViewType(cxxRecordReturnType)) {
           return !parentIsSelfContained;
         }
       }

lib/ClangImporter/ImportType.cpp

@@ -17,6 +17,7 @@
 #include "CFTypeInfo.h"
 #include "ClangDiagnosticConsumer.h"
 #include "ImporterImpl.h"
+#include "SwiftDeclSynthesizer.h"
 #include "swift/ABI/MetadataValues.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Decl.h"
@@ -42,6 +43,7 @@
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjCCommon.h"
 #include "clang/AST/DeclTemplate.h"
+#include "clang/AST/ExprCXX.h"
 #include "clang/AST/TypeVisitor.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Lex/Preprocessor.h"
@@ -2460,6 +2462,51 @@ ClangImporter::Implementation::importParameterType(
                                    isParamTypeImplicitlyUnwrapped};
 }
 
+bool ClangImporter::Implementation::isDefaultArgSafeToImport(
+    const clang::ParmVarDecl *param) {
+  // If the argument is explicitly marked as import_unsafe, import its default
+  // expression regardless of the safety heuristics.
+  if (hasUnsafeAPIAttr(param))
+    return true;
+
+  auto functionDecl = cast<clang::FunctionDecl>(param->getDeclContext());
+
+  if (param->hasUninstantiatedDefaultArg() &&
+      !functionDecl->getTemplateInstantiationPattern(
+          /*ForDefinition*/ false))
+    // HACK: Clang will crash while trying to instantiate this default arg.
+    return false;
+
+  clang::CXXDefaultArgExpr *defaultArgExpr = nullptr;
+  // Try to instantiate the default expression.
+  auto defaultArgExprResult = getClangSema().BuildCXXDefaultArgExpr(
+      clang::SourceLocation(), const_cast<clang::FunctionDecl *>(functionDecl),
+      const_cast<clang::ParmVarDecl *>(param));
+  // If the default expression can't be instantiated, bail.
+  if (!defaultArgExprResult.isUsable())
+    return false;
+  else
+    defaultArgExpr = cast<clang::CXXDefaultArgExpr>(defaultArgExprResult.get());
+
+  // If the type of this parameter is a view type, do not import the
+  // default expression, since we cannot guarantee the lifetime of the
+  // pointee value.
+  if (auto paramRecordDecl = param->getType()->getAsCXXRecordDecl()) {
+    if (isViewType(paramRecordDecl))
+      return false;
+  }
+  // If the parameter is a const reference, check if the expression
+  // creates temporaries. Since we import const T& as T in Swift, the
+  // value of the default expression will get copied in Swift unlike C++,
+  // which might be unexpected and unsafe.
+  if (param->getType()->isReferenceType() &&
+      param->getType()->getPointeeType().isConstQualified()) {
+    if (isa<clang::MaterializeTemporaryExpr>(defaultArgExpr->getExpr()))
+      return false;
+  }
+  return true;
+}
+
 static ParamDecl *getParameterInfo(ClangImporter::Implementation *impl,
                                    const clang::ParmVarDecl *param,
                                    const Identifier &name,
@@ -2484,6 +2531,24 @@ static ParamDecl *getParameterInfo(ClangImporter::Implementation *impl,
   paramInfo->setInterfaceType(swiftParamTy);
   impl->recordImplicitUnwrapForDecl(paramInfo, isParamTypeImplicitlyUnwrapped);
 
+  // Import the default expression for this parameter if possible.
+  // Swift doesn't support default values of inout parameters.
+  // TODO: support default arguments of constructors
+  // (https://github.com/apple/swift/issues/70124)
+  if (param->hasDefaultArg() && !isInOut &&
+      !isa<clang::CXXConstructorDecl>(param->getDeclContext()) &&
+      impl->isCxxInteropCompatVersionAtLeast(
+          version::getUpcomingCxxInteropCompatVersion()) &&
+      impl->isDefaultArgSafeToImport(param)) {
+    SwiftDeclSynthesizer synthesizer(*impl);
+    if (CallExpr *defaultArgExpr = synthesizer.makeDefaultArgument(
+            param, swiftParamTy, paramInfo->getParameterNameLoc())) {
+      paramInfo->setDefaultArgumentKind(DefaultArgumentKind::Normal);
+      paramInfo->setDefaultExpr(defaultArgExpr, /*isTypeChecked*/ true);
+      paramInfo->setDefaultValueStringRepresentation("cxxDefaultArg");
+    }
+  }
+
   return paramInfo;
 }
 

lib/ClangImporter/ImporterImpl.h

@@ -589,6 +589,10 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
     return Instance.get();
   }
 
+  /// Writes the mangled name of \p clangDecl to \p os.
+  void getMangledName(clang::MangleContext *mangler,
+                      const clang::NamedDecl *clangDecl, raw_ostream &os);
+
   /// Whether the C++ interoperability compatibility version is at least
   /// 'major'.
   ///
@@ -664,6 +668,10 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
       clonedBaseMembers;
 
 public:
+  llvm::DenseMap<const clang::ParmVarDecl*, FuncDecl*> defaultArgGenerators;
+
+  bool isDefaultArgSafeToImport(const clang::ParmVarDecl *param);
+
   ValueDecl *importBaseMemberDecl(ValueDecl *decl, DeclContext *newContext);
 
   static size_t getImportedBaseMemberDeclArity(const ValueDecl *valueDecl);
@@ -1985,6 +1993,10 @@ inline std::string getPrivateOperatorName(const std::string &OperatorToken) {
   return "None";
 }
 
+bool hasUnsafeAPIAttr(const clang::Decl *decl);
+
+bool isViewType(const clang::CXXRecordDecl *decl);
+
 }
 }
 

lib/ClangImporter/SwiftDeclSynthesizer.cpp

@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "SwiftDeclSynthesizer.h"
+#include "clang/AST/Mangle.h"
 #include "swift/AST/ASTMangler.h"
 #include "swift/AST/Builtins.h"
 #include "swift/AST/Expr.h"
@@ -2158,3 +2159,120 @@ SwiftDeclSynthesizer::makeComputedPropertyFromCXXMethods(FuncDecl *getter,
 
   return result;
 }
+
+static std::pair<BraceStmt *, bool>
+synthesizeDefaultArgumentBody(AbstractFunctionDecl *afd, void *context) {
+  auto funcDecl = cast<FuncDecl>(afd);
+  auto clangParam = static_cast<const clang::ParmVarDecl *>(context);
+  auto clangFuncDecl = cast<clang::FunctionDecl>(clangParam->getDeclContext());
+
+  ASTContext &ctx = funcDecl->getASTContext();
+  clang::ASTContext &clangCtx = clangParam->getASTContext();
+  clang::Sema &clangSema = ctx.getClangModuleLoader()->getClangSema();
+
+  auto clangDeclName = clang::DeclarationName(
+      &clangCtx.Idents.get(("__cxx" + funcDecl->getNameStr()).str()));
+  auto clangDeclContext = clangCtx.getTranslationUnitDecl();
+
+  // The following also instantiates the default argument if needed.
+  auto defaultArgCallExpr = clangSema.BuildCXXDefaultArgExpr(
+      clang::SourceLocation(), const_cast<clang::FunctionDecl *>(clangFuncDecl),
+      const_cast<clang::ParmVarDecl *>(clangParam));
+  if (!defaultArgCallExpr.isUsable())
+    return {nullptr, /*isTypeChecked=*/true};
+
+  // The following requires the default argument to be instantiated.
+  clang::QualType clangParamTy = clangParam->getDefaultArg()->getType();
+  clang::QualType funcTy = clangCtx.getFunctionType(
+      clangParamTy, {}, clang::FunctionProtoType::ExtProtoInfo());
+
+  // Synthesize `return {default expr};`.
+  auto defaultArgReturnStmt = clang::ReturnStmt::Create(
+      clangCtx, clang::SourceLocation(), defaultArgCallExpr.get(), nullptr);
+
+  // Synthesize `ParamTy __cxx__defaultArg_XYZ() { return {default expr}; }`.
+  auto defaultArgFuncDecl = clang::FunctionDecl::Create(
+      clangCtx, clangDeclContext, clang::SourceLocation(),
+      clang::SourceLocation(), clangDeclName, funcTy,
+      clangCtx.getTrivialTypeSourceInfo(clangParamTy),
+      clang::StorageClass::SC_Static);
+  defaultArgFuncDecl->setImplicit();
+  defaultArgFuncDecl->setImplicitlyInline();
+  defaultArgFuncDecl->setAccess(clang::AccessSpecifier::AS_public);
+  defaultArgFuncDecl->setBody(defaultArgReturnStmt);
+
+  // Import `func __cxx__defaultArg_XYZ() -> ParamTY` into Swift.
+  auto defaultArgGenerator = dyn_cast_or_null<FuncDecl>(
+      ctx.getClangModuleLoader()->importDeclDirectly(defaultArgFuncDecl));
+  if (!defaultArgGenerator)
+    return {nullptr, /*isTypeChecked=*/true};
+
+  auto defaultArgGeneratorRef = new (ctx) DeclRefExpr(
+      ConcreteDeclRef(defaultArgGenerator), DeclNameLoc(), /*Implicit=*/true);
+  defaultArgGeneratorRef->setType(defaultArgGenerator->getInterfaceType());
+
+  // Synthesize a call to `__cxx__defaultArg_XYZ()`.
+  auto initCall = CallExpr::createImplicit(
+      ctx, defaultArgGeneratorRef, ArgumentList::createImplicit(ctx, {}));
+  initCall->setType(defaultArgGenerator->getResultInterfaceType());
+  initCall->setThrows(nullptr);
+
+  // Synthesize `return __cxx__defaultArg_XYZ()`.
+  auto returnStmt = new (ctx) ReturnStmt(SourceLoc(), initCall,
+                                         /*implicit=*/true);
+
+  auto body = BraceStmt::create(ctx, SourceLoc(), {returnStmt}, SourceLoc(),
+                                /*implicit=*/true);
+  return {body, /*isTypeChecked=*/true};
+}
+
+CallExpr *
+SwiftDeclSynthesizer::makeDefaultArgument(const clang::ParmVarDecl *param,
+                                          const swift::Type &swiftParamTy,
+                                          SourceLoc paramLoc) {
+  assert(param->hasDefaultArg() && "must have a C++ default argument");
+  if (!param->getIdentifier())
+    // Work around an assertion failure in CXXNameMangler::mangleUnqualifiedName
+    // when mangling std::__fs::filesystem::path::format.
+    return nullptr;
+
+  ASTContext &ctx = ImporterImpl.SwiftContext;
+  clang::ASTContext &clangCtx = param->getASTContext();
+  auto clangFunc =
+      cast<clang::FunctionDecl>(param->getParentFunctionOrMethod());
+  if (isa<clang::CXXConstructorDecl>(clangFunc))
+    // TODO: support default arguments of constructors
+    // (https://github.com/apple/swift/issues/70124)
+    return nullptr;
+
+  std::string s;
+  llvm::raw_string_ostream os(s);
+  std::unique_ptr<clang::ItaniumMangleContext> mangler{
+      clang::ItaniumMangleContext::create(clangCtx, clangCtx.getDiagnostics())};
+  os << "__defaultArg_" << param->getFunctionScopeIndex() << "_";
+  ImporterImpl.getMangledName(mangler.get(), clangFunc, os);
+
+  // Synthesize `func __defaultArg_XYZ() -> ParamTy { ... }`.
+  DeclName funcName(ctx, DeclBaseName(ctx.getIdentifier(s)),
+                    ParameterList::createEmpty(ctx));
+  auto funcDecl = FuncDecl::createImplicit(
+      ctx, StaticSpellingKind::None, funcName, paramLoc, false, false, Type(),
+      {}, ParameterList::createEmpty(ctx), swiftParamTy,
+      ImporterImpl.ImportedHeaderUnit);
+  funcDecl->setBodySynthesizer(synthesizeDefaultArgumentBody, (void *)param);
+  funcDecl->setAccess(AccessLevel::Public);
+
+  ImporterImpl.defaultArgGenerators[param] = funcDecl;
+
+  auto declRefExpr = new (ctx)
+      DeclRefExpr(ConcreteDeclRef(funcDecl), DeclNameLoc(), /*Implicit*/ true);
+  declRefExpr->setType(funcDecl->getInterfaceType());
+  declRefExpr->setFunctionRefKind(FunctionRefKind::SingleApply);
+
+  auto callExpr = CallExpr::createImplicit(
+      ctx, declRefExpr, ArgumentList::forImplicitUnlabeled(ctx, {}));
+  callExpr->setType(funcDecl->getResultInterfaceType());
+  callExpr->setThrows(nullptr);
+
+  return callExpr;
+}

lib/ClangImporter/SwiftDeclSynthesizer.h

@@ -18,6 +18,8 @@
 
 namespace swift {
 
+class CallExpr;
+
 enum class MakeStructRawValuedFlags {
   /// whether to also create an unlabeled init
   MakeUnlabeledValueInit = 0x01,
@@ -294,6 +296,10 @@ class SwiftDeclSynthesizer {
   VarDecl *makeComputedPropertyFromCXXMethods(FuncDecl *getter,
                                               FuncDecl *setter);
 
+  CallExpr *makeDefaultArgument(const clang::ParmVarDecl *param,
+                                const swift::Type &swiftParamTy,
+                                SourceLoc paramLoc);
+
 private:
   Type getConstantLiteralType(Type type, ConstantConvertKind convertKind);
 };