NFC: make headers compatible with C++20

In a downstream project we are using the Swift code as a library and
compiling with C++20. This mostly works except for two backward
incompatibilities introduced by C++20:

* [P1008] disallows aggregate initialization when defaulted or deleted
  constructors are specified. This lead to a compilation error for
  aggregate initialization of `swift::Compilation::Result`. The backward
  and forward compatible fix for that is to provide a constructor
  turning aggregate initializations into a normal constructor call.
* [P1185] introduces more candidates for overload resolution of
  comparison operator calls. As explained in [P1630], this leads in some
  cases to ambiguity compilation errors in C++20, which is exactly the
  case with `swift::ValueOwnershipKind`. The fix in this case is to
  remove some redundant operator calls conditionally on the
  `__cpp_impl_three_way_comparison` feature test macro, which [includes
  the papers mentioned above][feature_test].

[P1008]: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1008r1.pdf
[P1185]: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1185r2.html
[P1630]: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1630r1.html
[feature_test]: https://en.cppreference.com/w/cpp/feature_test

Author: redsun82

include/swift/Driver/Compilation.h

@@ -89,6 +89,14 @@ class Compilation {
     /// This data is used for cross-module module dependencies.
     fine_grained_dependencies::ModuleDepGraph depGraph;
 
+    // this constructor is provided instead of relying on aggregate
+    // initialization to be compatible with C++20, as P1185 disallowed that for
+    // types with defaulted or deleted constructors
+    Result(bool hadAbnormalExit = false, int exitCode = 0,
+           fine_grained_dependencies::ModuleDepGraph&& depGraph = {})
+        : hadAbnormalExit{hadAbnormalExit}, exitCode{exitCode},
+          depGraph{std::move(depGraph)} {}
+
     Result(const Result &) = delete;
     Result &operator=(const Result &) = delete;
 
@@ -97,8 +105,7 @@ class Compilation {
 
     /// Construct a \c Compilation::Result from just an exit code.
     static Result code(int code) {
-      return Compilation::Result{false, code,
-                                 fine_grained_dependencies::ModuleDepGraph()};
+      return Compilation::Result{false, code};
     }
   };
 

include/swift/SIL/SILValue.h

@@ -271,6 +271,17 @@ struct ValueOwnershipKind {
 
   explicit operator bool() const { return value != OwnershipKind::Any; }
 
+#ifndef __cpp_impl_three_way_comparison
+  // C++20 (more precisely P1185) introduced more overload candidates for
+  // comparison operator calls. With that in place the following definitions are
+  // redundant and actually cause compilation errors because of ambiguity.
+  // P1630 explains the rationale behind introducing this backward
+  // incompatibility.
+  //
+  // References:
+  // https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1185r2.html
+  // https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1630r1.html
+
   bool operator==(ValueOwnershipKind other) const {
     return value == other.value;
   }
@@ -280,6 +291,7 @@ struct ValueOwnershipKind {
 
   bool operator==(innerty other) const { return value == other; }
   bool operator!=(innerty other) const { return !(value == other); }
+#endif
 
   /// We merge by moving down the lattice.
   ValueOwnershipKind merge(ValueOwnershipKind rhs) const {