C++Interop: Don't import c++ template functions with default arguments

SwiftDeclSynthesizer::makeDefaultArgument does not create substituion map while
creating the implicit FuncDecl which leads to TypeChecker complaining about
the absence when there are type parameters. Avoid importing such C++ functions for now.

Author: meg-gupta

lib/ClangImporter/ImportType.cpp

@@ -2616,12 +2616,10 @@ bool ClangImporter::Implementation::isDefaultArgSafeToImport(
   return true;
 }
 
-static ParamDecl *getParameterInfo(ClangImporter::Implementation *impl,
-                                   const clang::ParmVarDecl *param,
-                                   const Identifier &name,
-                                   const swift::Type &swiftParamTy,
-                                   const bool isInOut,
-                                   const bool isParamTypeImplicitlyUnwrapped) {
+static std::optional<ParamDecl *> getParameterInfo(
+    ClangImporter::Implementation *impl, const clang::ParmVarDecl *param,
+    const Identifier &name, const swift::Type &swiftParamTy, const bool isInOut,
+    const bool isParamTypeImplicitlyUnwrapped, const bool isTemplated) {
   // Figure out the name for this parameter.
   Identifier bodyName = impl->importFullName(param, impl->CurrentVersion)
                             .getBaseIdentifier(impl->SwiftContext);
@@ -2660,6 +2658,13 @@ static ParamDecl *getParameterInfo(ClangImporter::Implementation *impl,
   if (param->hasDefaultArg() && !isInOut &&
       !isa<clang::CXXConstructorDecl>(param->getDeclContext()) &&
       impl->isDefaultArgSafeToImport(param)) {
+
+    // If this was a default argument expression with template parameter, return
+    // std::nullopt
+    if (isTemplated) {
+      return std::nullopt;
+    }
+
     SwiftDeclSynthesizer synthesizer(*impl);
     if (CallExpr *defaultArgExpr = synthesizer.makeDefaultArgument(
             param, swiftParamTy, paramInfo->getParameterNameLoc())) {
@@ -2723,8 +2728,15 @@ ParameterList *ClangImporter::Implementation::importFunctionParameterList(
       name = argNames[index];
 
     auto paramInfo = getParameterInfo(this, param, name, swiftParamTy, isInOut,
-                                      isParamTypeImplicitlyUnwrapped);
-    parameters.push_back(paramInfo);
+                                      isParamTypeImplicitlyUnwrapped,
+                                      swiftParamTy->hasTypeParameter());
+    if (!paramInfo.has_value()) {
+      addImportDiagnostic(param,
+                          Diagnostic(diag::parameter_type_not_imported, param),
+                          param->getSourceRange().getBegin());
+      return nullptr;
+    }
+    parameters.push_back(*paramInfo);
     ++index;
   }
 
@@ -3349,8 +3361,9 @@ ImportedType ClangImporter::Implementation::importMethodParamsAndReturnType(
     ++nameIndex;
 
     // Set up the parameter info
-    auto paramInfo = getParameterInfo(this, param, name, swiftParamTy, isInOut,
-                                      isParamTypeImplicitlyUnwrapped);
+    auto paramInfo = *getParameterInfo(this, param, name, swiftParamTy, isInOut,
+                                       isParamTypeImplicitlyUnwrapped,
+                                       /*isTemplated*/ false);
 
     // Determine whether we have a default argument.
     if (kind == SpecialMethodKind::Regular ||

test/Interop/Cxx/templates/defaulted-template-type-parameter-module-interface.swift

@@ -1,4 +1,5 @@
 // RUN: %target-swift-ide-test -print-module -module-to-print=DefaultedTemplateTypeParameter -I %S/Inputs -source-filename=x -enable-experimental-cxx-interop | %FileCheck %s
+// REQUIRES: rdar136703069
 
 // CHECK: struct X {
 // CHECK:   init<T>(_: T)

test/Interop/Cxx/templates/defaulted-template-type-parameter.swift

@@ -1,6 +1,7 @@
 // RUN: %target-run-simple-swift(-I %S/Inputs -Xfrontend -enable-experimental-cxx-interop)
 //
 // REQUIRES: executable_test
+// REQUIRES: rdar136703069
 
 import DefaultedTemplateTypeParameter
 import StdlibUnittest