Merge branch 'apple:main' into my-branch

Author: li3zhen1

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LetPropertyLowering.swift

@@ -99,7 +99,8 @@ private func insertEndInitInstructions(
   atEndOf initRegion: InstructionRange,
   _ context: FunctionPassContext
 ) {
-  var ssaUpdater = SSAUpdater(type: markUninitialized.type, ownership: .owned, context)
+  var ssaUpdater = SSAUpdater(function: markUninitialized.parentFunction,
+                              type: markUninitialized.type, ownership: .owned, context)
   ssaUpdater.addAvailableValue(markUninitialized, in: markUninitialized.parentBlock)
 
   for endInst in initRegion.ends {

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/RedundantLoadElimination.swift

@@ -236,7 +236,8 @@ private extension LoadInst {
 }
 
 private func replace(load: LoadInst, with availableValues: [AvailableValue], _ context: FunctionPassContext) {
-  var ssaUpdater = SSAUpdater(type: load.type, ownership: load.ownership, context)
+  var ssaUpdater = SSAUpdater(function: load.parentFunction,
+                              type: load.type, ownership: load.ownership, context)
 
   for availableValue in availableValues {
     let block = availableValue.instruction.parentBlock

SwiftCompilerSources/Sources/Optimizer/Utilities/SSAUpdater.swift

@@ -17,9 +17,11 @@ import OptimizerBridging
 struct SSAUpdater<Context: MutatingContext> {
   let context: Context
 
-  init(type: Type, ownership: Ownership, _ context: Context) {
+  init(function: Function, type: Type, ownership: Ownership,
+       _ context: Context) {
     self.context = context
-    context._bridged.SSAUpdater_initialize(type.bridged, ownership._bridged)
+    context._bridged.SSAUpdater_initialize(function.bridged, type.bridged,
+                                           ownership._bridged)
   }
 
   mutating func addAvailableValue(_ value: Value, in block: BasicBlock) {

docs/Android.md

@@ -36,8 +36,8 @@ To follow along with this guide, you'll need:
    instructions in the Swift project README.
 2. The latest build of the Swift compiler for your Linux distro, available at
    https://www.swift.org/download/ or sometimes your distro package manager.
-3. The last version of the Android LTS NDK (r25c, the latest LTS NDK 26 at the
-   time of this writing doesn't work yet), available to download here:
+3. The latest version of the Android LTS NDK (r26c at the time of this writing),
+   available to download here:
    https://developer.android.com/ndk/downloads
 4. An Android device with remote debugging enabled or the emulator. We require
    remote debugging in order to deploy built stdlib products to the device. You
@@ -54,7 +54,7 @@ and the prebuilt Swift toolchain (add --skip-early-swift-driver if you already
 have a Swift toolchain in your path):
 
 ```
-$ NDK_PATH=path/to/android-ndk-r25c
+$ NDK_PATH=path/to/android-ndk-r26c
 $ SWIFT_PATH=path/to/swift-DEVELOPMENT-SNAPSHOT-2023-09-30-a-ubuntu20.04/usr/bin
 $ git checkout swift-DEVELOPMENT-SNAPSHOT-2023-09-30-a
 $ utils/build-script \
@@ -83,7 +83,7 @@ Then use the standalone Swift stdlib from the previous step to compile a Swift
 source file, targeting Android:
 
 ```
-$ NDK_PATH="path/to/android-ndk-r25c"
+$ NDK_PATH="path/to/android-ndk-r26c"
 $ SWIFT_PATH=path/to/swift-DEVELOPMENT-SNAPSHOT-2023-09-30-a-ubuntu20.04/usr/bin
 $ $SWIFT_PATH/swiftc \                                               # The prebuilt Swift compiler you downloaded
                                                                      # The location of the tools used to build Android binaries
@@ -133,7 +133,7 @@ $ adb push build/Ninja-ReleaseAssert/swift-linux-x86_64/lib/swift/android/libBlo
 In addition, you'll also need to copy the Android NDK's libc++:
 
 ```
-$ adb push /path/to/android-ndk-r25c/toolchains/llvm/prebuilt/linux-x86_64/sysroot/usr/lib/aarch64-linux-android/libc++_shared.so /data/local/tmp
+$ adb push /path/to/android-ndk-r26c/toolchains/llvm/prebuilt/linux-x86_64/sysroot/usr/lib/aarch64-linux-android/libc++_shared.so /data/local/tmp
 ```
 
 Finally, you'll need to copy the `hello` executable you built in the
@@ -176,7 +176,7 @@ $ utils/build-script \
   -R \                               # Build in ReleaseAssert mode.
   -T \                               # Run all tests, including on the Android device (add --host-test to only run Android tests on the Linux host).
   --android \                        # Build for Android.
-  --android-ndk ~/android-ndk-r25c \  # Path to an Android NDK.
+  --android-ndk ~/android-ndk-r26c \  # Path to an Android NDK.
   --android-arch aarch64 \           # Optionally specify Android architecture, alternately armv7
   --android-api-level 21
 ```

include/swift-c/DependencyScan/DependencyScan.h

@@ -61,6 +61,18 @@ typedef struct {
   size_t count;
 } swiftscan_dependency_set_t;
 
+typedef enum {
+  SWIFTSCAN_DIAGNOSTIC_SEVERITY_ERROR = 0,
+  SWIFTSCAN_DIAGNOSTIC_SEVERITY_WARNING = 1,
+  SWIFTSCAN_DIAGNOSTIC_SEVERITY_NOTE = 2,
+  SWIFTSCAN_DIAGNOSTIC_SEVERITY_REMARK = 3
+} swiftscan_diagnostic_severity_t;
+
+typedef struct {
+  swiftscan_diagnostic_info_t *diagnostics;
+  size_t count;
+} swiftscan_diagnostic_set_t;
+
 //=== Batch Scan Input Specification --------------------------------------===//
 
 /// Opaque container to a container of batch scan entry information.
@@ -92,6 +104,12 @@ SWIFTSCAN_PUBLIC swiftscan_dependency_set_t *
 swiftscan_dependency_graph_get_dependencies(
     swiftscan_dependency_graph_t result);
 
+// Return value disposed of together with the dependency_graph
+// using `swiftscan_dependency_graph_dispose`
+SWIFTSCAN_PUBLIC swiftscan_diagnostic_set_t *
+swiftscan_dependency_graph_get_diagnostics(
+    swiftscan_dependency_graph_t result);
+
 //=== Dependency Module Info Functions ------------------------------------===//
 
 SWIFTSCAN_PUBLIC swiftscan_string_ref_t
@@ -277,6 +295,11 @@ swiftscan_batch_scan_entry_get_is_swift(swiftscan_batch_scan_entry_t entry);
 SWIFTSCAN_PUBLIC swiftscan_string_set_t *
 swiftscan_import_set_get_imports(swiftscan_import_set_t result);
 
+// Return value disposed of together with the dependency_graph
+// using `swiftscan_import_set_dispose`
+SWIFTSCAN_PUBLIC swiftscan_diagnostic_set_t *
+swiftscan_import_set_get_diagnostics(swiftscan_import_set_t result);
+
 //=== Scanner Invocation Functions ----------------------------------------===//
 
 /// Create an \c swiftscan_scan_invocation_t instance.
@@ -378,18 +401,6 @@ SWIFTSCAN_PUBLIC swiftscan_import_set_t swiftscan_import_set_create(
 
 
 //=== Scanner Diagnostics -------------------------------------------------===//
-typedef enum {
-  SWIFTSCAN_DIAGNOSTIC_SEVERITY_ERROR = 0,
-  SWIFTSCAN_DIAGNOSTIC_SEVERITY_WARNING = 1,
-  SWIFTSCAN_DIAGNOSTIC_SEVERITY_NOTE = 2,
-  SWIFTSCAN_DIAGNOSTIC_SEVERITY_REMARK = 3
-} swiftscan_diagnostic_severity_t;
-
-typedef struct {
-  swiftscan_diagnostic_info_t *diagnostics;
-  size_t count;
-} swiftscan_diagnostic_set_t;
-
 /// For the specified \c scanner instance, query all insofar emitted diagnostics
 SWIFTSCAN_PUBLIC swiftscan_diagnostic_set_t*
 swiftscan_scanner_diagnostics_query(swiftscan_scanner_t scanner);

include/swift/AST/DiagnosticsSema.def

@@ -2465,7 +2465,7 @@ ERROR(spi_only_imports_not_enabled, none,
 ERROR(access_level_on_import_unsupported, none,
       "The access level %0 is unsupported on imports: "
       "only 'public', 'package', 'internal', 'fileprivate' and 'private' "
-      "are unsupported",
+      "are accepted",
       (DeclAttribute))
 ERROR(access_level_conflict_with_exported,none,
       "'%0' is incompatible with %1; it can only be applied to public imports",

include/swift/AST/Module.h

@@ -846,6 +846,7 @@ class ModuleDecl
                                            bool allowMissing = false);
 
   /// Global conformance lookup, checks conditional requirements.
+  /// Requires a contextualized type.
   ///
   /// \param type The type for which we are computing conformance. Must not
   /// contain type parameters.
@@ -859,8 +860,32 @@ class ModuleDecl
   /// \returns An invalid conformance if the search failed, otherwise an
   /// abstract, concrete or pack conformance, depending on the lookup type.
   ProtocolConformanceRef checkConformance(Type type, ProtocolDecl *protocol,
-                                          // Note: different default than above
-                                          bool allowMissing = true);
+                              // Note: different default from lookupConformance
+                              bool allowMissing = true);
+
+  /// Global conformance lookup, checks conditional requirements.
+  /// Accepts interface types without context. If the conformance cannot be
+  /// definitively established without the missing context, returns \c nullopt.
+  ///
+  /// \param type The type for which we are computing conformance. Must not
+  /// contain type parameters.
+  ///
+  /// \param protocol The protocol to which we are computing conformance.
+  ///
+  /// \param allowMissing When \c true, the resulting conformance reference
+  /// might include "missing" conformances, which are synthesized for some
+  /// protocols as an error recovery mechanism.
+  ///
+  /// \returns An invalid conformance if the search definitively failed. An
+  /// abstract, concrete or pack conformance, depending on the lookup type,
+  /// if the search succeeded. `std::nullopt` if the type could have
+  /// conditionally conformed depending on the context of the interface types.
+  std::optional<ProtocolConformanceRef>
+  checkConformanceWithoutContext(Type type,
+                                 ProtocolDecl *protocol,
+                                 // Note: different default from lookupConformance
+                                 bool allowMissing = true);
+
 
   /// Look for the conformance of the given existential type to the given
   /// protocol.

include/swift/AST/PlatformKind.h

@@ -42,6 +42,10 @@ StringRef platformString(PlatformKind platform);
 /// or None if such a platform kind does not exist.
 std::optional<PlatformKind> platformFromString(StringRef Name);
 
+/// Safely converts the given unsigned value to a valid \c PlatformKind value or
+/// \c nullopt otherwise.
+std::optional<PlatformKind> platformFromUnsigned(unsigned value);
+
 /// Returns a valid platform string that is closest to the candidate string
 /// based on edit distance. Returns \c None if the closest valid platform
 /// distance is not within a minimum threshold.

include/swift/AST/Requirement.h

@@ -223,6 +223,12 @@ enum class CheckRequirementsResult : uint8_t {
 /// not contain any type parameters.
 CheckRequirementsResult checkRequirements(ArrayRef<Requirement> requirements);
 
+/// Check if each substituted requirement is satisfied. If the requirement
+/// contains type parameters, and the answer would depend on the context of
+/// those type parameters, then `nullopt` is returned.
+std::optional<CheckRequirementsResult>
+checkRequirementsWithoutContext(ArrayRef<Requirement> requirements);
+
 /// Check if each requirement is satisfied after applying the given
 /// substitutions. The substitutions must replace all type parameters that
 /// appear in the requirement with concrete types or archetypes.

include/swift/DependencyScan/DependencyScanImpl.h

@@ -30,6 +30,9 @@ struct swiftscan_dependency_graph_s {
 
   /// The complete list of modules discovered
   swiftscan_dependency_set_t *dependencies;
+
+  /// Diagnostics produced during this scan
+  swiftscan_diagnostic_set_t *diagnostics;
 };
 
 struct swiftscan_dependency_info_s {
@@ -192,6 +195,8 @@ struct swiftscan_batch_scan_entry_s {
 struct swiftscan_import_set_s {
   /// The complete list of imports discovered
   swiftscan_string_set_t *imports;
+  /// Diagnostics produced during this import scan
+  swiftscan_diagnostic_set_t *diagnostics;
 };
 
 struct swiftscan_scan_invocation_s {

include/swift/DependencyScan/DependencyScanningTool.h

@@ -24,28 +24,48 @@
 namespace swift {
 namespace dependencies {
 class DependencyScanningTool;
+class DependencyScanDiagnosticCollector;
+
+struct ScanQueryInstance {
+  std::unique_ptr<CompilerInstance> ScanInstance;
+  std::unique_ptr<DependencyScanDiagnosticCollector> ScanDiagnostics;
+};
 
 /// Diagnostic consumer that simply collects the diagnostics emitted so-far
-class DependencyScannerDiagnosticCollectingConsumer : public DiagnosticConsumer {
-public:
-  friend DependencyScanningTool;
-  DependencyScannerDiagnosticCollectingConsumer() {}
-  void reset() { Diagnostics.clear(); }
+class DependencyScanDiagnosticCollector : public DiagnosticConsumer {
 private:
   struct ScannerDiagnosticInfo {
     std::string Message;
     llvm::SourceMgr::DiagKind Severity;
   };
-  
-  void handleDiagnostic(SourceManager &SM,
-                        const DiagnosticInfo &Info) override;
-  void addDiagnostic(SourceManager &SM, const DiagnosticInfo &Info);
+
+  void handleDiagnostic(SourceManager &SM, const DiagnosticInfo &Info) override;
   std::vector<ScannerDiagnosticInfo> Diagnostics;
-  // FIXME: For now, we isolate access to shared state of this object
-  // but we really should make sure that it doesn't get shared.
-  llvm::sys::SmartMutex<true> ScanningDiagnosticConsumerStateLock;
+
+protected:
+  virtual void addDiagnostic(SourceManager &SM, const DiagnosticInfo &Info);
+
+public:
+  friend DependencyScanningTool;
+  DependencyScanDiagnosticCollector() {}
+  void reset() { Diagnostics.clear(); }
+  const std::vector<ScannerDiagnosticInfo> &getDiagnostics() const {
+    return Diagnostics;
+  }
 };
 
+/// Locking variant of the above diagnostic collector that guards accesses to
+/// its state with a lock.
+class LockingDependencyScanDiagnosticCollector
+    : public DependencyScanDiagnosticCollector {
+private:
+  void addDiagnostic(SourceManager &SM, const DiagnosticInfo &Info) override;
+  llvm::sys::SmartMutex<true> ScanningDiagnosticConsumerStateLock;
+
+public:
+  friend DependencyScanningTool;
+  LockingDependencyScanDiagnosticCollector() {}
+};
 
 /// Given a set of arguments to a print-target-info frontend tool query, produce the
 /// JSON target info.
@@ -93,19 +113,19 @@ class DependencyScanningTool {
   /// Discard the tool's current `SharedCache` and start anew.
   void resetCache();
   /// Query diagnostics consumed so far.
-  std::vector<DependencyScannerDiagnosticCollectingConsumer::ScannerDiagnosticInfo> getDiagnostics();
+  std::vector<DependencyScanDiagnosticCollector::ScannerDiagnosticInfo> getDiagnostics();
   /// Discared the collection of diagnostics encountered so far.
   void resetDiagnostics();
 
   /// Using the specified invocation command, instantiate a CompilerInstance
   /// that will be used for this scan.
-  llvm::ErrorOr<std::unique_ptr<CompilerInstance>>
+  llvm::ErrorOr<ScanQueryInstance>
   initCompilerInstanceForScan(ArrayRef<const char *> Command);
 
 private:
   /// Using the specified invocation command, initialize the scanner instance
   /// for this scan. Returns the `CompilerInstance` that will be used.
-  llvm::ErrorOr<std::unique_ptr<CompilerInstance>>
+  llvm::ErrorOr<ScanQueryInstance>
   initScannerForAction(ArrayRef<const char *> Command);
 
   /// Shared cache of module dependencies, re-used by individual full-scan queries
@@ -120,7 +140,7 @@ class DependencyScanningTool {
   llvm::sys::SmartMutex<true> DependencyScanningToolStateLock;
 
   /// A shared consumer that accumulates encountered diagnostics.
-  DependencyScannerDiagnosticCollectingConsumer CDC;
+  LockingDependencyScanDiagnosticCollector CDC;
   llvm::BumpPtrAllocator Alloc;
   llvm::StringSaver Saver;
 };

include/swift/DependencyScan/ScanDependencies.h

@@ -30,6 +30,7 @@ class ModuleDependenciesCache;
 class SwiftDependencyScanningService;
 
 namespace dependencies {
+class DependencyScanDiagnosticCollector;
 
 using CompilerArgInstanceCacheMap =
     llvm::StringMap<std::tuple<std::unique_ptr<CompilerInstance>,
@@ -59,16 +60,19 @@ bool batchScanDependencies(CompilerInstance &instance,
 /// Scans the dependencies of the main module of \c instance.
 llvm::ErrorOr<swiftscan_dependency_graph_t>
 performModuleScan(CompilerInstance &instance,
+                  DependencyScanDiagnosticCollector *diagnostics,
                   ModuleDependenciesCache &cache);
 
 /// Scans the main module of \c instance for all direct module imports
 llvm::ErrorOr<swiftscan_import_set_t>
 performModulePrescan(CompilerInstance &instance,
+                     DependencyScanDiagnosticCollector *diagnostics,
                      ModuleDependenciesCache &cache);
 
 /// Batch scan the dependencies for modules specified in \c batchInputFile.
 std::vector<llvm::ErrorOr<swiftscan_dependency_graph_t>>
 performBatchModuleScan(CompilerInstance &invocationInstance,
+                       DependencyScanDiagnosticCollector *diagnostics,
                        ModuleDependenciesCache &invocationCache,
                        CompilerArgInstanceCacheMap *versionedPCMInstanceCache,
                        llvm::StringSaver &saver,

include/swift/SIL/AbstractionPattern.h

@@ -1014,6 +1014,7 @@ class AbstractionPattern {
 
   bool requiresClass() const;
   LayoutConstraint getLayoutConstraint() const;
+  bool isNoncopyable(CanType substTy) const;
 
   /// Return the Swift type which provides structure for this
   /// abstraction pattern.

include/swift/SIL/SILBuilder.h

@@ -200,7 +200,11 @@ class SILBuilder {
     assert(F && "cannot create this instruction without a function context");
     return *F;
   }
-  
+
+  /// If this SILBuilder is inserting into a function, return that function. If
+  /// we are inserting into a global, this returns nullptr.
+  SILFunction *maybeGetFunction() const { return F; }
+
   bool isInsertingIntoGlobal() const { return F == nullptr; }
 
   TypeExpansionContext getTypeExpansionContext() const {

include/swift/SIL/SILCloner.h

@@ -593,7 +593,7 @@ SILCloner<ImplClass>::getMappedValue(SILValue Value) {
   if (auto *U = dyn_cast<SILUndef>(Value)) {
     auto type = getOpType(U->getType());
     ValueBase *undef =
-      (type == U->getType() ? U : SILUndef::get(type, Builder.getFunction()));
+        (type == U->getType() ? U : SILUndef::get(Builder.getFunction(), type));
     return SILValue(undef);
   }