Update GettingStarted.md

benchmark/CMakeLists.txt

@@ -44,6 +44,7 @@ set(SWIFT_BENCH_MODULES
     single-source/BitCount
     single-source/Breadcrumbs
     single-source/BucketSort
+    single-source/BufferFill
     single-source/ByteSwap
     single-source/COWTree
     single-source/COWArrayGuaranteedParameterOverhead

benchmark/single-source/BufferFill.swift

@@ -0,0 +1,121 @@
+//===--- BufferFill.swift -------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2020 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
+
+public let BufferFill = [
+  BenchmarkInfo(name: "BufferFillFromSlice",
+                runFunction: bufferFillFromSliceExecute,
+                tags: [.validation, .api],
+                setUpFunction: bufferFillFromSliceSetup,
+                tearDownFunction: bufferFillFromSliceTeardown),
+  BenchmarkInfo(name: "RawBufferCopyBytes",
+                runFunction: rawBufferCopyBytesExecute,
+                tags: [.validation, .api],
+                setUpFunction: rawBufferCopyBytesSetup,
+                tearDownFunction: rawBufferCopyBytesTeardown),
+  BenchmarkInfo(name: "RawBufferInitializeMemory",
+                runFunction: rawBufferInitializeMemoryExecute,
+                tags: [.validation, .api],
+                setUpFunction: rawBufferInitializeMemorySetup,
+                tearDownFunction: rawBufferInitializeMemoryTeardown),
+]
+
+let c = 100_000
+let a = Array(0..<c)
+var b: UnsafeMutableBufferPointer<Int> = .init(start: nil, count: 0)
+var r = Int.zero
+
+public func bufferFillFromSliceSetup() {
+  assert(b.baseAddress == nil)
+  b = .allocate(capacity: c)
+  r = a.indices.randomElement()!
+}
+
+public func bufferFillFromSliceTeardown() {
+  b.deallocate()
+  b = .init(start: nil, count: 0)
+}
+
+@inline(never)
+public func bufferFillFromSliceExecute(n: Int) {
+  // Measure performance when filling an UnsafeBuffer from a Slice
+  // of a Collection that supports `withContiguousStorageIfAvailable`
+  // See: https://bugs.swift.org/browse/SR-14491
+
+  for _ in 0..<n {
+    let slice = Slice(base: a, bounds: a.indices)
+    var (iterator, copied) = b.initialize(from: slice)
+    blackHole(b)
+    CheckResults(copied == a.count && iterator.next() == nil)
+  }
+
+  CheckResults(a[r] == b[r])
+}
+
+var ra: [UInt8] = []
+var rb = UnsafeMutableRawBufferPointer(start: nil, count: 0)
+
+public func rawBufferCopyBytesSetup() {
+  assert(rb.baseAddress == nil)
+  ra = a.withUnsafeBytes(Array.init)
+  r = ra.indices.randomElement()!
+  rb = .allocate(byteCount: ra.count, alignment: 1)
+}
+
+public func rawBufferCopyBytesTeardown() {
+  rb.deallocate()
+  rb = .init(start: nil, count: 0)
+  ra = []
+}
+
+@inline(never)
+public func rawBufferCopyBytesExecute(n: Int) {
+  // Measure performance when copying bytes into an UnsafeRawBuffer
+  // from a Collection that supports `withContiguousStorageIfAvailable`
+  // See: https://bugs.swift.org/browse/SR-14886
+
+  for _ in 0..<n {
+    rb.copyBytes(from: ra)
+    blackHole(rb)
+  }
+
+  CheckResults(ra[r] == rb[r])
+}
+
+public func rawBufferInitializeMemorySetup() {
+  assert(rb.baseAddress == nil)
+  rb = .allocate(byteCount: a.count * MemoryLayout<Int>.stride, alignment: 1)
+  r = a.indices.randomElement()!
+}
+
+public func rawBufferInitializeMemoryTeardown() {
+  rb.deallocate()
+  rb = .init(start: nil, count: 0)
+}
+
+@inline(never)
+public func rawBufferInitializeMemoryExecute(n: Int) {
+  // Measure performance when initializing an UnsafeRawBuffer
+  // from a Collection that supports `withContiguousStorageIfAvailable`
+  // See: https://bugs.swift.org/browse/SR-14982
+
+  for _ in 0..<n {
+    var (iterator, initialized) = rb.initializeMemory(as: Int.self, from: a)
+    blackHole(rb)
+    CheckResults(initialized.count == a.count && iterator.next() == nil)
+  }
+
+  let offset = rb.baseAddress!.advanced(by: r*MemoryLayout<Int>.stride)
+  let value = offset.load(as: Int.self)
+  CheckResults(value == a[r])
+}

benchmark/utils/main.swift

@@ -32,6 +32,7 @@ import BinaryFloatingPointProperties
 import BitCount
 import Breadcrumbs
 import BucketSort
+import BufferFill
 import ByteSwap
 import COWTree
 import COWArrayGuaranteedParameterOverhead
@@ -225,6 +226,7 @@ registerBenchmark(BinaryFloatingPointPropertiesUlp)
 registerBenchmark(BitCount)
 registerBenchmark(Breadcrumbs)
 registerBenchmark(BucketSort)
+registerBenchmark(BufferFill)
 registerBenchmark(ByteSwap)
 registerBenchmark(COWTree)
 registerBenchmark(COWArrayGuaranteedParameterOverhead)

docs/HowToGuides/GettingStarted.md

@@ -130,6 +130,8 @@ Double-check that running `pwd` prints a path ending with `swift`.
 
 ⚠️ Since version 0.2.14, `sccache` no longer caches compile commands issued by `build-script` because of [sccache PR 898](https://github.com/mozilla/sccache/pull/898), since `build-script` adds the `-arch x86_64` argument twice. The instructions below may install `sccache` 0.2.14 or newer. You may want to instead download and install an older release from their [Releases page](https://github.com/mozilla/sccache/releases) until this issue is resolved.
 
+This issue is already resolved in sscache commit 7f8d643c633b240cf33fb5dbd5a89d36b0a0c1e3 at https://github.com/mozilla/sccache/commit/7f8d643c633b240cf33fb5dbd5a89d36b0a0c1e3. However, no current version builds sscache with this change.
+
 1. Install [Xcode 12.3][Xcode] or newer:
    The required version of Xcode changes frequently and is often a beta release.
    Check this document or the host information on <https://ci.swift.org> for the

docs/Testing.md

@@ -350,6 +350,9 @@ code for the target that is not the build machine:
 * ``%target-cc-options``: the clang flags to setup the target with the right
   architecture and platform version.
 
+* ``%target-sanitizer-opt``: if sanitizers are enabled for the build, the
+  corresponding ``-fsanitize=`` option.
+
 * ``%target-triple``: a triple composed of the ``%target-cpu``, the vendor,
   the ``%target-os``, and the operating system version number. Possible values
   include ``i386-apple-ios7.0`` or ``armv7k-apple-watchos2.0``.

include/swift/AST/ASTContext.h

@@ -105,6 +105,7 @@ namespace swift {
   class InheritedProtocolConformance;
   class SelfProtocolConformance;
   class SpecializedProtocolConformance;
+  class BuiltinProtocolConformance;
   enum class ProtocolConformanceState;
   class Pattern;
   enum PointerTypeKind : unsigned;
@@ -1029,6 +1030,12 @@ class ASTContext final {
   SelfProtocolConformance *
   getSelfConformance(ProtocolDecl *protocol);
 
+  /// Produce the builtin conformance for some structural type to some protocol.
+  BuiltinProtocolConformance *
+  getBuiltinConformance(Type type, ProtocolDecl *protocol,
+                        GenericSignature genericSig,
+                        ArrayRef<Requirement> conditionalRequirements);
+
   /// A callback used to produce a diagnostic for an ill-formed protocol
   /// conformance that was type-checked before we're actually walking the
   /// conformance itself, along with a bit indicating whether this diagnostic

include/swift/AST/Attr.def

@@ -621,11 +621,7 @@ SIMPLE_DECL_ATTR(reasync, AtReasync,
   ABIBreakingToAdd | ABIBreakingToRemove | APIBreakingToAdd | APIBreakingToRemove,
   110)
 
-DECL_ATTR(completionHandlerAsync, CompletionHandlerAsync,
-  OnAbstractFunction | ConcurrencyOnly | LongAttribute |
-  ABIStableToAdd | ABIStableToRemove |
-  APIStableToAdd | APIStableToRemove,
-  111)
+// 111 was an experimental @completionHandlerAsync and is now unused
 
 CONTEXTUAL_SIMPLE_DECL_ATTR(nonisolated, Nonisolated,
   DeclModifier | OnFunc | OnConstructor | OnVar | OnSubscript |

include/swift/AST/Attr.h

@@ -629,7 +629,7 @@ class AvailableAttr : public DeclAttribute {
 
   AvailableAttr(SourceLoc AtLoc, SourceRange Range,
                    PlatformKind Platform,
-                   StringRef Message, StringRef Rename,
+                   StringRef Message, StringRef Rename, ValueDecl *RenameDecl,
                    const llvm::VersionTuple &Introduced,
                    SourceRange IntroducedRange,
                    const llvm::VersionTuple &Deprecated,
@@ -639,7 +639,7 @@ class AvailableAttr : public DeclAttribute {
                    PlatformAgnosticAvailabilityKind PlatformAgnostic,
                    bool Implicit)
     : DeclAttribute(DAK_Available, AtLoc, Range, Implicit),
-      Message(Message), Rename(Rename),
+      Message(Message), Rename(Rename), RenameDecl(RenameDecl),
       INIT_VER_TUPLE(Introduced), IntroducedRange(IntroducedRange),
       INIT_VER_TUPLE(Deprecated), DeprecatedRange(DeprecatedRange),
       INIT_VER_TUPLE(Obsoleted), ObsoletedRange(ObsoletedRange),
@@ -660,6 +660,12 @@ class AvailableAttr : public DeclAttribute {
   /// the `NS_SWIFT_NAME` annotation in Objective-C.
   const StringRef Rename;
 
+  /// The declaration referred to by \c Rename. Note that this is only set for
+  /// deserialized attributes or inferred attributes from ObjectiveC code.
+  /// \c ValueDecl::getRenamedDecl should be used to find the declaration
+  /// corresponding to \c Rename.
+  ValueDecl *RenameDecl;
+
   /// Indicates when the symbol was introduced.
   const Optional<llvm::VersionTuple> Introduced;
 
@@ -746,6 +752,11 @@ class AvailableAttr : public DeclAttribute {
                          llvm::VersionTuple Obsoleted
                          = llvm::VersionTuple());
 
+  /// Create an AvailableAttr that indicates the given \p AsyncFunc should be
+  /// preferentially used in async contexts
+  static AvailableAttr *createForAlternative(ASTContext &C,
+                                             AbstractFunctionDecl *AsyncFunc);
+
   AvailableAttr *clone(ASTContext &C, bool implicit) const;
 
   static bool classof(const DeclAttribute *DA) {
@@ -2021,57 +2032,6 @@ class TransposeAttr final
   }
 };
 
-/// The `@completionHandlerAsync` attribute marks a function as having an async
-/// alternative, optionally providing a name (for cases when the alternative
-/// has a different name).
-class CompletionHandlerAsyncAttr final : public DeclAttribute {
-public:
-  /// Reference to the async alternative function. Only set for deserialized
-  /// attributes or inferred attributes from ObjectiveC code.
-  AbstractFunctionDecl *AsyncFunctionDecl;
-
-  /// DeclName of the async function in the attribute. Only set from actual
-  /// Swift code, deserialization/ObjectiveC imports will set the decl instead.
-  const DeclNameRef AsyncFunctionName;
-
-  /// Source location of the async function name in the attribute
-  const SourceLoc AsyncFunctionNameLoc;
-
-  /// The index of the completion handler
-  const size_t CompletionHandlerIndex;
-
-  /// Source location of the completion handler index passed to the index
-  const SourceLoc CompletionHandlerIndexLoc;
-
-  CompletionHandlerAsyncAttr(DeclNameRef asyncFunctionName,
-                             SourceLoc asyncFunctionNameLoc,
-                             size_t completionHandlerIndex,
-                             SourceLoc completionHandlerIndexLoc,
-                             SourceLoc atLoc, SourceRange range)
-      : DeclAttribute(DAK_CompletionHandlerAsync, atLoc, range,
-                      /*implicit*/ false),
-        AsyncFunctionDecl(nullptr),
-        AsyncFunctionName(asyncFunctionName),
-        AsyncFunctionNameLoc(asyncFunctionNameLoc),
-        CompletionHandlerIndex(completionHandlerIndex),
-        CompletionHandlerIndexLoc(completionHandlerIndexLoc) {}
-
-  CompletionHandlerAsyncAttr(AbstractFunctionDecl &asyncFunctionDecl,
-                             size_t completionHandlerIndex,
-                             SourceLoc completionHandlerIndexLoc,
-                             SourceLoc atLoc, SourceRange range,
-                             bool implicit)
-      : DeclAttribute(DAK_CompletionHandlerAsync, atLoc, range,
-                      implicit),
-        AsyncFunctionDecl(&asyncFunctionDecl) ,
-        CompletionHandlerIndex(completionHandlerIndex),
-        CompletionHandlerIndexLoc(completionHandlerIndexLoc) {}
-
-  static bool classof(const DeclAttribute *DA) {
-    return DA->getKind() == DAK_CompletionHandlerAsync;
-  }
-};
-
 /// Attributes that may be applied to declarations.
 class DeclAttributes {
   /// Linked list of declaration attributes.

include/swift/AST/ClangModuleLoader.h

@@ -236,6 +236,8 @@ class ClangModuleLoader : public ModuleLoader {
   instantiateCXXFunctionTemplate(ASTContext &ctx,
                                  clang::FunctionTemplateDecl *func,
                                  SubstitutionMap subst) = 0;
+
+  virtual bool isCXXMethodMutating(const clang::CXXMethodDecl *method) = 0;
 };
 
 /// Describes a C++ template instantiation error.

include/swift/AST/Decl.h

@@ -6196,9 +6196,22 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// constructor.
   bool hasDynamicSelfResult() const;
 
-
+  /// The async function marked as the alternative to this function, if any.
   AbstractFunctionDecl *getAsyncAlternative() const;
 
+  /// If \p asyncAlternative is set, then compare its parameters to this
+  /// (presumed synchronous) function's parameters to find the index of the
+  /// completion handler parameter. This should be the the only missing
+  /// parameter in \p asyncAlternative, ignoring defaulted parameters if they
+  /// have the same label. It must have a void-returning function type and be
+  /// attributed with @escaping but not @autoclosure.
+  ///
+  /// Returns the last index of the parameter that looks like a completion
+  /// handler if \p asyncAlternative is not set (with the same conditions on
+  /// its type as above).
+  Optional<unsigned> findPotentialCompletionHandlerParam(
+      AbstractFunctionDecl *asyncAlternative = nullptr) const;
+
   /// Determine whether this function is implicitly known to have its
   /// parameters of function type be @_unsafeSendable.
   ///

include/swift/AST/DiagnosticsParse.def

@@ -1703,11 +1703,6 @@ ERROR(sil_inst_autodiff_invalid_witness_generic_signature,PointsToFirstBadToken,
       "parameters as original function generic signature '%1'",
       (StringRef, StringRef))
 
-// completionHandlerAsync
-ERROR(attr_completion_handler_async_invalid_name, none,
-      "argument of '%0' attribute must be an identifier or full function name",
-      (StringRef))
-
 //------------------------------------------------------------------------------
 // MARK: Generics parsing diagnostics
 //------------------------------------------------------------------------------

include/swift/AST/DiagnosticsSema.def

@@ -1923,6 +1923,12 @@ ERROR(type_cannot_conform, none,
 NOTE(only_concrete_types_conform_to_protocols,none,
      "only concrete types such as structs, enums and classes can conform to protocols",
      ())
+NOTE(nonsendable_function_type,none,
+     "a function type must be marked '@Sendable' to conform to 'Sendable'", ())
+NOTE(nonsendable_tuple_type,none,
+     "a tuple type must be composed of 'Sendable' elements to conform to "
+     "'Sendable'", ())
+
 NOTE(required_by_opaque_return,none,
     "required by opaque return type of %0 %1", (DescriptiveDeclKind, DeclName))
 NOTE(required_by_decl,none,
@@ -3387,32 +3393,6 @@ ERROR(diff_params_clause_param_not_differentiable,none,
       "'Differentiable', but %0 does not conform to 'Differentiable'", (Type))
 
 // completionHanderAsync attribute
-ERROR(attr_completion_handler_async_handler_not_func,none,
-      "'%0' should be attached to a non-async completion-handler function",
-      (DeclAttribute))
-
-NOTE(note_attr_function_declared_async,none,
-     "function declared async", ())
-
-NOTE(note_attr_completion_function_must_return_void,none,
-     "completion handler must return 'Void'", ())
-
-NOTE(note_attr_completion_handler_async_type_is_not_function,none,
-     "%0 is not a function type", (Type))
-
-NOTE(note_attr_completion_handler_async_handler_attr_req,none,
-     "completion handler must%select{ not|}0 be '@%1'",
-     (bool, StringRef))
-
-ERROR(attr_completion_handler_async_handler_out_of_range,none,
-      "completion handler index out of range of the function parameters", ())
-
-ERROR(attr_completion_handler_async_ambiguous_function,none,
-      "ambiguous '%0' async function %1", (DeclAttribute, DeclNameRef))
-
-ERROR(attr_completion_handler_async_no_suitable_function,none,
-      "no corresponding async function named %0", (DeclNameRef))
-
 WARNING(warn_use_async_alternative,none,
         "consider using asynchronous alternative function",())