Merge main 2023-05-24

benchmark/CMakeLists.txt

@@ -37,6 +37,7 @@ set(SWIFT_BENCH_MODULES
     single-source/ArrayOfGenericRef
     single-source/ArrayOfPOD
     single-source/ArrayOfRef
+    single-source/ArrayRemoveAll
     single-source/ArraySetElement
     single-source/ArraySubscript
     single-source/BinaryFloatingPointConversionFromBinaryInteger

benchmark/single-source/ArrayRemoveAll.swift

@@ -0,0 +1,55 @@
+// This test checks the performance of removeAll
+// on a non-uniquely referenced array.
+
+import TestsUtils
+
+public let benchmarks = [
+  BenchmarkInfo(
+    name: "Array.removeAll.keepingCapacity.Int",
+    runFunction: run_ArrayRemoveAll_Class,
+    tags: [.validation, .api, .Array],
+    setUpFunction: { blackHole(inputArray_Class) }
+  ),
+  BenchmarkInfo(
+    name: "Array.removeAll.keepingCapacity.Object",
+    runFunction: run_ArrayRemoveAll_Int,
+    tags: [.validation, .api, .Array],
+    setUpFunction: { blackHole(inputArray_Int) }
+  )
+]
+
+class Slow {
+  public var num: Int
+
+  init(num: Int) {
+    self.num = num
+  }
+}
+
+let inputArray_Int: [Int] = Array(0..<500_000)
+let inputArray_Class: [Slow] = (0..<50_000).map(Slow.init(num:))
+
+@inline(never)
+func removeAll<T>(_ arr: [T]) -> [T] {
+  var copy = arr
+  copy.removeAll(keepingCapacity: true)
+  return copy
+}
+
+@inline(never)
+func run_ArrayRemoveAll_Class(_ n: Int) {
+  var copy = removeAll(inputArray_Class);
+  for _ in 1..<n {
+    copy = removeAll(inputArray_Class)
+  }
+  check(copy.capacity == inputArray_Class.capacity)
+}
+
+@inline(never)
+func run_ArrayRemoveAll_Int(_ n: Int) {
+  var copy = removeAll(inputArray_Int);
+  for _ in 1..<n {
+    copy = removeAll(inputArray_Int)
+  }
+  check(copy.capacity == inputArray_Int.capacity)
+}

benchmark/utils/main.swift

@@ -25,6 +25,7 @@ import ArrayOfGenericPOD
 import ArrayOfGenericRef
 import ArrayOfPOD
 import ArrayOfRef
+import ArrayRemoveAll
 import ArraySetElement
 import ArraySubscript
 import BinaryFloatingPointConversionFromBinaryInteger
@@ -217,6 +218,7 @@ register(ArrayOfGenericPOD.benchmarks)
 register(ArrayOfGenericRef.benchmarks)
 register(ArrayOfPOD.benchmarks)
 register(ArrayOfRef.benchmarks)
+register(ArrayRemoveAll.benchmarks)
 register(ArraySetElement.benchmarks)
 register(ArraySubscript.benchmarks)
 register(BinaryFloatingPointConversionFromBinaryInteger.benchmarks)

include/module.modulemap

@@ -0,0 +1,48 @@
+module BasicBridging {
+  header "swift/Basic/BridgedSwiftObject.h"
+  header "swift/Basic/BasicBridging.h"
+  header "swift/Basic/SourceLoc.h"
+  requires cplusplus
+  export *
+}
+
+module CBasicBridging {
+  header "swift/Basic/CBasicBridging.h"
+}
+
+module ASTBridging {
+  header "swift/AST/AnyFunctionRef.h"
+  header "swift/AST/ASTBridging.h"
+  header "swift/AST/Builtins.h"
+  header "swift/AST/DiagnosticEngine.h"
+  header "swift/AST/DiagnosticConsumer.h"
+  header "swift/AST/ForeignAsyncConvention.h"
+  header "swift/AST/ForeignErrorConvention.h"
+  header "swift/AST/SubstitutionMap.h"
+
+  textual header "swift/AST/Builtins.def"
+
+  requires cplusplus
+  export *
+}
+
+module CASTBridging {
+  header "swift/AST/CASTBridging.h"
+}
+
+module SILBridging {
+  header "swift/SIL/SILBridging.h"
+  header "swift/SIL/SILLocation.h"
+  requires cplusplus
+  export *
+}
+
+module OptimizerBridging {
+  header "swift/SILOptimizer/OptimizerBridging.h"
+  export *
+}
+
+module _RegexParserBridging {
+  header "swift/Parse/RegexParserBridging.h"
+  export *
+}

include/swift/ClangImporter/ClangImporter.h

@@ -397,7 +397,8 @@ class ClangImporter final : public ClangModuleLoader {
   /// replica.
   ///
   /// \sa clang::GeneratePCHAction
-  bool emitBridgingPCH(StringRef headerPath, StringRef outputPCHPath);
+  bool emitBridgingPCH(StringRef headerPath, StringRef outputPCHPath,
+                       bool cached);
 
   /// Returns true if a clang CompilerInstance can successfully read in a PCH,
   /// assuming it exists, with the current options. This can be used to find out
@@ -529,7 +530,7 @@ class ClangImporter final : public ClangModuleLoader {
 
   Optional<std::string>
   getOrCreatePCH(const ClangImporterOptions &ImporterOptions,
-                 StringRef SwiftPCHHash);
+                 StringRef SwiftPCHHash, bool Cached);
   Optional<std::string>
   /// \param isExplicit true if the PCH filename was passed directly
   /// with -import-objc-header option.

lib/ClangImporter/ClangImporter.cpp

@@ -194,7 +194,8 @@ namespace {
         Importer.addSearchPath(path, /*isFramework*/false, /*isSystem=*/false);
       }
 
-      auto PCH = Importer.getOrCreatePCH(ImporterOpts, SwiftPCHHash);
+      auto PCH =
+          Importer.getOrCreatePCH(ImporterOpts, SwiftPCHHash, /*Cached=*/true);
       if (PCH.has_value()) {
         Impl.getClangInstance()->getPreprocessorOpts().ImplicitPCHInclude =
             PCH.value();
@@ -582,8 +583,10 @@ importer::getNormalInvocationArguments(
     });
   }
 
-  if (auto path = getCxxShimModuleMapPath(searchPathOpts, triple)) {
-    invocationArgStrs.push_back((Twine("-fmodule-map-file=") + *path).str());
+  if (LangOpts.EnableCXXInterop) {
+    if (auto path = getCxxShimModuleMapPath(searchPathOpts, triple)) {
+      invocationArgStrs.push_back((Twine("-fmodule-map-file=") + *path).str());
+    }
   }
 
   // Set C language options.
@@ -996,8 +999,9 @@ ClangImporter::getPCHFilename(const ClangImporterOptions &ImporterOptions,
   return PCHFilename.str().str();
 }
 
-Optional<std::string> ClangImporter::getOrCreatePCH(
-    const ClangImporterOptions &ImporterOptions, StringRef SwiftPCHHash) {
+Optional<std::string>
+ClangImporter::getOrCreatePCH(const ClangImporterOptions &ImporterOptions,
+                              StringRef SwiftPCHHash, bool Cached) {
   bool isExplicit;
   auto PCHFilename = getPCHFilename(ImporterOptions, SwiftPCHHash,
                                     isExplicit);
@@ -1013,8 +1017,8 @@ Optional<std::string> ClangImporter::getOrCreatePCH(
         << EC.message();
       return None;
     }
-    auto FailedToEmit =
-        emitBridgingPCH(ImporterOptions.BridgingHeader, PCHFilename.value());
+    auto FailedToEmit = emitBridgingPCH(ImporterOptions.BridgingHeader,
+                                        PCHFilename.value(), Cached);
     if (FailedToEmit) {
       return None;
     }
@@ -1026,9 +1030,10 @@ Optional<std::string> ClangImporter::getOrCreatePCH(
 std::vector<std::string>
 ClangImporter::getClangArguments(ASTContext &ctx, bool ignoreClangTarget) {
   std::vector<std::string> invocationArgStrs;
-  // Clang expects this to be like an actual command line. So we need to pass in
-  // "clang" for argv[0]
-  invocationArgStrs.push_back(ctx.ClangImporterOpts.clangPath);
+  // When creating from driver commands, clang expects this to be like an actual
+  // command line. So we need to pass in "clang" for argv[0]
+  if (!ctx.ClangImporterOpts.DirectClangCC1ModuleBuild)
+    invocationArgStrs.push_back(ctx.ClangImporterOpts.clangPath);
   if (ctx.ClangImporterOpts.ExtraArgsOnly) {
     invocationArgStrs.insert(invocationArgStrs.end(),
                              ctx.ClangImporterOpts.ExtraArgs.begin(),
@@ -1777,13 +1782,13 @@ ClangImporter::cloneCompilerInstanceForPrecompiling() {
 }
 
 bool ClangImporter::emitBridgingPCH(
-    StringRef headerPath, StringRef outputPCHPath) {
+    StringRef headerPath, StringRef outputPCHPath, bool cached) {
   auto emitInstance = cloneCompilerInstanceForPrecompiling();
   auto &invocation = emitInstance->getInvocation();
 
   auto LangOpts = invocation.getLangOpts();
   LangOpts->NeededByPCHOrCompilationUsesPCH = true;
-  LangOpts->CacheGeneratedPCH = true;
+  LangOpts->CacheGeneratedPCH = cached;
 
   auto language = getLanguageFromOptions(LangOpts);
   auto inputFile = clang::FrontendInputFile(headerPath, language);
@@ -2034,12 +2039,16 @@ ModuleDecl *ClangImporter::Implementation::loadModuleClang(
   auto &clangHeaderSearch = getClangPreprocessor().getHeaderSearchInfo();
   auto realModuleName = SwiftContext.getRealModuleName(path.front().Item).str();
 
-  // Look up the top-level module first, to see if it exists at all.
-  clang::Module *clangModule = clangHeaderSearch.lookupModule(
-      realModuleName, /*ImportLoc=*/clang::SourceLocation(),
-      /*AllowSearch=*/true, /*AllowExtraModuleMapSearch=*/true);
-  if (!clangModule)
-    return nullptr;
+  // For explicit module build, module should always exist but module map might
+  // not be exist. Go straight to module loader.
+  if (Instance->getInvocation().getLangOpts()->ImplicitModules) {
+    // Look up the top-level module first, to see if it exists at all.
+    clang::Module *clangModule = clangHeaderSearch.lookupModule(
+        realModuleName, /*ImportLoc=*/clang::SourceLocation(),
+        /*AllowSearch=*/true, /*AllowExtraModuleMapSearch=*/true);
+    if (!clangModule)
+      return nullptr;
+  }
 
   // Convert the Swift import path over to a Clang import path.
   SmallVector<std::pair<clang::IdentifierInfo *, clang::SourceLocation>, 4>
@@ -2094,7 +2103,7 @@ ModuleDecl *ClangImporter::Implementation::loadModuleClang(
 
   // Now load the top-level module, so that we can check if the submodule
   // exists without triggering a fatal error.
-  clangModule = loadModule(clangPath.front(), clang::Module::AllVisible);
+  auto clangModule = loadModule(clangPath.front(), clang::Module::AllVisible);
   if (!clangModule)
     return nullptr;
 

lib/FrontendTool/FrontendTool.cpp

@@ -369,12 +369,13 @@ static bool precompileBridgingHeader(const CompilerInstance &Instance) {
   if (!PCHOutDir.empty()) {
     // Create or validate a persistent PCH.
     auto SwiftPCHHash = Invocation.getPCHHash();
-    auto PCH = clangImporter->getOrCreatePCH(ImporterOpts, SwiftPCHHash);
+    auto PCH = clangImporter->getOrCreatePCH(ImporterOpts, SwiftPCHHash,
+                                             /*cached=*/false);
     return !PCH.has_value();
   }
   return clangImporter->emitBridgingPCH(
       opts.InputsAndOutputs.getFilenameOfFirstInput(),
-      opts.InputsAndOutputs.getSingleOutputFilename());
+      opts.InputsAndOutputs.getSingleOutputFilename(), /*cached=*/false);
 }
 
 static bool precompileClangModule(const CompilerInstance &Instance) {
@@ -2072,6 +2073,11 @@ int swift::performFrontend(ArrayRef<const char *> Args,
   auto finishDiagProcessing = [&](int retValue, bool verifierEnabled) -> int {
     FinishDiagProcessingCheckRAII.CalledFinishDiagProcessing = true;
     PDC.setSuppressOutput(false);
+    if (auto *CDP = Instance->getCachingDiagnosticsProcessor()) {
+      // Don't cache if build failed.
+      if (retValue)
+        CDP->endDiagnosticCapture();
+    }
     bool diagnosticsError = Instance->getDiags().finishProcessing();
     // If the verifier is enabled and did not encounter any verification errors,
     // return 0 even if the compile failed. This behavior isn't ideal, but large

lib/SILOptimizer/Mandatory/MoveOnlyAddressCheckerUtils.cpp

@@ -1867,6 +1867,18 @@ bool GatherUsesVisitor::visitUse(Operand *op) {
     if (!leafRange)
       return false;
 
+    // Now check if we have a destructure through deinit. If we do, emit an
+    // error.
+    unsigned numDiagnostics =
+        moveChecker.diagnosticEmitter.getDiagnosticCount();
+    checkForDestructureThroughDeinit(markedValue, op, *leafRange,
+                                     diagnosticEmitter);
+    if (numDiagnostics != moveChecker.diagnosticEmitter.getDiagnosticCount()) {
+      LLVM_DEBUG(llvm::dbgs()
+                 << "Emitting destructure through deinit error!\n");
+      return true;
+    }
+
     LLVM_DEBUG(llvm::dbgs() << "Pure consuming use: " << *user);
     useState.takeInsts.insert({user, *leafRange});
     return true;

test/CAS/loc-directive-diagnostics.swift

@@ -1,5 +1,5 @@
 // RUN: %empty-directory(%t)
-// RUN: not %target-swift-frontend -emit-module -emit-module-path %t/test.module \
+// RUN: %target-swift-frontend -emit-module -emit-module-path %t/test.module \
 // RUN:   -enable-cas -cas-path %t/cas -allow-unstable-cache-key-for-testing %s 2>&1 | %FileCheck %s
 // RUN: %cache-tool -cas-path %t/cas -cache-tool-action print-output-keys -- \
 // RUN:   %target-swift-frontend -emit-module -emit-module-path %t/test.module -enable-cas -cas-path %t/cas \
@@ -9,7 +9,7 @@
 // RUN:   -allow-unstable-cache-key-for-testing %s 2>&1 | %FileCheck %s
 
 #sourceLocation(file: "anything.swift", line: 1)
-func 1() {}
+#warning("this is a warning")
 #sourceLocation()
 
-// CHECK: anything.swift:1:6: error: function name
+// CHECK: anything.swift:1:10: warning: this is a warning

test/ClangImporter/pcm-emit-direct-cc1-mode.swift

@@ -9,8 +9,8 @@
 // CHECK-DUMP:   Module map file: {{.*[/\\]}}Inputs{{/|\\}}custom-modules{{/|\\}}module.map
 
 // Verify that the clang command-line used is cc1
-// RUN: %FileCheck -check-prefix CHECK-CLANG %s < %t.diags.txt
-// CHECK-CLANG: '{{.*[/\\]}}clang'{{.*}}'-fmodules'
+// RUN: %FileCheck -check-prefix CHECK-CLANG -DTRIPLE=%target-triple %s < %t.diags.txt
+// CHECK-CLANG: '{{.*[/\\]}}module.map' '-o' '{{.*[/\\]}}script.pcm' '-fmodules' '-triple' '[[TRIPLE]]' '-x' 'objective-c'
 
 import script
 var _ : ScriptTy