Make default arg functions private static functions instead of public global functions

Author: j-hui

lib/ClangImporter/ImportType.cpp

@@ -2660,6 +2660,7 @@ bool ClangImporter::Implementation::isDefaultArgSafeToImport(
 }
 
 static ParamDecl *getParameterInfo(ClangImporter::Implementation *impl,
+                                   DeclContext *dc,
                                    const clang::ParmVarDecl *param,
                                    const Identifier &name,
                                    const swift::Type &swiftParamTy,
@@ -2709,7 +2710,7 @@ static ParamDecl *getParameterInfo(ClangImporter::Implementation *impl,
       !param->isTemplated()) {
     SwiftDeclSynthesizer synthesizer(*impl);
     if (CallExpr *defaultArgExpr = synthesizer.makeDefaultArgument(
-            param, swiftParamTy, paramInfo->getParameterNameLoc())) {
+            dc, param, swiftParamTy, paramInfo->getParameterNameLoc())) {
       paramInfo->setDefaultArgumentKind(DefaultArgumentKind::Normal);
       paramInfo->setTypeCheckedDefaultExpr(defaultArgExpr);
       paramInfo->setDefaultValueStringRepresentation("cxxDefaultArg");
@@ -2774,7 +2775,7 @@ ParameterList *ClangImporter::Implementation::importFunctionParameterList(
       name = argNames[index];
 
     auto paramInfo =
-        getParameterInfo(this, param, name, swiftParamTy, isInOut, isConsuming,
+        getParameterInfo(this, dc, param, name, swiftParamTy, isInOut, isConsuming,
                          isParamTypeImplicitlyUnwrapped);
     parameters.push_back(paramInfo);
     ++index;
@@ -3411,8 +3412,8 @@ ImportedType ClangImporter::Implementation::importMethodParamsAndReturnType(
 
     // Set up the parameter info
     auto paramInfo =
-        getParameterInfo(this, param, name, swiftParamTy, isInOut, isConsuming,
-                         isParamTypeImplicitlyUnwrapped);
+        getParameterInfo(this, origDC, param, name, swiftParamTy, isInOut,
+                         isConsuming, isParamTypeImplicitlyUnwrapped);
 
     // Determine whether we have a default argument.
     if (kind == SpecialMethodKind::Regular ||

lib/ClangImporter/SwiftDeclSynthesizer.cpp

@@ -2478,7 +2478,8 @@ synthesizeDefaultArgumentBody(AbstractFunctionDecl *afd, void *context) {
 }
 
 CallExpr *
-SwiftDeclSynthesizer::makeDefaultArgument(const clang::ParmVarDecl *param,
+SwiftDeclSynthesizer::makeDefaultArgument(DeclContext *dc,
+                                          const clang::ParmVarDecl *param,
                                           const swift::Type &swiftParamTy,
                                           SourceLoc paramLoc) {
   assert(param->hasDefaultArg() && "must have a C++ default argument");
@@ -2503,15 +2504,18 @@ SwiftDeclSynthesizer::makeDefaultArgument(const clang::ParmVarDecl *param,
   os << "__defaultArg_" << param->getFunctionScopeIndex() << "_";
   ImporterImpl.getMangledName(mangler.get(), clangFunc, os);
 
-  // Synthesize `func __defaultArg_XYZ() -> ParamTy { ... }`.
+  // Synthesize `static private func __defaultArg_XYZ() -> ParamTy { ... }`
+  // in the context of the function where the param is declared.
   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);
+      ctx, StaticSpellingKind::KeywordStatic, funcName, paramLoc, false, false,
+      Type(), {}, ParameterList::createEmpty(ctx), swiftParamTy, dc);
   funcDecl->setBodySynthesizer(synthesizeDefaultArgumentBody, (void *)param);
-  funcDecl->setAccess(AccessLevel::Public);
+  funcDecl->setAccess(AccessLevel::Private); // This is necessary in case the
+                                             // default parameter involves any
+                                             // private types, which are
+                                             // forbidden in public functions.
 
   ImporterImpl.defaultArgGenerators[param] = funcDecl;
 

lib/ClangImporter/SwiftDeclSynthesizer.h

@@ -330,7 +330,8 @@ class SwiftDeclSynthesizer {
   VarDecl *makeComputedPropertyFromCXXMethods(FuncDecl *getter,
                                               FuncDecl *setter);
 
-  CallExpr *makeDefaultArgument(const clang::ParmVarDecl *param,
+  CallExpr *makeDefaultArgument(DeclContext *dc,
+                                const clang::ParmVarDecl *param,
                                 const swift::Type &swiftParamTy,
                                 SourceLoc paramLoc);