Merge pull request #7 from apple/master

merge

Author: JacobMao

CHANGELOG.md

@@ -23,12 +23,24 @@ CHANGELOG
 Swift 5.0
 ---------
 
+* Public classes may now have internal `required` initializers. The rule for
+  `required` initializers is that they must be available everywhere the class
+  can be subclassed, but previously we said that `required` initializers on
+  public classes needed to be public themselves. (This limitation is a holdover
+  from before the introduction of the open/public distinction in Swift 3.)
+
 * C macros containing casts are no longer imported to Swift if the type in the
   cast is unavailable or deprecated, or produces some other diagnostic when
   referenced. (These macros were already only imported under very limited
   circumstances with very simple values, so this is unlikely to affect
   real-world code.)
 
+* [SE-0143][]
+
+	Runtime query of conditional conformances is now implemented. Therefore,
+	a dynamic cast such as `value as? P`, where the dynamic type of `value`
+	conditionally conforms to `P`, will succeed when the conditional
+	requirements are met.
 
 Swift 4.1
 ---------

CMakeLists.txt

@@ -1,5 +1,12 @@
 cmake_minimum_required(VERSION 3.4.3)
 
+# TODO: Fix RPATH usage to be CMP0068 compliant
+# Disable Policy CMP0068 for CMake 3.9
+# rdar://37725888
+if(POLICY CMP0068)
+  cmake_policy(SET CMP0068 OLD)
+endif()
+
 # Add path for custom CMake modules.
 list(APPEND CMAKE_MODULE_PATH
     "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
@@ -11,6 +18,8 @@ set_property(GLOBAL PROPERTY JOB_POOLS local_jobs=${localhost_logical_cores})
 # Put linking in that category
 set_property(GLOBAL PROPERTY JOB_POOL_LINK local_jobs)
 
+ENABLE_LANGUAGE(C)
+
 # First include general CMake utilities.
 include(SwiftUtils)
 include(CheckSymbolExists)
@@ -374,6 +383,10 @@ if(SWIFT_BUILT_STANDALONE)
   project(Swift C CXX ASM)
 endif()
 
+if(MSVC OR "${CMAKE_SIMULATE_ID}" STREQUAL MSVC)
+  include(ClangClCompileRules)
+endif()
+
 precondition(CMAKE_SYSTEM_NAME)
 if("${CMAKE_SYSTEM_NAME}" STREQUAL "Darwin")
   set(SWIFT_BUILD_SOURCEKIT_default TRUE)

benchmark/CMakeLists.txt

@@ -59,6 +59,7 @@ set(SWIFT_BENCH_MODULES
     single-source/DictTest
     single-source/DictTest2
     single-source/DictTest3
+    single-source/DictTest4
     single-source/DictionaryBridge
     single-source/DictionaryGroup
     single-source/DictionaryLiteral
@@ -113,15 +114,18 @@ set(SWIFT_BENCH_MODULES
     single-source/Prims
     single-source/ProtocolDispatch
     single-source/ProtocolDispatch2
+    single-source/Queue
     single-source/RC4
     single-source/RGBHistogram
     single-source/RangeAssignment
     single-source/RangeIteration
     single-source/RangeReplaceableCollectionPlusDefault
     single-source/RecursiveOwnedParameter
     single-source/ReduceInto
+    single-source/RemoveWhere
     single-source/ReversedCollections
     single-source/RomanNumbers
+    single-source/SequenceAlgos
     single-source/SetTests
     single-source/SevenBoom
     single-source/Sim2DArray

benchmark/cmake/modules/AddSwiftBenchmarkSuite.cmake

@@ -219,7 +219,6 @@ function (swift_benchmark_compile_archopts)
     endif()
   endif()
 
-  set(common_swift3_options ${common_options} "-swift-version" "3")
   set(common_swift4_options ${common_options} "-swift-version" "4")
 
   # Always optimize the driver modules.
@@ -247,7 +246,7 @@ function (swift_benchmark_compile_archopts)
       SOURCE_DIR "${srcdir}"
       OBJECT_DIR "${objdir}"
       SOURCES ${sources}
-      LIBRARY_FLAGS ${common_swift3_options})
+      LIBRARY_FLAGS ${common_swift4_options})
     precondition(objfile_out)
     list(APPEND bench_library_objects "${objfile_out}")
     if (SWIFT_BENCHMARK_EMIT_SIB)
@@ -316,7 +315,7 @@ function (swift_benchmark_compile_archopts)
             ${stdlib_dependencies} ${bench_library_objects}
             "${srcdir}/${module_name_path}.swift"
           COMMAND "${SWIFT_EXEC}"
-          ${common_swift3_options}
+          ${common_swift4_options}
           ${extra_options}
           "-parse-as-library"
           ${bench_flags}
@@ -334,7 +333,7 @@ function (swift_benchmark_compile_archopts)
               ${stdlib_dependencies} ${bench_library_sibfiles}
               "${srcdir}/${module_name_path}.swift"
             COMMAND "${SWIFT_EXEC}"
-            ${common_swift3_options}
+            ${common_swift4_options}
             "-parse-as-library"
             ${bench_flags}
             "-module-name" "${module_name}"
@@ -364,7 +363,7 @@ function (swift_benchmark_compile_archopts)
         SOURCE_DIR "${srcdir}"
         OBJECT_DIR "${objdir}"
         SOURCES ${${module_name}_sources}
-        LIBRARY_FLAGS ${common_swift3_options} ${bench_flags}
+        LIBRARY_FLAGS ${common_swift4_options} ${bench_flags}
         DEPENDS ${bench_library_objects} ${stdlib_dependencies})
       precondition(objfile_out)
       list(APPEND SWIFT_BENCH_OBJFILES "${objfile_out}")
@@ -382,7 +381,7 @@ function (swift_benchmark_compile_archopts)
         SOURCE_DIR "${srcdir}"
         OBJECT_DIR "${objdir}"
         SOURCES ${${module_name}_sources}
-        LIBRARY_FLAGS ${common_swift3_options} ${bench_flags}
+        LIBRARY_FLAGS ${common_swift4_options} ${bench_flags}
         DEPENDS ${bench_library_objects} ${stdlib_dependencies})
       precondition(objfiles_out)
       list(APPEND SWIFT_BENCH_OBJFILES ${objfiles_out})
@@ -435,7 +434,7 @@ function (swift_benchmark_compile_archopts)
         ${bench_library_sibfiles} ${bench_driver_sibfiles}
         ${SWIFT_BENCH_SIBFILES} "${source}"
       COMMAND "${SWIFT_EXEC}"
-      ${common_swift3_options}
+      ${common_swift4_options}
       "-force-single-frontend-invocation"
       "-emit-module" "-module-name" "${module_name}"
       "-I" "${objdir}"

benchmark/single-source/ArraySubscript.swift

@@ -30,7 +30,7 @@ public func run_ArraySubscript(_ N: Int) {
   var arrays = [[Int]](repeating: [], count: numArrays)
   for i in 0..<numArrays {
     for _ in 0..<numArrayElements {
-      arrays[i].append(Int(truncatingBitPattern: Random()))
+      arrays[i].append(Int(truncatingIfNeeded: Random()))
     }
   }
 

benchmark/single-source/CString.swift

@@ -37,7 +37,7 @@ public func run_StringWithCString(_ N: Int) {
 
 @inline(never)
 public func run_CStringLongAscii(_ N: Int) {
-  var res: UInt = 0
+  var res = 0
   for _ in 1...N*500 {
     // static string to c -> from c to String -> implicit conversion
     res &= strlen(ascii.withCString(String.init(cString:)))
@@ -47,7 +47,7 @@ public func run_CStringLongAscii(_ N: Int) {
 
 @inline(never)
 public func run_CStringLongNonAscii(_ N: Int) {
-  var res: UInt = 0
+  var res = 0
   for _ in 1...N*500 {
     res &= strlen(japanese.withCString(String.init(cString:)))
   }

benchmark/single-source/DictTest4.swift

@@ -0,0 +1,129 @@
+//===--- DictTest4.swift --------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import TestsUtils
+
+// This benchmark mostly measures lookups in dictionaries with complex keys,
+// exercising the default hash compression function.
+
+public let Dictionary4 = [
+  BenchmarkInfo(name: "Dictionary4", runFunction: run_Dictionary4, tags: [.validation, .api, .Dictionary]),
+  BenchmarkInfo(name: "Dictionary4OfObjects", runFunction: run_Dictionary4OfObjects, tags: [.validation, .api, .Dictionary]),
+]
+
+struct LargeKey: Hashable {
+  let i: Int
+  let j: Int
+  let k: Double
+  let l: UInt32
+  let m: Bool
+  let n: Bool
+  let o: Bool
+  let p: Bool
+  let q: Bool
+
+  init(_ value: Int) {
+    self.i = value
+    self.j = 2 * value
+    self.k = Double(value) / 7
+    self.l = UInt32(truncatingIfNeeded: value)
+    self.m = value & 1 == 0
+    self.n = value & 2 == 0
+    self.o = value & 4 == 0
+    self.p = value & 8 == 0
+    self.q = value & 16 == 0
+  }
+}
+
+@inline(never)
+public func run_Dictionary4(_ N: Int) {
+  let size1 = 100
+  let reps = 20
+  let ref_result = "1 99 \(reps) \(reps * 99)"
+  var hash1 = [LargeKey: Int]()
+  var hash2 = [LargeKey: Int]()
+  var res = ""
+
+  for _ in 1...N {
+    // Test insertions
+    hash1 = [:]
+    for i in 0..<size1 {
+      hash1[LargeKey(i)] = i
+    }
+
+    hash2 = hash1
+
+    // Test lookups & value replacement
+    for _ in 1..<reps {
+      for (k, v) in hash1 {
+        hash2[k] = hash2[k]! + v
+      }
+    }
+
+    res = "\(hash1[LargeKey(1)]!) \(hash1[LargeKey(99)]!)" +
+      " \(hash2[LargeKey(1)]!) \(hash2[LargeKey(99)]!)"
+    if res != ref_result {
+      break
+    }
+  }
+  CheckResults(res == ref_result)
+}
+
+class Box<T : Hashable> : Hashable {
+  var value: T
+
+  init(_ v: T) {
+    value = v
+  }
+
+  var hashValue: Int {
+    return value.hashValue
+  }
+  
+  static func ==(lhs: Box, rhs: Box) -> Bool {
+    return lhs.value == rhs.value
+  }
+}
+
+@inline(never)
+public func run_Dictionary4OfObjects(_ N: Int) {
+  let size1 = 100
+  let reps = 20
+  let ref_result = "1 99 \(reps) \(reps * 99)"
+  var hash1 = [Box<LargeKey>: Int]()
+  var hash2 = [Box<LargeKey>: Int]()
+  var res = ""
+
+  for _ in 1...N {
+    // Test insertions
+    hash1 = [:]
+    for i in 0..<size1 {
+      hash1[Box(LargeKey(i))] = i
+    }
+
+    hash2 = hash1
+
+    // Test lookups & value replacement
+    for _ in 1..<reps {
+      for (k, v) in hash1 {
+        hash2[k] = hash2[k]! + v
+      }
+    }
+
+    res = "\(hash1[Box(LargeKey(1))]!) \(hash1[Box(LargeKey(99))]!)" +
+      " \(hash2[Box(LargeKey(1))]!) \(hash2[Box(LargeKey(99))]!)"
+    if res != ref_result {
+      break
+    }
+  }
+  CheckResults(res == ref_result)
+}

benchmark/single-source/DoubleWidthDivision.swift

@@ -12,14 +12,20 @@
 
 // This test checks performance of division using DoubleWidth.
 
-import Foundation
+// FIXME: This needs to be disabled with an #if because it runs into pathological
+// compile time and code size problems.
+// [SR-6947] DoubleWidth compile time.
+// import Foundation
 import TestsUtils
 
 public let DoubleWidthDivision = BenchmarkInfo(
   name: "DoubleWidthDivision",
-  runFunction: run_DoubleWidthDivision,
+  runFunction: disabled,
   tags: [.validation, .algorithm]
 )
+public func disabled(_ N: Int) {}
+
+#if false
 
 private typealias Int128 = DoubleWidth<Int64>
 private typealias Int256 = DoubleWidth<Int128>
@@ -54,3 +60,4 @@ public func run_DoubleWidthDivision(_ N: Int) {
   }
   CheckResults(sum == 0)
 }
+#endif

benchmark/single-source/Hash.swift

@@ -114,17 +114,17 @@ class Hash {
   final
   func rol(_ x: UInt32, _ c: UInt32) -> UInt32 {
     // TODO: use the &>> operator.
-    let a = UInt32(truncatingBitPattern: Int64(x) << Int64(c))
-    let b = UInt32(truncatingBitPattern: Int64(x) >> (32 - Int64(c)))
+    let a = UInt32(truncatingIfNeeded: Int64(x) << Int64(c))
+    let b = UInt32(truncatingIfNeeded: Int64(x) >> (32 - Int64(c)))
     return a|b
   }
 
   /// \brief Right-rotate \p x by \p c.
   final
   func ror(_ x: UInt32, _ c: UInt32) -> UInt32 {
     // TODO: use the &>> operator.
-    let a = UInt32(truncatingBitPattern: Int64(x) >> Int64(c))
-    let b = UInt32(truncatingBitPattern: Int64(x) << (32 - Int64(c)))
+    let a = UInt32(truncatingIfNeeded: Int64(x) >> Int64(c))
+    let b = UInt32(truncatingIfNeeded: Int64(x) << (32 - Int64(c)))
     return a|b
   }
 }
@@ -177,10 +177,10 @@ class MD5 : Hash {
   }
 
   func appendBytes(_ Val: Int, _ Message: inout Array<UInt8>, _ Offset : Int) {
-    Message[Offset] = UInt8(truncatingBitPattern: Val)
-    Message[Offset + 1] = UInt8(truncatingBitPattern: Val >> 8)
-    Message[Offset + 2] = UInt8(truncatingBitPattern: Val >> 16)
-    Message[Offset + 3] = UInt8(truncatingBitPattern: Val >> 24)
+    Message[Offset] = UInt8(truncatingIfNeeded: Val)
+    Message[Offset + 1] = UInt8(truncatingIfNeeded: Val >> 8)
+    Message[Offset + 2] = UInt8(truncatingIfNeeded: Val >> 16)
+    Message[Offset + 3] = UInt8(truncatingIfNeeded: Val >> 24)
   }
 
   override

benchmark/single-source/IterateData.swift

@@ -21,8 +21,9 @@ public let IterateData = BenchmarkInfo(
 @inline(never)
 func generateData() -> Data {
   var data = Data(count: 16 * 1024)
+  let n = data.count
   data.withUnsafeMutableBytes { (ptr: UnsafeMutablePointer<UInt8>) -> () in
-    for i in 0..<data.count {
+    for i in 0..<n {
       ptr[i] = UInt8(i % 23)
     }
   }