Resolve conflicts with main

.mailmap

@@ -1,7 +1,7 @@
 Adrian-Constantin Popescu <epsilon.gamma@gmail.com> <adrian-constantin.popescu@outlook.com>
 Alex Blewitt <alblue@apple.com> <alex.blewitt@gmail.com>
 Alex Hoppen <alex@alexhoppen.de> <alex@ateamer.de>
-Alex Hoppen <alex@alexhoppen.de> <ahoppen@apple.com>>
+Alex Hoppen <alex@alexhoppen.de> <ahoppen@apple.com>
 Alexis Beingessner <abeingessner@apple.com> <a.beingessner@gmail.com>
 Alper Çugun <github@alper.nl> <alper@users.noreply.github.com>
 Amr Aboelela <amraboelela@gmail.com> <amraboelela@users.noreply.github.com>
@@ -79,6 +79,7 @@ Joe Shajrawi <shajrawi@apple.com> <joeshajrawi@Joes-iMac-Pro.local>
 Johannes Weiß <johannesweiss@apple.com> <github@tux4u.de>
 John Regner <john@johnregner.com> <regnerjr@gmail.com>
 Karoy Lorentey <klorentey@apple.com> <karoly@lorentey.hu>
+Kavon Farvardin <kfarvardin@apple.com> <kavon@farvard.in>
 Keith Smiley <k@keith.so> <keithbsmiley@gmail.com>
 Kevin Ballard <kevin@sb.org> <kevin.ballard@postmates.com>
 Kevin Saldaña <ksaldana1@gmail.com>

benchmark/CMakeLists.txt

@@ -80,6 +80,7 @@ set(SWIFT_BENCH_MODULES
     single-source/DictionaryRemove
     single-source/DictionarySubscriptDefault
     single-source/DictionarySwap
+    single-source/Differentiation
     single-source/Diffing
     single-source/DiffingMyers
     single-source/DropFirst

benchmark/single-source/Differentiation.swift

@@ -0,0 +1,73 @@
+//===--- Differentiation.swift -------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 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
+//
+//===----------------------------------------------------------------------===//
+
+#if canImport(_Differentiation)
+
+import TestsUtils
+import _Differentiation
+
+public let Differentiation = [
+  BenchmarkInfo(
+    name: "DifferentiationIdentity",
+    runFunction: run_DifferentiationIdentity,
+    tags: [.regression, .differentiation]
+  ),
+  BenchmarkInfo(
+    name: "DifferentiationSquare",
+    runFunction: run_DifferentiationSquare,
+    tags: [.regression, .differentiation]
+  ),
+  BenchmarkInfo(
+    name: "DifferentiationArraySum",
+    runFunction: run_DifferentiationArraySum,
+    tags: [.regression, .differentiation],
+    setUpFunction: { blackHole(onesArray) }
+  ),
+]
+
+@inline(never)
+public func run_DifferentiationIdentity(N: Int) {
+  func f(_ x: Float) -> Float {
+    x
+  }
+  for _ in 0..<1000*N {
+    blackHole(valueWithGradient(at: 1, in: f))
+  }
+}
+
+@inline(never)
+public func run_DifferentiationSquare(N: Int) {
+  func f(_ x: Float) -> Float {
+    x * x
+  }
+  for _ in 0..<1000*N {
+    blackHole(valueWithGradient(at: 1, in: f))
+  }
+}
+
+let onesArray: [Float] = Array(repeating: 1, count: 50)
+
+@inline(never)
+public func run_DifferentiationArraySum(N: Int) {
+  func sum(_ array: [Float]) -> Float {
+    var result: Float = 0
+    for i in withoutDerivative(at: 0..<array.count) {
+      result += array[i]
+    }
+    return result
+  }
+  for _ in 0..<N {
+    blackHole(valueWithGradient(at: onesArray, in: sum))
+  }
+}
+
+#endif

benchmark/utils/TestsUtils.swift

@@ -28,7 +28,7 @@ public enum BenchmarkCategory : String {
   case runtime, refcount, metadata
   // Other general areas of compiled code validation.
   case abstraction, safetychecks, exceptions, bridging, concurrency, existential
-  case exclusivity
+  case exclusivity, differentiation
 
   // Algorithms are "micro" that test some well-known algorithm in isolation:
   // sorting, searching, hashing, fibonaci, crypto, etc.

benchmark/utils/main.swift

@@ -69,6 +69,9 @@ import DictionaryOfAnyHashableStrings
 import DictionaryRemove
 import DictionarySubscriptDefault
 import DictionarySwap
+#if canImport(_Differentiation)
+import Differentiation
+#endif
 import Diffing
 import DiffingMyers
 import DropFirst
@@ -258,6 +261,9 @@ registerBenchmark(DictionaryOfAnyHashableStrings)
 registerBenchmark(DictionaryRemove)
 registerBenchmark(DictionarySubscriptDefault)
 registerBenchmark(DictionarySwap)
+#if canImport(_Differentiation)
+registerBenchmark(Differentiation)
+#endif
 registerBenchmark(Diffing)
 registerBenchmark(DiffingMyers)
 registerBenchmark(DropFirst)

cmake/modules/SwiftConfigureSDK.cmake

@@ -297,9 +297,9 @@ macro(configure_sdk_unix name architectures)
         else()
           message(SEND_ERROR "Couldn't find SWIFT_SDK_ANDROID_ARCH_armv7_PATH")
         endif()
-        set(SWIFT_SDK_ANDROID_ARCH_${arch}_TRIPLE "armv7-none-linux-androideabi")
+        set(SWIFT_SDK_ANDROID_ARCH_${arch}_TRIPLE "armv7-unknown-linux-androideabi")
         # The Android ABI isn't part of the module triple.
-        set(SWIFT_SDK_ANDROID_ARCH_${arch}_MODULE "armv7-none-linux-android")
+        set(SWIFT_SDK_ANDROID_ARCH_${arch}_MODULE "armv7-unknown-linux-android")
       elseif("${arch}" STREQUAL "aarch64")
         set(SWIFT_SDK_ANDROID_ARCH_${arch}_NDK_TRIPLE "aarch64-linux-android")
         set(SWIFT_SDK_ANDROID_ARCH_${arch}_ALT_SPELLING "aarch64")

cmake/modules/SwiftManpage.cmake

@@ -39,8 +39,12 @@ function(manpage)
       ALL)
 
   add_dependencies(${MP_INSTALL_IN_COMPONENT} ${manpage_target})
+  set(MANPAGE_DEST "share/")
+  if("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "OPENBSD")
+    set(MANPAGE_DEST "")
+  endif()
   swift_install_in_component(FILES "${output_file_name}"
-                             DESTINATION "share/man/man${MP_MAN_SECTION}"
+                             DESTINATION "${MANPAGE_DEST}man/man${MP_MAN_SECTION}"
                              COMPONENT "${MP_INSTALL_IN_COMPONENT}")
 endfunction()
 

docs/ABI/Mangling.rst

@@ -492,9 +492,11 @@ Types
 
   type ::= 'Bb'                              // Builtin.BridgeObject
   type ::= 'BB'                              // Builtin.UnsafeValueBuffer
+  type ::= 'Bc'                              // Builtin.RawUnsafeContinuation
   type ::= 'Bf' NATURAL '_'                  // Builtin.Float<n>
   type ::= 'Bi' NATURAL '_'                  // Builtin.Int<n>
   type ::= 'BI'                              // Builtin.IntLiteral
+  type ::= 'Bj'                              // Builtin.Job
   type ::= 'BO'                              // Builtin.UnknownObject (no longer a distinct type, but still used for AnyObject)
   type ::= 'Bo'                              // Builtin.NativeObject
   type ::= 'Bp'                              // Builtin.RawPointer
@@ -1006,6 +1008,8 @@ Function Specializations
 ::
 
   specialization ::= type '_' type* 'Tg' SPEC-INFO     // Generic re-abstracted specialization
+  specialization ::= type '_' type* 'TB' SPEC-INFO     // Alternative mangling for generic re-abstracted specializations,
+                                                       // used for functions with re-abstracted resilient parameter types.
   specialization ::= type '_' type* 'Ts' SPEC-INFO     // Generic re-abstracted prespecialization
   specialization ::= type '_' type* 'TG' SPEC-INFO     // Generic not re-abstracted specialization
   specialization ::= type '_' type* 'Ti' SPEC-INFO     // Inlined function with generic substitutions.

docs/Android.md

@@ -103,7 +103,7 @@ $ NDK_PATH="path/to/android-ndk21"
 $ build/Ninja-ReleaseAssert/swift-linux-x86_64/bin/swiftc \     # The Swift compiler built in the previous step.
                                                                 # The location of the tools used to build Android binaries
     -tools-directory ${NDK_PATH}/toolchains/llvm/prebuilt/linux-x86_64/bin/ \
-    -target armv7a-none-linux-androideabi \                     # Targeting android-armv7, and supply the path to libgcc.
+    -target armv7a-unknown-linux-androideabi \                  # Targeting android-armv7, and supply the path to libgcc.
     -L ${NDK_PATH}/toolchains/arm-linux-androideabi-4.9/prebuilt/linux-x86_64/lib/gcc/arm-linux-androideabi/4.9.x/armv7-a \
     -sdk ${NDK_PATH}/platforms/android-21/arch-arm \            # Use the same architecture and API version as you used to build the stdlib in the previous step.
     hello.swift

docs/ContinuousIntegration.md

@@ -215,7 +215,7 @@ preset=buildbot,tools=RA,stdlib=RD,test=non_executable
 
 ### Build and Test the Minimal Freestanding Stdlib using Toolchain Specific Preset Testing
 
-To test the minimal freestanding stdlib on macho, you can use the support for running a miscellanous preset against a snapshot toolchain.
+To test the minimal freestanding stdlib on macho, you can use the support for running a miscellaneous preset against a snapshot toolchain.
 
 ```
 preset=stdlib_S_standalone_minimal_macho_x86_64,build,test

docs/DifferentiableProgramming.md

@@ -1273,6 +1273,12 @@ The synthesized `TangentVector` has the same effective access level as the
 original type declaration. Properties in the synthesized `TangentVector` have
 the same effective access level as their corresponding original properties.
 
+The synthesized `TangentVector` adopts protocols from all `TangentVector`
+conformance constraints implied by the declaration that triggers synthesis. For
+example, synthesized `TangentVector`s always adopt the `AdditiveArithmetic` and
+`Differentiable` protocols because the `Differentiable` protocol requires that
+`TangentVector` conforms to `AdditiveArithmetic` and `Differentiable`.
+
 The synthesized `move(along:)` method calls `move(along:)` for each pair of a
 differentiable variable and its corresponding property in `TangentVector`.
 
@@ -1879,7 +1885,7 @@ Since complex numbers are not yet defined in the standard library, we extended
 the complex number type defined in the
 [NumericAnnex](https://github.com/xwu/NumericAnnex) library to be
 differentiable.
-[The full implementation is here](https://github.com/tensorflow/swift-apis/blob/master/Sources/third_party/Experimental/Complex.swift).
+[The full implementation is here](https://github.com/tensorflow/swift-apis/blob/main/Sources/third_party/Experimental/Complex.swift).
 The implementation adopts the
 [Autograd convention](https://github.com/HIPS/autograd/blob/master/docs/tutorial.md#complex-numbers)
 for derivatives of functions with complex arguments or results, so that we can

include/swift/ABI/Actor.h

@@ -0,0 +1,44 @@
+//===--- Actor.h - ABI structures for actors --------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Swift ABI describing actors.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_ABI_ACTOR_H
+#define SWIFT_ABI_ACTOR_H
+
+#include "swift/ABI/HeapObject.h"
+#include "swift/ABI/MetadataValues.h"
+
+namespace swift {
+
+/// The default actor implementation.  This is the layout of both
+/// the DefaultActor and NSDefaultActor classes.
+class alignas(Alignment_DefaultActor) DefaultActor : public HeapObject {
+public:
+  // These constructors do not initialize the actor instance, and the
+  // destructor does not destroy the actor instance; you must call
+  // swift_defaultActor_{initialize,destroy} yourself.
+  constexpr DefaultActor(const HeapMetadata *metadata)
+    : HeapObject(metadata), PrivateData{} {}
+
+  constexpr DefaultActor(const HeapMetadata *metadata,
+                         InlineRefCounts::Immortal_t immortal)
+    : HeapObject(metadata, immortal), PrivateData{} {}
+
+  void *PrivateData[NumWords_DefaultActor];
+};
+
+} // end namespace swift
+
+#endif

include/swift/ABI/Class.h

@@ -53,7 +53,12 @@ enum class ObjCClassFlags : uint32_t {
   /// This class provides a non-trivial .cxx_destruct method, but
   /// its .cxx_construct is trivial.  For backwards compatibility,
   /// when setting this flag, HasCXXStructors must be set as well.
-  HasCXXDestructorOnly = 0x00100
+  HasCXXDestructorOnly = 0x00100,
+
+  /// This class does not allow associated objects on instances.
+  ///
+  /// Will cause the objc runtime to trap in objc_setAssociatedObject.
+  ForbidsAssociatedObjects = 0x00400,
 };
 inline ObjCClassFlags &operator|=(ObjCClassFlags &lhs, ObjCClassFlags rhs) {
   lhs = ObjCClassFlags(uint32_t(lhs) | uint32_t(rhs));

include/swift/ABI/Executor.h

@@ -0,0 +1,119 @@
+//===--- Executor.h - ABI structures for executors --------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Swift ABI describing executors.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_ABI_EXECUTOR_H
+#define SWIFT_ABI_EXECUTOR_H
+
+#include <inttypes.h>
+
+namespace swift {
+class AsyncContext;
+class AsyncTask;
+class DefaultActor;
+class Job;
+
+/// An ExecutorRef isn't necessarily just a pointer to an executor
+/// object; it may have other bits set.
+class ExecutorRef {
+  static constexpr uintptr_t IsDefaultActor = 1;
+  static constexpr uintptr_t PointerMask = 7;
+
+  uintptr_t Value;
+
+  constexpr ExecutorRef(uintptr_t value) : Value(value) {}
+
+public:
+  /// A generic execution environment.  When running in a generic
+  /// environment, it's presumed to be okay to switch synchronously
+  /// to an actor.  As an executor request, this represents a request
+  /// to drop whatever the current actor is.
+  constexpr static ExecutorRef generic() {
+    return ExecutorRef(0);
+  }
+
+  /// Given a pointer to a default actor, return an executor reference
+  /// for it.
+  static ExecutorRef forDefaultActor(DefaultActor *actor) {
+    assert(actor);
+    return ExecutorRef(reinterpret_cast<uintptr_t>(actor) | IsDefaultActor);
+  }
+
+  /// Is this the generic executor reference?
+  bool isGeneric() const {
+    return Value == 0;
+  }
+
+  /// Is this a default-actor executor reference?
+  bool isDefaultActor() const {
+    return Value & IsDefaultActor;
+  }
+  DefaultActor *getDefaultActor() const {
+    assert(isDefaultActor());
+    return reinterpret_cast<DefaultActor*>(Value & ~PointerMask);
+  }
+
+  /// Do we have to do any work to start running as the requested
+  /// executor?
+  bool mustSwitchToRun(ExecutorRef newExecutor) const {
+    return *this != newExecutor;
+  }
+
+  bool operator==(ExecutorRef other) const {
+    return Value == other.Value;
+  }
+  bool operator!=(ExecutorRef other) const {
+    return Value != other.Value;
+  }
+};
+
+using JobInvokeFunction =
+  SWIFT_CC(swiftasync)
+  void (Job *, ExecutorRef);
+
+using TaskContinuationFunction =
+  SWIFT_CC(swiftasync)
+  void (AsyncTask *, ExecutorRef, AsyncContext *);
+
+template <class Fn>
+struct AsyncFunctionTypeImpl;
+template <class Result, class... Params>
+struct AsyncFunctionTypeImpl<Result(Params...)> {
+  // TODO: expand and include the arguments in the parameters.
+  using type = TaskContinuationFunction;
+};
+
+template <class Fn>
+using AsyncFunctionType = typename AsyncFunctionTypeImpl<Fn>::type;
+
+/// A "function pointer" for an async function.
+///
+/// Eventually, this will always be signed with the data key
+/// using a type-specific discriminator.
+template <class FnType>
+class AsyncFunctionPointer {
+public:
+  /// The function to run.
+  RelativeDirectPointer<AsyncFunctionType<FnType>,
+                        /*nullable*/ false,
+                        int32_t> Function;
+
+  /// The expected size of the context.
+  uint32_t ExpectedContextSize;
+};
+
+}
+
+#endif