Merge remote-tracking branch 'origin/main' into rebranch

Author: swift-ci

include/swift/Basic/Lazy.h

@@ -55,9 +55,6 @@ template <class T> class Lazy {
 };
 
 template <typename T> inline T &Lazy<T>::get(void (*initCallback)(void*)) {
-  static_assert(std::is_literal_type<Lazy<T>>::value,
-                "Lazy<T> must be a literal type");
-
   swift::once(OnceToken, initCallback, &Value);
   return unsafeGetAlreadyInitialized();
 }

lib/IRGen/Callee.h

@@ -340,7 +340,7 @@ namespace irgen {
           AuthInfo(authInfo), Sig(signature), awaitSignature(awaitSignature) {
       // The function pointer should have function type.
       assert(!value->getContext().supportsTypedPointers() ||
-             value->getType()->getPointerElementType()->isFunctionTy());
+             value->getType()->getNonOpaquePointerElementType()->isFunctionTy());
       // TODO: maybe assert similarity to signature.getType()?
       if (authInfo) {
         if (kind == Kind::Function) {

lib/IRGen/GenCall.cpp

@@ -3192,7 +3192,7 @@ void CallEmission::emitToExplosion(Explosion &out, bool isOutlined) {
       auto temp = IGF.createAlloca(resultTy, Alignment(), "indirect.result");
       if (IGF.IGM.getLLVMContext().supportsTypedPointers()) {
         temp = IGF.Builder.CreateElementBitCast(
-            temp, fnType->getParamType(0)->getPointerElementType());
+            temp, fnType->getParamType(0)->getNonOpaquePointerElementType());
       }
       emitToMemory(temp, substResultTI, isOutlined);
       return;

lib/IRGen/IRGenSIL.cpp

@@ -5433,7 +5433,7 @@ void IRGenSILFunction::emitDebugInfoForAllocStack(AllocStackInst *i,
       shadowTy = IGM.Int8Ty;
     }
     assert(!IGM.getLLVMContext().supportsTypedPointers() ||
-           shadowTy == shadow->getType()->getPointerElementType());
+           shadowTy == shadow->getType()->getNonOpaquePointerElementType());
     addr = builder.CreateLoad(shadowTy, shadow);
   }
 

lib/LLVMPasses/LLVMMergeFunctions.cpp

@@ -1271,15 +1271,15 @@ fixUpTypesInByValAndStructRetAttributes(llvm::FunctionType *fnType,
     auto paramTy = fnType->getParamType(i);
     auto attrListIndex = llvm::AttributeList::FirstArgIndex + i;
     if (attrList.hasParamAttr(i, llvm::Attribute::StructRet) &&
-        paramTy->getPointerElementType() != attrList.getParamStructRetType(i))
+        paramTy->getNonOpaquePointerElementType() != attrList.getParamStructRetType(i))
       attrList = attrList.replaceAttributeTypeAtIndex(
           context, attrListIndex, llvm::Attribute::StructRet,
-          paramTy->getPointerElementType());
+          paramTy->getNonOpaquePointerElementType());
     if (attrList.hasParamAttr(i, llvm::Attribute::ByVal) &&
-        paramTy->getPointerElementType() != attrList.getParamByValType(i))
+        paramTy->getNonOpaquePointerElementType() != attrList.getParamByValType(i))
       attrList = attrList.replaceAttributeTypeAtIndex(
           context, attrListIndex, llvm::Attribute::ByVal,
-          paramTy->getPointerElementType());
+          paramTy->getNonOpaquePointerElementType());
   }
   return attrList;
 }

lib/SILGen/SILGenApply.cpp

@@ -2251,9 +2251,13 @@ class ClaimedParamsRef {
     checkParams();
   }
 
-  struct iterator : public std::iterator<std::random_access_iterator_tag,
-                                         SILParameterInfo>
-  {
+  struct iterator {
+    using iterator_category = std::random_access_iterator_tag;
+    using value_type = SILParameterInfo;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;    
+
     const SILParameterInfo *Base;
     unsigned I, SkipParamIndex;
 

lib/SILOptimizer/PassManager/PassManager.cpp

@@ -1028,9 +1028,13 @@ namespace {
       SmallVector<Edge, 8> Children;
     };
 
-    struct child_iterator
-        : public std::iterator<std::random_access_iterator_tag, Node *,
-                               ptrdiff_t> {
+    struct child_iterator {
+      using iterator_category = std::random_access_iterator_tag;
+      using value_type = Node*;
+      using difference_type = std::ptrdiff_t;
+      using pointer = value_type*;
+      using reference = value_type&;    
+
       SmallVectorImpl<Edge>::iterator baseIter;
 
       child_iterator(SmallVectorImpl<Edge>::iterator baseIter) :

lib/SILOptimizer/UtilityPasses/ParseTestSpecification.cpp

@@ -544,7 +544,6 @@ static TraceValueMap traceValues;
 
 class ParseTestSpecification {
   friend class ParseArgumentSpecification;
-  SILFunction *function;
   SmallVectorImpl<StringRef> &components;
 
   SILValue getTraceValue(unsigned index, SILFunction *function) {
@@ -561,9 +560,8 @@ class ParseTestSpecification {
   }
 
 public:
-  ParseTestSpecification(SILFunction *function,
-                         SmallVectorImpl<StringRef> &components)
-      : function(function), components(components) {}
+  ParseTestSpecification(SmallVectorImpl<StringRef> &components)
+      : components(components) {}
 
   void parse(UnparsedSpecification const &specification, Arguments &arguments) {
     StringRef specificationString = specification.string;
@@ -607,6 +605,6 @@ void swift::test::getTestSpecifications(
 void swift::test::parseTestArgumentsFromSpecification(
     SILFunction *function, UnparsedSpecification const &specification,
     Arguments &arguments, SmallVectorImpl<StringRef> &argumentStrings) {
-  ParseTestSpecification parser(function, argumentStrings);
+  ParseTestSpecification parser(argumentStrings);
   parser.parse(specification, arguments);
 }

stdlib/include/llvm/ADT/DenseMap.h

@@ -128,6 +128,7 @@ class DenseMapBase {
           P->getFirst() = EmptyKey;
         }
       }
+      (void)NumEntries;
       assert(NumEntries == 0 && "Node count imbalance!");
     }
     setNumEntries(0);

stdlib/public/Concurrency/Task.cpp

@@ -91,7 +91,7 @@ void FutureFragment::destroy() {
   auto queueHead = waitQueue.load(std::memory_order_acquire);
   switch (queueHead.getStatus()) {
   case Status::Executing:
-    assert(false && "destroying a task that never completed");
+    swift_unreachable("destroying a task that never completed");
 
   case Status::Success:
     resultType->vw_destroy(getStoragePtr());

stdlib/public/runtime/Metadata.cpp

@@ -1342,7 +1342,7 @@ FunctionCacheEntry::FunctionCacheEntry(const Key &key) {
         Data.ValueWitnesses = &VALUE_WITNESS_SYM(DIFF_FUNCTION_MANGLING);
         break;
       default:
-        assert(false && "unsupported function witness");
+        swift_unreachable("unsupported function witness");
       case FunctionMetadataDifferentiabilityKind::NonDifferentiable:
         Data.ValueWitnesses = &VALUE_WITNESS_SYM(FUNCTION_MANGLING);
         break;
@@ -5771,13 +5771,11 @@ static Result performOnMetadataCache(const Metadata *metadata,
     swift_unreachable("bad metadata initialization kind");
   }
 
-  auto &generics = description->getFullGenericContextHeader();
-
   auto genericArgs =
     reinterpret_cast<const void * const *>(
                                     description->getGenericArguments(metadata));
   auto &cache = getCache(*description);
-  assert(generics.Base.NumKeyArguments == cache.SigLayout.sizeInWords());
+  assert(description->getFullGenericContextHeader().Base.NumKeyArguments == cache.SigLayout.sizeInWords());
   auto key = MetadataCacheKey(cache.SigLayout, genericArgs);
 
   return std::move(callbacks).forGenericMetadata(metadata, description,