Revert "[cxx-interop] Check template argument safety in ClangDeclExplicitSafety"

This reverts commit d2632d2.

Author: j-hui

lib/ClangImporter/ClangImporter.cpp

@@ -8881,29 +8881,6 @@ ClangDeclExplicitSafety::evaluate(Evaluator &evaluator,
           ClangTypeEscapability({recordDecl->getTypeForDecl(), nullptr}),
           CxxEscapability::Unknown) != CxxEscapability::Unknown)
     return ExplicitSafety::Safe;
-
-  // A template class is unsafe if any of its type arguments are unsafe.
-  // Note that this does not rely on the record being defined.
-  if (const auto *ctsd =
-          dyn_cast<clang::ClassTemplateSpecializationDecl>(recordDecl)) {
-    for (auto arg : ctsd->getTemplateArgs().asArray()) {
-      switch (arg.getKind()) {
-      case clang::TemplateArgument::Type:
-        if (hasUnsafeType(evaluator, arg.getAsType()))
-          return ExplicitSafety::Unsafe;
-        break;
-      case clang::TemplateArgument::Pack:
-        for (auto pkArg : arg.getPackAsArray()) {
-          if (pkArg.getKind() == clang::TemplateArgument::Type &&
-              hasUnsafeType(evaluator, pkArg.getAsType()))
-            return ExplicitSafety::Unsafe;
-        }
-        break;
-      default:
-        continue;
-      }
-    }
-  }
 
   // If we don't have a definition, leave it unspecified.
   recordDecl = recordDecl->getDefinition();
@@ -8917,7 +8894,7 @@ ClangDeclExplicitSafety::evaluate(Evaluator &evaluator,
         return ExplicitSafety::Unsafe;
     }
   }
-
+  
   // Check the fields.
   for (auto field : recordDecl->fields()) {
     if (hasUnsafeType(evaluator, field->getType()))

lib/ClangImporter/ImportDecl.cpp

@@ -2302,6 +2302,40 @@ namespace {
         }
       }
 
+      if (const auto *ctsd =
+              dyn_cast<clang::ClassTemplateSpecializationDecl>(decl)) {
+        for (auto arg : ctsd->getTemplateArgs().asArray()) {
+          auto done = false;
+          auto checkUnsafe = [&](clang::TemplateArgument tyArg) {
+            if (tyArg.getKind() != clang::TemplateArgument::Type)
+              return;
+
+            auto safety =
+                evaluateOrDefault(Impl.SwiftContext.evaluator,
+                                  ClangTypeExplicitSafety({tyArg.getAsType()}),
+                                  ExplicitSafety::Unspecified);
+
+            if (safety == ExplicitSafety::Unsafe) {
+              result->addAttribute(new (Impl.SwiftContext)
+                                       UnsafeAttr(/*implicit=*/true));
+              done = true;
+            }
+          };
+
+          if (arg.getKind() == clang::TemplateArgument::Pack) {
+            for (auto pkArg : arg.getPackAsArray()) {
+              checkUnsafe(pkArg);
+              if (done)
+                break;
+            }
+          } else {
+            checkUnsafe(arg);
+          }
+          if (done)
+            break;
+        }
+      }
+
       bool isNonEscapable = false;
       if (evaluateOrDefault(
               Impl.SwiftContext.evaluator,

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

@@ -94,16 +94,6 @@ using TTakePtr = TTake<int *>;
 using TTakeSafeTuple = TTake<SafeTuple>;
 using TTakeUnsafeTuple = TTake<UnsafeTuple>;
 
-// An escapability or explicit safety annotation means a type is considered safe
-// even if it would otherwise be considered unsafe.
-template <typename> struct SWIFT_ESCAPABLE TEscape {};
-template <typename> struct __attribute__((swift_attr("safe"))) TSafe { void *ptr; };
-
-using TEscapePtr = TEscape<int *>;
-using TEscapeUnsafeTuple = TEscape<UnsafeTuple>;
-using TSafePtr = TSafe<int *>;
-using TSafeTuple = TSafe<UnsafeTuple>;
-
 struct HoldsShared {
   SharedObject* obj;
 
@@ -223,8 +213,3 @@ func useTTakeUnsafeTuple(x: TTakeUnsafeTuple) {
   // expected-warning@+1{{expression uses unsafe constructs but is not marked with 'unsafe'}}
   _ = x // expected-note{{reference to parameter 'x' involves unsafe type}}
 }
-
-func useTEscapePtr(x: TEscapePtr) { _ = x }
-func useTEscapeUnsafeTuple(x: TEscapeUnsafeTuple) { _ = x }
-func useTSafePtr(x: TSafePtr) { _ = x }
-func useTSafeTuple(x: TSafeTuple) { _ = x }