Merge pull request #2768 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

include/swift/Runtime/Concurrency.h

@@ -225,6 +225,17 @@ size_t swift_task_getJobFlags(AsyncTask* task);
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 bool swift_task_isCancelled(AsyncTask* task);
 
+/// Create and add an cancellation record to the task.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+CancellationNotificationStatusRecord*
+swift_task_addCancellationHandler(
+    AsyncTask *task, CancellationNotificationStatusRecord::FunctionType handler);
+
+/// Remove the passed cancellation record from the task.
+SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
+void swift_task_removeCancellationHandler(
+    AsyncTask *task, CancellationNotificationStatusRecord *record);
+
 using TaskLocalValuesFragment = AsyncTask::TaskLocalValuesFragment;
 
 /// Get a task local value from the passed in task. Its Swift signature is

include/swift/Runtime/RuntimeFunctions.def

@@ -1527,7 +1527,7 @@ FUNCTION(TaskCreateFutureFunc,
 //                        ExecutorRef currentExecutor,
 //                        ExecutorRef newExecutor);
 FUNCTION(TaskSwitchFunc,
-         swift_task_switch, SwiftCC,
+         swift_task_switch, SwiftAsyncCC,
          ConcurrencyAvailability,
          RETURNS(VoidTy),
          ARGS(SwiftTaskPtrTy, SwiftExecutorPtrTy, SwiftExecutorPtrTy),

include/swift/SIL/SILVTableVisitor.h

@@ -92,8 +92,11 @@ template <class T> class SILVTableVisitor {
       //   replace the vtable entry for B.f(); a call to A.f()
       //   will correctly dispatch to the implementation of B.f()
       //   in the subclass.
+      auto *UseDC = declRef.getDecl()->getDeclContext();
       if (!baseRef.getDecl()->isAccessibleFrom(
-            declRef.getDecl()->getDeclContext()))
+            UseDC,
+            /*forConformance=*/false,
+            /*allowUsableFromInline=*/true))
         break;
 
       asDerived().addMethodOverride(baseRef, declRef);

include/swift/Sema/CSBindings.h

@@ -206,6 +206,11 @@ struct LiteralRequirement {
                                     bool canBeNil,
                                     DeclContext *useDC) const;
 
+  void resetCoverage() {
+    assert(isCovered() && "literal requirement is uncovered");
+    CoveredBy = nullptr;
+  }
+
   /// Determines whether literal protocol associated with this
   /// meta-information is viable for inclusion as a defaultable binding.
   bool viableAsBinding() const { return !isCovered() && hasDefaultType(); }
@@ -465,6 +470,13 @@ struct PotentialBindings {
 public:
   void infer(Constraint *constraint);
 
+  /// Retract all bindings and other information related to a given
+  /// constraint from this binding set.
+  ///
+  /// This would happen when constraint is simplified or solver backtracks
+  /// (either from overload choice or (some) type variable binding).
+  void retract(Constraint *constraint);
+
   /// Finalize binding computation for this type variable by
   /// inferring bindings from context e.g. transitive bindings.
   void finalize(llvm::SmallDenseMap<TypeVariableType *, PotentialBindings>

lib/AST/Decl.cpp

@@ -3418,13 +3418,16 @@ static bool checkAccess(const DeclContext *useDC, const ValueDecl *VD,
 }
 
 bool ValueDecl::isMoreVisibleThan(ValueDecl *other) const {
-  auto scope = getFormalAccessScope();
+  auto scope = getFormalAccessScope(/*UseDC=*/nullptr,
+                                    /*treatUsableFromInlineAsPublic=*/true);
 
   // 'other' may have come from a @testable import, so we need to upgrade it's
   // visibility to public here. That is not the same as whether 'other' is
   // being built with -enable-testing though -- we don't want to treat it
   // differently in that case.
-  auto otherScope = other->getFormalAccessScope(getDeclContext());
+  auto otherScope =
+      other->getFormalAccessScope(getDeclContext(),
+                                  /*treatUsableFromInlineAsPublic=*/true);
 
   if (scope.isPublic())
     return !otherScope.isPublic();

lib/IRGen/GenCall.cpp

@@ -462,7 +462,8 @@ static llvm::CallingConv::ID getFreestandingConvention(IRGenModule &IGM) {
 /// Expand the requirements of the given abstract calling convention
 /// into a "physical" calling convention.
 llvm::CallingConv::ID irgen::expandCallingConv(IRGenModule &IGM,
-                                    SILFunctionTypeRepresentation convention) {
+                                    SILFunctionTypeRepresentation convention,
+                                    bool isAsync) {
   switch (convention) {
   case SILFunctionTypeRepresentation::CFunctionPointer:
   case SILFunctionTypeRepresentation::ObjCMethod:
@@ -474,6 +475,8 @@ llvm::CallingConv::ID irgen::expandCallingConv(IRGenModule &IGM,
   case SILFunctionTypeRepresentation::Closure:
   case SILFunctionTypeRepresentation::Thin:
   case SILFunctionTypeRepresentation::Thick:
+    if (isAsync)
+      return IGM.SwiftAsyncCC;
     return getFreestandingConvention(IGM);
   }
   llvm_unreachable("bad calling convention!");
@@ -1849,7 +1852,8 @@ Signature SignatureExpansion::getSignature() {
            (FnType->getLanguage() == SILFunctionLanguage::C) &&
          "C function type without C function info");
 
-  auto callingConv = expandCallingConv(IGM, FnType->getRepresentation());
+  auto callingConv =
+      expandCallingConv(IGM, FnType->getRepresentation(), FnType->isAsync());
 
   Signature result;
   result.Type = llvmType;
@@ -4823,7 +4827,7 @@ IRGenFunction::getFunctionPointerForResumeIntrinsic(llvm::Value *resume) {
       IGM.VoidTy, {IGM.Int8PtrTy, IGM.Int8PtrTy, IGM.Int8PtrTy},
       false /*vaargs*/);
   auto signature =
-      Signature(fnTy, IGM.constructInitialAttributes(), IGM.SwiftCC);
+      Signature(fnTy, IGM.constructInitialAttributes(), IGM.SwiftAsyncCC);
   auto fnPtr = FunctionPointer(
       FunctionPointer::KindTy::Function,
       Builder.CreateBitOrPointerCast(resume, fnTy->getPointerTo()),

lib/IRGen/GenCall.h

@@ -316,7 +316,8 @@ namespace irgen {
       std::pair<bool, bool> values = {true, true},
       Size initialContextSize = Size(0));
   llvm::CallingConv::ID expandCallingConv(IRGenModule &IGM,
-                                     SILFunctionTypeRepresentation convention);
+                                     SILFunctionTypeRepresentation convention,
+                                     bool isAsync);
 
   Signature emitCastOfFunctionPointer(IRGenFunction &IGF, llvm::Value *&fnPtr,
                                       CanSILFunctionType fnType);

lib/IRGen/GenFunc.cpp

@@ -2582,7 +2582,7 @@ llvm::Function *IRGenFunction::createAsyncSuspendFn() {
       IGM.getTaskSwitchFuncFn(),
       { task, executor, targetExecutor });
   suspendCall->setDoesNotThrow();
-  suspendCall->setCallingConv(IGM.SwiftCC);
+  suspendCall->setCallingConv(IGM.SwiftAsyncCC);
   suspendCall->setTailCall();
   Builder.CreateRetVoid();
   return suspendFn;

lib/IRGen/GenObjC.cpp

@@ -710,8 +710,8 @@ static llvm::Function *emitObjCPartialApplicationForwarder(IRGenModule &IGM,
     llvm::Function::Create(fwdTy, llvm::Function::InternalLinkage,
                            MANGLE_AS_STRING(OBJC_PARTIAL_APPLY_THUNK_SYM),
                            &IGM.Module);
-  fwd->setCallingConv(
-      expandCallingConv(IGM, SILFunctionTypeRepresentation::Thick));
+  fwd->setCallingConv(expandCallingConv(
+      IGM, SILFunctionTypeRepresentation::Thick, false/*isAsync*/));
 
   fwd->setAttributes(attrs);
   // Merge initial attributes with attrs.

lib/IRGen/IRGenModule.cpp

@@ -547,6 +547,9 @@ IRGenModule::IRGenModule(IRGenerator &irgen,
   // TODO: use "tinycc" on platforms that support it
   DefaultCC = SWIFT_DEFAULT_LLVM_CC;
   SwiftCC = llvm::CallingConv::Swift;
+  // TODO: Once clang support is merged this should also use
+  //  clangASTContext.getTargetInfo().isSwiftAsyncCCSupported()
+  SwiftAsyncCC = opts.UseAsyncLowering ? llvm::CallingConv::SwiftTail : SwiftCC;
 
   if (opts.DebugInfoLevel > IRGenDebugInfoLevel::None)
     DebugInfo = IRGenDebugInfo::createIRGenDebugInfo(IRGen.Opts, *CI, *this,