Merge branch 'main' into class_templates

Author: hlopko

docs/DifferentiableProgramming.md

@@ -986,44 +986,6 @@ public protocol Differentiable {
     /// equivalent to exponential map, which moves `self` on the geodesic
     /// surface along the given tangent vector.
     mutating func move(along direction: TangentVector)
-    
-    /// A closure that produces a zero tangent vector and does not capture `self`.
-    ///
-    /// In some cases, the zero tangent vector of `self` is equal to
-    /// `TangentVector.zero`. In other cases, the zero tangent vector depends on
-    /// information in `self`, such as shape for an n-dimensional array type.
-    /// For differentiable programming, it is more memory-efficient to define a
-    /// custom `zeroTangentVectorInitializer` property which returns a closure
-    /// that captures and uses only the necessary information to create a zero
-    /// tangent vector. For example:
-    ///
-    /// ```swift
-    /// struct Vector {
-    ///     var scalars: [Float]
-    ///     var count: Int { scalars.count }
-    ///     init(repeating repeatedElement: Float, count: Int) { ... }
-    /// }
-    /// 
-    /// extension Vector: Differentiable {
-    ///     typealias TangentVector = Vector
-    ///
-    ///     @noDerivative
-    ///     var zeroTangentVectorInitializer: () -> TangentVector {
-    ///         let count = self.count
-    ///         return { TangentVector(repeating: 0, count: count) }
-    ///     }
-    /// }
-    /// ```
-    ///
-    @noDerivative
-    var zeroTangentVectorInitializer: () -> TangentVector { get }
-}
-
-extension Differentiable {
-    /// A tangent vector such that `move(along: zeroTangentVector)` will not modify
-    /// `self`.
-    @noDerivative
-    var zeroTangentVector: TangentVector { zeroTangentVectorInitializer() }
 }
 ```
 
@@ -1092,13 +1054,6 @@ public extension Differentiable where Self == TangentVector {
 }
 ```
 
-The `zeroTangentVector` property returns a tangent vector such that calling
-`move(along:)` on the vector will not modify `self`. A zero tangent vector is
-often used in the initialization of mathematical optimization, where tangent
-vectors are initially zero and modified iteratively. This property may be
-different from `TangentVector.zero` because some tangent vectors depend on
-instance properties of `self`, e.g. the `count` property in `Array`.
-
 #### `Differentiable` conformances
 
 Conforming a type to `Differentiable` tells Swift that changes in values of this
@@ -1146,13 +1101,6 @@ extension Array: Differentiable where Element: Differentiable {
             self[i].move(along: Element.TangentVector(direction.elements[i]))
         }
     }
-
-    @noDerivative
-    public var zeroTangentVectorInitializer: () -> TangentVector {
-        { [zeroInits = map(\.zeroTangentVectorInitializer)] in
-            TangentVector(zeroInits.map { $0() })
-        }
-    }
 }
 
 // struct Dictionary<Key: Hashable, Value>
@@ -1173,14 +1121,6 @@ extension Dictionary: Differentiable where Value: Differentiable {
             self[i].move(along: Value.TangentVector(direction.elements[i]))
         }
     }
-
-    @noDerivative
-    public var zeroTangentVectorInitializer: () -> TangentVector {
-        { [keys = self.keys] in
-            let pairs = zip(keys, sequence(first: .zero, next: {$0}))
-            return TangentVector(Dictionary(uniqueKeysWithValues: pairs))
-        }
-    }
 }
 
 // enum Optional<Wrapped>
@@ -1199,18 +1139,6 @@ extension Optional: Differentiable where Wrapped: Differentiable {
             self?.move(along: value)
         }
     }
-
-    @noDerivative
-    public var zeroTangentVectorInitializer: () -> TangentVector {
-        switch self {
-        case nil:
-            return { TangentVector(nil) }
-        case let x?:
-            return { [zeroTanInit = x.zeroTangentVectorInitializer] in
-                TangentVector(zeroTanInit())
-            }
-        }
-    }
 }
 ```
 
@@ -1261,13 +1189,12 @@ product manifold of the manifolds each differentiable variable's type
 represents. Differentiable variables' types are required to conform to
 `Differentiable` because the synthesized implementation needs to access each
 differentiable variable's type's `TangentVector` associated type and invoke each
-differentiable variable's implementation of `move(along:)` and
-`zeroTangentVectorInitializer`. Because the synthesized implementation needs to
-invoke `move(along:)` on each differentiable variable, the differentiable
-variables must have a `move(along:)` which satisfies the protocol requirement
-and can be invoked on the property. That is, the property must be either a
-variable (`var`) or a constant (`let`) with a non-`mutating` implementation of
-the `move(along:)` protocol requirement.
+differentiable variable's implementation of `move(along:)`. Because the
+synthesized implementation needs to invoke `move(along:)` on each differentiable
+variable, the differentiable variables must have a `move(along:)` which satisfies the
+protocol requirement and can be invoked on the property. That is, the property
+must be either a variable (`var`) or a constant (`let`) with a non-`mutating`
+implementation of the `move(along:)` protocol requirement.
 
 The synthesized `TangentVector` has the same effective access level as the
 original type declaration. Properties in the synthesized `TangentVector` have
@@ -1282,12 +1209,6 @@ example, synthesized `TangentVector`s always adopt the `AdditiveArithmetic` and
 The synthesized `move(along:)` method calls `move(along:)` for each pair of a
 differentiable variable and its corresponding property in `TangentVector`.
 
-The synthesized `zeroTangentVectorInitializer` property returns 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.
-
 ```swift
 struct Foo<T: Differentiable, U: Differentiable>: @memberwise Differentiable {
     // `x` and `y` are the "differentiable variables".
@@ -1306,13 +1227,6 @@ struct Foo<T: Differentiable, U: Differentiable>: @memberwise Differentiable {
     //         x.move(along: direction.x)
     //         y.move(along: direction.y)
     //     }
-    //
-    //     var zeroTangentVectorInitializer: () -> TangentVector {
-    //         { [xTanInit = x.zeroTangentVectorInitializer,
-    //            yTanInit = y.zeroTangentVectorInitializer] in
-    //             TangentVector(x: xTanInit(), y: yTanInit())
-    //         }
-    //     }
 }
 ```
 
@@ -1404,14 +1318,6 @@ struct Point<T: Real>: @memberwise Differentiable, @memberwise AdditiveArithmeti
     // The compiler synthesizes:
     //
     //     typealias TangentVector = Self
-    //
-    //     @noDerivative
-    //     var zeroTangentVectorInitializer: () -> TangentVector {
-    //         { [xTanInit = x.zeroTangentVectorInitializer,
-    //            yTanInit = y.zeroTangentVectorInitializer] in
-    //             TangentVector(x: xTanInit(), y: yTanInit())
-    //         }
-    //     }
 }
 ```
 

docs/DynamicCasting.md

@@ -299,6 +299,7 @@ Casting from a function type F1 to a function type F2 will succeed iff the follo
 * Corresponding arguments have identical types
 * The return types are identical
 * If F1 is a throwing function type, then F2 must be a throwing function type.  If F1 is not throwing, then F2 may be a throwing or non-throwing function type.
+* F1 and F2 have the same calling convention.
 
 Note that it is _not_ sufficient for argument and return types to be castable; they must actually be identical.
 

docs/HowToGuides/GettingStarted.md

@@ -60,8 +60,8 @@ toolchain as a one-off, there are a couple of differences:
 
 1. Create a directory for the whole project:
    ```sh
-   mkdir -p swift-project/swift
-   cd swift-project/swift
+   mkdir swift-project
+   cd swift-project
    ```
 2. Clone the sources:
    - Via SSH (recommended):

docs/OpenBSD.md

@@ -1,6 +1,6 @@
 # Getting started with Swift on OpenBSD
 
-Swift builds and runs on OpenBSD (tested on 6.8-beta), with some special considerations.
+Swift builds and runs on OpenBSD (tested on 6.8), with some special considerations.
 
 ## Preparing
 
@@ -66,7 +66,7 @@ These options are:
 * `--skip-build-clang-tools-extra` and `--skip-build-compiler-rt`: to ensure LLVM builds cleanly,
 * `--extra-cmake-options=`
   * `-DCMAKE_DISABLE_FIND_PACKAGE_Backtrace=TRUE,-DCMAKE_DISABLE_FIND_PACKAGE_LibXml2=TRUE,-DLLVM_VERSION_SUFFIX=''`: to ensure LLVM builds cleanly,
-  * `-DSWIFT_BUILD_SOURCEKIT=OFF,-DSWIFT_BUILD_SYNTAXPARSERLIB=OFF`: to ensure Swift does not attempt to build libdispatch, which is not yet supported on OpenBSD,
+  * `-DSWIFT_BUILD_SOURCEKIT=OFF,-DSWIFT_BUILD_SYNTAXPARSERLIB=OFF,-DSWIFT_ENABLE_EXPERIMENTAL_CONCURRENCY=OFF`: to ensure Swift does not attempt to build libdispatch, which is not yet supported on OpenBSD,
   * `-DSWIFT_USE_LINKER=lld`: to specify that `lld` should be used over `gold`,
   * `-DCMAKE_INSTALL_DIR=/usr/local"`: to set the correct platform install directory.
 
@@ -81,8 +81,11 @@ $ ./utils/build-script \
         -DLLVM_VERSION_SUFFIX='',\
         -DSWIFT_BUILD_SOURCEKIT=OFF,\
         -DSWIFT_BUILD_SYNTAXPARSERLIB=OFF,\
+        -DSWIFT_ENABLE_EXPERIMENTAL_CONCURRENCY=OFF,\
         -DSWIFT_USE_LINKER=lld,\
         -DCMAKE_INSTALL_DIR=/usr/local"
 ```
 
 You may wish to also supply the flag `--llvm-targets-to-build=host`, to speed up the LLVM build slightly.
+
+For debug builds especially, consider also installing the `llvm` package and setting `-DCMAKE_AR=/usr/local/bin/llvm-ar` with the `extra-cmake-options` flag, to work around problems creating indexes to archives containing object files with large numbers of section headers.

include/swift/AST/ASTContext.h

@@ -629,8 +629,15 @@ class ASTContext final {
     ArrayRef<SILParameterInfo> params, Optional<SILResultInfo> result,
     SILFunctionType::Representation trueRep);
 
-  /// Instantiates "Impl.Converter" if needed, then calls
-  /// ClangTypeConverter::getClangTemplateArguments.
+  /// Instantiates "Impl.Converter" if needed, then translate Swift generic
+  /// substitutions to equivalent C++ types using \p templateParams and \p
+  /// genericArgs. The converted Clang types are placed into \p templateArgs.
+  ///
+  /// \p templateArgs must be empty. \p templateParams and \p genericArgs must
+  /// be equal in size.
+  ///
+  /// \returns nullptr if successful. If an error occors, returns a list of
+  /// types that couldn't be converted.
   std::unique_ptr<TemplateInstantiationError> getClangTemplateArguments(
       const clang::TemplateParameterList *templateParams,
       ArrayRef<Type> genericArgs,

include/swift/AST/ASTMangler.h

@@ -222,7 +222,7 @@ class ASTMangler : public Mangler {
                                       GenericSignature signature,
                                       ResilienceExpansion expansion);
 
-  std::string mangleTypeForDebugger(Type decl, const DeclContext *DC);
+  std::string mangleTypeForDebugger(Type decl, GenericSignature sig);
 
   /// Create a mangled name to be used for _typeName constant propagation.
   std::string mangleTypeForTypeName(Type type);
@@ -282,9 +282,7 @@ class ASTMangler : public Mangler {
   void appendOpWithGenericParamIndex(StringRef,
                                      const GenericTypeParamType *paramTy);
 
-  void bindGenericParameters(const DeclContext *DC);
-
-  void bindGenericParameters(CanGenericSignature sig);
+  void bindGenericParameters(GenericSignature sig);
 
   /// Mangles a sugared type iff we are mangling for the debugger.
   template <class T> void appendSugaredType(Type type,

include/swift/AST/ClangModuleLoader.h

@@ -238,7 +238,7 @@ class ClangModuleLoader : public ModuleLoader {
                                  SubstitutionMap subst) = 0;
 };
 
-/// Used to describe a template instantiation error.
+/// Describes a C++ template instantiation error.
 struct TemplateInstantiationError {
   /// Generic types that could not be converted to QualTypes using the
   /// ClangTypeConverter.

include/swift/AST/Decl.h

@@ -333,7 +333,7 @@ class alignas(1 << DeclAlignInBits) Decl {
     NumElements : 32
   );
 
-  SWIFT_INLINE_BITFIELD(ValueDecl, Decl, 1+1+1,
+  SWIFT_INLINE_BITFIELD(ValueDecl, Decl, 1+1+1+1,
     AlreadyInLookupTable : 1,
 
     /// Whether we have already checked whether this declaration is a 
@@ -342,7 +342,11 @@ class alignas(1 << DeclAlignInBits) Decl {
 
     /// Whether the decl can be accessed by swift users; for instance,
     /// a.storage for lazy var a is a decl that cannot be accessed.
-    IsUserAccessible : 1
+    IsUserAccessible : 1,
+
+    /// Whether this member was synthesized as part of a derived
+    /// protocol conformance.
+    Synthesized : 1
   );
 
   SWIFT_INLINE_BITFIELD(AbstractStorageDecl, ValueDecl, 1,
@@ -387,7 +391,7 @@ class alignas(1 << DeclAlignInBits) Decl {
   SWIFT_INLINE_BITFIELD(SubscriptDecl, VarDecl, 2,
     StaticSpelling : 2
   );
-  SWIFT_INLINE_BITFIELD(AbstractFunctionDecl, ValueDecl, 3+8+1+1+1+1+1+1+1,
+  SWIFT_INLINE_BITFIELD(AbstractFunctionDecl, ValueDecl, 3+8+1+1+1+1+1+1,
     /// \see AbstractFunctionDecl::BodyKind
     BodyKind : 3,
 
@@ -406,10 +410,6 @@ class alignas(1 << DeclAlignInBits) Decl {
     /// Whether the function body throws.
     Throws : 1,
 
-    /// Whether this member was synthesized as part of a derived
-    /// protocol conformance.
-    Synthesized : 1,
-
     /// Whether this member's body consists of a single expression.
     HasSingleExpressionBody : 1,
 
@@ -2020,6 +2020,7 @@ class ValueDecl : public Decl {
     Bits.ValueDecl.AlreadyInLookupTable = false;
     Bits.ValueDecl.CheckedRedeclaration = false;
     Bits.ValueDecl.IsUserAccessible = true;
+    Bits.ValueDecl.Synthesized = false;
   }
 
   // MemberLookupTable borrows a bit from this type
@@ -2057,6 +2058,14 @@ class ValueDecl : public Decl {
     return Bits.ValueDecl.IsUserAccessible;
   }
 
+  bool isSynthesized() const {
+    return Bits.ValueDecl.Synthesized;
+  }
+
+  void setSynthesized(bool value = true) {
+    Bits.ValueDecl.Synthesized = value;
+  }
+
   bool hasName() const { return bool(Name); }
   bool isOperator() const { return Name.isOperator(); }
 
@@ -3544,7 +3553,7 @@ class ClassDecl final : public NominalTypeDecl {
 
   friend class SuperclassDeclRequest;
   friend class SuperclassTypeRequest;
-  friend class SemanticMembersRequest;
+  friend class ABIMembersRequest;
   friend class HasMissingDesignatedInitializersRequest;
   friend class InheritsSuperclassInitializersRequest;
 
@@ -5589,7 +5598,6 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
     Bits.AbstractFunctionDecl.Overridden = false;
     Bits.AbstractFunctionDecl.Async = Async;
     Bits.AbstractFunctionDecl.Throws = Throws;
-    Bits.AbstractFunctionDecl.Synthesized = false;
     Bits.AbstractFunctionDecl.HasSingleExpressionBody = false;
     Bits.AbstractFunctionDecl.HasNestedTypeDeclarations = false;
   }
@@ -5796,14 +5804,6 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// vtable.
   bool needsNewVTableEntry() const;
 
-  bool isSynthesized() const {
-    return Bits.AbstractFunctionDecl.Synthesized;
-  }
-
-  void setSynthesized(bool value = true) {
-    Bits.AbstractFunctionDecl.Synthesized = value;
-  }
-
 public:
   /// Retrieve the source range of the function body.
   SourceRange getBodySourceRange() const;

include/swift/AST/DeclContext.h

@@ -778,10 +778,17 @@ class IterableDeclContext {
   /// the implementation.
   ArrayRef<Decl *> getParsedMembers() const;
 
-  /// Get all the members that are semantically within this context,
-  /// including any implicitly-synthesized members.
+  /// Get all of the members within this context that can affect ABI, including
+  /// any implicitly-synthesized members.
+  ///
+  /// The resulting list of members will be stable across translation units.
+  ArrayRef<Decl *> getABIMembers() const;
+
+  /// Get all of the members within this context, including any
+  /// implicitly-synthesized members.
+  ///
   /// The resulting list of members will be stable across translation units.
-  ArrayRef<Decl *> getSemanticMembers() const;
+  ArrayRef<Decl *> getAllMembers() const;
 
   /// Retrieve the set of members in this context without loading any from the
   /// associated lazy loader; this should only be used as part of implementing