[cxx-interop] ExpirementalFeature -> LanguageFeature.

Author: zoecarver

SwiftCompilerSources/Sources/Basic/SourceLoc.swift

@@ -27,7 +27,7 @@ public struct SourceLoc {
     guard bridged.isValid() else {
       return nil
     }
-#if hasFeature(NewCxxMethodSafetyHeuristics)
+#if $NewCxxMethodSafetyHeuristics
     self.locationInFile = bridged.getOpaquePointerValue().assumingMemoryBound(to: UInt8.self)
 #else
     self.locationInFile = bridged.__getOpaquePointerValueUnsafe().assumingMemoryBound(to: UInt8.self)
@@ -61,7 +61,7 @@ public struct CharSourceRange {
   }
 
   public init?(bridged: swift.CharSourceRange) {
-#if hasFeature(NewCxxMethodSafetyHeuristics)
+#if $NewCxxMethodSafetyHeuristics
     guard let start = SourceLoc(bridged: bridged.getStart()) else {
       return nil
     }

SwiftCompilerSources/Sources/Basic/Utils.swift

@@ -66,15 +66,15 @@ public struct StringRef : CustomStringConvertible, NoReflectionChildren {
   public var description: String { string }
 
   public var count: Int {
-#if hasFeature(NewCxxMethodSafetyHeuristics)
+#if $NewCxxMethodSafetyHeuristics
     Int(_bridged.bytes_end() - _bridged.bytes_begin())
 #else
     Int(_bridged.__bytes_endUnsafe() - _bridged.__bytes_beginUnsafe())
 #endif
   }
 
   public subscript(index: Int) -> UInt8 {
-#if hasFeature(NewCxxMethodSafetyHeuristics)
+#if $NewCxxMethodSafetyHeuristics
     let buffer = UnsafeBufferPointer<UInt8>(start: _bridged.bytes_begin(),
                                             count: count)
 #else
@@ -85,7 +85,7 @@ public struct StringRef : CustomStringConvertible, NoReflectionChildren {
   }
 
   public static func ==(lhs: StringRef, rhs: StaticString) -> Bool {
-#if hasFeature(NewCxxMethodSafetyHeuristics)
+#if $NewCxxMethodSafetyHeuristics
     let lhsBuffer = UnsafeBufferPointer<UInt8>(
       start: lhs._bridged.bytes_begin(),
       count: lhs.count)

include/swift/Basic/Features.def

@@ -91,6 +91,7 @@ LANGUAGE_FEATURE(BuiltinStackAlloc, 0, "Builtin.stackAlloc", true)
 LANGUAGE_FEATURE(BuiltinUnprotectedStackAlloc, 0, "Builtin.unprotectedStackAlloc", true)
 LANGUAGE_FEATURE(BuiltinTaskRunInline, 0, "Builtin.taskRunInline", true)
 LANGUAGE_FEATURE(BuiltinUnprotectedAddressOf, 0, "Builtin.unprotectedAddressOf", true)
+LANGUAGE_FEATURE(NewCxxMethodSafetyHeuristics, 0, "Only import C++ methods that return pointers (projections) on owned types as unsafe", true)
 SUPPRESSIBLE_LANGUAGE_FEATURE(SpecializeAttributeWithAvailability, 0, "@_specialize attribute with availability", true)
 LANGUAGE_FEATURE(BuiltinAssumeAlignment, 0, "Builtin.assumeAlignment", true)
 LANGUAGE_FEATURE(BuiltinCreateTaskGroupWithFlags, 0, "Builtin.createTaskGroupWithFlags", true)
@@ -205,10 +206,6 @@ EXPERIMENTAL_FEATURE(RuntimeDiscoverableAttrs, false)
 /// signatures.
 EXPERIMENTAL_FEATURE(ImportSymbolicCXXDecls, false)
 
-// Only import C++ methods that return pointers (projections) on owned types as
-// unsafe.
-EXPERIMENTAL_FEATURE(NewCxxMethodSafetyHeuristics, true)
-
 /// Generate bindings for functions that 'throw' in the C++ section of the generated Clang header.
 EXPERIMENTAL_FEATURE(GenerateBindingsForThrowingFunctionsInCXX, false)
 

lib/ClangImporter/ClangImporter.cpp

@@ -6820,66 +6820,11 @@ bool anySubobjectsSelfContained(const clang::CXXRecordDecl *decl) {
   return false;
 }
 
-static bool legacyIsSafeUseOfCxxMethod(clang::CXXMethodDecl *method) {
-  // The user explicitly asked us to import this method.
-  if (hasUnsafeAPIAttr(method))
-    return true;
-
-  // If it's a static method, it cannot project anything. It's fine.
-  if (method->isOverloadedOperator() || method->isStatic() ||
-      isa<clang::CXXConstructorDecl>(decl))
-    return true;
-
-  if (isForeignReferenceType(method->getReturnType()))
-    return true;
-
-  // If it returns a pointer or reference, that's a projection.
-  if (method->getReturnType()->isPointerType() ||
-      method->getReturnType()->isReferenceType())
-    return false;
-
-  // Check if it's one of the known unsafe methods we currently
-  // mark as safe by default.
-  if (isUnsafeStdMethod(method))
-    return false;
-
-  // Try to figure out the semantics of the return type. If it's a
-  // pointer/iterator, it's unsafe.
-  if (auto returnType = dyn_cast<clang::RecordType>(
-          method->getReturnType().getCanonicalType())) {
-    if (auto cxxRecordReturnType =
-            dyn_cast<clang::CXXRecordDecl>(returnType->getDecl())) {
-      if (isSwiftClassType(cxxRecordReturnType))
-        return true;
-      if (hasIteratorAPIAttr(cxxRecordReturnType) ||
-          isIterator(cxxRecordReturnType)) {
-        return false;
-      }
-
-      // Mark this as safe to help our diganostics down the road.
-      if (!cxxRecordReturnType->getDefinition()) {
-        return true;
-      }
-
-      if (!hasCustomCopyOrMoveConstructor(cxxRecordReturnType) &&
-          !hasOwnedValueAttr(cxxRecordReturnType) &&
-          hasPointerInSubobjects(cxxRecordReturnType)) {
-        return false;
-      }
-    }
-  }
-  
-  return true;
-}
-
 bool IsSafeUseOfCxxDecl::evaluate(Evaluator &evaluator,
                                   SafeUseOfCxxDeclDescriptor desc) const {
   const clang::Decl *decl = desc.decl;
 
   if (auto method = dyn_cast<clang::CXXMethodDecl>(decl)) {
-    if (!desc.ctx.LangOpts.hasFeature(Feature::NewCxxMethodSafetyHeuristics))
-      return legacyIsSafeUseOfCxxMethod(method);
-    
     // The user explicitly asked us to import this method.
     if (hasUnsafeAPIAttr(method))
       return true;