[cxx-interop] Check the safety of C++ template arguments

Swift imports template specializations as a standalone type (not as an
instantiation of a generic) so unsafety is not propagated from the
template arguments to the specialization. This PR propagates this
information explicitly.

Author: Gabor Horvath

lib/ClangImporter/ImportDecl.cpp

@@ -61,6 +61,7 @@
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjCCommon.h"
 #include "clang/AST/PrettyPrinter.h"
+#include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Type.h"
 #include "clang/Basic/Specifiers.h"
 #include "clang/Basic/TargetInfo.h"
@@ -2178,6 +2179,29 @@ namespace {
             dc);
       Impl.ImportedDecls[{decl->getCanonicalDecl(), getVersion()}] = result;
 
+      // We have to do this after populating ImportedDecls to avoid importing
+      // the same multiple times.
+      if (Impl.SwiftContext.LangOpts.hasFeature(Feature::SafeInterop) &&
+          Impl.SwiftContext.LangOpts.hasFeature(
+              Feature::AllowUnsafeAttribute)) {
+        if (const auto *ctsd =
+                dyn_cast<clang::ClassTemplateSpecializationDecl>(decl)) {
+          for (auto arg : ctsd->getTemplateArgs().asArray()) {
+            if (arg.getKind() != clang::TemplateArgument::Type)
+              continue;
+            auto SwiftType = Impl.importTypeIgnoreIUO(
+                arg.getAsType(), ImportTypeKind::Abstract,
+                [](Diagnostic &&diag) {}, false, Bridgeability::None,
+                ImportTypeAttrs());
+            if (SwiftType && SwiftType->isUnsafe()) {
+              auto attr = new (Impl.SwiftContext) UnsafeAttr(/*implicit=*/true);
+              result->getAttrs().add(attr);
+              break;
+            }
+          }
+        }
+      }
+
       if (recordHasMoveOnlySemantics(decl)) {
         if (decl->isInStdNamespace() && decl->getName() == "promise") {
           // Do not import std::promise.
@@ -3001,14 +3025,14 @@ namespace {
     bool isSpecializationDepthGreaterThan(
         const clang::ClassTemplateSpecializationDecl *decl, unsigned maxDepth) {
       for (auto arg : decl->getTemplateArgs().asArray()) {
-        if (arg.getKind() == clang::TemplateArgument::Type) {
-          if (auto classSpec =
-                  dyn_cast_or_null<clang::ClassTemplateSpecializationDecl>(
-                      arg.getAsType()->getAsCXXRecordDecl())) {
-            if (maxDepth == 0 ||
-                isSpecializationDepthGreaterThan(classSpec, maxDepth - 1))
-              return true;
-          }
+        if (arg.getKind() != clang::TemplateArgument::Type)
+          continue;
+        if (auto classSpec =
+                dyn_cast_or_null<clang::ClassTemplateSpecializationDecl>(
+                    arg.getAsType()->getAsCXXRecordDecl())) {
+          if (maxDepth == 0 ||
+              isSpecializationDepthGreaterThan(classSpec, maxDepth - 1))
+            return true;
         }
       }
       return false;
@@ -8387,6 +8411,13 @@ static bool importAsUnsafe(ClangImporter::Implementation &impl,
   if (isa<ClassDecl>(MappedDecl))
     return false;
 
+  // Most STL containers have std::allocator as their default allocator. We need
+  // to consider std::allocator safe for the STL containers to be ever
+  // considered safe.
+  if (decl->isInStdNamespace() && decl->getIdentifier() &&
+      decl->getName() == "allocator")
+    return false;
+
   if (const auto *record = dyn_cast<clang::RecordDecl>(decl))
     return evaluateOrDefault(
                context.evaluator,

test/Interop/Cxx/class/safe-interop-mode.swift

@@ -18,6 +18,7 @@ module Test {
 //--- Inputs/nonescapable.h
 #include "swift/bridging"
 #include <span>
+#include <vector>
 
 struct SWIFT_NONESCAPABLE View {
     __attribute__((swift_attr("@lifetime(immortal)")))
@@ -54,6 +55,8 @@ struct MyContainer {
 
 using SpanOfInt = std::span<int>;
 using SpanOfIntAlias = SpanOfInt;
+using VecOfPtr = std::vector<int*>;
+using VecOfInt = std::vector<int>;
 
 //--- test.swift
 
@@ -85,6 +88,13 @@ func useCfType(x: CFArray) {
 func useString(x: std.string) {
 }
 
+// expected-warning@+1{{global function 'useVecOfPtr' involves unsafe code; use '@unsafe' to indicate that its use is not memory-safe}}
+func useVecOfPtr(x: VecOfPtr) { // expected-note{{reference to unsafe type alias 'VecOfPtr'}}
+}
+
+func useVecOfInt(x: VecOfInt) {
+}
+
 // expected-warning@+1{{global function 'useCppSpan' involves unsafe code; use '@unsafe' to indicate that its use is not memory-safe}}
 func useCppSpan(x: SpanOfInt) { // expected-note{{reference to unsafe type alias 'SpanOfInt'}}
 }