Merge branch 'main' into ns-option-linkage-spec-decl-fixes

Author: NuriAmari

.github/CODEOWNERS

@@ -5,6 +5,19 @@
 # Owners of ASTGen
 lib/ASTGen @zoecarver @CodaFi
 
+# Dependency scanning
+include/swift/DependencyScan                 @artemcm
+lib/AST/ModuleLoader.cpp                     @artemcm
+lib/DependencyScan                           @artemcm
+lib/Frontend/ModuleInterfaceLoader.cpp       @artemcm
+lib/Serialization/SerializedModuleLoader.cpp @artemcm
+test/ScanDependencies                        @artemcm
+
+# Driver
+include/swift/Driver @artemcm
+lib/Driver           @artemcm
+test/Driver          @artemcm
+
 # Owners of the parser
 include/swift/Parse @ahoppen @bnbarham @CodaFi @DougGregor @rintaro
 lib/Parse           @ahoppen @bnbarham @CodaFi @DougGregor @rintaro
@@ -19,3 +32,13 @@ lib/ClangImporter           @zoecarver @hyp @egorzhdan
 lib/PrintAsClang            @zoecarver @hyp @egorzhdan
 stdlib/public/Cxx           @zoecarver @hyp @egorzhdan
 test/Interop                @zoecarver @hyp @egorzhdan
+
+# Threading implementation
+include/swift/Threading @al45tair
+lib/Threading           @al45tair
+
+# Windows support
+cmake/**/*Windows*    @compnerd
+lib/Basic/Windows     @compnerd
+stdlib/public/Windows @compnerd
+utils/*windows*       @compnerd

.github/ISSUE_TEMPLATE/bug_report.md

@@ -2,7 +2,7 @@
 name: Bug report
 about: Create a report to help us improve
 title: ''
-labels: bug
+labels: bug, triage needed
 assignees: ''
 
 ---

.github/ISSUE_TEMPLATE/feature_request.md

@@ -2,7 +2,7 @@
 name: Feature request
 about: Share an idea
 title: ''
-labels: feature request
+labels: feature request, triage needed
 assignees: ''
 
 ---

CHANGELOG.md

@@ -4,6 +4,32 @@ _**Note:** This is in reverse chronological order, so newer entries are added to
 
 ## Swift 5.8
 
+* [#56139][]:
+
+  Сollection downcasts in cast patterns are now supported. For example:
+
+  ```swift
+  func collectionDowncast(_ arr: [Any]) {
+    switch arr {
+    case let ints as [Int]:
+      // ...
+    case is [Bool]:
+      // ...
+    }
+  }
+  ``` 
+* [SE-0370][]:
+
+  The API of `UnsafeMutableRawPointer`, `UnsafeMutableBufferPointer`, `UnsafeMutableRawBufferPointer` were improved, adding previously missing initialization (and deinitialization) methods, including more performant initialization from `Collection` types.
+
+  For `UnsafeMutablePointer<T>` and `UnsafeMutableBufferPointer<T>`, method names containing the word "assign" were renamed to use the word "update", and many more were added. Every multi-element initialization method of `UnsafeMutablePointer` and `UnsafeMutableBufferPointer` now has a corresponding "update" method.
+
+  Slices of `UnsafeBufferPointer`, `UnsafeRawBufferPointer`, `UnsafeMutableBufferPointer` and `UnsafeMutableRawBufferPointer` now share the collection-like API of their base type. For example, given an initialized `b: UnsafeMutableBufferPointer<Int>`, the following lines are synonymous:
+  ```swift
+  b.update(repeating: 0)
+  b[b.startIndex..<b.endIndex].update(repeating: 0)
+  ```
+
 * [SE-0365][]:
 
   Implicit `self` is now permitted for `weak self` captures, after `self` is unwrapped.
@@ -9584,6 +9610,7 @@ using the `.dynamicType` member to retrieve the type of an expression should mig
 [SE-0358]: <https://github.com/apple/swift-evolution/blob/main/proposals/0358-primary-associated-types-in-stdlib.md>
 [SE-0362]: <https://github.com/apple/swift-evolution/blob/main/proposals/0362-piecemeal-future-features.md>
 [SE-0365]: <https://github.com/apple/swift-evolution/blob/main/proposals/0365-implicit-self-weak-capture.md>
+[SE-0370]: <https://github.com/apple/swift-evolution/blob/main/proposals/0370-pointer-family-initialization-improvements.md>
 
 [#42697]: <https://github.com/apple/swift/issues/42697>
 [#42728]: <https://github.com/apple/swift/issues/42728>
@@ -9624,3 +9651,4 @@ using the `.dynamicType` member to retrieve the type of an expression should mig
 [#54246]: <https://github.com/apple/swift/issues/54246>
 [#57081]: <https://github.com/apple/swift/issues/57081>
 [#57225]: <https://github.com/apple/swift/issues/57225>
+[#56139]: <https://github.com/apple/swift/issues/56139>

SwiftCompilerSources/Sources/Basic/Utils.swift

@@ -11,7 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 @_exported import BasicBridging
-import std
+import CxxStdlib
 
 /// The assert function to be used in the compiler.
 ///

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeSideEffects.swift

@@ -463,7 +463,7 @@ private extension PartialApplyInst {
     struct EscapesToApply : EscapeVisitor {
       func visitUse(operand: Operand, path: EscapePath) -> UseResult {
         switch operand.instruction {
-        case is ApplySite:
+        case is FullApplySite:
           // Any escape to apply - regardless if it's an argument or the callee operand - might cause
           // the closure to be called.
           return .abort

cmake/modules/AddSwift.cmake

@@ -569,7 +569,7 @@ function(_add_swift_runtime_link_flags target relpath_to_lib_dir bootstrapping)
 
   if(SWIFT_SWIFT_PARSER)
     # Make sure we can find the early SwiftSyntax libraries.
-    target_link_directories(${target} PRIVATE "${SWIFT_PATH_TO_EARLYSWIFTSYNTAX_BUILD_DIR}/lib")
+    target_link_directories(${target} PRIVATE "${SWIFT_PATH_TO_EARLYSWIFTSYNTAX_BUILD_DIR}/lib/swift/host")
 
     # For the "end step" of bootstrapping configurations on Darwin, need to be
     # able to fall back to the SDK directory for libswiftCore et al.
@@ -912,9 +912,17 @@ function(add_swift_host_tool executable)
   endif()
 
   if(SWIFT_SWIFT_PARSER)
+    set(extra_relative_rpath "")
+    if(NOT ${ASHT_BOOTSTRAPPING} STREQUAL "")
+      if (${executable} MATCHES "-bootstrapping")
+        set(extra_relative_rpath "../")
+      endif()
+    endif()
+
     set_property(
       TARGET ${executable}
-      APPEND PROPERTY INSTALL_RPATH "@executable_path/../lib")
+      APPEND PROPERTY INSTALL_RPATH
+        "@executable_path/../${extra_relative_rpath}lib/swift/host")
   endif()
 
   if(ASHT_THINLTO_LD64_ADD_FLTO_CODEGEN_ONLY)

cmake/modules/SwiftConfigureSDK.cmake

@@ -378,7 +378,7 @@ macro(configure_sdk_unix name architectures)
           message(WARNING "CMAKE_SYSTEM_VERSION will not match target")
         endif()
 
-        string(REPLACE "[-].*" "" freebsd_system_version ${CMAKE_SYSTEM_VERSION})
+        string(REGEX REPLACE "[-].*" "" freebsd_system_version ${CMAKE_SYSTEM_VERSION})
         message(STATUS "FreeBSD Version: ${freebsd_system_version}")
 
         set(SWIFT_SDK_FREEBSD_ARCH_x86_64_TRIPLE "x86_64-unknown-freebsd${freebsd_system_version}")
@@ -387,14 +387,14 @@ macro(configure_sdk_unix name architectures)
           message(FATAL_ERROR "unsupported arch for OpenBSD: ${arch}")
         endif()
 
-        string(REPLACE "[-].*" "" openbsd_system_version ${CMAKE_SYSTEM_VERSION})
+        set(openbsd_system_version ${CMAKE_SYSTEM_VERSION})
         message(STATUS "OpenBSD Version: ${openbsd_system_version}")
 
         set(SWIFT_SDK_OPENBSD_ARCH_amd64_TRIPLE "amd64-unknown-openbsd${openbsd_system_version}")
 
-	if(CMAKE_SYSROOT)
-	  set(SWIFT_SDK_OPENBSD_ARCH_${arch}_PATH "${CMAKE_SYSROOT}${SWIFT_SDK_OPENBSD_ARCH_${arch}_PATH}" CACHE INTERNAL "sysroot path" FORCE)
-	endif()
+        if(CMAKE_SYSROOT)
+          set(SWIFT_SDK_OPENBSD_ARCH_${arch}_PATH "${CMAKE_SYSROOT}${SWIFT_SDK_OPENBSD_ARCH_${arch}_PATH}" CACHE INTERNAL "sysroot path" FORCE)
+        endif()
       elseif("${prefix}" STREQUAL "CYGWIN")
         if(NOT arch STREQUAL x86_64)
           message(FATAL_ERROR "unsupported arch for cygwin: ${arch}")

cmake/modules/SwiftHandleGybSources.cmake

@@ -135,7 +135,6 @@ function(handle_gyb_sources dependency_out_var_name sources_var_name)
       "${SWIFT_PATH_TO_SWIFT_SYNTAX_SOURCE}/gyb_syntax_support/DeclNodes.py"
       "${SWIFT_PATH_TO_SWIFT_SYNTAX_SOURCE}/gyb_syntax_support/ExprNodes.py"
       "${SWIFT_PATH_TO_SWIFT_SYNTAX_SOURCE}/gyb_syntax_support/GenericNodes.py"
-      "${SWIFT_PATH_TO_SWIFT_SYNTAX_SOURCE}/gyb_syntax_support/NodeSerializationCodes.py"
       "${SWIFT_PATH_TO_SWIFT_SYNTAX_SOURCE}/gyb_syntax_support/PatternNodes.py"
       "${SWIFT_PATH_TO_SWIFT_SYNTAX_SOURCE}/gyb_syntax_support/StmtNodes.py"
       "${SWIFT_PATH_TO_SWIFT_SYNTAX_SOURCE}/gyb_syntax_support/TypeNodes.py"

docs/ABI/Mangling.rst

@@ -362,6 +362,7 @@ Entities
   entity-spec ::= decl-name label-list? type 'v' ACCESSOR                           // variable
   entity-spec ::= decl-name type 'fp'                                               // generic type parameter
   entity-spec ::= decl-name type 'fo'                                               // enum element (currently not used)
+  entity-spec ::= decl-name label-list? type generic-signature? 'fm'   // macro
   entity-spec ::= identifier 'Qa'                                                   // associated type declaration
 
   ACCESSOR ::= 'm'                           // materializeForSet

docs/AccessControlInStdlib.md

@@ -0,0 +1,128 @@
+# Scope and introduction
+
+This document defines the policy for applying access control modifiers
+and related naming conventions for the Swift standard library and
+overlays.
+
+In this document, \"stdlib\" refers to the core standard library and
+overlays for system frameworks written in Swift.
+
+Swift has four levels of access control — `private`, `fileprivate`, `internal`
+and `public`. As currently implemented, access control is only concerned with
+API-level issues, not ABI. The stdlib does not have a stable ABI, and is
+compiled in \"non-resilient\" mode with inlining into user code; thus,
+all stdlib symbols are considered ABI and stdlib clients should be
+recompiled after *any* change to the stdlib.
+
+# `public`
+
+User-visible APIs should be marked public.
+
+Unfortunately, the compiler has bugs and limitations that the stdlib
+must work around by defining additional public symbols not intended for
+direct consumption by users. For example:
+
+```swift
+// Workaround. 
+public protocol _Pointer { 
+  // ... 
+}
+
+// Symbol intended for use outside stdlib. 
+public struct UnsafeRawPointer: _Pointer {
+  // ...
+}
+```
+
+These symbols are hidden using the [leading underscore
+rule](#leading-underscore-rule).
+
+Because Swift does not yet support a notion of SPI, any implementation
+details that are shared across the stdlib\'s various sub-modules must
+also be public. These names, too, use the [leading underscore
+rule](#leading-underscore-rule).
+
+To document the reason for marking symbols public, we use comments:
+
+-   symbols used in tests:
+
+        public // @testable
+        func _foo() { ... }
+
+-   symbols that are SPIs for the module X:
+
+        public // SPI(X)
+        func _foo() { ... }
+
+# `internal`
+
+In Swift, `internal` is an implied default everywhere — except within `public` 
+extensions and protocols. Therefore, `internal` should be used explicitly
+everywhere in the stdlib to avoid confusion.
+
+### Note
+
+> No declaration should omit an access.
+
+To create a \"single point of truth\" about whether a name is intended
+for user consumption, the following names should all use the [leading
+underscore rule](#leading-underscore-rule):
+
+-   module-scope `private` and `internal`
+    symbols:
+
+```swift
+var _internalStdlibConstant: Int { ... }
+```
+
+-   `private` and `internal` symbols nested within `public` types:
+
+```swift
+public struct Dictionary {
+  var _representation: _DictionaryRepresentation
+}
+```
+
+# `private`
+
+# Leading Underscore Rule
+
+Variables, functions and typealiases should have names that start with
+an underscore:
+
+```swift
+var _value: Int
+func _bridgeSomethingToAnything(_ something: AnyObject) -> AnyObject
+typealias _InternalTypealias = HeapBuffer<Int, Int>
+```
+
+To apply the rule to an initializer, one of its label arguments *or*
+internal parameter names must start with an underscore:
+
+```
+public struct Foo {
+  init(_count: Int) {}
+  init(_ _otherInitializer: Int) {}
+}
+```
+
+### Note
+
+> The identifier that consists of a single underscore `_` is not
+considered to be a name that starts with an underscore. For example,
+this initializer is public:
+
+```swift
+public struct Foo {
+  init(\_ count: Int) {}
+
+}
+```
+
+The compiler and IDE tools may use the leading underscore rule, combined
+with additional heuristics, to hide stdlib symbols that users don\'t
+need to see.
+
+Users are prohibited to use leading underscores symbols in their own
+source code, even if these symbols are visible through compiler
+diagnostics or IDE tools.