[cxx-interop] Remove UnsafeLifetimeOperation record semantic kind.

This makes "owned" the default kind for records that have custom copy constructors and no pointer-members.

Author: zoecarver

docs/CppInteroperability/UserManual.md

@@ -1,37 +1,37 @@
 # C++ Interop User Manual
 
+The following document explains how C++ APIs are imported into Swift and is targeted at users of C++ interoperability. Hopefully this document will help you understand why the compiler cannot import various APIs and help you update these APIs to be useable from Swift. First, the document will lay out some API patterns and definitions, then it will discuss how the Swift compiler decides if an API should be usable in Swift. 
+
 ## Reference Types
 
 Reference types have reference semantics and object identity. A reference type is a pointer (or “reference”) to some object which means there is a layer of indirection. When a reference type is copied, the pointer’s value is copied rather than the object’s storage. This means reference types can be used to represent non-copyable types in C++. Any C++ APIs that use reference types must have at least one layer of indirection to the type (a pointer or reference). Currently reference types must be immortal (never deallocated) or have manually managed lifetimes. You can specify a type has reference semantics by using the `import_reference` swift attribute.
 
 ## Owned Types
 
-Owned types “own” some storage which can be copied and destroyed. An owned type must be copyable and destructible. The copy constructor must copy any storage that is owned by the type and the destructor must destroy that storage. Copies and destroys must balance out and these operations must not have side effects. Examples of owned types include `std::vector` and `std::string`. You can specify a type is an owned type by using the `import_owned` swift attribute.
+Owned types “own” some storage which can be copied and destroyed. An owned type must be copyable and destructible. The copy constructor must copy any storage that is owned by the type and the destructor must destroy that storage. Copies and destroys must balance out and these operations must not have side effects. Examples of owned types include `std::vector` and `std::string`. The Swift compiler will assume that any types which do not contain pointers are owned types. You can also specify a type is an owned type by using the `import_owned` swift attribute.
 
 ## Iterator Types
 
-An iterator represents a point in a range. Iterator types must provide a comparison operator and increment operator (increment or ++ operators are imported as a member called successor). Iterators can be returned by `begin` and `end` methods to form a range which will automatically be imported as a Sequence in Swift. Iterators can often be inferred by the compiler, but you can also specify a type is an iterator by using the `import_iterator` swift attribute.
+An iterator represents a point in a range. Iterator types must provide a comparison operator and increment operator (increment or ++ operators are imported as a member called successor). Iterators can be returned by `begin` and `end` methods to form a range which will automatically be imported as a Sequence in Swift. Iterators can often be inferred by the compiler using the C++ iterator traits, but you can also specify a type is an iterator by using the `import_iterator` swift attribute.
 
 ## Trivial Types
 
 Trivial types can be copied by copying the bits of a value of the trivial type and do not need any special destruction logic. Trivial types are inferred by the compiler and cannot be specified using an attribute. Trivial types own their storage, so rules below that apply to owned types also apply to trivial types (specifically regarding projections). Pointers are not trivial types. When Objective-C++ mode is enabled, C++ types that hold Objective-C classes are still considered trivial, even though they technically violate the above contract.
 
 ## Unsafe Types
 
-All types which do not fall into one of the above categories are considered unsafe. Any unsafe API, including unsafe types that are copyable and destructible may be imported using the `import_unsafe` swift attribute. There are three kinds of unsafe types: **unsafe pointer types**, **unsafe lifetime types**, and **un-importable types**.
+All types which do not fall into one of the above categories are considered unsafe. Any unsafe API, including unsafe types that are copyable and destructible may be imported using the `import_unsafe` swift attribute. There are two kinds of unsafe types: **unsafe pointer types** and **un-importable types**.
 
 **Unsafe Pointer Types:** are types which contain an un-owned pointer. This type is assumed to represent an unsafe memory projection when used as a return type for the method of an owned type.
 
-**Unsafe Lifetime Types:** are types that have custom lifetime operations such as custom copy constructors or custom destructors. These custom lifetime operations are assumed to be unsafe in all contexts.
-
 **Un-importable Types:** are types that are not copyable or destructible. These types cannot be represented in Swift, so they cannot be imported (even if they are marked with the `import_unsafe` attribute).
 
 ## API rules
 
 The Swift compiler enforces certain API rules, not to ensure a completely safe C++ API interface, but to prevent especially unsafe patterns that will likely lead to bugs. Many of these unsafe patterns stem from the subtly different lifetime semantics in C++ and Swift and aim to prevent memory projections of owned types. The currently enforced rules are as follows:
 
-* Unsafe lifetime types and un-importable types are not allowed to be used in any contexts.
+* Un-importable types are not allowed to be used in any contexts.
 * Unsafe pointer types are not allowed to represent unsafe memory projections from owned types. Note: unsafe pointer types *are* allowed to represent memory projections from reference types. Note: the Swift compiler assumes that global and static functions do not return projections.
-* Iterators are not allowed to represent unsafe memory projections from owned types. Iterators may be used safely through the CxxIterator and CxxSequence protocols which iterators and ranges automatically conform to.
+* Iterators are not allowed to represent unsafe memory projections from owned types. Iterators may be used safely through the `CxxIterator` and `CxxSequence` protocols which iterators and ranges automatically conform to.
 * Members of an unsafe type that is explicitly imported using the `import_unsafe` swift attribute are still subject to the above rules. Each individual unsafe member must also have the `import_unsafe` swift attribute to be usable.
 

include/swift/ClangImporter/ClangImporterRequests.h

@@ -188,9 +188,6 @@ enum class CxxRecordSemanticsKind {
   ExplicitlyUnsafe,
   // A record that is either not copyable or not destructible.
   MissingLifetimeOperation,
-  // A record that has custom lifetime operations which we cannot prove are
-  // safe.
-  UnsafeLifetimeOperation,
   // A record that contains a pointer (aka non-trivial type).
   UnsafePointerMember
 };

lib/ClangImporter/ClangImporter.cpp

@@ -6026,15 +6026,15 @@ CxxRecordSemantics::evaluate(Evaluator &evaluator,
     return CxxRecordSemanticsKind::Iterator;
   }
 
-  if (!isSufficientlyTrivial(decl)) {
-    return CxxRecordSemanticsKind::UnsafeLifetimeOperation;
-  }
-
   if (hasPointerInSubobjects(decl)) {
     return CxxRecordSemanticsKind::UnsafePointerMember;
   }
 
-  return CxxRecordSemanticsKind::Trivial;
+  if (isSufficientlyTrivial(decl)) {
+    return CxxRecordSemanticsKind::Trivial;
+  }
+
+  return CxxRecordSemanticsKind::Owned;
 }
 
 bool IsSafeUseOfCxxDecl::evaluate(Evaluator &evaluator,
@@ -6083,8 +6083,7 @@ bool IsSafeUseOfCxxDecl::evaluate(Evaluator &evaluator,
       evaluator, CxxRecordSemantics({recordDecl, desc.ctx}), {});
 
   // Always unsafe.
-  if (semanticsKind == CxxRecordSemanticsKind::MissingLifetimeOperation ||
-      semanticsKind == CxxRecordSemanticsKind::UnsafeLifetimeOperation)
+  if (semanticsKind == CxxRecordSemanticsKind::MissingLifetimeOperation)
     return false;
 
   // Always OK.

lib/ClangImporter/ImportDecl.cpp

@@ -2494,15 +2494,6 @@ namespace {
                        Impl.SwiftContext.AllocateCopy(decl->getNameAsString()),
                        "does not have a copy constructor or destructor"));
         return nullptr;
-      } else if (semanticsKind ==
-                 CxxRecordSemanticsKind::UnsafeLifetimeOperation) {
-        Impl.addImportDiagnostic(
-            decl,
-            Diagnostic(diag::record_not_automatically_importable,
-                       Impl.SwiftContext.AllocateCopy(decl->getNameAsString()),
-                       "has custom, potentially unsafe copy constructor or "
-                       "destructor"));
-        return nullptr;
       }
 
       return VisitRecordDecl(decl);
@@ -2683,8 +2674,7 @@ namespace {
         auto semanticsKind = evaluateOrDefault(
             Impl.SwiftContext.evaluator,
             CxxRecordSemantics({parent, Impl.SwiftContext}), {});
-        if (semanticsKind == CxxRecordSemanticsKind::MissingLifetimeOperation ||
-            semanticsKind == CxxRecordSemanticsKind::UnsafeLifetimeOperation)
+        if (semanticsKind == CxxRecordSemanticsKind::MissingLifetimeOperation)
           return nullptr;
       }
 

test/Interop/Cxx/class/invalid-class-errors.swift

@@ -19,10 +19,6 @@ struct __attribute__((swift_attr("import_unsafe"))) B {
     B(const B&) = delete;
 };
 
-struct C {
-        C(const C&) {}
-};
-
 //--- test.swift
 
 import Test
@@ -33,6 +29,4 @@ public func test(x: X) { }
 // CHECK: note: record 'A' is not automatically importable: does not have a copy constructor or destructor. Refer to the C++ Interop User Manual to classify this type.
 public func test(x: A) { }
 // CHECK: note: record 'B' is not automatically importable: does not have a copy constructor or destructor. Refer to the C++ Interop User Manual to classify this type.
-public func test(x: B) { }
-// CHECK: note: record 'C' is not automatically importable: has custom, potentially unsafe copy constructor or destructor. Refer to the C++ Interop User Manual to classify this type.
-public func test(x: C) { }
+public func test(x: B) { }

test/Interop/Cxx/stdlib/overlay/std-string-overlay.swift

@@ -1,9 +1,7 @@
-// RUN: %target-run-simple-swift(-Xfrontend -enable-experimental-cxx-interop -Xfrontend -validate-tbd-against-ir=none -g)
+// RUN: %target-run-simple-swift(-Xfrontend -enable-experimental-cxx-interop -Xfrontend -validate-tbd-against-ir=none)
 //
 // REQUIRES: executable_test
 // REQUIRES: OS=macosx || OS=linux-gnu
-//
-// XFAIL: *
 
 import StdlibUnittest
 import std