Merge tag 'swift-DEVELOPMENT-SNAPSHOT-2019-10-24-a' into tensorflow-merge

Tag build swift-DEVELOPMENT-SNAPSHOT-2019-10-24-a

Author: pschuh

.github/PULL_REQUEST_TEMPLATE.md

@@ -2,7 +2,7 @@
 Replace this paragraph with a description of your changes and rationale. Provide links to external references/discussions if appropriate.
 
 <!-- If this pull request resolves any bugs in the Swift bug tracker, provide a link: -->
-Resolves [SR-NNNN](https://bugs.swift.org/browse/SR-NNNN).
+Resolves SR-NNNN.
 
 <!--
 Before merging this pull request, you must run the Swift continuous integration tests.

CHANGELOG.md

@@ -26,6 +26,21 @@ CHANGELOG
 Swift 5.2
 ---------
 
+* [SR-2189][]:
+
+  The compiler now supports local functions whose default arguments capture
+  values from outer scopes.
+
+  ```swift
+  func outer(x: Int) -> (Int, Int) {
+    func inner(y: Int = x) -> Int {
+      return y
+    }
+
+    return (inner(), inner(y: 0))
+  }
+  ```
+
 * [SR-11429][]:
 
   The compiler will now correctly strip argument labels from function references
@@ -58,6 +73,29 @@ Swift 5.2
   (foo as Magic)(5)
   ```
 
+* [SR-11298][]:
+
+  A class-constrained protocol extension, where the extended protocol does
+  not impose a class constraint, will now infer the constraint implicitly.
+
+  ```swift
+  protocol Foo {}
+  class Bar: Foo {
+    var someProperty: Int = 0
+  }
+
+  // Even though 'Foo' does not impose a class constraint, it is automatically
+  // inferred due to the Self: Bar constraint.
+  extension Foo where Self: Bar {
+    var anotherProperty: Int {
+      get { return someProperty }
+      // As a result, the setter is now implicitly nonmutating, just like it would
+      // be if 'Foo' had a class constraint.
+      set { someProperty = newValue }
+    }
+  }
+  ```
+
 * [SE-0253][]:
 
   Values of types that declare `func callAsFunction` methods can be called
@@ -83,7 +121,7 @@ Swift 5.2
 
 * [SR-4206][]:
 
-  A method override is no longer allowed to have a generic signature with 
+  A method override is no longer allowed to have a generic signature with
   requirements not imposed by the base method. For example:
 
   ```
@@ -7780,6 +7818,7 @@ Swift 1.0
 [SR-1529]: <https://bugs.swift.org/browse/SR-1529>
 [SR-2131]: <https://bugs.swift.org/browse/SR-2131>
 [SR-2176]: <https://bugs.swift.org/browse/SR-2176>
+[SR-2189]: <https://bugs.swift.org/browse/SR-2189>
 [SR-2388]: <https://bugs.swift.org/browse/SR-2388>
 [SR-2394]: <https://bugs.swift.org/browse/SR-2394>
 [SR-2608]: <https://bugs.swift.org/browse/SR-2608>
@@ -7799,4 +7838,5 @@ Swift 1.0
 [SR-8974]: <https://bugs.swift.org/browse/SR-8974>
 [SR-9043]: <https://bugs.swift.org/browse/SR-9043>
 [SR-9827]: <https://bugs.swift.org/browse/SR-9827>
+[SR-11298]: <https://bugs.swift.org/browse/SR-11298>
 [SR-11429]: <https://bugs.swift.org/browse/SR-11429>

CMakeLists.txt

@@ -472,6 +472,10 @@ if(MSVC OR "${CMAKE_SIMULATE_ID}" STREQUAL MSVC)
   include(ClangClCompileRules)
 endif()
 
+if(CMAKE_C_COMPILER_ID STREQUAL Clang)
+  add_compile_options($<$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:-Werror=gnu>)
+endif()
+
 if(CMAKE_SYSTEM_NAME STREQUAL Darwin OR
     EXISTS "${SWIFT_PATH_TO_LIBDISPATCH_SOURCE}")
   set(SWIFT_BUILD_SYNTAXPARSERLIB_default TRUE)
@@ -985,17 +989,14 @@ if(SWIFT_NEED_EXPLICIT_LIBDISPATCH)
     set(SWIFT_LIBDISPATCH_C_COMPILER ${CMAKE_C_COMPILER})
     set(SWIFT_LIBDISPATCH_CXX_COMPILER ${CMAKE_CXX_COMPILER})
   elseif(${CMAKE_SYSTEM_NAME} STREQUAL ${CMAKE_HOST_SYSTEM_NAME})
-    get_target_property(CLANG_LOCATION clang LOCATION)
-    get_filename_component(CLANG_LOCATION ${CLANG_LOCATION} DIRECTORY)
-
     if(CMAKE_SYSTEM_NAME STREQUAL Windows)
       set(SWIFT_LIBDISPATCH_C_COMPILER
-          ${CLANG_LOCATION}/clang-cl${CMAKE_EXECUTABLE_SUFFIX})
+          $<TARGET_FILE_DIR:clang>/clang-cl${CMAKE_EXECUTABLE_SUFFIX})
       set(SWIFT_LIBDISPATCH_CXX_COMPILER
-          ${CLANG_LOCATION}/clang-cl${CMAKE_EXECUTABLE_SUFFIX})
+          $<TARGET_FILE_DIR:clang>/clang-cl${CMAKE_EXECUTABLE_SUFFIX})
     else()
-      set(SWIFT_LIBDISPATCH_C_COMPILER ${CLANG_LOCATION}/clang)
-      set(SWIFT_LIBDISPATCH_CXX_COMPILER ${CLANG_LOCATION}/clang++)
+      set(SWIFT_LIBDISPATCH_C_COMPILER $<TARGET_FILE_DIR:clang>/clang)
+      set(SWIFT_LIBDISPATCH_CXX_COMPILER $<TARGET_FILE_DIR:clang>/clang++)
     endif()
   else()
     message(SEND_ERROR "libdispatch requires a newer clang compiler (${CMAKE_C_COMPILER_VERSION} < 3.9)")

benchmark/scripts/run_smoke_bench

@@ -93,6 +93,10 @@ def main():
     argparser.add_argument(
         '-num-samples', type=int,
         help='The (minimum) number of samples to run', default=3)
+    argparser.add_argument(
+        '-num-reruns', type=int,
+        help="The number of re-runs until it's assumed to be a real change",
+        default=8)
     argparser.add_argument(
         '-platform', type=str,
         help='The benchmark build platform', default='macosx')
@@ -120,7 +124,7 @@ def test_opt_levels(args):
             if test_performance(opt_level, args.oldbuilddir[0],
                                 args.newbuilddir[0],
                                 float(args.threshold) / 100, args.num_samples,
-                                output_file):
+                                args.num_reruns, output_file):
                 changes = True
 
         # There is no point in reporting code size for Onone.
@@ -171,7 +175,7 @@ def merge(results, other_results):
 
 
 def test_performance(opt_level, old_dir, new_dir, threshold, num_samples,
-                     output_file):
+                     num_reruns, output_file):
     """Detect performance changes in benchmarks.
 
     Start fast with few samples per benchmark and gradually spend more time
@@ -185,7 +189,7 @@ def test_performance(opt_level, old_dir, new_dir, threshold, num_samples,
     tests = TestComparator(results[0], results[1], threshold)
     changed = tests.decreased + tests.increased
 
-    while len(changed) > 0 and unchanged_length_count < 10:
+    while len(changed) > 0 and unchanged_length_count < num_reruns:
         i += 1
         if VERBOSE:
             log('        test again: ' + str([test.name for test in changed]))

benchmark/single-source/ObjectiveCBridging.swift

@@ -79,6 +79,18 @@ public let ObjectiveCBridging = [
   BenchmarkInfo(name: "UnicodeStringFromCodable",
                  runFunction: run_UnicodeStringFromCodable, tags: ts,
                  setUpFunction: setup_UnicodeStringFromCodable),
+  BenchmarkInfo(name: "NSArray.bridged.objectAtIndex",
+                  runFunction: run_BridgedNSArrayObjectAtIndex, tags: t,
+                  setUpFunction: setup_bridgedArrays),
+  BenchmarkInfo(name: "NSArray.bridged.mutableCopy.objectAtIndex",
+                  runFunction: run_BridgedNSArrayMutableCopyObjectAtIndex, tags: t,
+                  setUpFunction: setup_bridgedArrays),
+  BenchmarkInfo(name: "NSArray.nonbridged.objectAtIndex",
+                  runFunction: run_RealNSArrayObjectAtIndex, tags: t,
+                  setUpFunction: setup_bridgedArrays),
+  BenchmarkInfo(name: "NSArray.nonbridged.mutableCopy.objectAtIndex",
+                  runFunction: run_RealNSArrayMutableCopyObjectAtIndex, tags: t,
+                  setUpFunction: setup_bridgedArrays),
 ]
 
 #if _runtime(_ObjC)
@@ -773,3 +785,65 @@ public func run_UnicodeStringFromCodable(_ N: Int) {
   }
   #endif
 }
+
+#if _runtime(_ObjC)
+var bridgedArray:NSArray! = nil
+var bridgedArrayMutableCopy:NSMutableArray! = nil
+var nsArray:NSArray! = nil
+var nsArrayMutableCopy:NSMutableArray! = nil
+#endif
+
+public func setup_bridgedArrays() {
+  #if _runtime(_ObjC)
+  var arr = Array(repeating: NSObject(), count: 100) as [AnyObject]
+  bridgedArray = arr as NSArray
+  bridgedArrayMutableCopy = (bridgedArray.mutableCopy() as! NSMutableArray)
+  nsArray = NSArray(objects: &arr, count: 100)
+  nsArrayMutableCopy = (nsArray.mutableCopy() as! NSMutableArray)
+  #endif
+}
+
+@inline(never)
+public func run_BridgedNSArrayObjectAtIndex(_ N: Int) {
+  #if _runtime(_ObjC)
+  for _ in 0 ..< N * 50 {
+    for i in 0..<100 {
+      blackHole(bridgedArray[i])
+    }
+  }
+  #endif
+}
+
+@inline(never)
+public func run_BridgedNSArrayMutableCopyObjectAtIndex(_ N: Int) {
+  #if _runtime(_ObjC)
+  for _ in 0 ..< N * 100 {
+    for i in 0..<100 {
+      blackHole(bridgedArrayMutableCopy[i])
+    }
+  }
+  #endif
+}
+
+@inline(never)
+public func run_RealNSArrayObjectAtIndex(_ N: Int) {
+  #if _runtime(_ObjC)
+  for _ in 0 ..< N * 100 {
+    for i in 0..<100 {
+      blackHole(nsArray[i])
+    }
+  }
+  #endif
+}
+
+@inline(never)
+public func run_RealNSArrayMutableCopyObjectAtIndex(_ N: Int) {
+  #if _runtime(_ObjC)
+  for _ in 0 ..< N * 100 {
+    for i in 0..<100 {
+      blackHole(nsArrayMutableCopy[i])
+    }
+  }
+  #endif
+}
+

benchmark/single-source/UTF8Decode.swift

@@ -42,6 +42,18 @@ public let UTF8Decode = [
       name: "UTF8Decode_InitFromBytes_ascii",
       runFunction: run_UTF8Decode_InitFromBytes_ascii,
       tags: [.validation, .api, .String]),
+    BenchmarkInfo(
+      name: "UTF8Decode_InitFromData_ascii_as_ascii",
+      runFunction: run_UTF8Decode_InitFromData_ascii_as_ascii,
+      tags: [.validation, .api, .String]),
+    BenchmarkInfo(
+      name: "UTF8Decode_InitDecoding_ascii_as_ascii",
+      runFunction: run_UTF8Decode_InitDecoding_ascii_as_ascii,
+      tags: [.validation, .api, .String]),
+    BenchmarkInfo(
+      name: "UTF8Decode_InitFromBytes_ascii_as_ascii",
+      runFunction: run_UTF8Decode_InitFromBytes_ascii_as_ascii,
+      tags: [.validation, .api, .String]),
 ]
 
 // 1-byte sequences
@@ -129,4 +141,26 @@ public func run_UTF8Decode_InitFromBytes_ascii(_ N: Int) {
   }
 }
 
+@inline(never)
+public func run_UTF8Decode_InitFromData_ascii_as_ascii(_ N: Int) {
+  let input = asciiData
+  for _ in 0..<1_000*N {
+    blackHole(String(data: input, encoding: .ascii))
+  }
+}
+@inline(never)
+public func run_UTF8Decode_InitDecoding_ascii_as_ascii(_ N: Int) {
+  let input = asciiBytes
+  for _ in 0..<1_000*N {
+    blackHole(String(decoding: input, as: Unicode.ASCII.self))
+  }
+}
+@inline(never)
+public func run_UTF8Decode_InitFromBytes_ascii_as_ascii(_ N: Int) {
+  let input = asciiBytes
+  for _ in 0..<1_000*N {
+    blackHole(String(bytes: input, encoding: .ascii))
+  }
+}
+
 

cmake/modules/SwiftHandleGybSources.cmake

@@ -118,13 +118,11 @@ function(handle_gyb_sources dependency_out_var_name sources_var_name arch)
       "${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/AttributeNodes.py"
       "${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/AvailabilityNodes.py"
       "${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/CommonNodes.py"
-      "${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/CompletionOnlyNodes.py"
       "${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/DeclNodes.py"
       "${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/ExprNodes.py"
       "${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/GenericNodes.py"
       "${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/NodeSerializationCodes.py"
       "${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/PatternNodes.py"
-      "${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/SILOnlyNodes.py"
       "${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/StmtNodes.py"
       "${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/TypeNodes.py"
       "${SWIFT_SOURCE_DIR}/utils/gyb_syntax_support/Token.py"

cmake/modules/SwiftSource.cmake

@@ -346,6 +346,11 @@ function(_compile_swift_files
            "-emit-module-interface-path" "${interface_file}")
     endif()
 
+    if (NOT SWIFTFILE_IS_STDLIB_CORE)
+      list(APPEND swift_module_flags
+           "-Xfrontend" "-experimental-skip-non-inlinable-function-bodies")
+    endif()
+
     # If we have extra regexp flags, check if we match any of the regexps. If so
     # add the relevant flags to our swift_flags.
     if (SWIFT_EXPERIMENTAL_EXTRA_REGEXP_FLAGS OR SWIFT_EXPERIMENTAL_EXTRA_NEGATIVE_REGEXP_FLAGS)

cmake/modules/SwiftWindowsSupport.cmake

@@ -84,20 +84,19 @@ endfunction()
 macro(swift_swap_compiler_if_needed target)
   if(NOT CMAKE_C_COMPILER_ID MATCHES Clang)
     if(CMAKE_SYSTEM_NAME STREQUAL CMAKE_HOST_SYSTEM_NAME)
-      get_target_property(CLANG_LOCATION clang LOCATION)
-      get_filename_component(CLANG_LOCATION ${CLANG_LOCATION} DIRECTORY)
-
-      if("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC" OR
-          "${CMAKE_C_SIMULATE_ID}" STREQUAL "MSVC")
-        set(CMAKE_C_COMPILER
-          ${CLANG_LOCATION}/clang-cl${CMAKE_EXECUTABLE_SUFFIX})
-        set(CMAKE_CXX_COMPILER
-          ${CLANG_LOCATION}/clang-cl${CMAKE_EXECUTABLE_SUFFIX})
+      if(SWIFT_BUILT_STANDALONE)
+        get_target_property(CLANG_LOCATION clang LOCATION)
+        get_filename_component(CLANG_LOCATION ${CLANG_LOCATION} DIRECTORY)
       else()
-        set(CMAKE_C_COMPILER
-          ${CLANG_LOCATION}/clang${CMAKE_EXECUTABLE_SUFFIX})
-        set(CMAKE_CXX_COMPILER
-          ${CLANG_LOCATION}/clang++${CMAKE_EXECUTABLE_SUFFIX})
+        set(CLANG_LOCATION ${LLVM_RUNTIME_OUTPUT_INTDIR})
+      endif()
+
+      if("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC" OR "${CMAKE_C_SIMULATE_ID}" STREQUAL "MSVC")
+        set(CMAKE_C_COMPILER ${CLANG_LOCATION}/clang-cl${CMAKE_EXECUTABLE_SUFFIX})
+        set(CMAKE_CXX_COMPILER ${CLANG_LOCATION}/clang-cl${CMAKE_EXECUTABLE_SUFFIX})
+      else()
+        set(CMAKE_C_COMPILER ${CLANG_LOCATION}/clang${CMAKE_EXECUTABLE_SUFFIX})
+        set(CMAKE_CXX_COMPILER ${CLANG_LOCATION}/clang++${CMAKE_EXECUTABLE_SUFFIX})
       endif()
     else()
       message(SEND_ERROR "${target} requires a clang based compiler")