Porting to cygwin

CHANGELOG.md

@@ -1,5 +1,26 @@
-Latest
-------
+
+Swift 3
+-------
+
+* Curried function syntax has been removed, and now produces a compile-time
+  error.
+
+
+Swift 2.2
+---------
+
+* Associated types in protocols can now be specified with a new 'associatedtype'
+  declaration, to replace the use of 'typealias':
+
+    protocol P {
+      associatedtype Ty
+    }
+
+  The typealias keyword is still allowed (but deprecated and produces a warning)
+  in Swift 2.2. This warning will become an error in Swift 3.
+
+* Curried function syntax has been deprecated, and is slated to be removed in 
+  Swift 3.
 
 * The ++ and -- operators have been deprecated, and are slated to be removed in
   Swift 3.0.  As a replacement, please use "x += 1" on integer or floating point
@@ -104,6 +125,34 @@ Latest
 
   **(rdar://problem/21930334)**
 
+* When referencing a function or initializer, one can provide the
+  complete name, including argument labels. For example:
+
+      let fn1 = someView.insertSubview(_:at:)
+      let fn2 = someView.insertSubview(_:aboveSubview:)
+
+      let buttonFactory = UIButton.init(type:)
+
+  For more information, see [SE-0021](https://github.com/apple/swift-evolution/blob/master/proposals/0021-generalized-naming.md).
+
+* There is a new build configuration function, `#if swift(>=x.y)`, which
+  tests if the current Swift language version is at least `x.y`. This
+  allows you to conditionally compile code for multiple language
+  versions in the same file, even with different syntax, by deactivating
+  parsing in inactive code blocks. For example:
+
+  ```swift
+  #if swift(>=2.2)
+    // Only this code will be parsed in Swift 3
+    func foo(x: Int) -> (y: Int) -> () {}
+  #else
+    // This code is ignored entirely.
+    func foo(x: Int)(y: Int) {}
+  #endif
+  ```
+
+  For more information, see [SE-0020](https://github.com/apple/swift-evolution/blob/master/proposals/0020-if-swift-version.md).
+
 2015-09-17 [Xcode 7.1, Swift 2.1]
 ----------
 

CMakeLists.txt

@@ -1,4 +1,5 @@
 cmake_minimum_required(VERSION 2.8.12)
+cmake_policy(SET CMP0054 NEW)
 
 # Add path for custom CMake modules.
 list(APPEND CMAKE_MODULE_PATH
@@ -28,6 +29,10 @@ option(SWIFT_STDLIB_ASSERTIONS
     "Enable internal checks for the Swift standard library (useful for debugging the library itself, does not affect checks required for safety)"
     "${SWIFT_STDLIB_ASSERTIONS_default}")
 
+option(SWIFT_SERIALIZE_STDLIB_UNITTEST
+    "Compile the StdlibUnittest module with -sil-serialize-all to increase the test coverage for the optimizer"
+    FALSE)
+
 option(SWIFT_BUILD_TOOLS
     "Build the Swift compiler and other tools"
     TRUE)
@@ -54,7 +59,7 @@ option(SWIFT_INCLUDE_DOCS
     "Create targets for building docs."
     TRUE)
 
-set(SWIFT_VERSION "2.2" CACHE STRING
+set(SWIFT_VERSION "3.0" CACHE STRING
     "The user-visible version of the Swift compiler")
 set(SWIFT_VENDOR "" CACHE STRING
     "The vendor name of the Swift compiler")
@@ -154,7 +159,7 @@ option(SWIFT_AST_VERIFIER
     "Enable the AST verifier in the built compiler, and run it on every compilation"
     TRUE)
 
-option(SWIFT_VERIFY_ALL
+option(SWIFT_SIL_VERIFY_ALL
     "Run SIL verification after each transform when building Swift files in the build process"
     FALSE)
 
@@ -403,6 +408,14 @@ if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
     configure_sdk_unix(LINUX "Linux" "linux" "linux" "aarch64" "aarch64-unknown-linux-gnu")
     set(SWIFT_HOST_VARIANT_ARCH "aarch64")
     set(SWIFT_PRIMARY_VARIANT_ARCH_default "aarch64")
+  elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "ppc64")
+    configure_sdk_unix(LINUX "Linux" "linux" "linux" "powerpc64" "powerpc64-unknown-linux-gnu")
+    set(SWIFT_HOST_VARIANT_ARCH "powerpc64")
+    set(SWIFT_PRIMARY_VARIANT_ARCH_default "powerpc64")
+  elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "ppc64le")
+    configure_sdk_unix(LINUX "Linux" "linux" "linux" "powerpc64le" "powerpc64le-unknown-linux-gnu")
+    set(SWIFT_HOST_VARIANT_ARCH "powerpc64le")
+    set(SWIFT_PRIMARY_VARIANT_ARCH_default "powerpc64le")
   else()
     message(FATAL_ERROR "Unknown or unsupported architecture: ${CMAKE_SYSTEM_PROCESSOR}")
   endif()
@@ -425,6 +438,19 @@ elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "FreeBSD")
 
   set(SWIFT_PRIMARY_VARIANT_SDK_default "FREEBSD")
   set(SWIFT_PRIMARY_VARIANT_ARCH_default "x86_64")
+elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "CYGWIN")
+  configure_sdk_unix(CYGWIN "Cygwin" "windows" "cygwin" "x86_64" "x86_64-unknown-windows-cygnus")
+
+#  set(CMAKE_EXECUTABLE_FORMAT "ELF")
+
+  set(SWIFT_HOST_VARIANT "windows" CACHE STRING
+      "Deployment OS for Swift host tools (the compiler) [windows].")
+
+  set(SWIFT_HOST_VARIANT_SDK "CYGWIN")
+  set(SWIFT_HOST_VARIANT_ARCH "x86_64")
+
+  set(SWIFT_PRIMARY_VARIANT_SDK_default "CYGWIN")
+  set(SWIFT_PRIMARY_VARIANT_ARCH_default "x86_64")
 elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "Darwin")
   # Set defaults.
 

cmake/modules/AddSwift.cmake

@@ -47,9 +47,9 @@ function(compute_library_subdir result_var_name sdk arch)
   set("${result_var_name}" "${SWIFT_SDK_${sdk}_LIB_SUBDIR}/${arch}" PARENT_SCOPE)
 endfunction()
 
-
 function(_add_variant_c_compile_link_flags
-    sdk arch build_type enable_assertions result_var_name)
+    sdk arch build_type enable_assertions analyze_code_coverage
+    result_var_name)
   set(result
     ${${result_var_name}}
     "-target" "${SWIFT_SDK_${sdk}_ARCH_${arch}_TRIPLE}")
@@ -62,20 +62,27 @@ function(_add_variant_c_compile_link_flags
         "-arch" "${arch}"
         "-F" "${SWIFT_SDK_${sdk}_PATH}/../../../Developer/Library/Frameworks"
         "-m${SWIFT_SDK_${sdk}_VERSION_MIN_NAME}-version-min=${SWIFT_SDK_${sdk}_DEPLOYMENT_VERSION}")
+
+    if(analyze_code_coverage)
+      list(APPEND result "-fprofile-instr-generate=swift-%p.profraw"
+                         "-fcoverage-mapping")
+    endif()
   endif()
 
   set("${result_var_name}" "${result}" PARENT_SCOPE)
 endfunction()
 
 function(_add_variant_c_compile_flags
-    sdk arch build_type enable_assertions result_var_name)
+    sdk arch build_type enable_assertions analyze_code_coverage
+    result_var_name)
   set(result ${${result_var_name}})
 
   _add_variant_c_compile_link_flags(
       "${sdk}"
       "${arch}"
       "${build_type}"
       "${enable_assertions}"
+      FALSE
       result)
 
   is_build_type_optimized("${build_type}" optimized)
@@ -103,6 +110,11 @@ function(_add_variant_c_compile_flags
     list(APPEND result "-DNDEBUG")
   endif()
 
+  if(analyze_code_coverage)
+    list(APPEND result "-fprofile-instr-generate=swift-%p.profraw"
+                       "-fcoverage-mapping")
+  endif()
+
   set("${result_var_name}" "${result}" PARENT_SCOPE)
 endfunction()
 
@@ -139,7 +151,8 @@ function(_add_variant_swift_compile_flags
 endfunction()
 
 function(_add_variant_link_flags
-    sdk arch build_type enable_assertions result_var_name)
+    sdk arch build_type enable_assertions analyze_code_coverage
+    result_var_name)
 
   if("${sdk}" STREQUAL "")
     message(FATAL_ERROR "Should specify an SDK")
@@ -156,12 +169,15 @@ function(_add_variant_link_flags
       "${arch}"
       "${build_type}"
       "${enable_assertions}"
+      "${analyze_code_coverage}"
       result)
 
   if("${sdk}" STREQUAL "LINUX")
-    list(APPEND result "-lpthread" "-ldl")
+    list(APPEND result "-lpthread" "-ldl" "-Wl,-Bsymbolic")
   elseif("${sdk}" STREQUAL "FREEBSD")
-    list(APPEND result "-lpthread")
+    list(APPEND result "-lpthread" "-Wl,-Bsymbolic")
+  elseif("${sdk}" STREQUAL "CYGWIN")
+    # No extra libraries required.
   else()
     list(APPEND result "-lobjc")
   endif()
@@ -298,7 +314,7 @@ function(_compile_swift_files dependency_target_out_var_name)
   # Don't include libarclite in any build products by default.
   list(APPEND swift_flags "-no-link-objc-runtime")
 
-  if(SWIFT_VERIFY_ALL)
+  if(SWIFT_SIL_VERIFY_ALL)
     list(APPEND swift_flags "-Xfrontend" "-sil-verify-all")
   endif()
 
@@ -770,6 +786,11 @@ function(_add_swift_library_single target name)
     endif()
   endif()
 
+  if (SWIFT_COMPILER_VERSION)
+    if ("${CMAKE_SYSTEM_NAME}" STREQUAL "Darwin")
+      set(SWIFTLIB_SINGLE_LINK_FLAGS "${SWIFTLIB_SINGLE_LINK_FLAGS}" "-Xlinker" "-current_version" "-Xlinker" "${SWIFT_COMPILER_VERSION}" "-Xlinker" "-compatibility_version" "-Xlinker" "1")
+    endif()
+  endif()
 
   if(XCODE)
     string(REGEX MATCHALL "/[^/]+" split_path ${CMAKE_CURRENT_SOURCE_DIR})
@@ -896,8 +917,12 @@ function(_add_swift_library_single target name)
 
   if("${CMAKE_SYSTEM_NAME}" STREQUAL "Darwin")
     set(install_name_dir "@rpath")
+
     if(SWIFTLIB_SINGLE_IS_STDLIB)
-      set(install_name_dir "${SWIFT_DARWIN_STDLIB_INSTALL_NAME_DIR}")
+      # Always use @rpath for XCTest.
+      if(NOT "${module_name}" STREQUAL "XCTest")
+        set(install_name_dir "${SWIFT_DARWIN_STDLIB_INSTALL_NAME_DIR}")
+      endif()
     endif()
 
     set_target_properties("${target}"
@@ -907,6 +932,10 @@ function(_add_swift_library_single target name)
     set_target_properties("${target}"
       PROPERTIES
       INSTALL_RPATH "$ORIGIN:/usr/lib/swift/linux")
+  elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "Cygwin")
+    set_target_properties("${target}"
+      PROPERTIES
+      INSTALL_RPATH "$ORIGIN:/usr/lib/swift/windows")
   endif()
 
   set_target_properties("${target}" PROPERTIES BUILD_WITH_INSTALL_RPATH YES)
@@ -1041,18 +1070,21 @@ function(_add_swift_library_single target name)
   else()
     set(build_type "${CMAKE_BUILD_TYPE}")
     set(enable_assertions "${LLVM_ENABLE_ASSERTIONS}")
+    set(analyze_code_coverage "${SWIFT_ANALYZE_CODE_COVERAGE}")
   endif()
   _add_variant_c_compile_flags(
       "${SWIFTLIB_SINGLE_SDK}"
       "${SWIFTLIB_SINGLE_ARCHITECTURE}"
       "${build_type}"
       "${enable_assertions}"
+      "${analyze_code_coverage}"
       c_compile_flags)
   _add_variant_link_flags(
       "${SWIFTLIB_SINGLE_SDK}"
       "${SWIFTLIB_SINGLE_ARCHITECTURE}"
       "${build_type}"
       "${enable_assertions}"
+      "${analyze_code_coverage}"
       link_flags)
 
   # Handle gold linker flags for shared libraries.
@@ -1618,14 +1650,14 @@ function(_add_swift_executable_single name)
       "${SWIFTEXE_SINGLE_ARCHITECTURE}"
       "${CMAKE_BUILD_TYPE}"
       "${LLVM_ENABLE_ASSERTIONS}"
-      FALSE
+      "${SWIFT_ANALYZE_CODE_COVERAGE}"
       c_compile_flags)
   _add_variant_link_flags(
       "${SWIFTEXE_SINGLE_SDK}"
       "${SWIFTEXE_SINGLE_ARCHITECTURE}"
       "${CMAKE_BUILD_TYPE}"
       "${LLVM_ENABLE_ASSERTIONS}"
-      FALSE
+      "${SWIFT_ANALYZE_CODE_COVERAGE}"
       link_flags)
 
   list(APPEND link_flags

cmake/modules/SwiftSetIfArchBitness.cmake

@@ -13,7 +13,9 @@ function(set_if_arch_bitness var_name)
     set("${var_name}" "${SIA_CASE_32_BIT}" PARENT_SCOPE)
   elseif("${SIA_ARCH}" STREQUAL "x86_64" OR
          "${SIA_ARCH}" STREQUAL "arm64" OR
-         "${SIA_ARCH}" STREQUAL "aarch64")
+         "${SIA_ARCH}" STREQUAL "aarch64" OR
+         "${SIA_ARCH}" STREQUAL "powerpc64" OR
+         "${SIA_ARCH}" STREQUAL "powerpc64le")
     set("${var_name}" "${SIA_CASE_64_BIT}" PARENT_SCOPE)
   else()
     message(FATAL_ERROR "Unknown architecture: ${SIA_ARCH}")

docs/Arrays.rst

@@ -63,7 +63,7 @@ to all three of the components.
   efficient conversions from Cocoa and back—when ``Element`` can be a class
   type, ``Array<Element>`` can be backed by the (potentially non-contiguous)
   storage of an arbitrary ``NSArray`` rather than by a Swift
-  ``ContiguousArray``.  ``Array<Element>`` also supports up- and down- casts
+  ``ContiguousArray``.  ``Array<Element>`` also supports up- and downcasts
   between arrays of related class types.  When ``Element`` is known to be a
   non-class type, the performance of ``Array<Element>`` is identical to that
   of ``ContiguousArray<Element>``.

docs/CMakeLists.txt

@@ -82,7 +82,7 @@ if(LITRE_EXECUTABLE)
     VERBATIM
     )
 
-  # Only update the real top-level CMakeLists.txt if something  changed
+  # Only update the real top-level CMakeLists.txt if something changed
   add_custom_command(
     OUTPUT
       "litre-tests/CMakeLists.txt"

docs/ErrorHandling.rst

@@ -578,7 +578,7 @@ of failability.
 
 One limitation of this approach is that we need to be able to reconstruct
 the selector to use when an overload of a method is introduced.  For this
-reason, the import is likely to be limited to methods where  the error
+reason, the import is likely to be limited to methods where the error
 parameter is the last one and the corresponding selector
 chunk is either ``error:`` or the first chunk (see below).  Empirically,
 this seems to do the right thing for all but two sets of APIs in the

docs/ErrorHandlingRationale.rst

@@ -1,6 +1,8 @@
 Error Handling Rationale and Proposal
 *************************************
 
+.. contents::
+
 This paper surveys the error-handling world, analyzes various ideas
 which have been proposed or are in practice in other languages, and
 ultimately proposes an error-handling scheme for Swift together
@@ -636,7 +638,7 @@ of the disadvantages and investigate ways to ameliorate them:
 
   - There are many situations where errors are not actually possible
     because the programmer has carefully restricted the input.  For
-    example, matching :code:``/[0-9]{4}/`` and then parsing the result
+    example, matching ``/[0-9]{4}/`` and then parsing the result
     as an integer.  It needs to be convenient to do this in a context
     that cannot actually propagate errors, but the facility to do this
     needs to be carefully designed to discourage use for swallowing
@@ -1043,9 +1045,9 @@ C++ has exceptions.  Exceptions can have almost any type in the
 language.  Propagation typing is tied only to declarations; an
 indirect function pointer is generally assumed to be able to throw.
 Propagation typing used to allow functions to be specific about the
-kinds of exceptions they could throw (:code:``throws
+kinds of exceptions they could throw (``throws
 (std::exception)``), but this is deprecated in favor of just indicating
-whether a function can throw (:code:``noexcept(false)``).
+whether a function can throw (``noexcept(false)``).
 
 C++ aspires to making out-of-memory a recoverable condition, and so
 allocation can throw.  Therefore, it is essentially compulsory for the
@@ -1316,16 +1318,16 @@ generalized ``do`` statement::
   }
 
 Swift should also provide some tools for doing manual propagation.  We
-should have a standard Rust-like :code:``Result<T>`` enum in the
+should have a standard Rust-like ``Result<T>`` enum in the
 library, as well as a rich set of tools, e.g.:
 
 - A function to evaluate an error-producing closure and capture the
-  result as a :code:``Result<T>``.
+  result as a ``Result<T>``.
 
-- A function to unpack a :code:``Result<T>`` by either returning its
+- A function to unpack a ``Result<T>`` by either returning its
   value or propagating the error in the current context.
 
-- A futures library that traffics in :code:``Result<T>`` when
+- A futures library that traffics in ``Result<T>`` when
   applicable.
 
 - An overload of ``dispatch_sync`` which takes an error-producing