Merge branch 'release/6.0' into release/6.0-more-fixes

Author: gottesmm

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeSideEffects.swift

@@ -215,7 +215,7 @@ private struct CollectedEffects {
   }
 
   mutating func addEffectsForEscapingArgument(argument: FunctionArgument) {
-    var escapeWalker = ArgumentEscapingWalker()
+    var escapeWalker = ArgumentEscapingWalker(context)
 
     if escapeWalker.hasUnknownUses(argument: argument) {
       // Worst case: we don't know anything about how the argument escapes.
@@ -414,13 +414,18 @@ private func defaultPath(for value: Value) -> SmallProjectionPath {
 /// Checks if an argument escapes to some unknown user.
 private struct ArgumentEscapingWalker : ValueDefUseWalker, AddressDefUseWalker {
   var walkDownCache = WalkerCache<UnusedWalkingPath>()
+  private let calleeAnalysis: CalleeAnalysis
 
   /// True if the argument escapes to a load which (potentially) "takes" the memory location.
   private(set) var foundTakingLoad = false
 
   /// True, if the argument escapes to a closure context which might be destroyed when called.
   private(set) var foundConsumingPartialApply = false
 
+  init(_ context: FunctionPassContext) {
+    self.calleeAnalysis = context.calleeAnalysis
+  }
+
   mutating func hasUnknownUses(argument: FunctionArgument) -> Bool {
     if argument.type.isAddress {
       return walkDownUses(ofAddress: argument, path: UnusedWalkingPath()) == .abortWalk
@@ -444,14 +449,23 @@ private struct ArgumentEscapingWalker : ValueDefUseWalker, AddressDefUseWalker {
       return .continueWalk
 
     case let apply as ApplySite:
-      if apply.isCallee(operand: value) {
-        // `CollectedEffects.handleApply` only handles argument operands of an apply, but not the callee operand.
-        return .abortWalk
-      }
       if let pa = apply as? PartialApplyInst, !pa.isOnStack {
         foundConsumingPartialApply = true
       }
-      return .continueWalk
+      // `CollectedEffects.handleApply` only handles argument operands of an apply, but not the callee operand.
+      if let calleeArgIdx = apply.calleeArgumentIndex(of: value),
+         let callees = calleeAnalysis.getCallees(callee: apply.callee)
+      {
+        // If an argument escapes in a called function, we don't know anything about the argument's side effects.
+        // For example, it could escape to the return value and effects might occur in the caller.
+        for callee in callees {
+          if callee.effects.escapeEffects.canEscape(argumentIndex: calleeArgIdx, path: SmallProjectionPath.init(.anyValueFields)) {
+            return .abortWalk
+          }
+        }
+        return .continueWalk
+      }
+      return .abortWalk
     default:
       return .abortWalk
     }

include/swift/AST/DiagnosticsParse.def

@@ -984,7 +984,7 @@ ERROR(extra_var_in_multiple_pattern_list,none,
 ERROR(let_pattern_in_immutable_context,none,
       "'let' pattern cannot appear nested in an already immutable context", ())
 WARNING(borrowing_syntax_change,none,
-      "'_borrowing' spelling is deprecated; use 'borrowing' without the underscore", ())
+        "'borrowing' in pattern matches is deprecated; use 'let'", ())
 ERROR(borrowing_subpattern_unsupported,none,
       "'borrowing' pattern modifier must be directly applied to pattern variable name", ())
 ERROR(specifier_must_have_type,none,

include/swift/Basic/Features.def

@@ -179,6 +179,7 @@ LANGUAGE_FEATURE(MoveOnlyPartialConsumption, 429, "Partial consumption of noncop
 LANGUAGE_FEATURE(BitwiseCopyable, 426, "BitwiseCopyable protocol")
 SUPPRESSIBLE_LANGUAGE_FEATURE(ConformanceSuppression, 426, "Suppressible inferred conformances")
 SUPPRESSIBLE_LANGUAGE_FEATURE(BitwiseCopyable2, 426, "BitwiseCopyable feature")
+SUPPRESSIBLE_LANGUAGE_FEATURE(NoncopyableGenerics, 427, "Noncopyable generics")
 
 // Swift 6
 UPCOMING_FEATURE(ConciseMagicFile, 274, 6)
@@ -196,6 +197,7 @@ UPCOMING_FEATURE(RegionBasedIsolation, 414, 6)
 UPCOMING_FEATURE(DynamicActorIsolation, 423, 6)
 UPCOMING_FEATURE(NonfrozenEnumExhaustivity, 192, 6)
 UPCOMING_FEATURE(GlobalActorIsolatedTypesUsability, 0434, 6)
+UPCOMING_FEATURE(BorrowingSwitch, 432, 6)
 
 // Swift 7
 UPCOMING_FEATURE(ExistentialAny, 335, 7)
@@ -322,9 +324,6 @@ EXPERIMENTAL_FEATURE(RawLayout, true)
 /// Enables the "embedded" swift mode (no runtime).
 EXPERIMENTAL_FEATURE(Embedded, true)
 
-/// Enables noncopyable generics
-SUPPRESSIBLE_EXPERIMENTAL_FEATURE(NoncopyableGenerics, true)
-
 // Alias for NoncopyableGenerics
 EXPERIMENTAL_FEATURE(NoncopyableGenerics2, true)
 
@@ -353,9 +352,6 @@ EXPERIMENTAL_FEATURE(GroupActorErrors, true)
 // Allow for the 'transferring' keyword to be applied to arguments and results.
 SUPPRESSIBLE_EXPERIMENTAL_FEATURE(TransferringArgsAndResults, true)
 
-// Allow for `switch` of noncopyable values to be borrowing or consuming.
-EXPERIMENTAL_FEATURE(BorrowingSwitch, true)
-
 // Enable explicit isolation of closures.
 EXPERIMENTAL_FEATURE(ClosureIsolation, true)
 

include/swift/Runtime/EnvironmentVariables.h

@@ -53,6 +53,10 @@ SWIFT_RUNTIME_STDLIB_SPI bool concurrencyEnableJobDispatchIntegration();
 // Concurrency library can call.
 SWIFT_RUNTIME_STDLIB_SPI bool concurrencyValidateUncheckedContinuations();
 
+// Wrapper around SWIFT_IS_CURRENT_EXECUTOR_LEGACY_MODE_OVERRIDE that the
+// Concurrency library can call.
+SWIFT_RUNTIME_STDLIB_SPI const char *concurrencyIsCurrentExecutorLegacyModeOverride();
+
 } // end namespace environment
 } // end namespace runtime
 } // end namespace swift

lib/ASTGen/Sources/ASTGen/SourceFile.swift

@@ -60,7 +60,6 @@ extension Parser.ExperimentalFeatures {
     mapFeature(.DoExpressions, to: .doExpressions)
     mapFeature(.NonescapableTypes, to: .nonescapableTypes)
     mapFeature(.TransferringArgsAndResults, to: .transferringArgsAndResults)
-    mapFeature(.BorrowingSwitch, to: .borrowingSwitch)
   }
 }
 

lib/Basic/LangOptions.cpp

@@ -47,6 +47,9 @@ LangOptions::LangOptions() {
 #endif
 
   // Note: Introduce default-on language options here.
+  Features.insert(Feature::NoncopyableGenerics);
+  Features.insert(Feature::BorrowingSwitch);
+  Features.insert(Feature::MoveOnlyPartialConsumption);
 
   // Enable any playground options that are enabled by default.
 #define PLAYGROUND_OPTION(OptionName, Description, DefaultOn, HighPerfOn) \

lib/ClangImporter/ClangImporter.cpp

@@ -5778,16 +5778,16 @@ cloneBaseMemberDecl(ValueDecl *decl, DeclContext *newContext) {
   if (auto var = dyn_cast<VarDecl>(decl)) {
     auto oldContext = var->getDeclContext();
     auto oldTypeDecl = oldContext->getSelfNominalTypeDecl();
-    // If the base type is non-copyable, and non-copyable generics are disabled,
-    // we cannot synthesize the accessor, because its implementation would use
-    // `UnsafePointer<BaseTy>`.
+    // If the base type is non-copyable, we cannot synthesize the accessor,
+    // because its implementation would use `UnsafePointer<BaseTy>`, and that
+    // triggers a bug when building SwiftCompilerSources. (rdar://128013193)
+    //
     // We cannot use `ty->isNoncopyable()` here because that would create a
     // cyclic dependency between ModuleQualifiedLookupRequest and
     // LookupConformanceInModuleRequest, so we check for the presence of
     // move-only attribute that is implicitly added to non-copyable C++ types by
     // ClangImporter.
-    if (oldTypeDecl->getAttrs().hasAttribute<MoveOnlyAttr>() &&
-        !context.LangOpts.hasFeature(Feature::NoncopyableGenerics))
+    if (oldTypeDecl->getAttrs().hasAttribute<MoveOnlyAttr>())
       return nullptr;
 
     auto rawMemory = allocateMemoryForDecl<VarDecl>(var->getASTContext(),

lib/ClangImporter/ImportType.cpp

@@ -509,8 +509,10 @@ namespace {
         return importFunctionPointerLikeType(*type, pointeeType);
       }
 
-      // If non-copyable generics are disabled, we cannot specify
-      // UnsafePointer<T> with a non-copyable type T.
+      // We cannot specify UnsafePointer<T> with a non-copyable type T just yet,
+      // because it triggers a bug when building SwiftCompilerSources.
+      // (rdar://128013193)
+      //
       // We cannot use `ty->isNoncopyable()` here because that would create a
       // cyclic dependency between ModuleQualifiedLookupRequest and
       // LookupConformanceInModuleRequest, so we check for the presence of
@@ -519,9 +521,7 @@ namespace {
       if (pointeeType && pointeeType->getAnyNominal() &&
           pointeeType->getAnyNominal()
               ->getAttrs()
-              .hasAttribute<MoveOnlyAttr>() &&
-          !Impl.SwiftContext.LangOpts.hasFeature(
-              Feature::NoncopyableGenerics)) {
+              .hasAttribute<MoveOnlyAttr>()) {
         auto opaquePointerDecl = Impl.SwiftContext.getOpaquePointerDecl();
         if (!opaquePointerDecl)
           return Type();

lib/Frontend/CompilerInvocation.cpp

@@ -470,13 +470,6 @@ static void SaveModuleInterfaceArgs(ModuleInterfaceOptions &Opts,
     interleave(RenderedArgs,
                [&](const char *Argument) { PrintArg(OS, Argument, StringRef()); },
                [&] { OS << " "; });
-
-    // Backward-compatibility hack: disable availability checking in the
-    // _Concurrency module, so that older (Swift 5.5) compilers that did not
-    // support back deployment of concurrency do not complain about 'async'
-    // with older availability.
-    if (FOpts.ModuleName == "_Concurrency")
-      OS << " -disable-availability-checking";
   }
   {
     llvm::raw_string_ostream OS(Opts.IgnorablePrivateFlags);

lib/IRGen/LoadableByAddress.cpp

@@ -17,7 +17,6 @@
 //===----------------------------------------------------------------------===//
 
 #define DEBUG_TYPE "loadable-address"
-#include "Explosion.h"
 #include "FixedTypeInfo.h"
 #include "IRGenMangler.h"
 #include "IRGenModule.h"
@@ -3432,29 +3431,6 @@ class AddressAssignment {
     toDeleteBlockArg.push_back(std::make_pair(b, argIdx));
   }
 
-  bool isPotentiallyCArray(SILType ty) {
-    if (ty.isAddress() || ty.isClassOrClassMetatype()) {
-      return false;
-    }
-
-    auto canType = ty.getASTType();
-    if (canType->hasTypeParameter()) {
-      assert(genEnv && "Expected a GenericEnv");
-      canType = genEnv->mapTypeIntoContext(canType)->getCanonicalType();
-    }
-
-    if (canType.getAnyGeneric() || isa<TupleType>(canType)) {
-      assert(ty.isObject() &&
-             "Expected only two categories: address and object");
-      assert(!canType->hasTypeParameter());
-      const TypeInfo &TI = irgenModule->getTypeInfoForLowered(canType);
-      auto explosionSchema = TI.getSchema();
-      if (explosionSchema.size() > 15)
-        return true;
-    }
-    return false;
-  }
-
   bool isLargeLoadableType(SILType ty) {
     if (ty.isAddress() || ty.isClassOrClassMetatype()) {
       return false;
@@ -3472,11 +3448,7 @@ class AddressAssignment {
       assert(!canType->hasTypeParameter());
       const TypeInfo &TI = irgenModule->getTypeInfoForLowered(canType);
       auto &nativeSchemaOrigParam = TI.nativeParameterValueSchema(*irgenModule);
-      if (nativeSchemaOrigParam.size() > 15)
-        return true;
-      auto explosionSchema = TI.getSchema();
-      if (explosionSchema.size() > 15)
-        return true;
+      return nativeSchemaOrigParam.size() > 15;
     }
     return false;
   }
@@ -3489,7 +3461,7 @@ class AddressAssignment {
     auto it = valueToAddressMap.find(v);
 
     // This can happen if we deem a container type small but a contained type
-    // big.
+    // big or if we lower an undef value.
     if (it == valueToAddressMap.end()) {
       if (auto *sv = dyn_cast<SingleValueInstruction>(v)) {
         auto addr = createAllocStack(v->getType());
@@ -3499,6 +3471,11 @@ class AddressAssignment {
         mapValueToAddress(v, addr);
         return addr;
       }
+      if (isa<SILUndef>(v)) {
+        auto undefAddr = createAllocStack(v->getType());
+        mapValueToAddress(v, undefAddr);
+        return undefAddr;
+      }
     }
     assert(it != valueToAddressMap.end());
 
@@ -3794,6 +3771,7 @@ class AssignAddressToDef : SILInstructionVisitor<AssignAddressToDef> {
                           StoreOwnershipQualifier::Unqualified);
       assignment.mapValueToAddress(origValue, addr);
       assignment.markForDeletion(bc);
+
       return;
     }
     auto opdAddr = assignment.getAddressForValue(bc->getOperand());
@@ -3955,9 +3933,7 @@ class RewriteUser : SILInstructionVisitor<RewriteUser> {
   }
 
   void visitDebugValueInst(DebugValueInst *dbg) {
-    if (!dbg->hasAddrVal() &&
-        (assignment.isPotentiallyCArray(dbg->getOperand()->getType()) ||
-         overlapsWithOnStackDebugLoc(dbg->getOperand()))) {
+    if (!dbg->hasAddrVal() && overlapsWithOnStackDebugLoc(dbg->getOperand())) {
       assignment.markForDeletion(dbg);
       return;
     }

lib/Macros/Sources/SwiftMacros/DistributedResolvableMacro.swift

@@ -133,15 +133,6 @@ extension DistributedResolvableMacro {
     var isGenericStub = false
     var specificActorSystemRequirement: TypeSyntax?
 
-    if proto.genericWhereClause == nil {
-      throw DiagnosticsError(
-        syntax: node,
-        message: """
-                 Distributed protocol must declare actor system with SerializationRequirement, for example:
-                    protocol Greeter<ActorSystem>: DistributedActor where ActorSystem: DistributedActorSystem<any Codable>
-                 """, id: .invalidApplication)
-    }
-
     let accessModifiers = proto.accessControlModifiers
 
     for req in proto.genericWhereClause?.requirements ?? [] {

lib/Option/SanitizerOptions.cpp

@@ -92,6 +92,12 @@ llvm::SanitizerCoverageOptions swift::parseSanitizerCoverageArgValue(
     } else if (StringRef(A->getValue(i)) == "trace-pc-guard") {
       opts.TracePCGuard = true;
       continue;
+    } else if (StringRef(A->getValue(i)) == "inline-8bit-counters") {
+      opts.Inline8bitCounters = true;
+      continue;
+    } else if (StringRef(A->getValue(i)) == "pc-table") {
+      opts.PCTable = true;
+      continue;
     }
 
     // Argument is not supported.