Merge remote-tracking branch 'apple/main' into katei/merge-main-2022-07-01

Author: kateinoigakukun

CHANGELOG.md

@@ -5,6 +5,20 @@ _**Note:** This is in reverse chronological order, so newer entries are added to
 
 ## Swift 5.7
 
+* The Swift compiler no longer warns about redundant requirements in generic declarations. For example,
+  the following code diagnosed a warning in Swift 5.6 about the `T.Iterator : IteratorProtocol`
+  requirement being redundant, because it is implied by `T : Sequence`:
+
+  ```swift
+  func firstElement<T: Sequence>(_: T) -> T.Element where T.Iterator: IteratorProtocol {...}
+  ```
+
+  A redundant requirement does not indicate a coding error, and sometimes it is desirable to spell them
+  out for documentation purposes. For this reason these warnings are now disabled by default.
+
+  To restore the previous behavior, pass the `-Xfrontend -warn-redundant-requirements`
+  compiler flag.
+
 * [SE-0338][]:
 
   Non-isolated async functions now always execute on the global concurrent pool,
@@ -41,25 +55,29 @@ _**Note:** This is in reverse chronological order, so newer entries are added to
 * [SE-0350][]:
 
   The standard library has a new `Regex<Output>` type.
-  
+
   This type represents an _extended regular expression_, allowing more fluent
   string processing operations. A `Regex` may be created by
   [initialization from a string][SE-0355]:
-  ```
+
+  ```swift
   let pattern = "a[bc]+" // matches "a" followed by one or more instances
                          // of either "b" or "c"
   let regex = try! Regex(pattern)
   ```
+
   Or via a [regex literal][SE-0354]:
-  ```
+
+  ```swift
   let regex = #/a[bc]+/#
   ```
+
   In Swift 6, `/` will also be supported as a delimiter for `Regex` literals.
   You can enable this mode in Swift 5.7 with the `-enable-bare-slash-regex`
   flag. Doing so will cause some existing expressions that use `/` as an 
   operator to no longer compile; you can add parentheses or line breaks as a
   workaround.
-  
+
   There are [new string-processing algorithms][SE-0357] that support
   `String`, `Regex` and arbitrary `Collection` types.
 
@@ -151,7 +169,7 @@ _**Note:** This is in reverse chronological order, so newer entries are added to
   Protocols with primary associated types can now be used in existential types,
   enabling same-type constraints on those associated types.
 
-  ```
+  ```swift
   let strings: any Collection<String> = [ "Hello" ]
   ```
 
@@ -494,12 +512,12 @@ _**Note:** This is in reverse chronological order, so newer entries are added to
   struct S {
     @available(macOS 99, *) // error: stored properties cannot be marked potentially unavailable with '@available'
     lazy var a: Int = 42
-  
+
     @available(macOS 99, *) // error: stored properties cannot be marked potentially unavailable with '@available'
     @Wrapper var b: Int
   }
   ```
-  
+
 * The compiler now correctly emits warnings for more kinds of expressions where a protocol conformance is used and may be unavailable at runtime. Previously, member reference expressions and type erasing expressions that used potentially unavailable conformances were not diagnosed, leading to potential crashes at runtime.
 
   ```swift

cmake/modules/SwiftConfigureSDK.cmake

@@ -282,6 +282,21 @@ macro(configure_sdk_unix name architectures)
   endif()
   set(SWIFT_SDK_${prefix}_USE_ISYSROOT FALSE)
 
+  # GCC on Linux is usually located under `/usr`.
+  # However, Ubuntu 20.04 ships with another GCC installation under `/`, which
+  # does not include libstdc++. Swift build scripts pass `--sysroot=/` to
+  # Clang. By default, Clang tries to find GCC installation under sysroot, and
+  # if it doesn't exist, under `{sysroot}/usr`. On Ubuntu 20.04 and newer, it
+  # attempts to use the GCC without the C++ stdlib, which causes a build
+  # failure. To fix that, we tell Clang explicitly to use GCC from `/usr`.
+  # FIXME: This is a compromise. The value might depend on the architecture
+  # but add_swift_target_library does not allow passing different values
+  # depending on the architecture, so having a single value is the only
+  # possibility right now.
+  set(SWIFT_SDK_${prefix}_CXX_OVERLAY_SWIFT_COMPILE_FLAGS
+      -Xcc --gcc-toolchain=/usr
+    CACHE STRING "Extra flags for compiling the C++ overlay")
+
   foreach(arch ${architectures})
     if("${prefix}" STREQUAL "ANDROID")
       swift_android_sysroot(android_sysroot)

docs/ABI/Mangling.rst

@@ -638,7 +638,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 requirement* '_' 'XP'   // constrained existential type
   type ::= type-list 't'                     // tuple
   type ::= type generic-signature 'u'        // generic type
   type ::= 'x'                               // generic param, depth=0, idx=0
@@ -879,6 +879,7 @@ now codified into the ABI; the index 0 is therefore reserved.
   GENERIC-PARAM-INDEX ::= 'z'                // depth = 0,   idx = 0
   GENERIC-PARAM-INDEX ::= INDEX              // depth = 0,   idx = N+1
   GENERIC-PARAM-INDEX ::= 'd' INDEX INDEX    // depth = M+1, idx = N
+  GENERIC-PARAM-INDEX ::= 's'                // depth = 0,   idx = 0; Constrained existential 'Self' type
 
   LAYOUT-CONSTRAINT ::= 'N'  // NativeRefCountedObject
   LAYOUT-CONSTRAINT ::= 'R'  // RefCountedObject

docs/HowToGuides/GettingStarted.md

@@ -376,7 +376,7 @@ In project settings, locate `Build, Execution, Deployment > CMake`. You will nee
     - `-D SWIFT_PATH_TO_CMARK_BUILD=SOME_PATH/swift-project/build/Ninja-RelWithDebInfoAssert/cmark-macosx-arm64 -D LLVM_DIR=SOME_PATH/swift-project/build/Ninja-RelWithDebInfoAssert/llvm-macosx-arm64/lib/cmake/llvm -D Clang_DIR=SOME_PATH/swift-project/build/Ninja-RelWithDebInfoAssert/llvm-macosx-arm64/lib/cmake/clang -D CMAKE_BUILD_TYPE=RelWithDebInfoAssert -G Ninja -S .`
     - replace the `SOME_PATH` to the path where your `swift-project` directory is
     - the CMAKE_BUILD_TYPE should match the build configuration name, so if you named this profile `RelWithDebInfo` the CMAKE_BUILD_TYPE should also be `RelWithDebInfo`
-    - **Note**: If you're using an intel machine to build swift, you'll need to replace the architecture in the options. (ex: `arm64` with `x86_64`)
+    - **Note**: If you're using an Intel machine to build swift, you'll need to replace the architecture in the options. (ex: `arm64` with `x86_64`)
 
 With this done, CLion should be able to successfully import the project and have full autocomplete and code navigation powers.
 

docs/SILInitializerConventions.md

@@ -0,0 +1,184 @@
+# SIL Initializer Conventions
+
+A nominal type can define a number of initializers, some of which may
+delegate initialization to another initializer. There are specific calling
+conventions for these initializers within SIL that make up a part of the ABI
+for a type. This document aims to summarize the key calling conventions for
+these initializers.
+
+
+# Structs and Enums
+
+The delegation status for the initializer of a struct or enum is not encoded
+in the definitions of these initializers. Thus, all of these initializers
+have an implicit `metatype` argument for the instance to be passed in as the
+last argument to the initializer. Using `<...>` as a stand-in for other
+arguments that are part of the usual function calling convention, consider this
+example:
+
+```swift
+// the non-delegating init MyStruct.init(final:)
+sil hidden [ossa] @$s4test8MyStructV5finalACSi_tcfC : $@convention(method) (<...>, @thin MyStruct.Type) -> MyStruct {
+bb0(<...>, %meta : $@thin MyStruct.Type):
+  %a = alloc_box ${ var MyStruct }, var, name "self"
+  %b = mark_uninitialized [rootself] %a : ${ var MyStruct }
+  %c = begin_borrow [lexical] %b : ${ var MyStruct }
+  %d = project_box %c : ${ var MyStruct }, 0
+  
+  // ... initialize properties, etc ...
+  
+  %end = load [trivial] %d : $*MyStruct
+  end_borrow %c : ${ var MyStruct }
+  destroy_value %b : ${ var MyStruct }
+  return %end : $MyStruct
+}
+
+
+// the delegating init MyStruct.init(delegates:)
+sil hidden [ossa] @$s4test8MyStructV9delegatesACyt_tcfC : $@convention(method) (<...>, @thin MyStruct.Type) -> MyStruct {
+bb0(<...>, %meta : $@thin MyStruct.Type):
+  // Same allocation as the non-delegating:
+  %a = alloc_box ${ var MyStruct }, var, name "self"
+  %b = mark_uninitialized [rootself] %a : ${ var MyStruct }
+  %c = begin_borrow [lexical] %b : ${ var MyStruct }
+  %d = project_box %c : ${ var MyStruct }, 0
+  
+  // ... delegate to MyStruct.init(final:) ...
+  
+  %ctor = function_ref @$s4test8MyStructV5finalACSi_tcfC : $@convention(method) (Int, @thin MyStruct.Type) -> MyStruct
+  %ret = apply %ctor(<...>, %meta) : $@convention(method) (Int, @thin MyStruct.Type) -> MyStruct
+  
+  assign %ret to %d : $*MyStruct
+  %end = load [trivial] %d : $*MyStruct
+  end_borrow %c : ${ var MyStruct }
+  destroy_value %b : ${ var MyStruct }
+  return %end : $MyStruct
+}
+```
+
+It's important to note that all initializers take a metadata argument, 
+regardless of whether it is a delegating initializer. There is also no
+separation between allocating and non-allocating initializer entrypoints.
+All initializers may perform allocation.
+
+# Classes
+
+Every designated initializer has two entry-points. One performs allocation 
+(i.e., the "allocating" entry) before continuing at the second entrypoint 
+which does the initialization (i.e., the "initializing" entrypoint). 
+Here's an example of `MyClass.init(final:)`, which is a designated initializer,
+with its two entry-points:
+
+```swift
+// MyClass.__allocating_init(final:)
+sil hidden [exact_self_class] [ossa] @$s4test7MyClassC5finalACSi_tcfC : $@convention(method) (<...>, @thick MyClass.Type) -> @owned MyClass {
+bb0(%0 : $Int, %1 : $@thick MyClass.Type):
+  %2 = alloc_ref $MyClass
+  // function_ref MyClass.init(final:)
+  %3 = function_ref @$s4test7MyClassC5finalACSi_tcfc : $@convention(method) (Int, @owned MyClass) -> @owned MyClass
+  %4 = apply %3(%0, %2) : $@convention(method) (Int, @owned MyClass) -> @owned MyClass // user: %5
+  return %4 : $MyClass
+}
+
+// MyClass.init(final:)
+sil hidden [ossa] @$s4test7MyClassC5finalACSi_tcfc : $@convention(method) (Int, @owned MyClass) -> @owned MyClass {
+bb0(<...>, %1 : @owned $MyClass):
+  %4 = mark_uninitialized [rootself] %1 : $MyClass
+  
+  // ... initialize MyClass ...
+  
+  %11 = copy_value %4 : $MyClass
+  destroy_value %4 : $MyClass
+  return %11 : $MyClass
+}
+```
+
+In the mangling of these entrypoint labels, the uppercase `C` suffix indicates
+that it's the allocating entrypoint, whereas the lowercase `c` is the 
+initializing entrypoint. Only the allocating entrypoint is published in the
+type's vtable:
+
+```swift
+sil_vtable MyClass {
+  // ...
+  #MyClass.init!allocator: (MyClass.Type) -> (<...>) -> MyClass : @$s4test7MyClassC5finalACSi_tcfC	// MyClass.__allocating_init(final:)
+}
+```
+
+The initializing entrypoint is only referenced by either it's corresponding
+allocating entrypoint, or by a sub-class that is delegating up in a `super.init`
+call. For example, if we had:
+
+```swift
+class MyClass {
+  var x: Int
+  init(final x: Int) {
+    self.x = x
+  }
+}
+
+class MyDerivedClass: MyClass {
+  var y: Int
+  init(subFinal y: Int) {
+    self.y = y
+    super.init(final: y)
+  }
+}
+```
+
+Then the `super.init(final: y)` call directly invokes `MyClass.init(final:)`'s
+initializing entrypoint, bypassing its allocating init. Here's what that looks
+like in SIL:
+
+```
+// MyDerivedClass.__allocating_init(final:)
+sil hidden [exact_self_class] [ossa] @$s4test14MyDerivedClassC5finalACSi_tcfC : $@convention(method) (Int, @thick MyDerivedClass.Type) -> @owned MyDerivedClass {
+  // ... calls $s4test14MyDerivedClassC5finalACSi_tcfc in the usual way ...
+}
+
+// MyDerivedClass.init(final:)
+sil hidden [ossa] @$s4test14MyDerivedClassC5finalACSi_tcfc : $@convention(method) (Int, @owned MyDerivedClass) -> @owned MyDerivedClass {
+bb0(%0 : $Int, %1 : @owned $MyDerivedClass):
+  %2 = alloc_box ${ var MyDerivedClass }, let, name "self"
+  %3 = mark_uninitialized [derivedself] %2 : ${ var MyDerivedClass }
+  %4 = begin_borrow [lexical] %3 : ${ var MyDerivedClass }
+  %5 = project_box %4 : ${ var MyDerivedClass }, 0
+  debug_value %0 : $Int, let, name "y", argno 1
+  store %1 to [init] %5 : $*MyDerivedClass
+  
+  // ... initialize self.y ...
+  
+  // perform the super call. notice the ownership transfer to the super.init.
+  %14 = load [take] %5 : $*MyDerivedClass
+  %15 = upcast %14 : $MyDerivedClass to $MyClass
+  // function_ref MyClass.init(final:)
+  %16 = function_ref @$s4test7MyClassC5finalACSi_tcfc : $@convention(method) (Int, @owned MyClass) -> @owned MyClass // user: %17
+  %17 = apply %16(%0, %15) : $@convention(method) (Int, @owned MyClass) -> @owned MyClass // user: %18
+  %18 = unchecked_ref_cast %17 : $MyClass to $MyDerivedClass
+  store %18 to [init] %5 : $*MyDerivedClass       // id: %19
+  
+  // return as usual
+  %20 = load [copy] %5 : $*MyDerivedClass
+  end_borrow %4 : ${ var MyDerivedClass }
+  destroy_value %3 : ${ var MyDerivedClass }
+  return %20 : $MyDerivedClass
+}
+```
+
+# Actors
+
+There does not exist a sub-actor that inherits from some other actor in the type
+system. As a result, the `convenience` keyword is not required for actor 
+initializers in the source code. Without inheritance, only the allocating
+entry-points can ever be used by an actor. 
+
+Nevertheless, internally the compiler will still differentiate between 
+convenience and designated initializers. So everything discussed
+earlier for classes also apply to actors. The body of the initializer determines
+whether the compiler internally treats it as `convenience` or not. For example,
+an internally designated initializer for an actor still emits two entry-points,
+but the initializing entrypoint is exclusively used by its corresponding
+allocating entrypoint.
+
+
+ 

docs/WindowsBuild.md

@@ -102,15 +102,15 @@ Set up the `ucrt`, `visualc`, and `WinSDK` modules by:
 
 - copying `ucrt.modulemap` located at `swift/stdlib/public/Platform/ucrt.modulemap` into
   `${UniversalCRTSdkDir}/Include/${UCRTVersion}/ucrt` as `module.modulemap`
-- copying `visualc.modulemap` located at `swift/stdlib/public/Platform/visualc.modulemap` into `${VCToolsInstallDir}/include` as `module.modulemap`
+- copying `vcruntime.modulemap` located at `swift/stdlib/public/Platform/vcruntime.modulemap` into `${VCToolsInstallDir}/include` as `module.modulemap`
 - copying `winsdk.modulemap` located at `swift/stdlib/public/Platform/winsdk.modulemap` into `${UniversalCRTSdkDir}/Include/${UCRTVersion}/um`
-- and setup the `visualc.apinotes` located at `swift/stdlib/public/Platform/visualc.apinotes` into `${VCToolsInstallDir}/include` as `visualc.apinotes`
+- and setup the `vcruntime.apinotes` located at `swift/stdlib/public/Platform/vcruntime.apinotes` into `${VCToolsInstallDir}/include` as `vcruntime.apinotes`
 
 ```cmd
 mklink "%UniversalCRTSdkDir%\Include\%UCRTVersion%\ucrt\module.modulemap" S:\swift\stdlib\public\Platform\ucrt.modulemap
 mklink "%UniversalCRTSdkDir%\Include\%UCRTVersion%\um\module.modulemap" S:\swift\stdlib\public\Platform\winsdk.modulemap
-mklink "%VCToolsInstallDir%\include\module.modulemap" S:\swift\stdlib\public\Platform\visualc.modulemap
-mklink "%VCToolsInstallDir%\include\visualc.apinotes" S:\swift\stdlib\public\Platform\visualc.apinotes
+mklink "%VCToolsInstallDir%\include\module.modulemap" S:\swift\stdlib\public\Platform\vcruntime.modulemap
+mklink "%VCToolsInstallDir%\include\vcruntime.apinotes" S:\swift\stdlib\public\Platform\vcruntime.apinotes
 ```
 
 Warning: Creating the above links usually requires administrator privileges. The quick and easy way to do this is to open a second developer prompt by right clicking whatever shortcut you used to open the first one, choosing Run As Administrator, and pasting the above commands into the resulting window. You can then close the privileged prompt; this is the only step which requires elevation.

include/swift/AST/ASTContext.h

@@ -537,7 +537,7 @@ class ASTContext final {
   /// Retrieve the declaration of Swift.Error.
   ProtocolDecl *getErrorDecl() const;
   CanType getErrorExistentialType() const;
-  
+
 #define KNOWN_STDLIB_TYPE_DECL(NAME, DECL_CLASS, NUM_GENERIC_PARAMS) \
   /** Retrieve the declaration of Swift.NAME. */ \
   DECL_CLASS *get##NAME##Decl() const; \
@@ -561,7 +561,13 @@ class ASTContext final {
   /// Retrieve the declaration of the "pointee" property of a pointer type.
   VarDecl *getPointerPointeePropertyDecl(PointerTypeKind ptrKind) const;
 
-  /// Retrieve the type Swift.AnyObject.
+  /// Retrieve the type Swift.Any as an existential type.
+  CanType getAnyExistentialType() const;
+
+  /// Retrieve the type Swift.AnyObject as a constraint.
+  CanType getAnyObjectConstraint() const;
+
+  /// Retrieve the type Swift.AnyObject as an existential type.
   CanType getAnyObjectType() const;
 
 #define KNOWN_SDK_TYPE_DECL(MODULE, NAME, DECL_CLASS, NUM_GENERIC_PARAMS) \

include/swift/AST/ASTDemangler.h

@@ -64,6 +64,8 @@ class ASTBuilder {
   using BuiltRequirement = swift::Requirement;
   using BuiltSubstitutionMap = swift::SubstitutionMap;
 
+  static constexpr bool needsToPrecomputeParentGenericContextShapes = false;
+
   explicit ASTBuilder(ASTContext &ctx) : Ctx(ctx) {}
 
   ASTContext &getASTContext() { return Ctx; }
@@ -119,7 +121,8 @@ class ASTBuilder {
 
   Type createProtocolTypeFromDecl(ProtocolDecl *protocol);
 
-  Type createParameterizedProtocolType(Type base, ArrayRef<Type> args);
+  Type createConstrainedExistentialType(Type base,
+                                        ArrayRef<BuiltRequirement> constraints);
 
   Type createExistentialMetatypeType(Type instance,
                      Optional<Demangle::ImplMetatypeRepresentation> repr=None);