[SE-0458] Unify escapibility inference for AST and Interop

Interop is injecting escapability annotations for the STL and doing a
limited inference for aggregates. Let's reuse the same facilities in the
AST when we calculate the safety of the foreign types.

Author: Gabor Horvath

include/swift/ClangImporter/ClangImporterRequests.h

@@ -417,10 +417,8 @@ class CxxRecordAsSwiftType
 
 struct SafeUseOfCxxDeclDescriptor final {
   const clang::Decl *decl;
-  ASTContext &ctx;
 
-  SafeUseOfCxxDeclDescriptor(const clang::Decl *decl, ASTContext &ctx)
-      : decl(decl), ctx(ctx) {}
+  SafeUseOfCxxDeclDescriptor(const clang::Decl *decl) : decl(decl) {}
 
   friend llvm::hash_code hash_value(const SafeUseOfCxxDeclDescriptor &desc) {
     return llvm::hash_combine(desc.decl);
@@ -528,7 +526,7 @@ enum class CxxEscapability { Escapable, NonEscapable, Unknown };
 
 struct EscapabilityLookupDescriptor final {
   const clang::Type *type;
-  ClangImporter::Implementation &impl;
+  ClangImporter::Implementation *impl;
   bool annotationOnly = true;
 
   friend llvm::hash_code hash_value(const EscapabilityLookupDescriptor &desc) {

lib/AST/Decl.cpp

@@ -1153,9 +1153,9 @@ ExplicitSafety Decl::getExplicitSafety() const {
   // If this declaration is from C, ask the Clang importer.
   if (auto clangDecl = getClangDecl()) {
     ASTContext &ctx = getASTContext();
-    return evaluateOrDefault(
-        ctx.evaluator, ClangDeclExplicitSafety({clangDecl, ctx}),
-        ExplicitSafety::Unspecified);
+    return evaluateOrDefault(ctx.evaluator,
+                             ClangDeclExplicitSafety({clangDecl}),
+                             ExplicitSafety::Unspecified);
   }
 
   // Inference: Check the enclosing context.

lib/ClangImporter/ClangImporter.cpp

@@ -5213,9 +5213,10 @@ ClangTypeEscapability::evaluate(Evaluator &evaluator,
           } else
             nonPackArgs.push_back(arg);
           for (auto nonPackArg : nonPackArgs) {
-            if (nonPackArg.getKind() != clang::TemplateArgument::Type) {
-              desc.impl.diagnose(loc, diag::type_template_parameter_expected,
-                                 argToCheck.second);
+            if (nonPackArg.getKind() != clang::TemplateArgument::Type &&
+                desc.impl) {
+              desc.impl->diagnose(loc, diag::type_template_parameter_expected,
+                                  argToCheck.second);
               return CxxEscapability::Unknown;
             }
 
@@ -5236,8 +5237,9 @@ ClangTypeEscapability::evaluate(Evaluator &evaluator,
         }
       }
 
-      for (auto name : conditionalParams)
-        desc.impl.diagnose(loc, diag::unknown_template_parameter, name);
+      if (desc.impl)
+        for (auto name : conditionalParams)
+          desc.impl->diagnose(loc, diag::unknown_template_parameter, name);
 
       return hadUnknown ? CxxEscapability::Unknown : CxxEscapability::Escapable;
     }
@@ -8216,9 +8218,7 @@ CustomRefCountingOperationResult CustomRefCountingOperation::evaluate(
 }
 
 /// Check whether the given Clang type involves an unsafe type.
-static bool hasUnsafeType(
-    Evaluator &evaluator, ASTContext &swiftContext, clang::QualType clangType
-) {
+static bool hasUnsafeType(Evaluator &evaluator, clang::QualType clangType) {
   // Handle pointers.
   auto pointeeType = clangType->getPointeeType();
   if (!pointeeType.isNull()) {
@@ -8239,10 +8239,9 @@ static bool hasUnsafeType(
 
   // Handle records recursively.
   if (auto recordDecl = clangType->getAsTagDecl()) {
-    auto safety = evaluateOrDefault(
-        evaluator, 
-        ClangDeclExplicitSafety({recordDecl, swiftContext}),
-        ExplicitSafety::Unspecified);
+    auto safety =
+        evaluateOrDefault(evaluator, ClangDeclExplicitSafety({recordDecl}),
+                          ExplicitSafety::Unspecified);
     switch (safety) {
       case ExplicitSafety::Unsafe:
         return true;
@@ -8285,7 +8284,10 @@ ExplicitSafety ClangDeclExplicitSafety::evaluate(
 
   // Escapable and non-escapable annotations imply that the declaration is
   // safe.
-  if (hasNonEscapableAttr(recordDecl) || hasEscapableAttr(recordDecl))
+  if (evaluateOrDefault(
+          evaluator,
+          ClangTypeEscapability({recordDecl->getTypeForDecl(), nullptr}),
+          CxxEscapability::Unknown) != CxxEscapability::Unknown)
     return ExplicitSafety::Safe;
 
   // If we don't have a definition, leave it unspecified.
@@ -8296,14 +8298,14 @@ ExplicitSafety ClangDeclExplicitSafety::evaluate(
   // If this is a C++ class, check its bases.
   if (auto cxxRecordDecl = dyn_cast<clang::CXXRecordDecl>(recordDecl)) {
     for (auto base : cxxRecordDecl->bases()) {
-      if (hasUnsafeType(evaluator, desc.ctx, base.getType()))
+      if (hasUnsafeType(evaluator, base.getType()))
         return ExplicitSafety::Unsafe;
     }
   }
 
   // Check the fields.
   for (auto field : recordDecl->fields()) {
-    if (hasUnsafeType(evaluator, desc.ctx, field->getType()))
+    if (hasUnsafeType(evaluator, field->getType()))
       return ExplicitSafety::Unsafe;
   }
 

lib/ClangImporter/ImportDecl.cpp

@@ -2246,7 +2246,7 @@ namespace {
       bool isNonEscapable = false;
       if (evaluateOrDefault(
               Impl.SwiftContext.evaluator,
-              ClangTypeEscapability({decl->getTypeForDecl(), Impl}),
+              ClangTypeEscapability({decl->getTypeForDecl(), &Impl}),
               CxxEscapability::Unknown) == CxxEscapability::NonEscapable) {
         result->getAttrs().add(new (Impl.SwiftContext)
                                    NonEscapableAttr(/*Implicit=*/true));
@@ -4118,7 +4118,7 @@ namespace {
             evaluateOrDefault(
                 Impl.SwiftContext.evaluator,
                 ClangTypeEscapability(
-                    {ctordecl->getParent()->getTypeForDecl(), Impl}),
+                    {ctordecl->getParent()->getTypeForDecl(), &Impl}),
                 CxxEscapability::Unknown) == CxxEscapability::NonEscapable)
           lifetimeDependencies.push_back(immortalLifetime);
       }
@@ -8505,8 +8505,7 @@ static bool importAsUnsafe(ClangImporter::Implementation &impl,
     return false;
 
   if (isa<clang::CXXMethodDecl>(decl) &&
-      !evaluateOrDefault(context.evaluator, IsSafeUseOfCxxDecl({decl, context}),
-                         {}))
+      !evaluateOrDefault(context.evaluator, IsSafeUseOfCxxDecl({decl}), {}))
     return true;
 
   if (isa<ClassDecl>(MappedDecl))
@@ -8522,7 +8521,7 @@ static bool importAsUnsafe(ClangImporter::Implementation &impl,
   if (const auto *record = dyn_cast<clang::RecordDecl>(decl))
     return evaluateOrDefault(
                context.evaluator,
-               ClangTypeEscapability({record->getTypeForDecl(), impl, false}),
+               ClangTypeEscapability({record->getTypeForDecl(), &impl, false}),
                CxxEscapability::Unknown) == CxxEscapability::Unknown;
 
   return false;

lib/ClangImporter/ImportName.cpp

@@ -1494,7 +1494,7 @@ static StringRef renameUnsafeMethod(ASTContext &ctx,
                                     const clang::NamedDecl *decl,
                                     StringRef name) {
   if (isa<clang::CXXMethodDecl>(decl) &&
-      !evaluateOrDefault(ctx.evaluator, IsSafeUseOfCxxDecl({decl, ctx}), {})) {
+      !evaluateOrDefault(ctx.evaluator, IsSafeUseOfCxxDecl({decl}), {})) {
     return ctx.getIdentifier(("__" + name + "Unsafe").str()).str();
   }