Merge pull request #2541 from swiftwasm/maxd/main-merge

Resolve conflicts with the `main` branch

Author: kateinoigakukun

.mailmap

@@ -9,11 +9,11 @@ Ankit Aggarwal <ankit_aggarwal@apple.com> <ankit.spd@gmail.com>
 Argyrios Kyrtzidis <kyrtzidis@apple.com> <akyrtzi@gmail.com>
 Arsen Gasparyan <to.arsen.gasparyan@gmail.com> <frootloops@users.noreply.github.com>
 Ashley Garland <acgarland@apple.com> <dfarler@apple.com>
+Becca Royal-Gordon <beccadax@apple.com> <broyalgordon@apple.com> <becca@beccadax.com> <brentdax@apple.com> <brent@brentdax.com>
 Ben Cohen <ben_cohen@apple.com>
 Ben Cohen <ben_cohen@apple.com> <airspeedswift@users.noreply.github.com>
 Ben Cohen <ben_cohen@apple.com> <ben@airspeedvelocity.net>
 Ben Langmuir <blangmuir@apple.com> <ben.langmuir@gmail.com>
-Brent Royal-Gordon <brent@brentdax.com> <brent@architechies.com>
 Brian Croom <bcroom@apple.com> <brian.s.croom@gmail.com>
 Brian Gesiak <bgesiak@fb.com> <modocache@gmail.com>
 Bryan Chan <bryan.chan@ca.ibm.com> <bryanpkc@gmail.com>

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/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

@@ -228,7 +228,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/DiagnosticsSema.def

@@ -1692,7 +1692,7 @@ ERROR(where_nongeneric_toplevel,none,
       "declaration", ())
 ERROR(unable_to_convert_generic_swift_types,none,
       "could not generate C++ types from the generic Swift types provided. "
-      "The following Swift type(s) provided to '%0' were unable to be "
+      "The following Swift type(s) provided to '%0' could not be "
       "converted: %1.",
       (StringRef, StringRef))
 
@@ -3785,9 +3785,14 @@ WARNING(guard_always_succeeds,none,
 ERROR(expression_unused_closure,none,
       "closure expression is unused", ())
 ERROR(expression_unused_function,none,
-      "expression resolves to an unused function", ())
+      "function is unused", ())
 WARNING(expression_unused_lvalue,none,
-        "expression resolves to an unused %select{variable|property|subscript}0", (unsigned))
+      "%select{"
+        "variable|"
+        "property is accessed but result|"
+        "subscript is accessed but result"
+      "}0 is unused",
+      (unsigned))
 WARNING(expression_unused_result_call,none,
         "result of call to %0 is unused", (DeclName))
 WARNING(expression_unused_result_operator,none,

include/swift/AST/FileUnit.h

@@ -402,6 +402,9 @@ class LoadedFile : public FileUnit {
     return false;
   }
 
+  virtual void collectBasicSourceFileInfo(
+      llvm::function_ref<void(const BasicSourceFileInfo &)> callback) const {}
+
   static bool classof(const FileUnit *file) {
     return file->getKind() == FileUnitKind::SerializedAST ||
            file->getKind() == FileUnitKind::ClangModule ||

include/swift/AST/KnownIdentifiers.def

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

include/swift/AST/Module.h

@@ -626,6 +626,10 @@ class ModuleDecl : public DeclContext, public TypeDecl {
   /// This assumes that \p module was imported.
   bool isImportedImplementationOnly(const ModuleDecl *module) const;
 
+  /// Returns true if a function, which is using \p nominal, can be serialized
+  /// by cross-module-optimization.
+  bool canBeUsedForCrossModuleOptimization(NominalTypeDecl *nominal) const;
+
   /// Finds all top-level decls of this module.
   ///
   /// This does a simple local lookup, not recursively looking through imports.
@@ -728,6 +732,10 @@ class ModuleDecl : public DeclContext, public TypeDecl {
     return ReverseFullNameIterator(this);
   }
 
+  /// Calls \p callback for each source file of the module.
+  void collectBasicSourceFileInfo(
+      llvm::function_ref<void(const BasicSourceFileInfo &)> callback);
+
   SourceRange getSourceRange() const { return SourceRange(); }
 
   static bool classof(const DeclContext *DC) {

include/swift/AST/RawComment.h

@@ -13,11 +13,15 @@
 #ifndef SWIFT_AST_RAW_COMMENT_H
 #define SWIFT_AST_RAW_COMMENT_H
 
+#include "swift/Basic/Fingerprint.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/SourceLoc.h"
 #include "swift/Basic/SourceManager.h"
 
 namespace swift {
+
+class SourceFile;
+
 struct SingleRawComment {
   enum class CommentKind {
     OrdinaryLine,  ///< Any normal // comments
@@ -92,6 +96,17 @@ struct BasicDeclLocs {
   LineColumn EndLoc;
 };
 
+struct BasicSourceFileInfo {
+  StringRef FilePath;
+  Fingerprint InterfaceHash = Fingerprint::ZERO();
+  llvm::sys::TimePoint<> LastModified = {};
+  uint64_t FileSize = 0;
+
+  BasicSourceFileInfo() {}
+
+  bool populate(SourceFile *SF);
+};
+
 } // namespace swift
 
 #endif // LLVM_SWIFT_AST_RAW_COMMENT_H

include/swift/AST/SourceFile.h

@@ -531,6 +531,9 @@ class SourceFile final : public FileUnit {
     out << getInterfaceHash() << '\n';
   }
 
+  /// Get this file's interface hash including the type members in the file.
+  Fingerprint getInterfaceHashIncludingTypeMembers() const;
+
   /// If this source file has been told to collect its parsed tokens, retrieve
   /// those tokens.
   ArrayRef<Token> getAllTokens() const;