add tests

Author: tayloraswift

test/Interpreter/synthesized_extension_conformances.swift

@@ -39,6 +39,7 @@ enum EGeneric<T> {
 }
 extension EGeneric: Equatable where T: Equatable {}
 extension EGeneric: Hashable where T: Hashable {}
+extension EGeneric: Comparable where T: Comparable {}
 
 enum NoValues {
     case a, b, c
@@ -89,6 +90,19 @@ func testEquatableHashable<T: Equatable & Hashable>(cases: [Int: (T, T, Bool, Bo
                     "\(#file):\(testLine) LHS <\(debugDescription(lhs)).hashValue> (\(lhsHash)) == RHS <\(debugDescription(rhs)).hashValue> (\(rhsHash)) doesn't match <\(hashEqual)>")
     }
 }
+func testEquatableHashableComparable<T: Hashable & Comparable>(cases: [Int: (T, T, Bool, Bool, Bool)]) {
+    for (testLine, (lhs, rhs, equal, hashEqual, less)) in cases {
+        expectEqual(lhs == rhs, equal,
+                    "\(#file):\(testLine) LHS <\(debugDescription(lhs))> == RHS <\(debugDescription(rhs))> doesn't match <\(equal)>")
+        expectEqual(lhs < rhs, less,
+                    "\(#file):\(testLine) LHS <\(debugDescription(lhs))> < RHS <\(debugDescription(rhs))> doesn't match <\(less)>")
+
+        let lhsHash = lhs.hashValue
+        let rhsHash = rhs.hashValue
+        expectEqual(lhsHash == rhsHash, hashEqual,
+                    "\(#file):\(testLine) LHS <\(debugDescription(lhs)).hashValue> (\(lhsHash)) == RHS <\(debugDescription(rhs)).hashValue> (\(rhsHash)) doesn't match <\(hashEqual)>")
+    }
+}
 
 class TestEquatableHashable : TestSuper {
     lazy var int: [Int: (SInt, SInt, Bool, Bool)] = [
@@ -147,28 +161,28 @@ class TestEquatableHashable : TestSuper {
         testEquatableHashable(cases: generic)
     }
 
-    lazy var egeneric: [Int: (EGeneric<SInt>, EGeneric<SInt>, Bool, Bool)] = [
-      #line : (EGaOne, EGaOne, true, true),
-      #line : (EGaOne, EGaTwo, false, false),
-      #line : (EGaOne, EGbOne, false, false),
-      #line : (EGaOne, EGbTwo, false, false),
-      #line : (EGaOne, EGc___, false, false),
-
-      #line : (EGbOne, EGaOne, false, false),
-      #line : (EGbOne, EGaTwo, false, false),
-      #line : (EGbOne, EGbOne, true, true),
-      #line : (EGbOne, EGbTwo, false, false),
-      #line : (EGbOne, EGc___, false, false),
-
-      #line : (EGc___, EGaOne, false, false),
-      #line : (EGc___, EGaTwo, false, false),
-      #line : (EGc___, EGbOne, false, false),
-      #line : (EGc___, EGbTwo, false, false),
-      #line : (EGc___, EGc___, true, true),
+    lazy var egeneric: [Int: (EGeneric<SInt>, EGeneric<SInt>, Bool, Bool, Bool)] = [
+      #line : (EGaOne, EGaOne, true, true, false),
+      #line : (EGaOne, EGaTwo, false, false, true),
+      #line : (EGaOne, EGbOne, false, false, true),
+      #line : (EGaOne, EGbTwo, false, false, true),
+      #line : (EGaOne, EGc___, false, false, true),
+
+      #line : (EGbOne, EGaOne, false, false, false),
+      #line : (EGbOne, EGaTwo, false, false, false),
+      #line : (EGbOne, EGbOne, true, true, false),
+      #line : (EGbOne, EGbTwo, false, false, true),
+      #line : (EGbOne, EGc___, false, false, true),
+
+      #line : (EGc___, EGaOne, false, false, false),
+      #line : (EGc___, EGaTwo, false, false, false),
+      #line : (EGc___, EGbOne, false, false, false),
+      #line : (EGc___, EGbTwo, false, false, false),
+      #line : (EGc___, EGc___, true, true, false),
     ]
 
     func test_EGeneric() {
-        testEquatableHashable(cases: egeneric)
+        testEquatableHashableComparable(cases: egeneric)
     }
 }
 

test/Sema/enum_conformance_synthesis.swift

@@ -357,6 +357,17 @@ func miss(_ a: Publicist, outsold b: Publicist) -> Bool {
   return b < a // expected-error{{binary operator '<' cannot be applied to two 'Publicist' operands}}
 }
 
+// can synthesize Comparable conformance through extension 
+enum Birthyear {
+  case eighties(Int)
+  case nineties(Int)
+  case twothousands(Int)
+}
+extension Birthyear: Comparable {
+}
+func canEatHotChip(_ birthyear:Birthyear) -> Bool {
+  return birthyear > .nineties(3)
+}
 // FIXME: Remove -verify-ignore-unknown.
 // <unknown>:0: error: unexpected error produced: invalid redeclaration of 'hashValue'
 // <unknown>:0: error: unexpected note produced: candidate has non-matching type '(Foo, Foo) -> Bool'