Fix nested generic typerefs applying generic params at the wrong level

Generic params of typerefs are supposed to be "attached" on the level
they belong, not as a flat list, unlike other parts of the system. Fix
the application of bound generic params by checking how many were
already applied in the hierarchy and ignoring them.

Author: augusto2112

include/swift/Reflection/TypeRef.h

@@ -283,14 +283,38 @@ class NominalTypeRef final : public TypeRef, public NominalTypeTrait {
 class BoundGenericTypeRef final : public TypeRef, public NominalTypeTrait {
   std::vector<const TypeRef *> GenericParams;
 
+  static uint64_t
+  GetNumberOfGenericParametersInHierarchy(const TypeRef *typeref) {
+    uint64_t count = 0;
+
+    // Only nominal and bound generic typeref have parents.
+    if (auto nominalTyperef = llvm::dyn_cast_or_null<NominalTypeRef>(typeref)) {
+      if (auto *parent = nominalTyperef->getParent())
+        count = GetNumberOfGenericParametersInHierarchy(parent);
+    } else if (auto genericTyperef =
+                   llvm::dyn_cast_or_null<BoundGenericTypeRef>(typeref)) {
+      if (auto *parent = genericTyperef->getParent())
+        count = GetNumberOfGenericParametersInHierarchy(parent);
+      count += genericTyperef->getGenericParams().size();
+    }
+
+    return count;
+  }
+
   static TypeRefID Profile(const std::string &MangledName,
                            const std::vector<const TypeRef *> &GenericParams,
                            const TypeRef *Parent) {
     TypeRefID ID;
     ID.addPointer(Parent);
     ID.addString(MangledName);
-    for (auto Param : GenericParams)
-      ID.addPointer(Param);
+    uint64_t StartIndex = 0;
+    if (Parent) 
+      StartIndex = GetNumberOfGenericParametersInHierarchy(Parent);
+    
+    // GenericParams contains a flat vector of parameters used in the whole
+    // typeref hierarchy, so we skip the ones that belong to our parents.
+    for (auto i = StartIndex; i < GenericParams.size(); ++i)
+      ID.addPointer(GenericParams[i]);
     return ID;
   }
 

include/swift/Remote/MetadataReader.h

@@ -30,12 +30,16 @@
 #include "swift/Runtime/HeapObject.h"
 #include "swift/Basic/Unreachable.h"
 
+#include <type_traits>
 #include <vector>
 #include <unordered_map>
 
 #include <inttypes.h>
 
 namespace swift {
+namespace reflection {
+  class TypeRefBuilder;
+}
 namespace remote {
 
 template <typename BuiltType>
@@ -2905,25 +2909,8 @@ class MetadataReader {
     return builtSubsts;
   }
 
-  BuiltType readNominalTypeFromMetadata(MetadataRef origMetadata,
-                                        bool skipArtificialSubclasses = false) {
-    auto metadata = origMetadata;
-    auto descriptorAddress =
-      readAddressOfNominalTypeDescriptor(metadata,
-                                         skipArtificialSubclasses);
-    if (!descriptorAddress)
-      return BuiltType();
-
-    // If we've skipped an artificial subclasses, check the cache at
-    // the superclass.  (This also protects against recursion.)
-    if (skipArtificialSubclasses && metadata != origMetadata) {
-      auto it = TypeCache.find(getAddress(metadata));
-      if (it != TypeCache.end())
-        return it->second;
-    }
-
-    // Read the nominal type descriptor.
-    ContextDescriptorRef descriptor = readContextDescriptor(descriptorAddress);
+  BuiltType readNominalTypeFromDescriptor(MetadataRef metadata,
+                                          ContextDescriptorRef descriptor) {
     if (!descriptor)
       return BuiltType();
 
@@ -2932,34 +2919,67 @@ class MetadataReader {
     if (!typeDecl)
       return BuiltType();
 
+    BuiltType parent;
+    // Attempt to build the parent (if it exists). We only do this when building
+    // typerefs as that's the only implementation of builder that actually needs
+    // the parent to build the nominal type correctly.
+    if (std::is_same<BuilderType, reflection::TypeRefBuilder>::value)
+      if (auto parentDescriptor = readParentContextDescriptor(descriptor))
+        if (parentDescriptor->isResolved())
+          if (auto resolvedParent = parentDescriptor->getResolved())
+            parent = readNominalTypeFromDescriptor(metadata, resolvedParent);
+
     // Build the nominal type.
     BuiltType nominal;
     if (descriptor->isGeneric()) {
       // Resolve the generic arguments.
       auto builtGenerics = getGenericSubst(metadata, descriptor);
       if (builtGenerics.empty())
         return BuiltType();
-      nominal = Builder.createBoundGenericType(typeDecl, builtGenerics);
+      nominal = Builder.createBoundGenericType(typeDecl, builtGenerics, parent);
     } else {
-      nominal = Builder.createNominalType(typeDecl);
+      nominal = Builder.createNominalType(typeDecl, parent);
     }
 
+    return nominal;
+  }
+
+  BuiltType readNominalTypeFromMetadata(MetadataRef origMetadata,
+                                        bool skipArtificialSubclasses = false) {
+    auto metadata = origMetadata;
+    auto descriptorAddress =
+        readAddressOfNominalTypeDescriptor(metadata, skipArtificialSubclasses);
+    if (!descriptorAddress)
+      return BuiltType();
+
+    // If we've skipped an artificial subclasses, check the cache at
+    // the superclass.  (This also protects against recursion.)
+    if (skipArtificialSubclasses && metadata != origMetadata) {
+      auto it = TypeCache.find(getAddress(metadata));
+      if (it != TypeCache.end())
+        return it->second;
+    }
+
+    // Read the nominal type descriptor.
+    ContextDescriptorRef descriptor = readContextDescriptor(descriptorAddress);
+    auto nominal = readNominalTypeFromDescriptor(origMetadata, descriptor);
+
     if (!nominal)
       return BuiltType();
-    
+
     TypeCache[getAddress(metadata)] = nominal;
 
     // If we've skipped an artificial subclass, remove the
     // recursion-protection entry we made for it.
     if (skipArtificialSubclasses && metadata != origMetadata) {
       TypeCache.erase(getAddress(origMetadata));
     }
-
     return nominal;
   }
 
-  BuiltType readNominalTypeFromClassMetadata(MetadataRef origMetadata,
-                                       bool skipArtificialSubclasses = false) {
+  BuiltType
+  readNominalTypeFromClassMetadata(MetadataRef origMetadata,
+                                   bool skipArtificialSubclasses = false) {
     auto classMeta = cast<TargetClassMetadata>(origMetadata);
     if (classMeta->isTypeMetadata())
       return readNominalTypeFromMetadata(origMetadata, skipArtificialSubclasses);