[cxx-interop] Avoid crashing upon invalid function template instantiation

We were previously not handling cases where the instantiation of the
**declaration** of a function template is valid, but the instantiation
of its **definition** is invalid (e.g., because it contains an invalid
static_cast() or static_assert()). This patch teaches ClangImporter to
correctly diagnose these as compiler errors, rather than simply
crashing.

rdar://137456897

Author: j-hui

lib/ClangImporter/ClangImporter.cpp

@@ -7300,10 +7300,8 @@ clang::FunctionDecl *ClangImporter::instantiateCXXFunctionTemplate(
   // Instantiate a specialization of this template using the substitution map.
   auto *templateArgList = clang::TemplateArgumentList::CreateCopy(
       func->getASTContext(), templateSubst);
-  auto &sema = getClangInstance().getSema();
-  auto *spec = sema.InstantiateFunctionDeclaration(func, templateArgList,
-                                                   clang::SourceLocation());
-  if (!spec) {
+
+  auto diagnoseSubstFail = [&]() {
     std::string templateParams;
     llvm::raw_string_ostream templateParamsStream(templateParams);
     llvm::interleaveComma(templateArgList->asArray(), templateParamsStream,
@@ -7315,9 +7313,24 @@ clang::FunctionDecl *ClangImporter::instantiateCXXFunctionTemplate(
     Impl.diagnose(HeaderLoc(func->getBeginLoc()),
                   diag::unable_to_substitute_cxx_function_template,
                   getFuncName(), templateParams);
+  };
+
+  auto &sema = getClangInstance().getSema();
+  auto *spec = sema.InstantiateFunctionDeclaration(func, templateArgList,
+                                                   clang::SourceLocation());
+  if (!spec || spec->isInvalidDecl()) {
+    diagnoseSubstFail();
     return nullptr;
   }
+
   sema.InstantiateFunctionDefinition(clang::SourceLocation(), spec);
+  // Even if the declaration can be instantiated, the definition may contain
+  // a substitution failure that renders spec invalid as a side-effect.
+  if (spec->isInvalidDecl()) {
+    diagnoseSubstFail();
+    return nullptr;
+  }
+
   return spec;
 }
 

test/Interop/Cxx/templates/static-cast-typecheck.swift

@@ -0,0 +1,44 @@
+// RUN: split-file %s %t
+// RUN: %target-swift-frontend -typecheck -verify -suppress-remarks -suppress-notes \
+// RUN:     -cxx-interoperability-mode=default \
+// RUN:     -I %t/Inputs %t/main.swift \
+// RUN:     -verify-additional-file %t%{fs-sep}Inputs%{fs-sep}header.h
+
+//--- Inputs/module.modulemap
+module CxxHeader {
+    header "header.h"
+    requires cplusplus
+}
+
+//--- Inputs/header.h
+#pragma once
+
+// TODO: the following diagnostics should be moved to main.swift at the call site
+//       that triggers the instantiation
+// expected-error@+4 {{could not substitute parameters for C++ function template 'cxxCast': BaseT, UnrelatedT}}
+// expected-error@+3 {{could not substitute parameters for C++ function template 'cxxCast': BaseT, SubClassT}}
+// expected-error@+2 {{could not substitute parameters for C++ function template 'cxxCast': BaseT, SubProtectedT}}
+// expected-error@+1 {{could not substitute parameters for C++ function template 'cxxCast': BaseT, SubPrivateT}}
+template <class O, class I> O cxxCast(I i) { return static_cast<O>(i); }
+// expected-error@-1 {{cannot cast 'const SubPrivateT' to its private base class 'const BaseT'}}
+// expected-error@-2 {{cannot cast 'const SubProtectedT' to its protected base class 'const BaseT'}}
+// expected-error@-3 {{cannot cast 'const SubClassT' to its private base class 'const BaseT'}}
+// expected-error@-4 {{no matching conversion for static_cast from 'UnrelatedT' to 'BaseT'}}
+
+struct BaseT { };
+
+struct SubT          : BaseT            { }; // publicly inherit from BaseT
+struct SubPrivateT   : private BaseT    { }; // privately inherit from BaseT
+struct SubProtectedT : protected BaseT  { }; // privately inherit from BaseT
+class  SubClassT     : BaseT            { }; // privately inherit from BaseT
+struct UnrelatedT                       { }; // does not inherit from BaseT
+
+
+//--- main.swift
+import CxxHeader
+
+let _: BaseT = cxxCast(SubT())          // valid:   upcast to public base
+let _: BaseT = cxxCast(SubPrivateT())   // invalid: upcast to non-public base
+let _: BaseT = cxxCast(SubProtectedT()) // invalid: upcast to non-public base
+let _: BaseT = cxxCast(SubClassT())     // invalid: upcast to non-public base
+let _: BaseT = cxxCast(UnrelatedT())    // invalid: cast to unrelated type