[AST] Make GenericEnvironment's reverse mapping deterministic.

GenericEnvironment walked its input mapping in DenseMap order while
populating a reverse mapping from archetypes to interface
types. However, this mapping is not unique, because two generic
parameters can end up mapping to the same archetype. In such cases,
which generic parameter we mapped to was nondeterministic.

Make this deterministic by preferring to map back to the earlier
generic parameter.

Author: DougGregor

lib/AST/GenericEnvironment.cpp

@@ -47,11 +47,24 @@ GenericEnvironment::GenericEnvironment(
 
     // If we mapped the generic parameter to an archetype, add it to the
     // reverse mapping.
-    if (auto *archetypeTy = entry.second->getAs<ArchetypeType>())
-      ArchetypeToInterfaceMap[archetypeTy] = entry.first;
+    if (auto *archetypeTy = entry.second->getAs<ArchetypeType>()) {
+      // If we've already recorded an interface type for this archetype, then
+      // multiple generic parameters map to the same archetype. If the
+      // existing entry comes from a later generic parameter, replace it with
+      // the earlier generic parameter. This gives us a deterministic reverse
+      // mapping.
+      auto knownInterfaceType = ArchetypeToInterfaceMap.find(archetypeTy);
+      if (knownInterfaceType != ArchetypeToInterfaceMap.end()) {
+        auto otherGP
+          = knownInterfaceType->second->castTo<GenericTypeParamType>();
+        if (std::make_pair(canParamTy->getDepth(), canParamTy->getIndex())
+              < std::make_pair(otherGP->getDepth(), otherGP->getIndex()))
+          knownInterfaceType->second = entry.first;
+        continue;
+      }
 
-    // FIXME: If multiple generic parameters map to the same archetype,
-    // the reverse mapping order is not deterministic.
+      ArchetypeToInterfaceMap[archetypeTy] = entry.first;
+    }
   }
 
   // Make sure this generic environment gets destroyed.