Merge branch 'master' into objc-protocols-have-a-layout-constraint

Author: slavapestov

CMakeLists.txt

@@ -369,6 +369,10 @@ option(SWIFT_REPORT_STATISTICS
     "Create json files which contain internal compilation statistics"
     FALSE)
 
+option(SWIFT_DISABLE_OBJC_INTEROP
+    "Disable Objective-C interoperability even on platforms what would normally have it"
+    FALSE)
+
 #
 # User-configurable experimental options.  Do not use in production builds.
 #

cmake/modules/AddSwift.cmake

@@ -93,7 +93,7 @@ function(_add_host_variant_c_compile_link_flags name)
 
   set(_sysroot
     "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_ARCH_${SWIFT_HOST_VARIANT_ARCH}_PATH}")
-  if(SWIFT_HOST_VARIANT_SDK IN_LIST SWIFT_APPLE_PLATFORMS)
+  if(SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_USE_ISYSROOT)
     target_compile_options(${name} PRIVATE -isysroot;${_sysroot})
   elseif(NOT SWIFT_COMPILER_IS_MSVC_LIKE AND NOT "${_sysroot}" STREQUAL "/")
     target_compile_options(${name} PRIVATE --sysroot=${_sysroot})

cmake/modules/SwiftConfigureSDK.cmake

@@ -145,6 +145,8 @@ endfunction()
 #   SWIFT_SDK_${prefix}_LIB_SUBDIR          Library subdir for this SDK
 #   SWIFT_SDK_${prefix}_VERSION_MIN_NAME    Version min name for this SDK
 #   SWIFT_SDK_${prefix}_TRIPLE_NAME         Triple name for this SDK
+#   SWIFT_SDK_${prefix}_OBJECT_FORMAT       The object file format (e.g. MACHO)
+#   SWIFT_SDK_${prefix}_USE_ISYSROOT        Whether to use -isysroot
 #   SWIFT_SDK_${prefix}_ARCHITECTURES       Architectures (as a list)
 #   SWIFT_SDK_${prefix}_IS_SIMULATOR        Whether this is a simulator target.
 #   SWIFT_SDK_${prefix}_ARCH_${ARCH}_TRIPLE Triple name
@@ -187,6 +189,7 @@ macro(configure_sdk_darwin
   set(SWIFT_SDK_${prefix}_VERSION_MIN_NAME "${version_min_name}")
   set(SWIFT_SDK_${prefix}_TRIPLE_NAME "${triple_name}")
   set(SWIFT_SDK_${prefix}_OBJECT_FORMAT "MACHO")
+  set(SWIFT_SDK_${prefix}_USE_ISYSROOT TRUE)
 
   set(SWIFT_SDK_${prefix}_ARCHITECTURES ${architectures})
   if(SWIFT_DARWIN_SUPPORTED_ARCHS)
@@ -270,6 +273,7 @@ macro(configure_sdk_unix name architectures)
   else()
     set(SWIFT_SDK_${prefix}_OBJECT_FORMAT "ELF")
   endif()
+  set(SWIFT_SDK_${prefix}_USE_ISYSROOT FALSE)
 
   foreach(arch ${architectures})
     if("${prefix}" STREQUAL "ANDROID")
@@ -432,6 +436,7 @@ macro(configure_sdk_windows name environment architectures)
   set(SWIFT_SDK_${prefix}_LIB_SUBDIR "windows")
   set(SWIFT_SDK_${prefix}_ARCHITECTURES "${architectures}")
   set(SWIFT_SDK_${prefix}_OBJECT_FORMAT "COFF")
+  set(SWIFT_SDK_${prefix}_USE_ISYSROOT FALSE)
 
   foreach(arch ${architectures})
     if(arch STREQUAL armv7)

docs/ABI/Mangling.rst

@@ -1107,3 +1107,40 @@ nominal type descriptor symbol for ``CxxStruct`` while compiling the ``main`` mo
 .. code::
 
   sSo9CxxStructVMn // -> nominal type descriptor for __C.CxxStruct
+
+Importing C++ class template instantiations
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+A class template instantiation is imported as a struct named
+``__CxxTemplateInst`` plus Itanium mangled type of the instantiation (see the
+``type`` production in the Itanium specification). Note that Itanium mangling is
+used on all platforms, regardless of the ABI of the C++ toolchain, to ensure
+that the mangled name is a valid Swift type name (this is not the case for MSVC
+mangled names). A prefix with a double underscore (to ensure we have a reserved
+C++ identifier) is added to limit the possibility for conflicts with names of
+user-defined structs. The struct is notionally defined in the ``__C`` module,
+similarly to regular C and C++ structs and classes. Consider the following C++
+module:
+
+.. code-block:: c++
+
+  template<class T>
+  struct MagicWrapper {
+    T t;
+  };
+
+  struct MagicNumber {};
+
+  typedef MagicWrapper<MagicNumber> WrappedMagicNumber;
+
+``WrappedMagicNumber`` is imported as a typealias for struct
+``__CxxTemplateInst12MagicWrapperI11MagicNumberE``. Interface of the imported
+module looks as follows:
+
+.. code-block:: swift
+
+  struct __CxxTemplateInst12MagicWrapperI11MagicNumberE {
+    var t: MagicNumber
+  }
+  struct MagicNumber {}
+  typealias WrappedMagicNumber = __CxxTemplateInst12MagicWrapperI11MagicNumberE

docs/CppInteroperabilityManifesto.md

@@ -67,6 +67,7 @@ Assumptions:
     + [Function templates: calls with generic type parameters](#function-templates-calls-with-generic-type-parameters)
     + [Function templates: importing as real generic functions](#function-templates-importing-as-real-generic-functions)
     + [Class templates](#class-templates)
+    + [Class templates: importing instantiation behind typedef](#class-templates-importing-instantiation-behind-typedef)
     + [Class templates: importing specific specilalizations](#class-templates-importing-specific-specilalizations)
     + [Class templates: using with generic type parameters](#class-templates-using-with-generic-type-parameters)
     + [Class templates: using in generic code through a synthesized protocol](#class-templates-using-in-generic-code-through-a-synthesized-protocol)
@@ -2575,6 +2576,45 @@ We could ignore explicit specializations of function templates, because they
 don't affect the API. Explicit specializations of class templates can
 dramatically change the API of the type.
 
+### Class templates: Importing full class template instantiations
+
+A class template instantiation could be imported as a struct named
+`__CxxTemplateInst` plus Itanium mangled type of the instantiation (see the
+`type` production in the Itanium specification). Note that Itanium mangling is
+used on all platforms, regardless of the ABI of the C++ toolchain, to ensure
+that the mangled name is a valid Swift type name (this is not the case for MSVC
+mangled names). A prefix with a double underscore (to ensure we have a reserved
+C++ identifier) is added to limit the possibility for conflicts with names of
+user-defined structs. The struct is notionally defined in the `__C` module,
+similarly to regular C and C++ structs and classes. Consider the following C++
+module:
+
+```c++
+// C++ header.
+
+template<class T>
+struct MagicWrapper {
+  T t;
+};
+struct MagicNumber {};
+
+typedef MagicWrapper<MagicNumber> WrappedMagicNumber;
+```
+
+`WrappedMagicNumber` will be imported as a typealias for a struct
+`__CxxTemplateInst12MagicWrapperI11MagicNumberE`. Interface of the imported
+module will look as follows:
+
+```swift
+// C++ header imported to Swift.
+
+struct __CxxTemplateInst12MagicWrapperI11MagicNumberE {
+    var t: MagicNumber
+}
+struct MagicNumber {}
+typealias WrappedMagicNumber = __CxxTemplateInst12MagicWrapperI11MagicNumberE
+```
+
 ### Class templates: importing specific specilalizations
 
 Just like with calls to C++ function templates, it is easy to compile a use of a
@@ -2752,7 +2792,7 @@ func useConcrete() {
 
 ### Class templates: importing as real generic structs
 
-If we know the complete set of allowed type arguments to a C++ function
+If we know the complete set of allowed type arguments to a C++ struct
 template, we could import it as an actual Swift generic struct. Every method of
 that struct will perform dynamic dispatch based on type parameters. See
 the section about function templates for more details.