ABI FIXME#16,17: Hoist += operator out of the array types into RangeReplaceableCollection

.dir-locals.el

@@ -10,28 +10,19 @@
 ;
 ;===----------------------------------------------------------------------===;
 ;;; Directory Local Variables
-;;; See Info node `(emacs) Directory Variables' for more information.
+;;; For more information see (info "(emacs) Directory Variables")
 
 ((nil
   (tab-width . 2)
   (fill-column . 80)
-  (eval .
-        ;; Load the Swift project's settings.  To suppress this action
-        ;; you can put "(provide 'swift-project-settings)" in your
-        ;; .emacs
+  (eval let* ((x (dir-locals-find-file default-directory))
+              (this-directory (if (listp x) (car x)
+                                (file-name-directory x))))
         (unless (featurep 'swift-project-settings)
-          ;; Make sure the project's own utils directory is in the
-          ;; load path, but don't override any one the user might have
-          ;; set up.
-          (add-to-list
-           'load-path
-           (concat
-            (let ((dlff (dir-locals-find-file default-directory)))
-              (if (listp dlff) (car dlff) (file-name-directory dlff)))
-            "utils")
-           :append)
-            ;; Load our project's settings -- indirectly brings in swift-mode
+          (add-to-list 'load-path  (concat this-directory "utils") :append)
+          (let ((swift-project-directory this-directory))
           (require 'swift-project-settings)))
+        (set (make-local-variable 'swift-project-directory) this-directory))
   (c-file-style . "swift")
   )
  (c++-mode
@@ -44,6 +35,8 @@
   (whitespace-style . (face lines indentation:space))
   (eval . (whitespace-mode)))
  (swift-mode
+  (swift-find-executable-fn . swift-project-executable-find)
+  (swift-syntax-check-fn . swift-project-swift-syntax-check)
   (whitespace-style . (face lines indentation:space))
   (eval . (whitespace-mode))
   (swift-basic-offset . 2)

CMakeLists.txt

@@ -275,6 +275,10 @@ option(SWIFT_STDLIB_ENABLE_RESILIENCE
     "Build the standard libraries and overlays with resilience enabled; see docs/LibraryEvolution.rst"
     FALSE)
 
+option(SWIFT_STDLIB_ENABLE_SIL_OWNERSHIP
+  "Build the standard libraries and overlays with sil ownership enabled."
+  FALSE)
+
 option(SWIFT_STDLIB_SIL_SERIALIZE_ALL
     "Build the standard libraries and overlays serializing all method bodies"
     TRUE)
@@ -419,6 +423,12 @@ include_directories(BEFORE
 #  endif()
 set(SWIFT_DARWIN_VARIANTS "^(macosx|iphoneos|iphonesimulator|appletvos|appletvsimulator|watchos|watchsimulator)")
 
+# A convenient list to match Darwin SDKs. Example:
+#  if("${SWIFT_HOST_VARIANT_SDK}" IN_LIST SWIFT_APPLE_PLATFORMS)
+#    ...
+#  endif()
+set(SWIFT_APPLE_PLATFORMS "IOS" "IOS_SIMULATOR" "TVOS" "TVOS_SIMULATOR" "WATCHOS" "WATCHOS_SIMULATOR" "OSX")
+
 # Configuration flags passed to all of our invocations of gyb.  Try to
 # avoid making up new variable names here if you can find a CMake
 # variable that will do the job.

apinotes/Foundation.apinotes

@@ -157,7 +157,7 @@ Classes:
   Methods:
   - Selector: 'notificationCenterForType:'
     MethodKind: Class
-    FactoryAsInit: C
+    SwiftName: 'forType(_:)'
 - Name: NSHTTPCookie
   SwiftName: HTTPCookie
 - Name: NSHTTPCookieStorage
@@ -209,10 +209,6 @@ Classes:
 - Name: NSProcessInfo
   SwiftName: ProcessInfo
   Methods:
-  - Selector: processInfo
-    MethodKind: Class
-    NullabilityOfRet: N
-    FactoryAsInit: C
   - Selector: 'isOperatingSystemAtLeastVersion:'
     SwiftName: isOperatingSystemAtLeast(_:)
     MethodKind: Instance

apinotes/GameKit.apinotes

@@ -5,7 +5,7 @@ Classes:
     Methods:
       - Selector:        'localPlayer'
         MethodKind:      Class
-        FactoryAsInit:   C
+        SwiftName:       'localPlayer()'
 Tags:
 - Name: GKErrorCode
   NSErrorDomain: GKErrorDomain

apinotes/NotificationCenter.apinotes

@@ -4,4 +4,4 @@ Classes:
     Methods:
       - Selector:        'widgetController'
         MethodKind:      Class
-        FactoryAsInit:   C
+        SwiftName:       'widgetController()'

apinotes/UIKit.apinotes

@@ -10,7 +10,7 @@ Classes:
   Methods:
   - Selector: printInfo
     MethodKind: Class
-    FactoryAsInit: C
+    SwiftName: 'printInfo()'
 - Name: UIPrintInteractionController
   Properties:
   - Name: 'sharedPrintController'

cmake/modules/AddSwift.cmake

@@ -53,7 +53,15 @@ function(_set_target_prefix_and_suffix target kind sdk)
   precondition(kind MESSAGE "kind is required")
   precondition(sdk MESSAGE "sdk is required")
 
-  if("${sdk}" STREQUAL "WINDOWS")
+  if("${sdk}" STREQUAL "ANDROID")
+    if("${kind}" STREQUAL "STATIC")
+      set_property(TARGET "${target}" PROPERTY PREFIX "lib")
+      set_property(TARGET "${target}" PROPERTY SUFFIX ".a")
+    elseif("${libkind}" STREQUAL "SHARED")
+      set_property(TARGET "${target}" PROPERTY PREFIX "lib")
+      set_property(TARGET "${target}" PROPERTY SUFFIX ".so")
+    endif()
+  elseif("${sdk}" STREQUAL "WINDOWS")
     if("${kind}" STREQUAL "STATIC")
       set_property(TARGET "${target}" PROPERTY PREFIX "lib")
       set_property(TARGET "${target}" PROPERTY SUFFIX ".lib")
@@ -380,12 +388,20 @@ endfunction()
 #     source_targets...   # The source targets whose outputs will be
 #                         # lipo'd into the output.
 #   )
-function(_add_swift_lipo_target sdk target output)
-  precondition(sdk MESSAGE "sdk is required")
-  precondition(target MESSAGE "target is required")
-  precondition(output MESSAGE "output is required")
+function(_add_swift_lipo_target)
+  cmake_parse_arguments(
+    LIPO                # prefix
+    "CODESIGN"          # options
+    "SDK;TARGET;OUTPUT" # single-value args
+    ""                  # multi-value args
+    ${ARGN})
 
-  set(source_targets ${ARGN})
+  precondition(LIPO_SDK MESSAGE "sdk is required")
+  precondition(LIPO_TARGET MESSAGE "target is required")
+  precondition(LIPO_OUTPUT MESSAGE "output is required")
+  precondition(LIPO_UNPARSED_ARGUMENTS MESSAGE "one or more inputs are required")
+
+  set(source_targets ${LIPO_UNPARSED_ARGUMENTS})
 
   # Gather the source binaries.
   set(source_binaries)
@@ -400,20 +416,24 @@ function(_add_swift_lipo_target sdk target output)
     endif()
   endforeach()
 
-  is_darwin_based_sdk("${sdk}" IS_DARWIN)
+  is_darwin_based_sdk("${LIPO_SDK}" IS_DARWIN)
   if(IS_DARWIN)
+    if(LIPO_CODESIGN)
+      set(codesign_command COMMAND "codesign" "-f" "-s" "-" "${LIPO_OUTPUT}")
+    endif()
     # Use lipo to create the final binary.
     add_custom_command_target(unused_var
-        COMMAND "${LIPO}" "-create" "-output" "${output}" ${source_binaries}
-        CUSTOM_TARGET_NAME "${target}"
-        OUTPUT "${output}"
+        COMMAND "${LIPO}" "-create" "-output" "${LIPO_OUTPUT}" ${source_binaries}
+        ${codesign_command}
+        CUSTOM_TARGET_NAME "${LIPO_TARGET}"
+        OUTPUT "${LIPO_OUTPUT}"
         DEPENDS ${source_targets})
   else()
     # We don't know how to create fat binaries for other platforms.
     add_custom_command_target(unused_var
-        COMMAND "${CMAKE_COMMAND}" "-E" "copy" "${source_binaries}" "${output}"
-        CUSTOM_TARGET_NAME "${target}"
-        OUTPUT "${output}"
+        COMMAND "${CMAKE_COMMAND}" "-E" "copy" "${source_binaries}" "${LIPO_OUTPUT}"
+        CUSTOM_TARGET_NAME "${LIPO_TARGET}"
+        OUTPUT "${LIPO_OUTPUT}"
         DEPENDS ${source_targets})
   endif()
 endfunction()
@@ -1230,7 +1250,7 @@ function(add_swift_library name)
     set(SWIFTLIB_TARGET_SDKS ${SWIFT_SDKS})
   endif()
   list_replace(SWIFTLIB_TARGET_SDKS ALL_POSIX_PLATFORMS "ALL_APPLE_PLATFORMS;ANDROID;CYGWIN;FREEBSD;LINUX")
-  list_replace(SWIFTLIB_TARGET_SDKS ALL_APPLE_PLATFORMS "IOS;IOS_SIMULATOR;TVOS;TVOS_SIMULATOR;WATCHOS;WATCHOS_SIMULATOR;OSX")
+  list_replace(SWIFTLIB_TARGET_SDKS ALL_APPLE_PLATFORMS "${SWIFT_APPLE_PLATFORMS}")
 
   # All Swift code depends on the standard library, except for the standard
   # library itself.
@@ -1465,18 +1485,15 @@ function(add_swift_library name)
         endif()
 
         set(lipo_target "${name}-${SWIFT_SDK_${sdk}_LIB_SUBDIR}")
-        _add_swift_lipo_target(
-            ${sdk}
-            ${lipo_target}
-            ${UNIVERSAL_LIBRARY_NAME}
-            ${THIN_INPUT_TARGETS})
-
         if("${CMAKE_SYSTEM_NAME}" STREQUAL "Darwin" AND SWIFTLIB_SHARED)
-          # Ad-hoc sign stdlib dylibs
-          add_custom_command(TARGET "${name}-${SWIFT_SDK_${sdk}_LIB_SUBDIR}"
-                             POST_BUILD
-                             COMMAND "codesign" "-f" "-s" "-" "${UNIVERSAL_LIBRARY_NAME}")
+          set(codesign_arg CODESIGN)
         endif()
+        _add_swift_lipo_target(
+            SDK ${sdk}
+            TARGET ${lipo_target}
+            OUTPUT ${UNIVERSAL_LIBRARY_NAME}
+            ${codesign_arg}
+            ${THIN_INPUT_TARGETS})
 
         # Cache universal libraries for dependency purposes
         set(UNIVERSAL_LIBRARY_NAMES_${SWIFT_SDK_${sdk}_LIB_SUBDIR}
@@ -1526,9 +1543,9 @@ function(add_swift_library name)
           set(UNIVERSAL_LIBRARY_NAME
               "${SWIFTSTATICLIB_DIR}/${SWIFT_SDK_${sdk}_LIB_SUBDIR}/${CMAKE_STATIC_LIBRARY_PREFIX}${name}${CMAKE_STATIC_LIBRARY_SUFFIX}")
           _add_swift_lipo_target(
-              ${sdk}
-              ${lipo_target_static}
-              "${UNIVERSAL_LIBRARY_NAME}"
+              SDK ${sdk}
+              TARGET ${lipo_target_static}
+              OUTPUT "${UNIVERSAL_LIBRARY_NAME}"
               ${THIN_INPUT_TARGETS_STATIC})
           swift_install_in_component("${SWIFTLIB_INSTALL_IN_COMPONENT}"
               FILES "${UNIVERSAL_LIBRARY_NAME}"

cmake/modules/SwiftAddCustomCommandTarget.cmake

@@ -120,15 +120,11 @@ function(add_custom_command_target dependency_out_var_name)
   set(ACCT_COMMANDS ${ACCT_UNPARSED_ARGUMENTS})
 
   if("${ACCT_CUSTOM_TARGET_NAME}" STREQUAL "")
-    # Construct a unique name for the custom target.
-    # Use a hash so that the file name does not push the OS limits for filename
-    # length.
+    # CMake doesn't allow '/' characters in filenames, so replace them with '-'
     list(GET ACCT_OUTPUT 0 output_filename)
-    string(MD5 target_md5
-        "add_custom_command_target${CMAKE_CURRENT_BINARY_DIR}/${output_filename}")
-    get_filename_component(output_filename_basename "${output_filename}" NAME)
-    set(target_name
-        "add_custom_command_target-${target_md5}-${output_filename_basename}")
+    string(REPLACE "${CMAKE_BINARY_DIR}/" "" target_name "${output_filename}")
+    string(REPLACE "${CMAKE_CFG_INTDIR}/" "" target_name "${target_name}")
+    string(REPLACE "/" "-" target_name "${target_name}")
   else()
     set(target_name "${ACCT_CUSTOM_TARGET_NAME}")
   endif()

cmake/modules/SwiftSource.cmake

@@ -225,6 +225,10 @@ function(_compile_swift_files dependency_target_out_var_name)
     list(APPEND swift_flags "-Xfrontend" "-enable-resilience")
   endif()
 
+  if(SWIFT_STDLIB_ENABLE_SIL_OWNERSHIP AND SWIFTFILE_IS_STDLIB)
+    list(APPEND swift_flags "-Xfrontend" "-enable-sil-ownership")
+  endif()
+
   if(SWIFT_EMIT_SORTED_SIL_OUTPUT)
     list(APPEND swift_flags "-Xfrontend" "-emit-sorted-sil")
   endif()

docs/ARCOptimization.rst

@@ -861,3 +861,69 @@ Now imagine that we move the strong_retain before the is_unique. Then we have::
 Thus is_unique is guaranteed to return false introducing a copy that was not
 needed. We wish to avoid that if it is at all possible.
 
+Deinit Model
+============
+
+The semantics around deinits in swift are a common area of confusion. This
+section is not attempting to state where the deinit model may be in the future,
+but is just documenting where things are today in the hopes of improving
+clarity.
+
+The following characteristics of deinits are important to the optimizer:
+
+1. deinits run on the same thread and are not asynchronous like Java
+   finalizers.
+2. deinits are not sequenced with regards to each other or code in normal
+   control flow.
+3. If the optimizer takes advantage of the lack of sequencing it must do so in a
+   way that preserves memory safety.
+
+Consider the following pseudo-Swift example::
+
+  class D {}
+  class D1 : D {}
+  class D2 : D {}
+
+  var GLOBAL_D : D = D1()
+
+  class C { deinit { GLOBAL_D = D2 } }
+
+  func main() {
+    let c = C()
+    let d = GLOBAL_D
+    useC(c)
+    useD(d)
+  }
+
+  main()
+
+Assume that useC does not directly in any way touch an instance of class D
+except via the destructor.
+
+Since memory operations in normal control flow are not sequenced with respect to
+deinits, there are two correct programs here that the optimizer can produce: the
+original and the one where useC(c) and GLOBAL_D are swapped, i.e.::
+
+  func main() {
+    let c = C()
+    useC(c)
+    let d = GLOBAL_D
+    useD(d)
+  }
+
+In the first program, d would be an instance of class D1. In the second, it
+would be an instance of class D2. Notice how in both programs though, no
+deinitialized object is accessed. On the other hand, imagine if we had split
+main like so::
+
+  func main() {
+    let c = C()
+    let d = unsafe_unowned_load(GLOBAL_D)
+    useC(c)
+    let owned_d = retain(d)
+    useD(owned_d)
+  }
+
+In this case, we would be passing off to useD a deallocated instance of class D1
+which would be undefined behavior. An optimization that produced such code would
+be a miscompile.

docs/ContinuousIntegration.md

@@ -35,10 +35,14 @@ We describe each in detail below:
 
         Platform     | Comment | Check Status
         ------------ | ------- | ------------
-        All supported platforms     | @swift-ci Please smoke test                | Swift Test Linux Platform (smoke test)<br>Swift Test OS X Platform (smoke test)
-        All supported platforms     | @swift-ci Please smoke test and merge      | Swift Test Linux Platform (smoke test)<br>Swift Test OS X Platform (smoke test)
-        OS X platform               | @swift-ci Please smoke test OS X platform  | Swift Test OS X Platform (smoke test)
-        Linux platform              | @swift-ci Please smoke test Linux platform | Swift Test Linux Platform (smoke test)
+        All supported platforms     | @swift-ci Please smoke test                      | Swift Test Linux Platform (smoke test)<br>Swift Test OS X Platform (smoke test)
+        All supported platforms     | @swift-ci Please clean smoke test                | Swift Test Linux Platform (smoke test)<br>Swift Test OS X Platform (smoke test)
+        All supported platforms     | @swift-ci Please smoke test and merge            | Swift Test Linux Platform (smoke test)<br>Swift Test OS X Platform (smoke test)
+        All supported platforms     | @swift-ci Please clean smoke test and merge      | Swift Test Linux Platform (smoke test)<br>Swift Test OS X Platform (smoke test)
+        OS X platform               | @swift-ci Please smoke test OS X platform        | Swift Test OS X Platform (smoke test)
+        OS X platform               | @swift-ci Please clean smoke test OS X platform  | Swift Test OS X Platform (smoke test)
+        Linux platform              | @swift-ci Please smoke test Linux platform       | Swift Test Linux Platform (smoke test)
+        Linux platform              | @swift-ci Please clean smoke test Linux platform | Swift Test Linux Platform (smoke test)
 
 A smoke test on macOS does the following:
 
@@ -69,6 +73,7 @@ A smoke test on Linux does the following:
         All supported platforms     | @swift-ci Please test                         | Swift Test Linux Platform (smoke test)<br>Swift Test OS X Platform (smoke test)<br>Swift Test Linux Platform<br>Swift Test OS X Platform<br>  
         All supported platforms     | @swift-ci Please clean test                   | Swift Test Linux Platform (smoke test)<br>Swift Test OS X Platform (smoke test)<br>Swift Test Linux Platform<br>Swift Test OS X Platform<br>  
         All supported platforms     | @swift-ci Please test and merge               | Swift Test Linux Platform (smoke test)<br>Swift Test OS X Platform (smoke test)<br> Swift Test Linux Platform <br>Swift Test OS X Platform
+        All supported platforms     | @swift-ci Please clean test and merge               | Swift Test Linux Platform (smoke test)<br>Swift Test OS X Platform (smoke test)<br> Swift Test Linux Platform <br>Swift Test OS X Platform
         OS X platform               | @swift-ci Please test OS X platform           | Swift Test OS X Platform (smoke test)<br>Swift Test OS X Platform
         OS X platform               | @swift-ci Please clean test OS X platform     | Swift Test OS X Platform (smoke test)<br>Swift Test OS X Platform
         OS X platform               | @swift-ci Please benchmark                    | Swift Benchmark on OS X Platform