Merge branch 'master' of github.com:apple/swift into new-refcount-representation

Author: Greg Parker

CODE_OWNERS.TXT

@@ -13,7 +13,7 @@ D: Swift standard library
 
 N: David Farler
 E: dfarler@apple.com
-D: Markup, Swift Linux port
+D: Markup, lib/Syntax, Swift Linux port
 
 N: Doug Gregor
 E: dgregor@apple.com

README.md

@@ -53,7 +53,7 @@ discussed below.
 macOS, Ubuntu Linux LTS, and the latest Ubuntu Linux release are the current
 supported host development operating systems.
 
-For macOS, you need [Xcode 8.3 Beta 2](https://developer.apple.com/xcode/downloads/).
+For macOS, you need [Xcode 8.3 Beta 3](https://developer.apple.com/xcode/downloads/).
 
 For Ubuntu, you'll need the following development dependencies:
 

benchmark/scripts/compare_perf_tests.py

@@ -13,6 +13,8 @@
 #
 # ===---------------------------------------------------------------------===//
 
+from __future__ import print_function
+
 import argparse
 import csv
 import sys

benchmark/scripts/generate_harness/generate_harness.py

@@ -14,6 +14,8 @@
 
 # Generate CMakeLists.txt and utils/main.swift from templates.
 
+from __future__ import print_function
+
 import glob
 import os
 import re

benchmark/scripts/perf_test_driver/perf_test_driver.py

@@ -12,6 +12,8 @@
 #
 # ===---------------------------------------------------------------------===//
 
+from __future__ import print_function
+
 import functools
 import multiprocessing
 import os

benchmark/utils/convertToJSON.py

@@ -57,6 +57,8 @@
 #     ]
 # }
 
+from __future__ import print_function
+
 import json
 import re
 import sys

cmake/modules/AddSwift.cmake

@@ -181,47 +181,65 @@ function(_add_variant_c_compile_flags)
   if(optimized OR CFLAGS_FORCE_BUILD_OPTIMIZED)
     list(APPEND result "-O2")
 
-    # Add -momit-leaf-frame-pointer on x86.
-    if("${CFLAGS_ARCH}" STREQUAL "i386" OR "${CFLAGS_ARCH}" STREQUAL "x86_64")
-      list(APPEND result "-momit-leaf-frame-pointer")
+    # Omit leaf frame pointers on x86.
+    if("${CFLAGS_ARCH}" STREQUAL "i386" OR "${CFLAGS_ARCH}" STREQUAL "i686")
+      if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
+        list(APPEND result "-momit-leaf-frame-pointer")
+      else()
+        list(APPEND result "/Oy")
+      endif()
     endif()
   else()
-    list(APPEND result "-O0")
-  endif()
-  is_build_type_with_debuginfo("${CFLAGS_BUILD_TYPE}" debuginfo)
-  if(debuginfo)
-    _compute_lto_flag("${CFLAGS_ENABLE_LTO}" _lto_flag_out)
-    if(_lto_flag_out)
-      list(APPEND result "-gline-tables-only")
+    if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
+      list(APPEND result "-O0")
     else()
-      list(APPEND result "-g")
+      list(APPEND result "/Od")
     endif()
-  else()
-    list(APPEND result "-g0")
   endif()
 
-  if("${CFLAGS_SDK}" STREQUAL "WINDOWS")
-    list(APPEND result -Xclang;--dependent-lib=oldnames)
-    # TODO(compnerd) handle /MT, /MTd, /MD, /MDd
-    if("${CMAKE_BUILD_TYPE}" STREQUAL "RELEASE")
-      list(APPEND result "-D_MD")
-      list(APPEND result -Xclang;--dependent-lib=msvcrt)
+  # CMake automatically adds the flags for debug info if we use MSVC/clang-cl.
+  if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
+    is_build_type_with_debuginfo("${CFLAGS_BUILD_TYPE}" debuginfo)
+    if(debuginfo)
+      _compute_lto_flag("${CFLAGS_ENABLE_LTO}" _lto_flag_out)
+      if(_lto_flag_out)
+        list(APPEND result "-gline-tables-only")
+      else()
+        list(APPEND result "-g")
+      endif()
     else()
-      list(APPEND result "-D_MDd")
-      list(APPEND result -Xclang;--dependent-lib=msvcrtd)
+      list(APPEND result "-g0")
     endif()
-    list(APPEND result -fno-pic)
   endif()
 
   if("${CFLAGS_SDK}" STREQUAL "WINDOWS")
+    # MSVC doesn't support -Xclang. We don't need to manually specify
+    # -D_MD or D_MDd either, as CMake does this automatically.
+    if(NOT "${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC")
+      list(APPEND result -Xclang;--dependent-lib=oldnames)
+      # TODO(compnerd) handle /MT, /MTd, /MD, /MDd
+      if("${CMAKE_BUILD_TYPE}" STREQUAL "RELEASE")
+        list(APPEND result "-D_MD")
+        list(APPEND result -Xclang;--dependent-lib=msvcrt)
+      else()
+        list(APPEND result "-D_MDd")
+        list(APPEND result -Xclang;--dependent-lib=msvcrtd)
+      endif()
+    endif()
+
+    # MSVC/clang-cl don't support -fno-pic or -fms-compatability-version.
+    if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
+      list(APPEND result -fno-pic)
+      list(APPEND result "-fms-compatibility-version=1900")
+    endif()
+
     list(APPEND result "-DLLVM_ON_WIN32")
     list(APPEND result "-D_CRT_SECURE_NO_WARNINGS")
     list(APPEND result "-D_CRT_NONSTDC_NO_WARNINGS")
     # TODO(compnerd) permit building for different families
     list(APPEND result "-D_CRT_USE_WINAPI_FAMILY_DESKTOP_APP")
     # TODO(compnerd) handle /MT
     list(APPEND result "-D_DLL")
-    list(APPEND result "-fms-compatibility-version=1900")
   endif()
 
   if(CFLAGS_ENABLE_ASSERTIONS)
@@ -321,9 +339,12 @@ function(_add_variant_link_flags)
   elseif("${LFLAGS_SDK}" STREQUAL "CYGWIN")
     # No extra libraries required.
   elseif("${LFLAGS_SDK}" STREQUAL "WINDOWS")
-    # NOTE: we do not use "/MD" or "/MDd" and select the runtime via linker
-    # options.  This causes conflicts.
-    list(APPEND result "-nostdlib")
+    # We don't need to add -nostdlib using MSVC or clang-cl, as MSVC and clang-cl rely on auto-linking entirely.
+    if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
+      # NOTE: we do not use "/MD" or "/MDd" and select the runtime via linker
+      # options. This causes conflicts.
+      list(APPEND result "-nostdlib")
+    endif()
   elseif("${LFLAGS_SDK}" STREQUAL "ANDROID")
     list(APPEND result
         "-ldl"
@@ -351,15 +372,17 @@ function(_add_variant_link_flags)
   if(NOT "${SWIFT_${LFLAGS_SDK}_ICU_I18N}" STREQUAL "")
     list(APPEND library_search_directories "${SWIFT_${sdk}_ICU_I18N}")
   endif()
-  
-  if(SWIFT_ENABLE_GOLD_LINKER AND
-     "${SWIFT_SDK_${LFLAGS_SDK}_OBJECT_FORMAT}" STREQUAL "ELF")
-    list(APPEND result "-fuse-ld=gold")
-  endif()
-  if(SWIFT_ENABLE_LLD_LINKER OR
-     ("${LFLAGS_SDK}" STREQUAL "WINDOWS" AND
-      NOT "${CMAKE_SYSTEM_NAME}" STREQUAL "WINDOWS"))
-    list(APPEND result "-fuse-ld=lld")
+
+  if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
+    if(SWIFT_ENABLE_GOLD_LINKER AND
+       "${SWIFT_SDK_${LFLAGS_SDK}_OBJECT_FORMAT}" STREQUAL "ELF")
+      list(APPEND result "-fuse-ld=gold")
+    endif()
+    if(SWIFT_ENABLE_LLD_LINKER OR
+       ("${LFLAGS_SDK}" STREQUAL "WINDOWS" AND
+        NOT "${CMAKE_SYSTEM_NAME}" STREQUAL "WINDOWS"))
+      list(APPEND result "-fuse-ld=lld")
+    endif()
   endif()
 
   set("${LFLAGS_RESULT_VAR_NAME}" "${result}" PARENT_SCOPE)

cmake/modules/AddSwiftUnittests.cmake

@@ -28,7 +28,7 @@ function(add_swift_unittest test_dirname)
 
     set(new_libnames)
     foreach(dep ${libnames})
-      if("${dep}" MATCHES "^(LLVM|Clang|gtest)")
+      if("${dep}" MATCHES "^(LLVM|Clang|gtest)" AND NOT "${CMAKE_SYSTEM_NAME}" STREQUAL "Windows")
         list(APPEND new_libnames "${LLVM_LIBRARY_OUTPUT_INTDIR}/lib${dep}.a")
       else()
         list(APPEND new_libnames "${dep}")

cmake/modules/SwiftSource.cmake

@@ -477,6 +477,8 @@ function(_compile_swift_files
   if (NOT SWIFTFILE_IS_MAIN)
     add_custom_command_target(
         module_dependency_target
+        COMMAND
+          "${CMAKE_COMMAND}" "-E" "remove" "-f" "${module_file}"
         COMMAND
           "${PYTHON_EXECUTABLE}" "${line_directive_tool}" "@${file_path}" --
           "${swift_compiler_tool}" "-emit-module" "-o" "${module_file}" ${swift_flags}

docs/ContinuousIntegration.md

@@ -9,6 +9,7 @@
     - [Smoke Testing](#smoke-testing)
     - [Validation Testing](#validation-testing)
     - [Lint Testing](#lint-testing)
+    - [Specific Preset Testing](#specific-preset-testing)
 - [Cross Repository Testing](#cross-repository-testing)
 - [ci.swift.org bots](#ciswiftorg-bots)
 
@@ -28,6 +29,7 @@ swift-ci pull request testing is triggered by writing a comment on this PR addre
 2. Validation Testing
 3. Benchmarking.
 4. Lint Testing
+5. Specific Preset Testing
 
 We describe each in detail below:
 
@@ -79,6 +81,7 @@ A smoke test on Linux does the following:
         OS X platform               | @swift-ci Please benchmark                    | Swift Benchmark on OS X Platform
         Linux platform              | @swift-ci Please test Linux platform          | Swift Test Linux Platform (smoke test)<br>Swift Test Linux Platform
         Linux platform              | @swift-ci Please clean test Linux platform    | Swift Test Linux Platform (smoke test)<br>Swift Test Linux Platform
+        OS X platform               | @swift-ci Please ASAN test                    | Swift ASAN Test OS X Platform
 
 The core principles of validation testing is that:
 
@@ -121,6 +124,20 @@ A validation test on Linux does the following:
         ------------ | ------- | ------------
         Python       | @swift-ci Please Python lint | Python lint
 
+### Specific Preset Testing
+
+        Platform     | Comment | Check Status
+        ------------ | ------- | ------------
+        OS X platform | preset=<preset> <br> @swift-ci Please test macOS with preset | Swift Test macOS Platform with preset
+
+For example:
+
+```
+preset=buildbot_incremental,tools=RA,stdlib=RD,smoketest=macosx,single-thread
+@swift-ci Please test macOS with preset
+
+```
+
 ## Cross Repository Testing
 
 Simply provide the URL from corresponding pull requests in the same comment as "@swift-ci Please test" phrase. List all of the pull requests and then provide the specific test phrase you would like to trigger. Currently, it will only merge the main pull request you requested testing from as opposed to all of the PR's.

docs/OwnershipManifesto.md

@@ -92,7 +92,7 @@ the ownership system from an implementation detail to a more
 visible aspect of the language.  They are also somewhat
 inseparable, for reasons we'll explain, although of course they
 can be prioritized differently.  For these reasons, we will
-talk about them as a cohensive feature called "ownership".
+talk about them as a cohesive feature called "ownership".
 
 ### A bit more detail
 
@@ -118,7 +118,7 @@ arbitrary function will use its arguments; it just falls
 back on a default rule for whether to pass ownership of
 the value.  When that default rule is wrong, the program
 will end up making extra copies at runtime.  So one simple
-thing we can do is allow programs to be more explicit at
+thing we can do is to allow programs to be more explicit at
 certain points about whether they need ownership or not.
 
 That closely dovetails with the desire to support non-copyable
@@ -311,7 +311,7 @@ A *variable* is the semantics concept of a unique place in
 memory that stores a value.  It's not necessarily mutable, at least
 as we're using it in this document.  Variables are usually created for
 storage declarations, but they can also be created dynamically in
-raw memory, e.g. using UnsafeRawPointer.  A variable always has a
+raw memory, e.g. using `UnsafeRawPointer`.  A variable always has a
 specific type.  It also has a *lifetime*, i.e. a point in the language
 semantics where it comes into existence and a point (or several)
 where it is destroyed.
@@ -725,7 +725,7 @@ use static enforcement for some class instance properties.
 
 Undefined enforcement means that conflicts are not detected
 either statically or dynamically, and instead simply have
-undefined behavior.  This is not a desireable mechanism
+undefined behavior.  This is not a desirable mechanism
 for ordinary code given Swift's "safe by default" design,
 but it's the only real choice for things like unsafe pointers.
 
@@ -747,7 +747,7 @@ not to escape.  The following principles apply:
 - If a closure `C` potentially escapes, then for any variable
   `V` captured by `C`, all accesses to `V` potentially executed
   after a potential escape (including the accesses within `C`
-  itself) must use dynamic enforcement unless all such acesses
+  itself) must use dynamic enforcement unless all such accesses
   are reads.
 
 - If a closure `C` does not escape a function, then its
@@ -797,7 +797,7 @@ additional semantic concerns.
 A shared value can be used in the scope that binds it
 just like an ordinary parameter or `let` binding.
 If the shared value is used in a place that requires
-ownership, Swift will simply implicitly copy the value —
+ownership, Swift will simply implicitly copy the value --
 again, just like an ordinary parameter or `let` binding.
 
 #### Limitations of shared values
@@ -819,7 +819,7 @@ born from a trio of concerns:
 - We have to scope this proposal to something that can
   conceivably be implemented in the coming months.  We expect this
   proposal to yield major benefits to the language and its
-  implementaton, but it is already quite broad and aggressive.
+  implementation, but it is already quite broad and aggressive.
   First-class ephemerals would add enough complexity to the
   implementation and design that they are clearly out of scope.
   Furthermore, the remaining language-design questions are
@@ -861,7 +861,7 @@ born from a trio of concerns:
   lexical and maintains the ability to run arbitrary code
   at the end of an access.  Imagine what it would take to
   implement a loop that added these temporary mutable
-  references to an array — each iteration of the loop would
+  references to an array -- each iteration of the loop would
   have to be able to queue up arbitrary code to run as a clean-up
   when the function was finished with the array.  This would
   hardly be a low-cost abstraction!  A more Rust-like
@@ -1078,7 +1078,7 @@ A non-mutating iteration simply visits each of the elements
 in the collection, leaving it intact and unmodified.  We have
 no reason to copy the elements; the iteration variable can
 simply be bound to a shared value.  This is a `nonmutating`
-operaton on `Collection`.
+operation on `Collection`.
 
 This can be explicitly requested by declaring the iteration
 variable `shared`:
@@ -1285,7 +1285,7 @@ value is returned.  This is useful for several reasons:
   reference, that storage is normally accessed for the duration
   of the call.  The programmer can suppress this and force the
   copy to complete before the call by calling `copy` on the
-  storage reference before 
+  storage reference before.
 
 - It is necessary for types that have suppressed implicit
   copies.  See the section below on non-copyable types.
@@ -1402,7 +1402,7 @@ default.
 
 The logical solution is to maintain the default assumption
 that all types are copyable, and then allow select contexts
-to turn that assumption off.  We will cause these contexts
+to turn that assumption off.  We will call these contexts
 `moveonly` contexts.  All contexts lexically nested within
 a `moveonly` context are also implicitly `moveonly`.