Merge remote-tracking branch 'upstream/main' into swift-lexical-lookup-validation

Author: MAJKFL

SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift

@@ -696,11 +696,23 @@ private struct FindBeginBorrowWalker : ValueUseDefWalker {
     if value == beginBorrow {
       return .abortWalk
     }
+    if value.ownership != .guaranteed {
+      // If value is owned then it cannot be the borrowed value.
+      return .continueWalk
+    }
     return walkUpDefault(value: value, path: path)
   }
 
   mutating func rootDef(value: Value, path: SmallProjectionPath) -> WalkResult {
-    return .continueWalk
+    switch value {
+    case is FunctionArgument,
+         // Loading a value from memory cannot be the borrowed value.
+         // Note that we exclude the "regular" `load` by checking for guaranteed ownership in `walkUp`.
+         is LoadBorrowInst:
+      return .continueWalk
+    default:
+      return .abortWalk
+    }
   }
 }
 

cmake/modules/SwiftUtils.cmake

@@ -190,33 +190,27 @@ endfunction()
 # we create a `swift-driver` symlink adjacent to the `swift` and `swiftc` executables
 # to ensure that `swiftc` forwards to the standalone driver when invoked.
 function(swift_create_early_driver_copies target)
-  # Early swift-driver is built adjacent to the compiler (swift build dir)
-  if(CMAKE_BUILD_TYPE STREQUAL "Release" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
-    set(driver_package_configuration_dir "release")
-  else()
-    set(driver_package_configuration_dir "debug")
-  endif()
-  
-  set(driver_bin_dir "${CMAKE_BINARY_DIR}/../earlyswiftdriver-${SWIFT_HOST_VARIANT}-${SWIFT_HOST_VARIANT_ARCH}/${driver_package_configuration_dir}/bin")
-  set(swift_bin_dir "${SWIFT_RUNTIME_OUTPUT_INTDIR}")
-  # If early swift-driver wasn't built, nothing to do here.
-  if(NOT EXISTS "${driver_bin_dir}/swift-driver" OR NOT EXISTS "${driver_bin_dir}/swift-help")
-      message(STATUS "Skipping creating early SwiftDriver symlinks - no early SwiftDriver build found at: ${driver_bin_dir}.")
-      return()
+  set(SWIFT_EARLY_SWIFT_DRIVER_BUILD "" CACHE PATH "Path to early swift-driver build")
+
+  if(NOT SWIFT_EARLY_SWIFT_DRIVER_BUILD)
+    return()
   endif()
 
-  message(STATUS "Copying over early SwiftDriver executable.")
-  message(STATUS "From: ${driver_bin_dir}/swift-driver")
-  message(STATUS "To: ${swift_bin_dir}/swift-driver")
-  # Use configure_file instead of file(COPY...) to establish a dependency.
-  # Further Changes to `swift-driver` will cause it to be copied over.
-  configure_file(${driver_bin_dir}/swift-driver ${swift_bin_dir}/swift-driver COPYONLY)
-
-  message(STATUS "From: ${driver_bin_dir}/swift-help")
-  message(STATUS "To: ${swift_bin_dir}/swift-help")
-  # Use configure_file instead of file(COPY...) to establish a dependency.
-  # Further Changes to `swift-driver` will cause it to be copied over.  
-  configure_file(${driver_bin_dir}/swift-help ${swift_bin_dir}/swift-help COPYONLY)
+  if(EXISTS ${SWIFT_EARLY_SWIFT_DRIVER_BUILD}/swift-driver${CMAKE_EXECUTABLE_SUFFIX})
+    message(STATUS "Creating early SwiftDriver symlinks")
+
+    # Use `configure_file` instead of `file(COPY ...)` to establish a
+    # dependency.  Further changes to `swift-driver` will cause it to be copied
+    # over.
+    configure_file(${SWIFT_EARLY_SWIFT_DRIVER_BUILD}/swift-driver${CMAKE_EXECUTABLE_SUFFIX}
+                   ${SWIFT_RUNTIME_OUTPUT_INTDIR}/swift-driver${CMAKE_EXECUTABLE_SUFFIX}
+                   COPYONLY)
+    configure_file(${SWIFT_EARLY_SWIFT_DRIVER_BUILD}/swift-help${CMAKE_EXECUTABLE_SUFFIX}
+                   ${SWIFT_RUNTIME_OUTPUT_INTDIR}/swift-help${CMAKE_EXECUTABLE_SUFFIX}
+                   COPYONLY)
+  else()
+    message(STATUS "Not creating early SwiftDriver symlinks (swift-driver not found)")
+  endif()
 endfunction()
 
 function(dump_swift_vars)

include/swift/AST/DiagnosticsSema.def

@@ -5105,7 +5105,8 @@ ERROR(unknown_case_must_be_last,none,
       "'@unknown' can only be applied to the last case in a switch", ())
 
 WARNING(where_on_one_item, none,
-        "'where' only applies to the second pattern match in this case", ())
+        "'where' only applies to the second pattern match in this "
+        "'%select{case|catch}0'", (bool))
 
 NOTE(add_where_newline, none,
      "disambiguate by adding a line break between them if this is desired", ())

include/swift/Option/Options.td

@@ -1670,6 +1670,15 @@ def omit_extension_block_symbols: Flag<["-"], "omit-extension-block-symbols">,
         NoInteractiveOption, SupplementaryOutput, HelpHidden]>,
   HelpText<"Directly associate members and conformances with the extended nominal when generating symbol graphs instead of emitting 'swift.extension' symbols for extensions to external types">;
 
+// swift-synthesize-interface-only options
+def include_submodules : Flag<["-"], "include-submodules">,
+  Flags<[NoDriverOption, SwiftSynthesizeInterfaceOption]>,
+  HelpText<"Also print the declarations synthesized for any Clang submodules">;
+
+def print_fully_qualified_types : Flag<["-"], "print-fully-qualified-types">,
+  Flags<[NoDriverOption, SwiftSynthesizeInterfaceOption]>,
+  HelpText<"Always print fully qualified type names">;
+
 // swift-symbolgraph-extract-only options
 def output_dir : Separate<["-"], "output-dir">,
   Flags<[NoDriverOption, SwiftSymbolGraphExtractOption, SwiftAPIDigesterOption,

lib/ASTGen/Sources/ASTGen/Exprs.swift

@@ -161,8 +161,8 @@ extension ASTGenVisitor {
       return self.generate(subscriptCallExpr: node).asExpr
     case .superExpr(let node):
       return self.generate(superExpr: node).asExpr
-    case .switchExpr:
-      break
+    case .switchExpr(let node):
+      return self.generate(switchExpr: node).asExpr
     case .ternaryExpr:
       preconditionFailure("TernaryExprSyntax only appear after operator folding")
     case .tryExpr(let node):
@@ -1063,6 +1063,18 @@ extension ASTGenVisitor {
     return .createParsed(self.ctx, superLoc: self.generateSourceLoc(node))
   }
 
+  func generate(switchExpr node: SwitchExprSyntax) -> BridgedSingleValueStmtExpr {
+    let stmt = self.generateSwitchStmt(switchExpr: node)
+
+    // Wrap in a SingleValueStmtExpr to embed as an expression.
+    return .createWithWrappedBranches(
+      ctx,
+      stmt: stmt.asStmt,
+      declContext: declContext,
+      mustBeExpr: true
+    )
+  }
+
   func generate(tryExpr node: TryExprSyntax) -> BridgedExpr {
     let tryLoc = self.generateSourceLoc(node.tryKeyword)
     let subExpr = self.generate(expr: node.expression)

lib/ClangImporter/ClangModuleDependencyScanner.cpp

@@ -552,15 +552,8 @@ bool ClangImporter::getHeaderDependencies(
     auto swiftBinaryDeps = targetModuleInfo.getAsSwiftBinaryModule();
     if (!swiftBinaryDeps->headerImport.empty()) {
       auto clangModuleDependencies = scanHeaderDependencies(swiftBinaryDeps->headerImport);
-      if (!clangModuleDependencies) {
-        // FIXME: Route this to a normal diagnostic.
-        llvm::logAllUnhandledErrors(clangModuleDependencies.takeError(),
-                                    llvm::errs());
-        Impl.SwiftContext.Diags.diagnose(
-            SourceLoc(), diag::clang_dependency_scan_error,
-            "failed to scan header dependencies");
+      if (!clangModuleDependencies)
         return true;
-      }
     }
   }
 

lib/DriverTool/swift_synthesize_interface_main.cpp

@@ -200,11 +200,19 @@ int swift_synthesize_interface_main(ArrayRef<const char *> Args,
     return EXIT_FAILURE;
   }
 
-  StreamPrinter printer(fs);
   PrintOptions printOpts =
       PrintOptions::printModuleInterface(/*printFullConvention=*/true);
-  ide::printModuleInterface(M, /*GroupNames=*/{},
-                            /*TraversalOptions=*/std::nullopt, printer,
+  if (ParsedArgs.hasArg(OPT_print_fully_qualified_types)) {
+    printOpts.FullyQualifiedTypes = true;
+  }
+
+  swift::OptionSet<swift::ide::ModuleTraversal> traversalOpts = std::nullopt;
+  if (ParsedArgs.hasArg(OPT_include_submodules)) {
+    traversalOpts = swift::ide::ModuleTraversal::VisitSubmodules;
+  }
+
+  StreamPrinter printer(fs);
+  ide::printModuleInterface(M, /*GroupNames=*/{}, traversalOpts, printer,
                             printOpts, /*PrintSynthesizedExtensions=*/false);
 
   return EXIT_SUCCESS;

lib/IRGen/GenDecl.cpp

@@ -6192,13 +6192,18 @@ IRGenModule::getAddrOfContinuationPrototype(CanSILFunctionType fnType) {
 /// Should we be defining the given helper function?
 static llvm::Function *shouldDefineHelper(IRGenModule &IGM,
                                           llvm::Constant *fn,
-                                          bool setIsNoInline) {
+                                          bool setIsNoInline,
+                                          IRLinkage *linkage) {
   auto *def = dyn_cast<llvm::Function>(fn);
   if (!def) return nullptr;
   if (!def->empty()) return nullptr;
 
   def->setAttributes(IGM.constructInitialAttributes());
-  ApplyIRLinkage(IRLinkage::InternalLinkOnceODR).to(def);
+  if (!linkage)
+    ApplyIRLinkage(IRLinkage::InternalLinkOnceODR).to(def);
+  else
+    ApplyIRLinkage(*linkage).to(def);
+
   def->setDoesNotThrow();
   def->setCallingConv(IGM.DefaultCC);
   if (setIsNoInline)
@@ -6220,15 +6225,17 @@ IRGenModule::getOrCreateHelperFunction(StringRef fnName, llvm::Type *resultTy,
                         llvm::function_ref<void(IRGenFunction &IGF)> generate,
                         bool setIsNoInline,
                         bool forPrologue,
-                        bool isPerformanceConstraint) {
+                        bool isPerformanceConstraint,
+                        IRLinkage *optionalLinkageOverride) {
   llvm::FunctionType *fnTy =
     llvm::FunctionType::get(resultTy, paramTys, false);
 
   llvm::Constant *fn =
       cast<llvm::Constant>(
           Module.getOrInsertFunction(fnName, fnTy).getCallee());
 
-  if (llvm::Function *def = shouldDefineHelper(*this, fn, setIsNoInline)) {
+  if (llvm::Function *def = shouldDefineHelper(*this, fn, setIsNoInline,
+                                               optionalLinkageOverride)) {
     IRGenFunction IGF(*this, def, isPerformanceConstraint);
     if (DebugInfo && !forPrologue)
       DebugInfo->emitArtificialFunction(IGF, def);

lib/IRGen/IRGenModule.h

@@ -147,6 +147,7 @@ namespace irgen {
   class StructLayout;
   class IRGenDebugInfo;
   class IRGenFunction;
+  struct IRLinkage;
   class LinkEntity;
   class LoadableTypeInfo;
   class MetadataLayout;
@@ -1221,7 +1222,8 @@ class IRGenModule {
                         llvm::function_ref<void(IRGenFunction &IGF)> generate,
                         bool setIsNoInline = false,
                         bool forPrologue = false,
-                        bool isPerformanceConstraint = false);
+                        bool isPerformanceConstraint = false,
+                        IRLinkage *optionalLinkage = nullptr);
 
   llvm::Constant *getOrCreateRetainFunction(const TypeInfo &objectTI, SILType t,
                               llvm::Type *llvmType, Atomicity atomicity);

lib/IRGen/Outlining.cpp

@@ -30,6 +30,7 @@
 #include "swift/AST/IRGenOptions.h"
 #include "swift/Basic/Assertions.h"
 #include "swift/IRGen/GenericRequirement.h"
+#include "swift/IRGen/Linking.h"
 #include "swift/SIL/SILModule.h"
 
 using namespace swift;
@@ -489,6 +490,22 @@ llvm::Constant *IRGenModule::getOrCreateOutlinedCopyAddrHelperFunction(
   paramTys.push_back(ptrTy);
   collector.addPolymorphicParameterTypes(paramTys);
 
+  IRLinkage *linkage = nullptr;
+  IRLinkage privateLinkage = {
+    llvm::GlobalValue::PrivateLinkage,
+    llvm::GlobalValue::DefaultVisibility,
+    llvm::GlobalValue::DefaultStorageClass,
+  };
+  auto &TL =
+    getSILModule().Types.getTypeLowering(T, TypeExpansionContext::minimal());
+  // Opaque result types might lead to different expansions in different files.
+  // The default hidden linkonce_odr might lead to linking an implementation
+  // from another file that head a different expansion/different
+  // signature/different implementation.
+  if (TL.getRecursiveProperties().isTypeExpansionSensitive()) {
+    linkage = &privateLinkage;
+  }
+
   return getOrCreateHelperFunction(funcName, ptrTy, paramTys,
       [&](IRGenFunction &IGF) {
         auto params = IGF.collectParameters();
@@ -500,7 +517,8 @@ llvm::Constant *IRGenModule::getOrCreateOutlinedCopyAddrHelperFunction(
       },
       true /*setIsNoInline*/,
       false /*forPrologue*/,
-      collector.IGF.isPerformanceConstraint);
+      collector.IGF.isPerformanceConstraint,
+      linkage);
 }
 
 void TypeInfo::callOutlinedDestroy(IRGenFunction &IGF,
@@ -544,6 +562,22 @@ llvm::Constant *IRGenModule::getOrCreateOutlinedDestroyFunction(
   auto funcName = mangler.mangleOutlinedDestroyFunction(manglingBits.first,
                      manglingBits.second, collector.IGF.isPerformanceConstraint);
 
+  IRLinkage *linkage = nullptr;
+  IRLinkage privateLinkage = {
+    llvm::GlobalValue::PrivateLinkage,
+    llvm::GlobalValue::DefaultVisibility,
+    llvm::GlobalValue::DefaultStorageClass,
+  };
+  auto &TL =
+    getSILModule().Types.getTypeLowering(T, TypeExpansionContext::minimal());
+  // Opaque result types might lead to different expansions in different files.
+  // The default hidden linkonce_odr might lead to linking an implementation
+  // from another file that head a different expansion/different
+  // signature/different implementation.
+  if (TL.getRecursiveProperties().isTypeExpansionSensitive()) {
+    linkage = &privateLinkage;
+  }
+
   auto ptrTy = ti.getStorageType()->getPointerTo();
   llvm::SmallVector<llvm::Type *, 4> paramTys;
   paramTys.push_back(ptrTy);
@@ -565,7 +599,8 @@ llvm::Constant *IRGenModule::getOrCreateOutlinedDestroyFunction(
       },
       true /*setIsNoInline*/,
       false /*forPrologue*/,
-      collector.IGF.isPerformanceConstraint);
+      collector.IGF.isPerformanceConstraint,
+      linkage);
 }
 
 llvm::Constant *IRGenModule::getOrCreateRetainFunction(const TypeInfo &ti,