AST: Use the right module name in TypeDecl::compare()

The last step in building a generic signature is to sort the requirements.
Requirements are sorted by comparing their subject types. If two
requirements have the same subject type, which can only happen with
conformance requirements, we break the tie by comparing protocol
declarations.

We compare protocol declarations using TypeDecl::compare(), which is a
shortlex order on the components of the fully qualified name of a
protocol (eg, Swift.Sequence, etc.)

While this order is part of the ABI, it has not been updated over the
years for several important changes:

- It did not handle module aliases; if we import a module via an
  alias, we should use the real module name to compare protocols, and
  not the aliased name. This produced inconsistent results if the
  same module was imported under different names, which can happen
  with module interface files that use module aliases.

- It did not handle the -module-abi-name flag. Changing the ABI name
  of a module changes how we mangle protocol names, and the order
  should match the mangling.

This change uses the correct module names for comparison to match
what the mangler does.

Of course this is an ABI break, however it should have limited impact
since module aliases and -module-abi-name are not widely used.

Fixes rdar://147441890.

Author: slavapestov

lib/AST/Decl.cpp

@@ -15,6 +15,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "swift/Strings.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/ASTMangler.h"
@@ -5348,9 +5349,39 @@ int TypeDecl::compare(const TypeDecl *type1, const TypeDecl *type2) {
 
   // Prefer module names earlier in the alphabet.
   if (dc1->isModuleScopeContext() && dc2->isModuleScopeContext()) {
-    auto module1 = dc1->getParentModule();
-    auto module2 = dc2->getParentModule();
-    if (int result = module1->getName().str().compare(module2->getName().str()))
+    // For protocol declarations specifically, the order here is part
+    // of the ABI, and so we must take care to get the correct module
+    // name for the comparison.
+    auto getModuleNameForOrder = [&](const TypeDecl *decl) -> StringRef {
+      // This used to just call getName(), which caused accidental ABI breaks
+      // when a module is imported under different aliases.
+      //
+      // The new behavior matches the behavior in the mangler:
+      //
+      // - getName() returns the name of the module as its imported by the
+      //   client, which might be an alias different from the real name.
+      // - getRealName() returns the real name after desugaring aliases.
+      // - getABIName() returns the name set with the -module-abi-name flag, or
+      //   **getName()** if the flag is not set.
+      //
+      // Thus, the correct module name to use for mangling and ordering is
+      // getRealName(), unless getABIName() is distinct from getName(), in
+      // which case we use getABIName().
+      //
+      // FIXME: This should be fixed after auditing callers of getABIName().
+      //
+      // However, to maintain ABI compatibility, we ignore the ABI name for the
+      // _Concurrency module, which is "Swift", and still use the real name in
+      // this case.
+      auto *module = decl->getDeclContext()->getParentModule();
+      if (module->getRealName().str() == SWIFT_CONCURRENCY_NAME ||
+          module->getName() == module->getABIName()) {
+        return module->getRealName().str();
+      }
+      return module->getABIName().str();
+    };
+
+    if (int result = getModuleNameForOrder(type1).compare(getModuleNameForOrder(type2)))
       return result;
   }
 

test/SILGen/conformance_requirement_order.swift

@@ -0,0 +1,24 @@
+// RUN: %empty-directory(%t)
+
+// Name: SwiftHorse, RealName: Horse, ABIName: SwiftHorse
+
+// RUN: %target-swift-frontend -emit-module %s -module-name Horse -D LIB -emit-module-path %t/Horse.swiftmodule
+// RUN: %target-swift-emit-silgen %s -module-name main -I %t -module-alias SwiftHorse=Horse | %FileCheck %s
+
+// Name: SwiftHorse, RealName: SwiftHorse, ABIName: Horse
+
+// RUN: %target-swift-frontend -emit-module %s -module-name SwiftHorse -module-abi-name Horse -D LIB -emit-module-path %t/SwiftHorse.swiftmodule
+// RUN: %target-swift-emit-silgen %s -module-name main -I %t | %FileCheck %s
+
+#if LIB
+  public protocol Equine {}
+#else
+  import SwiftHorse
+
+  // Make sure we use the module's real name, and not its alias name, so that
+  // we always have Horse.Equine < Swift.Equatable. If this doesn't hold, the
+  // two requirements in the mangling will be flipped.
+
+  // CHECK-LABEL: sil hidden [ossa] @$s4main21requirementOrderHorseyyx0D06EquineRzSQRzlF : $@convention(thin) <T where T : Equine, T : Equatable> (@in_guaranteed T) -> () {
+  func requirementOrderHorse<T: Equine & Equatable>(_: T) {}
+#endif

test/SILGen/conformance_requirement_order_concurrency.swift

@@ -0,0 +1,10 @@
+// RUN: %target-swift-emit-silgen %s -module-name main | %FileCheck %s
+
+// See conformance_requirement_order.swift for the general case.
+//
+// For the _Concurrency module, the mistake is baked into the ABI. For example,
+// we mangle the below type as Swift.Executor, but order it as if it were
+// _Concurrency.Executor.
+
+// CHECK-LABEL: sil hidden [ossa] @$s4main27requirementOrderConcurrencyyyxSTRzScFRzlF : $@convention(thin) <T where T : Sequence, T : Executor> (@guaranteed T) -> () {
+func requirementOrderConcurrency<T: Executor & Sequence>(_: T) {}