[pull] swiftwasm from master

CMakeLists.txt

@@ -147,24 +147,20 @@ set(SWIFT_COMPILER_VERSION "" CACHE STRING
 set(CLANG_COMPILER_VERSION "" CACHE STRING
     "The internal version of the Clang compiler")
 
-# Indicate whether Swift should attempt to use the lld linker.
-if(CMAKE_SYSTEM_NAME STREQUAL Windows AND NOT CMAKE_HOST_SYSTEM_NAME STREQUAL Windows)
-  set(SWIFT_ENABLE_LLD_LINKER_default TRUE)
+# Which default linker to use. Prefer LLVM_USE_LINKER if it set, otherwise use
+# our own defaults. This should only be possible in a unified (not stand alone)
+# build environment.
+if(LLVM_USE_LINKER)
+  set(SWIFT_USE_LINKER_default "${LLVM_USE_LINKER}")
+elseif(CMAKE_SYSTEM_NAME STREQUAL Windows AND NOT CMAKE_HOST_SYSTEM_NAME STREQUAL Windows)
+  set(SWIFT_USE_LINKER_default "lld")
+elseif(CMAKE_SYSTEM_NAME STREQUAL Darwin)
+  set(SWIFT_USE_LINKER_default "")
 else()
-  set(SWIFT_ENABLE_LLD_LINKER_default FALSE)
+  set(SWIFT_USE_LINKER_default "gold")
 endif()
-set(SWIFT_ENABLE_LLD_LINKER ${SWIFT_ENABLE_LLD_LINKER_default} CACHE BOOL
-    "Enable using the lld linker when available")
-
-# Indicate whether Swift should attempt to use the gold linker.
-# This is not used on Darwin.
-if(CMAKE_SYSTEM_NAME STREQUAL Darwin OR CMAKE_SYSTEM_NAME STREQUAL Windows)
-  set(SWIFT_ENABLE_GOLD_LINKER_default FALSE)
-else()
-  set(SWIFT_ENABLE_GOLD_LINKER_default TRUE)
-endif()
-set(SWIFT_ENABLE_GOLD_LINKER ${SWIFT_ENABLE_GOLD_LINKER_default} CACHE BOOL
-    "Enable using the gold linker when available")
+set(SWIFT_USE_LINKER ${SWIFT_USE_LINKER_default} CACHE STRING
+    "Build Swift with a non-default linker")
 
 set(SWIFT_TOOLS_ENABLE_LTO OFF CACHE STRING "Build Swift tools with LTO. One
     must specify the form of LTO by setting this to one of: 'full', 'thin'. This

README.md

@@ -154,8 +154,6 @@ with version 2 shipped with Ubuntu.
 
 **Note:** For Ubuntu 20.04, use `libpython2-dev` in place of the libpython-dev package above.
 
-Build instructions for Ubuntu 14.04 LTS can be found [here](docs/Ubuntu14.md).
-
 ### Getting Sources for Swift and Related Projects
 
 First create a directory for all of the Swift sources:

cmake/modules/AddSwift.cmake

@@ -116,7 +116,7 @@ function(_add_host_variant_c_compile_link_flags name)
   if(SWIFT_HOST_VARIANT_SDK STREQUAL ANDROID)
     # lld can handle targeting the android build.  However, if lld is not
     # enabled, then fallback to the linker included in the android NDK.
-    if(NOT SWIFT_ENABLE_LLD_LINKER)
+    if(NOT SWIFT_USE_LINKER STREQUAL "lld")
       swift_android_tools_path(${SWIFT_HOST_VARIANT_ARCH} tools_path)
       target_compile_options(${name} PRIVATE -B${tools_path})
     endif()
@@ -368,12 +368,9 @@ function(_add_host_variant_link_flags target)
   endif()
 
   if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
-    if(SWIFT_ENABLE_LLD_LINKER)
+    if(SWIFT_USE_LINKER)
       target_link_options(${target} PRIVATE
-        -fuse-ld=lld$<$<STREQUAL:${CMAKE_HOST_SYSTEM_NAME},Windows>:.exe>)
-    elseif(SWIFT_ENABLE_GOLD_LINKER)
-      target_link_options(${target} PRIVATE
-        -fuse-ld=gold$<$<STREQUAL:${CMAKE_HOST_SYSTEM_NAME},Windows>:.exe>)
+        -fuse-ld=${SWIFT_USE_LINKER}$<$<STREQUAL:${CMAKE_HOST_SYSTEM_NAME},Windows>:.exe>)
     endif()
   endif()
 

cmake/modules/AddSwiftUnittests.cmake

@@ -57,15 +57,9 @@ function(add_swift_unittest test_dirname)
       _ENABLE_EXTENDED_ALIGNED_STORAGE)
   endif()
 
-  find_program(LDLLD_PATH "ld.lld")
-  # Strangely, macOS finds lld and then can't find it when using -fuse-ld=
-  if(SWIFT_ENABLE_LLD_LINKER AND LDLLD_PATH AND NOT APPLE)
+  if(SWIFT_USE_LINKER)
     set_property(TARGET "${test_dirname}" APPEND_STRING PROPERTY
-      LINK_FLAGS " -fuse-ld=lld")
-  elseif(SWIFT_ENABLE_GOLD_LINKER AND
-     "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_OBJECT_FORMAT}" STREQUAL "ELF")
-    set_property(TARGET "${test_dirname}" APPEND_STRING PROPERTY
-      LINK_FLAGS " -fuse-ld=gold")
+      LINK_FLAGS " -fuse-ld=${SWIFT_USE_LINKER}")
   endif()
 
   if(SWIFT_ANALYZE_CODE_COVERAGE)

docs/DifferentiableProgramming.md

@@ -1079,11 +1079,6 @@ public extension Differentiable where Self == TangentVector {
     mutating func move(along direction: TangentVector) {
         self += direction
     }
-
-    @noDerivative
-    var zeroTangentVectorInitializer: () -> TangentVector {
-        { .zero }
-    }
 }
 ```
 
@@ -1144,8 +1139,8 @@ extension Array: Differentiable where Element: Differentiable {
 
     @noDerivative
     public var zeroTangentVectorInitializer: () -> TangentVector {
-        { [count = self.count] in
-            TangentVector(Array(repeating: .zero, count: count))
+        { [zeroInits = map(\.zeroTangentVectorInitializer)] in
+            TangentVector(zeroInits.map { $0() })
         }
     }
 }
@@ -1238,8 +1233,15 @@ the same effective access level as their corresponding original properties.
 
 A `move(along:)` method is synthesized with a body that calls `move(along:)` for
 each pair of the original property and its corresponding property in
-`TangentVector`. Similarly, `zeroTangentVector` is synthesized to return a
-tangent vector that consists of each stored property's `zeroTangentVector`.
+`TangentVector`.
+
+Similarly, when memberwise derivation is possible,
+`zeroTangentVectorInitializer` is synthesized to return a closure that captures
+and calls each stored property's `zeroTangentVectorInitializer` closure.
+When memberwise derivation is not possible (e.g. for custom user-defined
+`TangentVector` types), `zeroTangentVectorInitializer` is synthesized as a
+`{ TangentVector.zero }` closure.
+
 Here's an example:
 
 ```swift
@@ -1251,14 +1253,17 @@ struct Foo<T: Differentiable, U: Differentiable>: @memberwise Differentiable {
     @noDerivative let helperVariable: T
 
     // The compiler synthesizes:
+    //
     //     struct TangentVector: Differentiable, AdditiveArithmetic {
     //         var x: T.TangentVector
     //         var y: U.TangentVector
     //     }
+    //
     //     mutating func move(along direction: TangentVector) {
     //         x.move(along: direction.x)
     //         y.move(along: direction.y)
     //     }
+    //
     //     @noDerivative
     //     var zeroTangentVectorInitializer: () -> TangentVector {
     //         { [xTanInit = x.zeroTangentVectorInitializer,
@@ -1278,16 +1283,25 @@ properties are declared to conform to `AdditiveArithmetic`. There are no
 `@noDerivative` stored properties.
 
 In these cases, the compiler will make `TangentVector` be a type alias for Self.
-Method `move(along:)` and property `zeroTangentVector` will not be synthesized
-because a default implementation already exists.
+Method `move(along:)` will not be synthesized because a default implementation
+already exists.
 
 ```swift
 struct Point<T: Real>: @memberwise Differentiable, @memberwise AdditiveArithmetic {
     // `x` and `y` are the "differentiation properties".
     var x, y: T
 
     // The compiler synthesizes:
+    //
     //     typealias TangentVector = Self
+    //
+    //     @noDerivative
+    //     var zeroTangentVectorInitializer: () -> TangentVector {
+    //         { [xTanInit = x.zeroTangentVectorInitializer,
+    //            yTanInit = y.zeroTangentVectorInitializer] in
+    //             TangentVector(x: xTanInit(), y: yTanInit())
+    //         }
+    //     }
 }
 ```
 

docs/WindowsBuild.md

@@ -1,6 +1,6 @@
 # Building Swift on Windows
 
-Visual Studio 2017 or newer is needed to build Swift on Windows.
+Visual Studio 2017 or newer is needed to build Swift on Windows. The free Community edition is sufficient to build Swift.
 
 The commands below (with the exception of installing Visual Studio) must be entered in the "**x64 Native** Tools Command Prompt for VS2017" (or VS2019, VS2019 Preview depending on the Visual Studio that you are using) in the Start Menu. This sets environment variables to select the correct target platform.
 
@@ -32,7 +32,7 @@ The command above already installs Python 2 and 3. Alternatively, in the Visual
 
 1. Install *Python 2*, either the 32-bit version (C:\Python27\\) or the 64-bit version (C:\Python27amd64\\)
 
-> If you install the 64-bit version only, you will need to adjust `PYTHON_EXECUTABLE` below to `C:\Python27amd64\python.exe`
+   **Note:** If you install the 64-bit version only, you will need to adjust `PYTHON_EXECUTABLE` below to `C:\Python27amd64\python.exe`
 
 2. Install *Python 3 64 bits (3.7.x)*
 
@@ -150,6 +150,9 @@ cmake -B "S:\b\toolchain" ^
 ninja -C S:\b\toolchain
 ```
 
+**Note:** If you installed only the 64-bit version of Python, you will need to adjust `PYTHON_EXECUTABLE` argument to `C:\Python27amd64\python.exe`
+
+
 ## Running Swift tests on Windows
 
 ```cmd

include/swift/ABI/Metadata.h

@@ -1025,7 +1025,7 @@ struct TargetAnyClassMetadata : public TargetHeapMetadata<Runtime> {
   using TargetMetadata<Runtime>::setClassISA;
 #endif
 
-  // Note that ObjC classes does not have a metadata header.
+  // Note that ObjC classes do not have a metadata header.
 
   /// The metadata for the superclass.  This is null for the root class.
   ConstTargetMetadataPointer<Runtime, swift::TargetClassMetadata> Superclass;

include/swift/AST/Attr.def

@@ -126,7 +126,7 @@ DECL_ATTR(available, Available,
 CONTEXTUAL_SIMPLE_DECL_ATTR(final, Final,
   OnClass | OnFunc | OnAccessor | OnVar | OnSubscript |
   DeclModifier |
-  ABIBreakingToAdd | ABIBreakingToRemove | APIBreakingToAdd | APIStableToRemove,
+  ABIBreakingToAdd | ABIBreakingToRemove | APIStableToAdd | APIStableToRemove,
   2)
 DECL_ATTR(objc, ObjC,
   OnAbstractFunction | OnClass | OnProtocol | OnExtension | OnVar |

include/swift/AST/KnownIdentifiers.def

@@ -223,6 +223,7 @@ IDENTIFIER(move)
 IDENTIFIER(pullback)
 IDENTIFIER(TangentVector)
 IDENTIFIER(zero)
+IDENTIFIER(zeroTangentVectorInitializer)
 
 #undef IDENTIFIER
 #undef IDENTIFIER_

include/swift/AST/Types.h

@@ -852,7 +852,17 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// \returns The superclass of this type, or a null type if it has no
   ///          superclass.
   Type getSuperclass(bool useArchetypes = true);
-
+
+  /// Retrieve the root class of this type by repeatedly retrieving the
+  /// superclass.
+  ///
+  /// \param useArchetypes Whether to use context archetypes for outer generic
+  /// parameters if the class is nested inside a generic function.
+  ///
+  /// \returns The base class of this type, or this type itself if it has no
+  ///          superclasses.
+  Type getRootClass(bool useArchetypes = true);
+
   /// True if this type is the exact superclass of another type.
   ///
   /// \param ty       The potential subclass.

include/swift/Basic/LLVM.h

@@ -36,8 +36,8 @@ namespace llvm {
   template <typename T, unsigned N> class SmallPtrSet;
 #if !defined(swiftCore_EXPORTS)
   template <typename T> class SmallVectorImpl;
-#endif
   template <typename T, unsigned N> class SmallVector;
+#endif
   template <unsigned N> class SmallString;
   template <typename T, unsigned N> class SmallSetVector;
 #if !defined(swiftCore_EXPORTS)
@@ -86,8 +86,8 @@ namespace swift {
   using llvm::SmallPtrSetImpl;
   using llvm::SmallSetVector;
   using llvm::SmallString;
-  using llvm::SmallVector;
 #if !defined(swiftCore_EXPORTS)
+  using llvm::SmallVector;
   using llvm::SmallVectorImpl;
 #endif
   using llvm::StringLiteral;

include/swift/Demangling/DemangleNodes.def

@@ -287,5 +287,9 @@ NODE(OpaqueTypeDescriptorAccessorVar)
 NODE(OpaqueReturnType)
 CONTEXT_NODE(OpaqueReturnTypeOf)
 
+// Added in Swift 5.3
+NODE(CanonicalSpecializedGenericMetaclass)
+NODE(CanonicalSpecializedGenericTypeMetadataAccessFunction)
+
 #undef CONTEXT_NODE
 #undef NODE

include/swift/Demangling/TypeDecoder.h

@@ -361,7 +361,7 @@ class TypeDecoder {
       if (Node->getNumChildren() < 2)
         return BuiltType();
 
-      SmallVector<BuiltType, 8> args;
+      llvm::SmallVector<BuiltType, 8> args;
 
       const auto &genericArgs = Node->getChild(1);
       if (genericArgs->getKind() != NodeKind::TypeList)
@@ -474,7 +474,7 @@ class TypeDecoder {
         return BuiltType();
 
       // Find the protocol list.
-      SmallVector<BuiltProtocolDecl, 8> Protocols;
+      llvm::SmallVector<BuiltProtocolDecl, 8> Protocols;
       auto TypeList = Node->getChild(0);
       if (TypeList->getKind() == NodeKind::ProtocolList &&
           TypeList->getNumChildren() >= 1) {
@@ -576,7 +576,7 @@ class TypeDecoder {
         return BuiltType();
 
       bool hasParamFlags = false;
-      SmallVector<FunctionParam<BuiltType>, 8> parameters;
+      llvm::SmallVector<FunctionParam<BuiltType>, 8> parameters;
       if (!decodeMangledFunctionInputType(Node->getChild(isThrow ? 1 : 0),
                                           parameters, hasParamFlags))
         return BuiltType();
@@ -598,9 +598,9 @@ class TypeDecoder {
     }
     case NodeKind::ImplFunctionType: {
       auto calleeConvention = ImplParameterConvention::Direct_Unowned;
-      SmallVector<ImplFunctionParam<BuiltType>, 8> parameters;
-      SmallVector<ImplFunctionResult<BuiltType>, 8> results;
-      SmallVector<ImplFunctionResult<BuiltType>, 8> errorResults;
+      llvm::SmallVector<ImplFunctionParam<BuiltType>, 8> parameters;
+      llvm::SmallVector<ImplFunctionResult<BuiltType>, 8> results;
+      llvm::SmallVector<ImplFunctionResult<BuiltType>, 8> errorResults;
       ImplFunctionTypeFlags flags;
 
       for (unsigned i = 0; i < Node->getNumChildren(); i++) {
@@ -684,7 +684,7 @@ class TypeDecoder {
       return decodeMangledType(Node->getChild(0));
 
     case NodeKind::Tuple: {
-      SmallVector<BuiltType, 8> elements;
+      llvm::SmallVector<BuiltType, 8> elements;
       std::string labels;
       bool variadic = false;
       for (auto &element : *Node) {