Debug Info: Avoid type uniquing clashes for bound generic structs.

This patch changes the DWARF representation of bound generic struct to a nested
struct where the (sized) outer struct is anonymous and thus distinct and the
inner struct in uniqued and sizeless.

This is anologous the the previous commit that did the same thing for bound
generic enums.

rdar://problem/56521648

Author: adrian-prantl

lib/IRGen/IRGenDebugInfo.cpp

@@ -1328,9 +1328,9 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
       auto *StructTy = BaseTy->castTo<BoundGenericStructType>();
       auto *Decl = StructTy->getDecl();
       auto L = getDebugLoc(*this, Decl);
-      return createOpaqueStruct(Scope, Decl ? Decl->getNameStr() : MangledName,
-                                File, L.Line, SizeInBits, AlignInBits, Flags,
-                                MangledName);
+      return createOpaqueStructWithSizedContainer(
+          Scope, Decl ? Decl->getNameStr() : "", File, L.Line, SizeInBits,
+          AlignInBits, Flags, MangledName);
     }
 
     case TypeKind::BoundGenericClass: {

test/DebugInfo/generic_arg5.swift

@@ -15,10 +15,13 @@ public func foo<Type>(_ values : [S<Type>])
   // CHECK: ![[TYP:[0-9]+]] = !DICompositeType({{.*}}, identifier: "$s12generic_arg51SVyxGD")
   // The argument is a by-ref struct and thus needs to be dereferenced.
   // CHECK: ![[ARG]] = !DILocalVariable(name: "arg", arg: 1,
-  // CHECK-SAME:                        line: [[@LINE+4]],
+  // CHECK-SAME:                        line: [[@LINE+7]],
   // CHECK-SAME:                        type: ![[LET_TYP:[0-9]+]])
   // CHECK: ![[LET_TYP]] = !DIDerivedType(tag: DW_TAG_const_type,
-  // CHECK-SAME:                          baseType: ![[TYP]])
+  // CHECK-SAME:                          baseType: ![[TYP_CONTAINER:[0-9]+]])
+  // CHECK: ![[TYP_CONTAINER]] = !DICompositeType({{.*}}elements: ![[TYP_ELTS:[0-9]+]]
+  // CHECK: ![[TYP_ELTS]] = !{![[TYP_MEMBER:[0-9]+]]}
+  // CHECK: ![[TYP_MEMBER]] = !DIDerivedType(tag: DW_TAG_member, {{.*}}baseType: ![[TYP]]
   let _ = values.flatMap { arg in
     return .some(arg)
   }

test/DebugInfo/generic_enum_closure.swift

@@ -15,8 +15,11 @@ struct CErrorOr<T>
     // CHECK-SAME: !DIExpression(DW_OP_deref))
     // CHECK-DAG: store i8* %[[DYN:.*]], i8** %[[SHADOW]]
     // CHECK-DAG: %[[DYN]] = alloca i8, i{{32|64}} %
-    // CHECK-DAG: ![[SELF]] = !DILocalVariable(name: "self", scope:{{.*}}, type: ![[T1:.*]])
-    // CHECK-DAG: ![[T1]] = !DICompositeType({{.*}}, identifier: "$s20generic_enum_closure8CErrorOrVyxGD")
+    // CHECK-DAG: ![[SELF]] = !DILocalVariable(name: "self", scope:{{.*}}, type: ![[TY_CONTAINER:.*]])
+    // CHECK-DAG: ![[TY_CONTAINER]] = !DICompositeType({{.*}}elements: ![[TY_ELTS:[0-9]+]]
+    // CHECK-DAG: ![[TY_ELTS]] = !{![[TY_MEMBER:[0-9]+]]}
+    // CHECK-DAG: ![[TY_MEMBER]] = !DIDerivedType(tag: DW_TAG_member, {{.*}}baseType: ![[TY:[0-9]+]]
+    // CHECK-DAG: ![[TY]] = !DICompositeType({{.*}}, identifier: "$s20generic_enum_closure8CErrorOrVyxGD")
     value = .none
   }
 }

test/DebugInfo/mangling.swift

@@ -9,8 +9,11 @@ func markUsed<T>(_ t: T) {}
 // mangling.myDict : Swift.Dictionary<Swift.Int64, Swift.String>
 // CHECK: !DIGlobalVariable(name: "myDict",
 // CHECK-SAME:       linkageName: "$s8mangling6myDictSDys5Int64VSSGvp",
-// CHECK-SAME:              line: [[@LINE+3]]
-// CHECK-SAME:              type: ![[DT:[0-9]+]]
+// CHECK-SAME:              line: [[@LINE+6]]
+// CHECK-SAME:              type: ![[DT_CONTAINER:[0-9]+]]
+// CHECK: ![[DT_CONTAINER]] = !DICompositeType({{.*}}elements: ![[DT_ELTS:[0-9]+]]
+// CHECK: ![[DT_ELTS]] = !{![[DT_MEMBER:[0-9]+]]}
+// CHECK: ![[DT_MEMBER]] = !DIDerivedType(tag: DW_TAG_member, {{.*}}baseType: ![[DT:[0-9]+]]
 // CHECK: ![[DT]] = !DICompositeType(tag: DW_TAG_structure_type, name: "Dictionary"
 var myDict = Dictionary<Int64, String>()
 myDict[12] = "Hello!"

test/DebugInfo/variables.swift

@@ -72,7 +72,10 @@ myprint(tuple)
 
 // Arrays are represented as an instantiation of Array.
 // CHECK-DAG: ![[ARRAYTY:.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "Array",
-// CHECK-DAG: !DIGlobalVariable(name: "array_of_tuples",{{.*}} type: ![[ARRAYTY]]
+// CHECK-DAG: ![[ARRAY_MEMBER:.*]] = !DIDerivedType(tag: DW_TAG_member, {{.*}}baseType: ![[ARRAYTY]]
+// CHECK-DAG: ![[ARRAY_ELTS:.*]] = !{![[ARRAY_MEMBER]]}
+// CHECK-DAG: ![[ARRAY_CONTAINER:.*]] = !DICompositeType({{.*}}elements: ![[ARRAY_ELTS]]
+// CHECK-DAG: !DIGlobalVariable(name: "array_of_tuples",{{.*}} type: ![[ARRAY_CONTAINER]]
 var array_of_tuples : [(a : Int, b : Int)] = [(1,2)]
 var twod : [[Int]] = [[1]]