Debug Info: Distinguish between types of unknown size and types with size=0.

DebugInfoTypes didn't properly distinguish between types with an unknown size
and used 0 as the default value. This can cause types to show up in DWARF with a
size of 0, which will prevent LLDB from looking at the type further. In
practice, this meant that many resilient types (for example, SwiftUI Views)
couldn't be displayed in the debugger and just showed up as empty.

This patch does three things:

0. Make size in DebugTypeInfo optional.
1. Introduce CompletedDebugTypeInfo, a subclass of DebugTypeInfo where
   size is guaranteed to be non-empty.
2. Change some APIs that only make sense with a size to use
   CompletedDebugTypeInfo. This caused some churn because I needed to refactor
	 the get*Elements() functions back into their callers to facilitate the new
	 early-exit path. These functions are only called when compiling with
	 -gdwarf-types.
3. Change createOpaqueStructWithSizedContainer() to create a size-less forward
   declaration instead of a zero-sized type for the inner type.

rdar://76973844
(cherry picked from commit b8e6eeb)

Author: adrian-prantl

lib/IRGen/DebugTypeInfo.cpp

@@ -24,9 +24,9 @@
 using namespace swift;
 using namespace irgen;
 
-DebugTypeInfo::DebugTypeInfo(swift::Type Ty, llvm::Type *StorageTy, Size size,
-                             Alignment align, bool HasDefaultAlignment,
-                             bool IsMetadata)
+DebugTypeInfo::DebugTypeInfo(swift::Type Ty, llvm::Type *StorageTy,
+                             Optional<Size> size, Alignment align,
+                             bool HasDefaultAlignment, bool IsMetadata)
     : Type(Ty.getPointer()), StorageType(StorageTy), size(size), align(align),
       DefaultAlignment(HasDefaultAlignment), IsMetadataType(IsMetadata) {
   assert(align.getValue() != 0);
@@ -43,14 +43,10 @@ static bool hasDefaultAlignment(swift::Type Ty) {
 
 DebugTypeInfo DebugTypeInfo::getFromTypeInfo(swift::Type Ty,
                                              const TypeInfo &Info) {
-  Size size;
+  Optional<Size> size;
   if (Info.isFixedSize()) {
     const FixedTypeInfo &FixTy = *cast<const FixedTypeInfo>(&Info);
     size = FixTy.getFixedSize();
-  } else {
-    // FIXME: Handle NonFixedTypeInfo here or assert that we won't
-    // encounter one.
-    size = Size(0);
   }
   assert(Info.getStorageType() && "StorageType is a nullptr");
   return DebugTypeInfo(Ty.getPointer(), Info.getStorageType(), size,
@@ -160,10 +156,12 @@ TypeDecl *DebugTypeInfo::getDecl() const {
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void DebugTypeInfo::dump() const {
-  llvm::errs() << "[Size " << size.getValue() << " Alignment "
-               << align.getValue() << "] ";
-
+  llvm::errs() << "[";
+  if (size)
+    llvm::errs() << "Size " << size->getValue() << " ";
+  llvm::errs() << "Alignment " << align.getValue() << "] ";
   getType()->dump(llvm::errs());
+
   if (StorageType) {
     llvm::errs() << "StorageType=";
     StorageType->dump();

lib/IRGen/DebugTypeInfo.h

@@ -36,22 +36,23 @@ class TypeInfo;
 /// This data structure holds everything needed to emit debug info
 /// for a type.
 class DebugTypeInfo {
+protected:
   /// The type we need to emit may be different from the type
   /// mentioned in the Decl, for example, stripped of qualifiers.
   TypeBase *Type = nullptr;
   /// Needed to determine the size of basic types and to determine
   /// the storage type for undefined variables.
   llvm::Type *StorageType = nullptr;
-  Size size = Size(0);
-  Alignment align = Alignment();
+  Optional<Size> size;
+  Alignment align;
   bool DefaultAlignment = true;
   bool IsMetadataType = false;
 
 public:
   DebugTypeInfo() = default;
-  DebugTypeInfo(swift::Type Ty, llvm::Type *StorageTy, Size SizeInBytes,
-                Alignment AlignInBytes, bool HasDefaultAlignment,
-                bool IsMetadataType);
+  DebugTypeInfo(swift::Type Ty, llvm::Type *StorageTy,
+                Optional<Size> SizeInBytes, Alignment AlignInBytes,
+                bool HasDefaultAlignment, bool IsMetadataType);
 
   /// Create type for a local variable.
   static DebugTypeInfo getLocalVariable(VarDecl *Decl,
@@ -92,24 +93,44 @@ class DebugTypeInfo {
   }
 
   llvm::Type *getStorageType() const {
-    assert((StorageType || size.isZero()) &&
-           "only defined types may have a size");
+    if (size && size->isZero())
+      assert(StorageType && "only defined types may have a size");
     return StorageType;
   }
-  Size getSize() const { return size; }
+  Optional<Size> getSize() const { return size; }
   void setSize(Size NewSize) { size = NewSize; }
   Alignment getAlignment() const { return align; }
   bool isNull() const { return Type == nullptr; }
   bool isForwardDecl() const { return StorageType == nullptr; }
   bool isMetadataType() const { return IsMetadataType; }
   bool hasDefaultAlignment() const { return DefaultAlignment; }
-  
+
   bool operator==(DebugTypeInfo T) const;
   bool operator!=(DebugTypeInfo T) const;
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   LLVM_DUMP_METHOD void dump() const;
 #endif
 };
+
+/// A DebugTypeInfo with a defined size (that may be 0).
+class CompletedDebugTypeInfo : public DebugTypeInfo {
+  CompletedDebugTypeInfo(DebugTypeInfo DbgTy) : DebugTypeInfo(DbgTy) {}
+public:
+  static Optional<CompletedDebugTypeInfo> get(DebugTypeInfo DbgTy) {
+    if (!DbgTy.getSize())
+      return {};
+    return CompletedDebugTypeInfo(DbgTy);
+  }
+
+  static Optional<CompletedDebugTypeInfo>
+  getFromTypeInfo(swift::Type Ty, const TypeInfo &Info) {
+    return CompletedDebugTypeInfo::get(
+        DebugTypeInfo::getFromTypeInfo(Ty, Info));
+  }
+
+  Size::int_type getSizeValue() const { return size.getValue().getValue(); }
+};
+
 }
 }