Merge pull request #4452 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

include/swift/AST/DiagnosticsSema.def

@@ -4635,6 +4635,9 @@ ERROR(distributed_actor_func_param_not_codable,none,
 ERROR(distributed_actor_target_result_not_codable,none,
       "result type %0 of %1 %2 does not conform to serialization requirement '%3'",
       (Type, DescriptiveDeclKind, Identifier, StringRef))
+ERROR(distributed_actor_system_serialization_req_must_be_protocol,none,
+      "'SerializationRequirement' type witness %0 must be a protocol type",
+      (Type))
 ERROR(distributed_actor_remote_func_implemented_manually,none,
       "distributed instance method's %0 remote counterpart %1 cannot not be implemented manually.",
       (Identifier, Identifier))

include/swift/AST/NameLookup.h

@@ -491,6 +491,9 @@ void lookupVisibleMemberDecls(VisibleDeclConsumer &Consumer,
 
 namespace namelookup {
 
+/// Add semantic members to \p type before attempting a semantic lookup.
+void installSemanticMembersIfNeeded(Type type, DeclNameRef name);
+
 void extractDirectlyReferencedNominalTypes(
     Type type, SmallVectorImpl<NominalTypeDecl *> &decls);
 

include/swift/Reflection/ReflectionContext.h

@@ -1377,8 +1377,15 @@ class ReflectionContext
       return std::string("failure reading allocation pool contents");
     auto Pool = reinterpret_cast<const PoolRange *>(PoolBytes.get());
 
+    // Limit how many iterations of this loop we'll do, to avoid potential
+    // infinite loops when reading bad data. Limit to 1 million iterations. In
+    // normal operation, each pool allocation is 16kB, so that would be ~16GB of
+    // metadata which is far more than any normal program should have.
+    unsigned LoopCount = 0;
+    unsigned LoopLimit = 1000000;
+
     auto TrailerPtr = Pool->Begin + Pool->Remaining;
-    while (TrailerPtr) {
+    while (TrailerPtr && LoopCount++ < LoopLimit) {
       auto TrailerBytes = getReader()
         .readBytes(RemoteAddress(TrailerPtr), sizeof(PoolTrailer));
       if (!TrailerBytes)
@@ -1426,8 +1433,15 @@ class ReflectionContext
     if (!BacktraceListNextPtr)
       return llvm::None;
 
+    // Limit how many iterations of this loop we'll do, to avoid potential
+    // infinite loops when reading bad data. Limit to 1 billion iterations. In
+    // normal operation, a program shouldn't have anywhere near 1 billion
+    // metadata allocations.
+    unsigned LoopCount = 0;
+    unsigned LoopLimit = 1000000000;
+
     auto BacktraceListNext = BacktraceListNextPtr->getResolvedAddress();
-    while (BacktraceListNext) {
+    while (BacktraceListNext && LoopCount++ < LoopLimit) {
       auto HeaderBytes = getReader().readBytes(
           RemoteAddress(BacktraceListNext),
           sizeof(MetadataAllocationBacktraceHeader<Runtime>));
@@ -1473,30 +1487,40 @@ class ReflectionContext
     // provide the whole thing as one big chunk.
     size_t HeaderSize =
         llvm::alignTo(sizeof(*Slab), llvm::Align(MaximumAlignment));
-    AsyncTaskAllocationChunk Chunk;
 
-    Chunk.Start = SlabPtr + HeaderSize;
-    Chunk.Length = Slab->CurrentOffset;
-    Chunk.Kind = AsyncTaskAllocationChunk::ChunkKind::Unknown;
+    AsyncTaskAllocationChunk AllocatedSpaceChunk;
+    AllocatedSpaceChunk.Start = SlabPtr + HeaderSize;
+    AllocatedSpaceChunk.Length = Slab->CurrentOffset;
+    AllocatedSpaceChunk.Kind = AsyncTaskAllocationChunk::ChunkKind::Unknown;
+
+    // Provide a second chunk just for the Next pointer, so the client knows
+    // that there's an allocation there.
+    AsyncTaskAllocationChunk NextPtrChunk;
+    NextPtrChunk.Start =
+        SlabPtr + offsetof(typename StackAllocator::Slab, Next);
+    NextPtrChunk.Length = sizeof(Slab->Next);
+    NextPtrChunk.Kind = AsyncTaskAllocationChunk::ChunkKind::RawPointer;
 
     // Total slab size is the slab's capacity plus the header.
     StoredPointer SlabSize = Slab->Capacity + HeaderSize;
 
-    return {llvm::None, {Slab->Next, SlabSize, {Chunk}}};
+    return {llvm::None,
+            {Slab->Next, SlabSize, {NextPtrChunk, AllocatedSpaceChunk}}};
   }
 
   std::pair<llvm::Optional<std::string>, AsyncTaskInfo>
-  asyncTaskInfo(StoredPointer AsyncTaskPtr) {
+  asyncTaskInfo(StoredPointer AsyncTaskPtr, unsigned ChildTaskLimit,
+                unsigned AsyncBacktraceLimit) {
     loadTargetPointers();
 
     if (supportsPriorityEscalation)
       return asyncTaskInfo<
           AsyncTask<Runtime, ActiveTaskStatusWithEscalation<Runtime>>>(
-          AsyncTaskPtr);
+          AsyncTaskPtr, ChildTaskLimit, AsyncBacktraceLimit);
     else
       return asyncTaskInfo<
           AsyncTask<Runtime, ActiveTaskStatusWithoutEscalation<Runtime>>>(
-          AsyncTaskPtr);
+          AsyncTaskPtr, ChildTaskLimit, AsyncBacktraceLimit);
   }
 
   std::pair<llvm::Optional<std::string>, ActorInfo>
@@ -1588,7 +1612,8 @@ class ReflectionContext
 
   template <typename AsyncTaskType>
   std::pair<llvm::Optional<std::string>, AsyncTaskInfo>
-  asyncTaskInfo(StoredPointer AsyncTaskPtr) {
+  asyncTaskInfo(StoredPointer AsyncTaskPtr, unsigned ChildTaskLimit,
+                unsigned AsyncBacktraceLimit) {
     auto AsyncTaskObj = readObj<AsyncTaskType>(AsyncTaskPtr);
     if (!AsyncTaskObj)
       return {std::string("failure reading async task"), {}};
@@ -1620,8 +1645,9 @@ class ReflectionContext
     Info.RunJob = getRunJob(AsyncTaskObj.get());
 
     // Find all child tasks.
+    unsigned ChildTaskLoopCount = 0;
     auto RecordPtr = AsyncTaskObj->PrivateStorage.Status.Record;
-    while (RecordPtr) {
+    while (RecordPtr && ChildTaskLoopCount++ < ChildTaskLimit) {
       auto RecordObj = readObj<TaskStatusRecord<Runtime>>(RecordPtr);
       if (!RecordObj)
         break;
@@ -1661,7 +1687,8 @@ class ReflectionContext
     // Walk the async backtrace.
     if (Info.HasIsRunning && !Info.IsRunning) {
       auto ResumeContext = AsyncTaskObj->ResumeContextAndReserved[0];
-      while (ResumeContext) {
+      unsigned AsyncBacktraceLoopCount = 0;
+      while (ResumeContext && AsyncBacktraceLoopCount++ < AsyncBacktraceLimit) {
         auto ResumeContextObj = readObj<AsyncContext<Runtime>>(ResumeContext);
         if (!ResumeContextObj)
           break;

include/swift/Sema/CSFix.h

@@ -316,11 +316,19 @@ enum class FixKind : uint8_t {
   /// succeed.
   AllowNoopCheckedCast,
 
+  /// Warn about special runtime case where statically known
+  /// checked cast from existentials to CFType always succeed.
+  AllowNoopExistentialToCFTypeCheckedCast,
+
   /// Allow a runtime checked cast where at compile time the from is
   /// convertible, but runtime does not support such convertions. e.g.
   /// function type casts.
   AllowUnsupportedRuntimeCheckedCast,
 
+  /// Allow a runtime checked cast where it is known at compile time
+  /// always fails.
+  AllowCheckedCastToUnrelated,
+
   /// Allow reference to a static member on a protocol metatype
   /// even though result type of the reference doesn't conform
   /// to an expected protocol.
@@ -2789,6 +2797,31 @@ class AllowNoopCheckedCast final : public CheckedCastContextualMismatchWarning {
   }
 };
 
+class AllowNoopExistentialToCFTypeCheckedCast final
+    : public CheckedCastContextualMismatchWarning {
+  AllowNoopExistentialToCFTypeCheckedCast(ConstraintSystem &cs, Type fromType,
+                                          Type toType, CheckedCastKind kind,
+                                          ConstraintLocator *locator)
+      : CheckedCastContextualMismatchWarning(
+            cs, FixKind::AllowNoopExistentialToCFTypeCheckedCast, fromType,
+            toType, kind, locator) {}
+
+public:
+  std::string getName() const override {
+    return "checked cast from existential to CFType always succeeds";
+  }
+
+  bool diagnose(const Solution &solution, bool asNote = false) const override;
+
+  static AllowNoopExistentialToCFTypeCheckedCast *
+  attempt(ConstraintSystem &cs, Type fromType, Type toType,
+          CheckedCastKind kind, ConstraintLocator *locator);
+
+  static bool classof(ConstraintFix *fix) {
+    return fix->getKind() == FixKind::AllowNoopExistentialToCFTypeCheckedCast;
+  }
+};
+
 class AllowUnsupportedRuntimeCheckedCast final
     : public CheckedCastContextualMismatchWarning {
   AllowUnsupportedRuntimeCheckedCast(ConstraintSystem &cs, Type fromType,
@@ -2816,6 +2849,29 @@ class AllowUnsupportedRuntimeCheckedCast final
   }
 };
 
+class AllowCheckedCastToUnrelated final
+    : public CheckedCastContextualMismatchWarning {
+  AllowCheckedCastToUnrelated(ConstraintSystem &cs, Type fromType, Type toType,
+                              CheckedCastKind kind, ConstraintLocator *locator)
+      : CheckedCastContextualMismatchWarning(
+            cs, FixKind::AllowCheckedCastToUnrelated, fromType, toType, kind,
+            locator) {}
+
+public:
+  std::string getName() const override { return "checked cast always fails"; }
+
+  bool diagnose(const Solution &solution, bool asNote = false) const override;
+
+  static AllowCheckedCastToUnrelated *attempt(ConstraintSystem &cs,
+                                              Type fromType, Type toType,
+                                              CheckedCastKind kind,
+                                              ConstraintLocator *locator);
+
+  static bool classof(ConstraintFix *fix) {
+    return fix->getKind() == FixKind::AllowCheckedCastToUnrelated;
+  }
+};
+
 class AllowInvalidStaticMemberRefOnProtocolMetatype final
     : public ConstraintFix {
   AllowInvalidStaticMemberRefOnProtocolMetatype(ConstraintSystem &cs,

lib/AST/DistributedDecl.cpp

@@ -271,12 +271,24 @@ swift::getDistributedSerializationRequirements(
   if (existentialRequirementTy->isAny())
     return true; // we're done here, any means there are no requirements
 
-  auto serialReqType = existentialRequirementTy->castTo<ExistentialType>()
-                           ->getConstraintType()
-                           ->getDesugaredType();
+  if (auto alias = dyn_cast<TypeAliasType>(existentialRequirementTy.getPointer())) {
+    auto ty = alias->getDesugaredType();
+    if (isa<ClassType>(ty) || isa<StructType>(ty) || isa<EnumType>(ty)) {
+      // SerializationRequirement cannot be class or struct nowadays
+      return false;
+    }
+  }
+
+  ExistentialType *serialReqType = existentialRequirementTy
+                                       ->castTo<ExistentialType>();
+  if (!serialReqType || serialReqType->hasError()) {
+    return false;
+  }
+
+  auto desugaredTy = serialReqType->getConstraintType()->getDesugaredType();
   auto flattenedRequirements =
       flattenDistributedSerializationTypeToRequiredProtocols(
-          serialReqType);
+          desugaredTy);
   for (auto p : flattenedRequirements) {
     requirementProtos.insert(p);
   }

lib/AST/NameLookup.cpp

@@ -1592,6 +1592,32 @@ void namelookup::pruneLookupResultSet(const DeclContext *dc, NLOptions options,
   filterForDiscriminator(decls, M->getDebugClient());
 }
 
+// An unfortunate hack to kick the decl checker into adding semantic members to
+// the current type before we attempt a semantic lookup. The places this method
+// looks needs to be in sync with \c extractDirectlyReferencedNominalTypes.
+// See the note in \c synthesizeSemanticMembersIfNeeded about a better, more
+// just, and peaceful world.
+void namelookup::installSemanticMembersIfNeeded(Type type, DeclNameRef name) {
+  // Look-through class-bound archetypes to ensure we synthesize e.g.
+  // inherited constructors.
+  if (auto archetypeTy = type->getAs<ArchetypeType>()) {
+    if (auto super = archetypeTy->getSuperclass()) {
+      type = super;
+    }
+  }
+
+  if (type->isExistentialType()) {
+    auto layout = type->getExistentialLayout();
+    if (auto super = layout.explicitSuperclass) {
+      type = super;
+    }
+  }
+
+  if (auto *current = type->getAnyNominal()) {
+    current->synthesizeSemanticMembersIfNeeded(name.getFullName());
+  }
+}
+
 /// Inspect the given type to determine which nominal type declarations it
 /// directly references, to facilitate name lookup into those types.
 void namelookup::extractDirectlyReferencedNominalTypes(

lib/IDE/ExprContextAnalysis.cpp

@@ -21,6 +21,7 @@
 #include "swift/AST/Initializer.h"
 #include "swift/AST/LazyResolver.h"
 #include "swift/AST/Module.h"
+#include "swift/AST/NameLookup.h"
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/Pattern.h"
 #include "swift/AST/SourceFile.h"
@@ -364,6 +365,9 @@ static void collectPossibleCalleesByQualifiedLookup(
   if (!baseInstanceTy->mayHaveMembers())
     return;
 
+  // Make sure we've resolved implicit members.
+  namelookup::installSemanticMembersIfNeeded(baseInstanceTy, name);
+
   bool isOnMetaType = baseTy->is<AnyMetatypeType>();
 
   SmallVector<ValueDecl *, 2> decls;