Merge pull request swiftlang#12949 from apple/revert-12910-conditional-conformance-equatable

Revert "Use conditional conformances to implement Equatable for Optional, Array and Dictionary"

Author: Greg Parker

lib/Sema/CSApply.cpp

@@ -474,6 +474,9 @@ namespace {
               tc.conformsToProtocol(baseTy, proto, cs.DC,
                                     (ConformanceCheckFlags::InExpression|
                                          ConformanceCheckFlags::Used));
+            assert((!conformance ||
+                    conformance->getConditionalRequirements().empty()) &&
+                   "unhandled conditional conformance");
             if (conformance && conformance->isConcrete()) {
               if (auto witness =
                         conformance->getConcrete()->getWitnessDecl(decl, &tc)) {

lib/Sema/CSDiag.cpp

@@ -4844,7 +4844,7 @@ bool FailureDiagnosis::diagnoseArgumentGenericRequirements(
     AFD = dyn_cast<AbstractFunctionDecl>(candidate);
   }
 
-  if (!AFD || !AFD->getGenericSignature() || !AFD->hasInterfaceType())
+  if (!AFD || !AFD->isGeneric() || !AFD->hasInterfaceType())
     return false;
 
   auto env = AFD->getGenericEnvironment();

lib/Sema/MiscDiagnostics.cpp

@@ -1418,15 +1418,7 @@ static void diagSyntacticUseRestrictions(TypeChecker &TC, const Expr *E,
     ///       x == nil    // also !=
     ///
     void checkOptionalPromotions(ApplyExpr *call) {
-      // We only care about binary expressions.
-      if (!isa<BinaryExpr>(call)) return;
-
-      // Dig out the function we're calling.
-      auto fnExpr = call->getSemanticFn();
-      if (auto dotSyntax = dyn_cast<DotSyntaxCallExpr>(fnExpr))
-        fnExpr = dotSyntax->getSemanticFn();
-
-      auto DRE = dyn_cast<DeclRefExpr>(fnExpr);
+      auto DRE = dyn_cast<DeclRefExpr>(call->getSemanticFn());
       auto args = dyn_cast<TupleExpr>(call->getArg());
       if (!DRE || !DRE->getDecl()->isOperator() ||
           !args || args->getNumElements() != 2)

stdlib/public/core/Arrays.swift.gyb

@@ -2181,55 +2181,57 @@ extension _ArrayBufferProtocol {
 // that are the same, e.g. Array<Int> and Array<Int>, not
 // ArraySlice<Int> and Array<Int>.
 
-extension ${Self} : Equatable where Element : Equatable {
-  /// Returns `true` if these arrays contain the same elements.
-  @_inlineable
-  public static func ==(lhs: ${Self}<Element>, rhs: ${Self}<Element>) -> Bool {
-    let lhsCount = lhs.count
-    if lhsCount != rhs.count {
-      return false
-    }
+/// Returns `true` if these arrays contain the same elements.
+@_inlineable
+public func == <Element : Equatable>(
+  lhs: ${Self}<Element>, rhs: ${Self}<Element>
+) -> Bool {
+  let lhsCount = lhs.count
+  if lhsCount != rhs.count {
+    return false
+  }
 
-    // Test referential equality.
-    if lhsCount == 0 || lhs._buffer.identity == rhs._buffer.identity {
-      return true
-    }
+  // Test referential equality.
+  if lhsCount == 0 || lhs._buffer.identity == rhs._buffer.identity {
+    return true
+  }
 
-  %if Self == 'ArraySlice':
+%if Self == 'ArraySlice':
 
-    var streamLHS = lhs.makeIterator()
-    var streamRHS = rhs.makeIterator()
+  var streamLHS = lhs.makeIterator()
+  var streamRHS = rhs.makeIterator()
 
-    var nextLHS = streamLHS.next()
-    while nextLHS != nil {
-      let nextRHS = streamRHS.next()
-      if nextLHS != nextRHS {
-        return false
-      }
-      nextLHS = streamLHS.next()
+  var nextLHS = streamLHS.next()
+  while nextLHS != nil {
+    let nextRHS = streamRHS.next()
+    if nextLHS != nextRHS {
+      return false
     }
+    nextLHS = streamLHS.next()
+  }
 
-  %else:
+%else:
 
-    _sanityCheck(lhs.startIndex == 0 && rhs.startIndex == 0)
-    _sanityCheck(lhs.endIndex == lhsCount && rhs.endIndex == lhsCount)
+  _sanityCheck(lhs.startIndex == 0 && rhs.startIndex == 0)
+  _sanityCheck(lhs.endIndex == lhsCount && rhs.endIndex == lhsCount)
 
-    // We know that lhs.count == rhs.count, compare element wise.
-    for idx in 0..<lhsCount {
-      if lhs[idx] != rhs[idx] {
-        return false
-      }
+  // We know that lhs.count == rhs.count, compare element wise.
+  for idx in 0..<lhsCount {
+    if lhs[idx] != rhs[idx] {
+      return false
     }
-  %end
-
-    return true
   }
+%end
 
-  /// Returns `true` if the arrays do not contain the same elements.
-  @_inlineable
-  public static func !=(lhs: ${Self}<Element>, rhs: ${Self}<Element>) -> Bool {
-    return !(lhs == rhs)
-  }
+  return true
+}
+
+/// Returns `true` if the arrays do not contain the same elements.
+@_inlineable
+public func != <Element : Equatable>(
+  lhs: ${Self}<Element>, rhs: ${Self}<Element>
+) -> Bool {
+  return !(lhs == rhs)
 }
 
 extension ${Self} {

stdlib/public/core/HashedCollections.swift.gyb

@@ -2708,7 +2708,7 @@ extension Dictionary {
   }
 }
 
-extension Dictionary : Equatable where Value : Equatable {
+extension Dictionary where Value : Equatable {
   @_inlineable // FIXME(sil-serialize-all)
   public static func == (lhs: [Key : Value], rhs: [Key : Value]) -> Bool {
     switch (lhs._variantBuffer, rhs._variantBuffer) {