[Demangle-to-AST type] Make sure we can find the original nominal type in its own module

With noncopyable generics, we can end up using an extension mangling to refer to the
original nominal type, even in its own module. Make sure we resolve that to the
original nominal type declaration, rather than hunting for an extension that
might not be there.

Author: DougGregor

lib/AST/ASTDemangler.cpp

@@ -1268,17 +1268,33 @@ ASTBuilder::findDeclContext(NodePointer node) {
       return nullptr;
 
     CanGenericSignature genericSig;
-    if (node->getNumChildren() > 2)
+    bool genericSigMatchesNominal = false;
+    if (node->getNumChildren() > 2) {
       genericSig = demangleGenericSignature(nominalDecl, node->getChild(2));
 
+      // If the generic signature are equivalent to that of the nominal type,
+      // we're either in another module or the nominal type is generic and
+      // involves inverse requirements on its generic parameters.
+      genericSigMatchesNominal = genericSig &&
+        genericSig == nominalDecl->getGenericSignatureOfContext().getCanonicalSignature();
+
+      // If the generic signature is equivalent to that of the nominal type,
+      // and we're in the same module, it's due to inverse requirements.
+      // Just return the nominal declaration.
+      if (genericSigMatchesNominal &&
+          nominalDecl->getParentModule() == moduleDecl) {
+        return nominalDecl;
+      }
+    }
+
     for (auto *ext : nominalDecl->getExtensions()) {
       if (ext->getParentModule() != moduleDecl)
         continue;
 
       if (!ext->isConstrainedExtension()) {
-        if (!genericSig ||
-            genericSig->isEqual(nominalDecl->getGenericSignature()))
+        if (!genericSig || genericSigMatchesNominal)
           return ext;
+
         continue;
       }
 

test/IRGen/mangling_inverse_generics_evolution.swift

@@ -86,3 +86,16 @@ func useAtomicRepresentation() {
   let x = UnsafePointer<Int>.AtomicRepresentation()
   print(x)
 }
+
+struct Box<Wrapped: ~Copyable>: ~Copyable { }
+
+struct List<Element: ~Copyable>: ~Copyable {
+  // CHECK: $s4test4ListVAARiczrlE4NodeVwst
+  struct Node: ~Copyable {
+    var element: Element
+    var next: Link
+  }
+  typealias Link = Box<Node>?
+
+  var head: Link
+}