Merge branch 'release/5.7' of github.com:apple/swift into swiftwasm-release/5.7

# Conflicts:
#	include/swift/ABI/CompactFunctionPointer.h
#	include/swift/Runtime/Config.h
#	lib/IRGen/IRGenSIL.cpp
#	stdlib/public/core/KeyPath.swift

Author: MaxDesiatov

CHANGELOG.md

@@ -5,6 +5,72 @@ _**Note:** This is in reverse chronological order, so newer entries are added to
 
 ## Swift 5.7
 
+* [SE-0352][]:
+
+  It's now possible to call a generic function with a value of protocol type
+  in places that would previously fail because `any` types do not conform
+  to their protocols. For example:
+
+  ```
+  protocol P {
+    associatedtype A
+    func getA() -> A
+  }
+
+  func takeP<T: P>(_ value: T) { }
+
+  func test(p: any P) {
+    takeP(p) // was an error "type 'any P' cannot conform to 'P'", now accepted
+  }
+  ```
+
+  This operates by "opening" the value of protocol type and passing the
+  underlying type directly to the generic function.
+
+* [SE-0347][]:
+
+  It's now possible to use a default value expression with a generic parameter type
+  to default the argument and its type:
+
+  ```
+  func compute<C: Collection>(_ values: C = [0, 1, 2]) {
+    ...
+  }
+  ```
+
+  `compute` is now accepted by compiler and `[Int]` is going to be inferred
+  for `C` at call sites that do not provide the argument explicitly.
+
+* [SE-0326][]:
+
+  It's now possible to infer parameter and result types from the body of a multi-statement
+  closure. The distinction between single- and multi-statement closures has been removed.
+
+  Use of closures becomes less cumbersome by removing the need to constantly specify explicit
+  closure types which sometimes could be pretty large e.g. when there are multiple parameters
+  or a complex tuple result type.
+
+  For example:
+
+  ```swift
+  func map<T>(fn: (Int) -> T) -> T {
+    return fn(42)
+  }
+
+  func computeResult<U: BinaryInteger>(_: U) -> U { /* processing */ }
+
+  let _ = map {
+    if let $0 < 0 {
+       // do some processing
+    }
+
+    return computeResult($0)
+  }
+  ```
+
+  The result type of `map` can now be inferred from the body of the trailing closure
+  passed as an argument.
+
 * [SE-0345][]:
 
   It is now possible to unwrap optional variables with a shorthand syntax that
@@ -9119,6 +9185,9 @@ Swift 1.0
 [SE-0343]: <https://github.com/apple/swift-evolution/blob/main/proposals/0343-top-level-concurrency.md>
 [SE-0340]: <https://github.com/apple/swift-evolution/blob/main/proposals/0340-swift-noasync.md>
 [SE-0345]: <https://github.com/apple/swift-evolution/blob/main/proposals/0345-if-let-shorthand.md>
+[SE-0326]: <https://github.com/apple/swift-evolution/blob/main/proposals/0326-extending-multi-statement-closure-inference.md>
+[SE-0347]: <https://github.com/apple/swift-evolution/blob/main/proposals/0347-type-inference-from-default-exprs.md>
+[SE-0352]: <https://github.com/apple/swift-evolution/blob/main/proposals/0352-implicit-open-existentials.md>
 
 [SR-75]: <https://bugs.swift.org/browse/SR-75>
 [SR-106]: <https://bugs.swift.org/browse/SR-106>

CMakeLists.txt

@@ -137,6 +137,10 @@ option(SWIFT_BUILD_PERF_TESTSUITE
     "Create in-tree targets for building swift performance benchmarks."
     FALSE)
 
+option(SWIFT_BUILD_REGEX_PARSER_IN_COMPILER
+    "Build the Swift regex parser as part of the compiler."
+    TRUE)
+
 option(SWIFT_INCLUDE_TESTS "Create targets for building/running tests." TRUE)
 
 option(SWIFT_INCLUDE_TEST_BINARIES

CODEOWNERS

@@ -0,0 +1 @@
+* @apple/swift5-branch-managers

SwiftCompilerSources/Package.swift

@@ -11,7 +11,7 @@ let package = Package(
     .library(
       name: "Swift",
       type: .static,
-      targets: ["SIL", "Optimizer", "_RegexParser"]),
+      targets: ["SIL", "Optimizer", "_CompilerRegexParser"]),
   ],
   dependencies: [
   ],
@@ -26,15 +26,23 @@ let package = Package(
           "-cross-module-optimization"
         ])]),
     .target(
-      name: "_RegexParser",
+      name: "_CompilerRegexParser",
       dependencies: [],
-      swiftSettings: [SwiftSetting.unsafeFlags([
+      path: "_RegexParser",
+      swiftSettings: [
+        .unsafeFlags([
           "-I", "../include/swift",
-          "-cross-module-optimization"
+          "-cross-module-optimization",
+        ]),
+        // Workaround until `_RegexParser` is imported as implementation-only
+        // by `_StringProcessing`.
+        .unsafeFlags([
+          "-Xfrontend",
+          "-disable-implicit-string-processing-module-import"
         ])]),
     .target(
       name: "Optimizer",
-      dependencies: ["SIL", "_RegexParser"],
+      dependencies: ["SIL", "_CompilerRegexParser"],
       swiftSettings: [SwiftSetting.unsafeFlags([
           "-I", "../include/swift",
           "-cross-module-optimization"

SwiftCompilerSources/Sources/CMakeLists.txt

@@ -10,7 +10,7 @@
 
 add_subdirectory(Basic)
 add_subdirectory(AST)
-if(SWIFT_ENABLE_EXPERIMENTAL_STRING_PROCESSING)
+if(SWIFT_BUILD_REGEX_PARSER_IN_COMPILER)
   add_subdirectory(_RegexParser)
 endif()
 add_subdirectory(SIL)

SwiftCompilerSources/Sources/Optimizer/CMakeLists.txt

@@ -8,8 +8,8 @@
 
 set(dependencies)
 list(APPEND dependencies Basic SIL)
-if(SWIFT_ENABLE_EXPERIMENTAL_STRING_PROCESSING)
-  list(APPEND dependencies _RegexParser)
+if(SWIFT_BUILD_REGEX_PARSER_IN_COMPILER)
+  list(APPEND dependencies _CompilerRegexParser)
 endif()
 
 add_swift_compiler_module(Optimizer DEPENDS ${dependencies})

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -13,16 +13,16 @@
 import SIL
 import OptimizerBridging
 
-#if canImport(_RegexParser)
-import _RegexParser
+#if canImport(_CompilerRegexParser)
+import _CompilerRegexParser
 #endif
 
 @_cdecl("initializeSwiftModules")
 public func initializeSwiftModules() {
   registerSILClasses()
   registerSwiftPasses()
 
-  #if canImport(_RegexParser)
+  #if canImport(_CompilerRegexParser)
   registerRegexParser()
   #endif
 }

SwiftCompilerSources/Sources/_RegexParser/CMakeLists.txt

@@ -15,6 +15,6 @@ foreach(source ${_LIBSWIFT_REGEX_PARSER_SOURCES})
 endforeach()
 message(STATUS "Using Experimental String Processing library for libswift _RegexParser (${EXPERIMENTAL_STRING_PROCESSING_SOURCE_DIR}).")
 
-add_swift_compiler_module(_RegexParser
+add_swift_compiler_module(_CompilerRegexParser
   "${LIBSWIFT_REGEX_PARSER_SOURCES}"
   Regex.swift)

docs/ABI/Mangling.rst

@@ -189,6 +189,8 @@ Globals
   global ::= global 'MN'                 // noncanonical specialized generic type metadata for global
   global ::= global 'Mz'                 // canonical specialized generic type metadata caching token
 
+  global ::= global 'Mq'                 // global with a uniquing prefix
+
   #if SWIFT_RUNTIME_VERSION >= 5.4
     global ::= context (decl-name '_')+ 'WZ' // global variable one-time initialization function
     global ::= context (decl-name '_')+ 'Wz' // global variable one-time initialization token
@@ -635,7 +637,7 @@ Types
   type ::= protocol-list 'p'                 // existential type
   type ::= protocol-list superclass 'Xc'     // existential type with superclass
   type ::= protocol-list 'Xl'                // existential type with AnyObject
-  type ::= protocol-list 'y' (type* '_')* type* retroactive-conformance* 'Xp'   // parameterized protocol type
+  type ::= protocol-list 'y' (type* '_')* type* retroactive-conformance* 'XP'   // parameterized protocol type
   type ::= type-list 't'                     // tuple
   type ::= type generic-signature 'u'        // generic type
   type ::= 'x'                               // generic param, depth=0, idx=0
@@ -914,6 +916,11 @@ than the module of the conforming type or the conformed-to protocol), it is
 mangled with its offset into the set of conformance requirements, the
 root protocol conformance, and the suffix 'g'.
 
+::
+
+  // No generalization signature.
+  extended-existential-shape ::= type 'Xg' // no generalization signature
+  extended-existential-shape ::= generic-signature type 'XG'
 
 Identifiers
 ~~~~~~~~~~~

docs/RequirementMachine/RequirementMachine.tex

@@ -3053,7 +3053,7 @@ \chapter{The Requirement Machine}\label{requirementmachine}
 
 \section{Generic Parameters}\label{genericparamsym}
 \index{generic parameter symbol}
-So far, I've only shown you how to build rewrite rules from requirements in the requirement signature of some protocol $\proto{P}$. When lowering a type parameter, the protocol $\genericparam{Self}$ type lowers to the protocol symbol $\protosym{P}$. Once such a rewrite system is built, queries can be performed against the protocol generic signature $\gensig{\genericparam{Self}}{\genericparam{Self}\colon\proto{P}}$. When lowering parameters and requirements in an arbitary generic signature, generic parameter types instead become generic parameter symbols.
+So far, I've only shown you how to build rewrite rules from requirements in the requirement signature of some protocol $\proto{P}$. When lowering a type parameter, the protocol $\genericparam{Self}$ type lowers to the protocol symbol $\protosym{P}$. Once such a rewrite system is built, queries can be performed against the protocol generic signature $\gensig{\genericparam{Self}}{\genericparam{Self}\colon\proto{P}}$. When lowering parameters and requirements in an arbitrary generic signature, generic parameter types instead become generic parameter symbols.
 
 Generic parameter symbols should only ever appear as the initial symbol in a term. While the rewrite system would have no trouble with terms where generic parameter symbols appear elsewhere in the abstract, they don't actually make sense semantically, since they do not correspond to valid Swift type parameter types.