Merge pull request #2934 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

include/swift/ABI/Task.h

@@ -566,7 +566,7 @@ class ContinuationAsyncContext : public AsyncContext {
 /// task.
 ///
 /// This type matches the ABI of a function `<T> () async throws -> T`, which
-/// is the type used by `Task.runDetached` and `Task.group.add` to create
+/// is the type used by `detach` and `Task.group.add` to create
 /// futures.
 class FutureAsyncContext : public AsyncContext {
 public:

include/swift/AST/Builtins.def

@@ -626,6 +626,9 @@ BUILTIN_MISC_OPERATION(ExtractElement, "extractelement", "n", Special)
 /// InsertElement has type (Vector<N, T>, T, Int32) -> Vector<N, T>.
 BUILTIN_MISC_OPERATION(InsertElement, "insertelement", "n", Special)
 
+// Shufflevector has type (VecN<T>, VecN<T>, VecM<Int32>) -> VecM<T>
+BUILTIN_MISC_OPERATION(ShuffleVector, "shufflevector", "n", Special)
+
 /// StaticReport has type (Builtin.Int1, Builtin.Int1, Builtin.RawPointer) -> ()
 BUILTIN_MISC_OPERATION(StaticReport, "staticReport", "", Special)
 
@@ -655,8 +658,6 @@ BUILTIN_MISC_OPERATION(UToUCheckedTrunc, "u_to_u_checked_trunc", "n", Special)
 /// IntToFPWithOverflow has type (Integer) -> Float
 BUILTIN_MISC_OPERATION(IntToFPWithOverflow, "itofp_with_overflow", "n", Special)
 
-// FIXME: shufflevector
-
 /// zeroInitializer has type <T> () -> T
 BUILTIN_MISC_OPERATION(ZeroInitializer, "zeroInitializer", "n", Special)
 

include/swift/AST/Decl.h

@@ -3486,7 +3486,7 @@ class StructDecl final : public NominalTypeDecl {
   SourceLoc StructLoc;
 
   // We import C++ class templates as generic structs. Then when in Swift code
-  // we want to substitude generic parameters with actual arguments, we
+  // we want to substitute generic parameters with actual arguments, we
   // convert the arguments to C++ equivalents and ask Clang to instantiate the
   // C++ template. Then we import the C++ class template instantiation
   // as a non-generic structs with a name prefixed with `__CxxTemplateInst`.

include/swift/Runtime/Concurrency.h

@@ -117,6 +117,9 @@ SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 JobPriority
 swift_task_escalate(AsyncTask *task, JobPriority newPriority);
 
+// TODO: "async let wait" and "async let destroy" would be expressed
+//       similar to like TaskFutureWait;
+
 /// This matches the ABI of a closure `<T>(Builtin.NativeObject) async -> T`
 using TaskFutureWaitSignature =
     SWIFT_CC(swiftasync)
@@ -237,11 +240,12 @@ void swift_taskGroup_destroy(TaskGroup *group);
 ///
 /// \code
 /// func swift_taskGroup_addPending(
-///     group: Builtin.RawPointer
+///     group: Builtin.RawPointer,
+///     unconditionally: Bool
 /// ) -> Bool
 /// \endcode
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-bool swift_taskGroup_addPending(TaskGroup *group);
+bool swift_taskGroup_addPending(TaskGroup *group, bool unconditionally);
 
 /// Cancel all tasks in the group.
 /// This also prevents new tasks from being added.

lib/AST/Builtins.cpp

@@ -1649,6 +1649,27 @@ static ValueDecl *getInsertElementOperation(ASTContext &Context, Identifier Id,
   return getBuiltinFunction(Id, ArgElts, VecTy);
 }
 
+static ValueDecl *getShuffleVectorOperation(ASTContext &Context, Identifier Id,
+                                 Type FirstTy, Type SecondTy) {
+  // (Vector<N, T>, Vector<N, T>, Vector<M, Int32) -> Vector<M, T>
+  auto VecTy = FirstTy->getAs<BuiltinVectorType>();
+  if (!VecTy)
+    return nullptr;
+  auto ElementTy = VecTy->getElementType();
+
+  auto IndexTy = SecondTy->getAs<BuiltinVectorType>();
+  if (!IndexTy)
+    return nullptr;
+  auto IdxElTy = IndexTy->getElementType()->getAs<BuiltinIntegerType>();
+  if (!IdxElTy || !IdxElTy->isFixedWidth() || IdxElTy->getFixedWidth() != 32)
+    return nullptr;
+
+  Type ArgElts[] = { VecTy, VecTy, IndexTy };
+  Type ResultTy = BuiltinVectorType::get(Context, ElementTy,
+                                         IndexTy->getNumElements());
+  return getBuiltinFunction(Id, ArgElts, ResultTy);
+}
+
 static ValueDecl *getStaticReportOperation(ASTContext &Context, Identifier Id) {
   auto BoolTy = BuiltinIntegerType::get(1, Context);
   auto MessageTy = Context.TheRawPointerType;
@@ -2594,6 +2615,10 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
   case BuiltinValueKind::InsertElement:
     if (Types.size() != 3) return nullptr;
     return getInsertElementOperation(Context, Id, Types[0], Types[1], Types[2]);
+      
+  case BuiltinValueKind::ShuffleVector:
+    if (Types.size() != 2) return nullptr;
+    return getShuffleVectorOperation(Context, Id, Types[0], Types[1]);
 
   case BuiltinValueKind::StaticReport:
     if (!Types.empty()) return nullptr;

lib/AST/DeclContext.cpp

@@ -1188,7 +1188,9 @@ bool DeclContext::hasValueSemantics() const {
 bool DeclContext::isClassConstrainedProtocolExtension() const {
   if (getExtendedProtocolDecl()) {
     auto ED = cast<ExtensionDecl>(this);
-    return ED->getGenericSignature()->requiresClass(ED->getSelfInterfaceType());
+    if (auto sig = ED->getGenericSignature()) {
+      return sig->requiresClass(ED->getSelfInterfaceType());
+    }
   }
   return false;
 }

lib/IRGen/GenBuiltin.cpp

@@ -835,6 +835,16 @@ if (Builtin.ID == BuiltinValueKind::id) { \
     out.add(IGF.Builder.CreateInsertElement(vector, newValue, index));
     return;
   }
+  
+  if (Builtin.ID == BuiltinValueKind::ShuffleVector) {
+    using namespace llvm;
+
+    auto dict0 = args.claimNext();
+    auto dict1 = args.claimNext();
+    auto index = args.claimNext();
+    out.add(IGF.Builder.CreateShuffleVector(dict0, dict1, index));
+    return;
+  }
 
   if (Builtin.ID == BuiltinValueKind::SToSCheckedTrunc ||
       Builtin.ID == BuiltinValueKind::UToUCheckedTrunc ||

lib/SIL/IR/OperandOwnership.cpp

@@ -709,6 +709,7 @@ BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, SToUCheckedTrunc)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, Expect)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, Shl)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, GenericShl)
+BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, ShuffleVector)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, Sizeof)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, StaticReport)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, Strideof)

lib/SIL/IR/ValueOwnership.cpp

@@ -569,6 +569,7 @@ UNOWNED_OR_NONE_DEPENDING_ON_RESULT(CmpXChg)
 UNOWNED_OR_NONE_DEPENDING_ON_RESULT(AtomicLoad)
 UNOWNED_OR_NONE_DEPENDING_ON_RESULT(ExtractElement)
 UNOWNED_OR_NONE_DEPENDING_ON_RESULT(InsertElement)
+UNOWNED_OR_NONE_DEPENDING_ON_RESULT(ShuffleVector)
 UNOWNED_OR_NONE_DEPENDING_ON_RESULT(ZeroInitializer)
 #undef UNOWNED_OR_NONE_DEPENDING_ON_RESULT
 

lib/SILGen/SILGenDecl.cpp

@@ -1142,6 +1142,8 @@ void SILGenFunction::emitPatternBinding(PatternBindingDecl *PBD,
   auto initialization = emitPatternBindingInitialization(PBD->getPattern(idx),
                                                          JumpDest::invalid());
 
+  // TODO: need to allocate the variable, stackalloc it? pass the address to the start()
+
   // If this is an async let, create a child task to compute the initializer
   // value.
   if (PBD->isAsyncLet()) {
@@ -1157,11 +1159,35 @@ void SILGenFunction::emitPatternBinding(PatternBindingDecl *PBD,
            "Could not find async let autoclosure");
     bool isThrowing = init->getType()->castTo<AnyFunctionType>()->isThrowing();
 
+    // TODO: there's a builtin to make an address into a raw pointer
+    //       --- note dont need that; just have the builtin take it inout?
+    //       --- the builtin can take the address (for start())
+
+    // TODO: make a builtin start async let
+    // Builtin.startAsyncLet -- and in the builtin create the async let record
+
+    // TODO: make a builtin for end async let
+
+    // TODO: IRGen would make a local allocation for the builtins
+
+    // TODO: remember if we did an await already?
+
+    // TODO: force in typesystem that we always await; then end aysnc let does not have to be async
+    // the local let variable is actually owning the result
+    // - but since throwing we can't know; maybe we didnt await on a thing yet
+    // so we do need the tracking if we waited on a thing
+
+    // TODO: awaiting an async let should be able to take ownership
+    // that means we will not await on this async let again, maybe?
+    // it means that the async let destroy should not destroy the result anymore
+
     // Emit the closure for the child task.
     SILValue childTask;
     {
       FullExpr Scope(Cleanups, CleanupLocation(init));
       SILLocation loc(PBD);
+      // TODO: opaque object in the async context that represents the async let
+      //
       childTask = emitRunChildTask(
           loc,
           init->getType(),
@@ -1173,7 +1199,7 @@ void SILGenFunction::emitPatternBinding(PatternBindingDecl *PBD,
     enterDestroyCleanup(childTask);
 
     // Push a cleanup that will cancel the child task at the end of the scope.
-    enterCancelAsyncTaskCleanup(childTask);
+    enterCancelAsyncTaskCleanup(childTask); // TODO: this is "went out scope" rather than just a cancel
 
     // Save the child task so we can await it as needed.
     AsyncLetChildTasks[{PBD, idx}] = { childTask, isThrowing };

lib/SILOptimizer/Transforms/AccessEnforcementReleaseSinking.cpp

@@ -120,6 +120,7 @@ static bool isBarrier(SILInstruction *inst) {
     case BuiltinValueKind::OnFastPath:
     case BuiltinValueKind::ExtractElement:
     case BuiltinValueKind::InsertElement:
+    case BuiltinValueKind::ShuffleVector:
     case BuiltinValueKind::StaticReport:
     case BuiltinValueKind::AssertConf:
     case BuiltinValueKind::StringObjectOr:

lib/Sema/ConstraintSystem.cpp

@@ -702,11 +702,9 @@ Type ConstraintSystem::openUnboundGenericType(
   // pointing at a generic TypeAliasDecl here. If we find a way to
   // handle generic TypeAliases elsewhere, this can just become a
   // call to BoundGenericType::get().
-  return TypeChecker::applyUnboundGenericArguments(
-      decl, parentTy, SourceLoc(),
-      TypeResolution::forContextual(DC, None, /*unboundTyOpener*/ nullptr,
-                                    /*placeholderHandler*/ nullptr),
-      arguments);
+  return TypeResolution::forContextual(DC, None, /*unboundTyOpener*/ nullptr,
+                                       /*placeholderHandler*/ nullptr)
+      .applyUnboundGenericArguments(decl, parentTy, SourceLoc(), arguments);
 }
 
 static void checkNestedTypeConstraints(ConstraintSystem &cs, Type type,
@@ -1291,12 +1289,12 @@ ConstraintSystem::getTypeOfReference(ValueDecl *value,
   // Unqualified reference to a type.
   if (auto typeDecl = dyn_cast<TypeDecl>(value)) {
     // Resolve the reference to this type declaration in our current context.
-    auto type = TypeChecker::resolveTypeInContext(
-        typeDecl, nullptr,
+    auto type =
         TypeResolution::forContextual(useDC, TypeResolverContext::InExpression,
                                       /*unboundTyOpener*/ nullptr,
-                                      /*placeholderHandler*/ nullptr),
-        /*isSpecialized=*/false);
+                                      /*placeholderHandler*/ nullptr)
+            .resolveTypeInContext(typeDecl, /*foundDC*/ nullptr,
+                                  /*isSpecialized=*/false);
 
     checkNestedTypeConstraints(*this, type, locator);