AST: Move AvailabilityDomain ordering to Availabilty.cpp.

Availability attribute inferrence is currently the only thing that depends on
having a total ordering on AvailabilityDomains.

Author: tshortli

include/swift/AST/AvailabilityDomain.h

@@ -196,23 +196,6 @@ class AvailabilityDomain final {
     return !(*this == other);
   }
 
-  /// A total, stable ordering on domains.
-  bool operator<(const AvailabilityDomain &other) const {
-    if (getKind() != other.getKind())
-      return getKind() < other.getKind();
-
-    switch (getKind()) {
-    case Kind::Universal:
-    case Kind::SwiftLanguage:
-    case Kind::PackageDescription:
-    case Kind::Embedded:
-      // These availability domains are singletons.
-      return false;
-    case Kind::Platform:
-      return getPlatformKind() < other.getPlatformKind();
-    }
-  }
-
   void Profile(llvm::FoldingSetNodeID &ID) const {
     ID.AddPointer(getOpaqueValue());
   }
@@ -249,6 +232,10 @@ struct DenseMapInfo<AvailabilityDomain> {
   static inline AvailabilityDomain getTombstoneKey() {
     return DenseMapInfo<AvailabilityDomain::Storage>::getTombstoneKey();
   }
+  static inline unsigned getHashValue(AvailabilityDomain domain) {
+    return DenseMapInfo<AvailabilityDomain::Storage>::getHashValue(
+        domain.storage);
+  }
   static bool isEqual(const AvailabilityDomain LHS,
                       const AvailabilityDomain RHS) {
     return LHS == RHS;

lib/AST/Availability.cpp

@@ -201,9 +201,37 @@ void AvailabilityInference::applyInferredAvailableAttrs(
     Decl *ToDecl, ArrayRef<const Decl *> InferredFromDecls) {
   auto &Context = ToDecl->getASTContext();
 
+  /// A wrapper for AvailabilityDomain that implements a stable, total ordering for
+  /// domains. This is needed to ensure that the inferred attributes are added to
+  /// the declaration in a consistent order, preserving interface printing output
+  /// stability across compilations.
+  class OrderedAvailabilityDomain {
+  public:
+    AvailabilityDomain domain;
+
+    OrderedAvailabilityDomain(AvailabilityDomain domain) : domain(domain) {}
+
+    bool operator<(const OrderedAvailabilityDomain &other) const {
+      auto kind = domain.getKind();
+      auto otherKind = other.domain.getKind();
+      if (kind != otherKind)
+        return kind < otherKind;
+
+      switch (kind) {
+      case AvailabilityDomain::Kind::Universal:
+      case AvailabilityDomain::Kind::SwiftLanguage:
+      case AvailabilityDomain::Kind::PackageDescription:
+      case AvailabilityDomain::Kind::Embedded:
+        return false;
+      case AvailabilityDomain::Kind::Platform:
+        return domain.getPlatformKind() < other.domain.getPlatformKind();
+      }
+    }
+  };
+
   // Iterate over the declarations and infer required availability on
   // a per-platform basis.
-  std::map<AvailabilityDomain, InferredAvailability> Inferred;
+  std::map<OrderedAvailabilityDomain, InferredAvailability> Inferred;
   for (const Decl *D : InferredFromDecls) {
     llvm::SmallVector<SemanticAvailableAttr, 8> MergedAttrs;
 
@@ -238,7 +266,8 @@ void AvailabilityInference::applyInferredAvailableAttrs(
   // Create an availability attribute for each observed platform and add
   // to ToDecl.
   for (auto &Pair : Inferred) {
-    if (auto Attr = createAvailableAttr(Pair.first, Pair.second, Context))
+    if (auto Attr =
+            createAvailableAttr(Pair.first.domain, Pair.second, Context))
       Attrs.add(Attr);
   }
 }