Merge remote-tracking branch 'origin/master' into master-next

Author: swift-ci

include/swift/Reflection/ReflectionContext.h

@@ -838,6 +838,18 @@ class ReflectionContext
     return 0;
   }
 
+  /// Get the name of a metadata tag, if known.
+  llvm::Optional<std::string> metadataAllocationTagName(int Tag) {
+    switch (Tag) {
+#define TAG(name, value)                                                       \
+  case value:                                                                  \
+    return std::string(#name);
+#include "../../../stdlib/public/runtime/MetadataAllocatorTags.def"
+    default:
+      return llvm::None;
+    }
+  }
+
   /// Iterate the metadata allocations in the target process, calling Call with
   /// each allocation found. Returns None on success, and a string describing
   /// the error on failure.

include/swift/Runtime/Metadata.h

@@ -29,29 +29,9 @@ namespace swift {
 // allocator. This is encoded in a header on each allocation when metadata
 // iteration is enabled, and allows tools to know where each allocation came
 // from.
-//
-// Some of these values are also declared in SwiftRemoteMirrorTypes.h. Those
-// values must be kept stable to preserve compatibility.
 enum MetadataAllocatorTags : uint16_t {
-  UnusedTag = 0,
-  BoxesTag,
-  ObjCClassWrappersTag,
-  FunctionTypesTag,
-  MetatypeTypesTag,
-  ExistentialMetatypeValueWitnessTablesTag,
-  ExistentialMetatypesTag,
-  ExistentialTypesTag,
-  OpaqueExistentialValueWitnessTablesTag,
-  ClassExistentialValueWitnessTablesTag,
-  ForeignWitnessTablesTag,
-  ResilientMetadataAllocatorTag,
-  MetadataTag,
-  TupleCacheTag,
-  GenericMetadataCacheTag,
-  ForeignMetadataCacheTag,
-  GenericWitnessTableCacheTag,
-  GenericClassMetadataTag,
-  GenericValueMetadataTag,
+#define TAG(name, value) name##Tag = value,
+#include "../../../stdlib/public/runtime/MetadataAllocatorTags.def"
 };
 
 template <typename Runtime> struct MetadataAllocationBacktraceHeader {

include/swift/SwiftRemoteMirror/SwiftRemoteMirror.h

@@ -324,16 +324,24 @@ const char *swift_reflection_iterateMetadataAllocations(
 /// Given a metadata allocation, return the metadata it points to. Returns NULL
 /// on failure. Despite the name, not all allocations point to metadata.
 /// Currently, this will return a metadata only for allocations with tag
-/// SWIFT_GENERIC_METADATA_CACHE_ALLOCATION. Support for additional tags may be
-/// added in the future. The caller must gracefully handle failure.
+/// GenericMetadataCache. Support for additional tags may be added in the
+/// future. The caller must gracefully handle failure.
 SWIFT_REMOTE_MIRROR_LINKAGE
 swift_reflection_ptr_t swift_reflection_allocationMetadataPointer(
   SwiftReflectionContextRef ContextRef,
   swift_metadata_allocation_t Allocation);
 
+/// Return the name of a metadata allocation tag, or NULL if the tag is unknown.
+/// This pointer remains valid until the next swift_reflection call on the given
+/// context.
+SWIFT_REMOTE_MIRROR_LINKAGE
+const char *
+swift_reflection_metadataAllocationTagName(SwiftReflectionContextRef ContextRef,
+                                           swift_metadata_allocation_tag_t Tag);
+
 /// Backtrace iterator callback passed to
 /// swift_reflection_iterateMetadataAllocationBacktraces
-typedef void (*swift_metadataAllocationIterator)(
+typedef void (*swift_metadataAllocationBacktraceIterator)(
     swift_reflection_ptr_t AllocationPtr, size_t Count,
     const swift_reflection_ptr_t Ptrs[], void *ContextPtr);
 
@@ -350,8 +358,8 @@ typedef void (*swift_metadataAllocationIterator)(
 /// swift_reflection call on the given context.
 SWIFT_REMOTE_MIRROR_LINKAGE
 const char *swift_reflection_iterateMetadataAllocationBacktraces(
-    SwiftReflectionContextRef ContextRef, swift_metadataAllocationIterator Call,
-    void *ContextPtr);
+    SwiftReflectionContextRef ContextRef,
+    swift_metadataAllocationBacktraceIterator Call, void *ContextPtr);
 
 #ifdef __cplusplus
 } // extern "C"

lib/Sema/CSSolver.cpp

@@ -800,6 +800,12 @@ void ConstraintSystem::shrink(Expr *expr) {
         return {false, expr};
       }
 
+      // Similar to 'ClosureExpr', 'TapExpr' has a 'VarDecl' the type of which
+      // is determined by type checking the parent interpolated string literal.
+      if (isa<TapExpr>(expr)) {
+        return {false, expr};
+      }
+
       if (auto coerceExpr = dyn_cast<CoerceExpr>(expr)) {
         if (coerceExpr->isLiteralInit())
           ApplyExprs.push_back({coerceExpr, 1});

stdlib/public/SwiftRemoteMirror/SwiftRemoteMirror.cpp

@@ -40,8 +40,8 @@ struct SwiftReflectionContext {
   NativeReflectionContext *nativeContext;
   std::vector<std::function<void()>> freeFuncs;
   std::vector<std::tuple<swift_addr_t, swift_addr_t>> dataSegments;
-  std::string lastError;
-  
+  std::string lastString;
+
   SwiftReflectionContext(MemoryReaderImpl impl) {
     auto Reader = std::make_shared<CMemoryReader>(impl);
     nativeContext = new NativeReflectionContext(Reader);
@@ -423,11 +423,11 @@ static swift_childinfo_t convertChild(const TypeInfo *TI, unsigned Index) {
   };
 }
 
-static const char *convertError(SwiftReflectionContextRef ContextRef,
-                                llvm::Optional<std::string> Error) {
-  if (Error) {
-    ContextRef->lastError = *Error;
-    return ContextRef->lastError.c_str();
+static const char *returnableCString(SwiftReflectionContextRef ContextRef,
+                                      llvm::Optional<std::string> String) {
+  if (String) {
+    ContextRef->lastString = *String;
+    return ContextRef->lastString.c_str();
   }
   return nullptr;
 }
@@ -605,7 +605,7 @@ const char *swift_reflection_iterateConformanceCache(
   auto Error = Context->iterateConformances([&](auto Type, auto Proto) {
     Call(Type, Proto, ContextPtr);
   });
-  return convertError(ContextRef, Error);
+  return returnableCString(ContextRef, Error);
 }
 
 const char *swift_reflection_iterateMetadataAllocations(
@@ -621,10 +621,9 @@ const char *swift_reflection_iterateMetadataAllocations(
     CAllocation.Size = Allocation.Size;
     Call(CAllocation, ContextPtr);
   });
-  return convertError(ContextRef, Error);
+  return returnableCString(ContextRef, Error);
 }
 
-SWIFT_REMOTE_MIRROR_LINKAGE
 swift_reflection_ptr_t swift_reflection_allocationMetadataPointer(
   SwiftReflectionContextRef ContextRef,
   swift_metadata_allocation_t Allocation) {
@@ -636,9 +635,16 @@ swift_reflection_ptr_t swift_reflection_allocationMetadataPointer(
   return Context->allocationMetadataPointer(NativeAllocation);
 }
 
+const char *swift_reflection_metadataAllocationTagName(
+    SwiftReflectionContextRef ContextRef, swift_metadata_allocation_tag_t Tag) {
+  auto Context = ContextRef->nativeContext;
+  auto Result = Context->metadataAllocationTagName(Tag);
+  return returnableCString(ContextRef, Result);
+}
+
 const char *swift_reflection_iterateMetadataAllocationBacktraces(
-    SwiftReflectionContextRef ContextRef, swift_metadataAllocationIterator Call,
-    void *ContextPtr) {
+    SwiftReflectionContextRef ContextRef,
+    swift_metadataAllocationBacktraceIterator Call, void *ContextPtr) {
   auto Context = ContextRef->nativeContext;
   auto Error = Context->iterateMetadataAllocationBacktraces(
       [&](auto AllocationPtr, auto Count, auto Ptrs) {
@@ -651,5 +657,5 @@ const char *swift_reflection_iterateMetadataAllocationBacktraces(
                                                           &Ptrs[Count]};
         Call(AllocationPtr, Count, ConvertedPtrs.data(), ContextPtr);
       });
-  return convertError(ContextRef, Error);
+  return returnableCString(ContextRef, Error);
 }

stdlib/public/runtime/MetadataAllocatorTags.def

@@ -0,0 +1,45 @@
+//===--- MetadataAllocatorTags.def - Metadata allocator tags. ---*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines x-macros used for metaprogramming with the set of tags used
+// to mark metadata allocations when
+// SWIFT_DEBUG_ENABLE_METADATA_ALLOCATION_ITERATION is enabled.
+//
+//===----------------------------------------------------------------------===//
+
+// #define TAG(name, value)
+
+#ifndef TAG
+#error "Must define TAG to include MetadataAllocatorTags.def"
+#endif
+
+TAG(NotSet, 0)
+TAG(Boxes, 1)
+TAG(ObjCClassWrappers, 2)
+TAG(FunctionTypes, 3)
+TAG(MetatypeTypes, 4)
+TAG(ExistentialMetatypeValueWitnessTables, 5)
+TAG(ExistentialMetatypes, 6)
+TAG(ExistentialTypes, 7)
+TAG(OpaqueExistentialValueWitnessTables, 8)
+TAG(ClassExistentialValueWitnessTables, 9)
+TAG(ForeignWitnessTables, 10)
+TAG(ResilientMetadataAllocator, 11)
+TAG(Metadata, 12)
+TAG(TupleCache, 13)
+TAG(GenericMetadataCache, 14)
+TAG(ForeignMetadataCache, 15)
+TAG(GenericWitnessTableCache, 16)
+TAG(GenericClassMetadata, 17)
+TAG(GenericValueMetadata, 18)
+
+#undef TAG

tools/swift-inspect/Sources/swift-inspect/main.swift

@@ -40,8 +40,10 @@ func dumpRawMetadata(
 ) throws {
   let backtraces = backtraceStyle != nil ? context.allocationBacktraces : [:]
   for allocation in context.allocations {
+    let tagNameC = swift_reflection_metadataAllocationTagName(context, allocation.tag)
+    let tagName = tagNameC.map(String.init) ?? "<unknown>"
     print("Metadata allocation at: \(hex: allocation.ptr) " +
-          "size: \(allocation.size) tag: \(allocation.tag)")
+          "size: \(allocation.size) tag: \(allocation.tag) (\(tagName))")
     printBacktrace(style: backtraceStyle, for: allocation.ptr, in: backtraces, inspector: inspector)
   }
 }