Automatically infer Equatable conformance for plain C enums

This provides the == operator as well as ~=, which allows for
less encumbered pattern matching for these imported types.

rdar://problem/17287720

Swift SVN r31469

Author: bitjammer

lib/ClangImporter/ImportDecl.cpp

@@ -1932,7 +1932,8 @@ namespace {
         structDecl->computeType();
 
         ProtocolDecl *protocols[]
-          = {cxt.getProtocol(KnownProtocolKind::RawRepresentable)};
+          = {cxt.getProtocol(KnownProtocolKind::RawRepresentable),
+             cxt.getProtocol(KnownProtocolKind::Equatable)};
         populateInheritedTypes(structDecl, protocols);
 
         // Note that this is a raw representable type.

test/ClangModules/Inputs/SwiftPrivateAttr.txt

@@ -54,19 +54,19 @@ struct __PrivS2 {
   init(value: Int32)
 }
 var __PrivAnonymousA: Int { get }
-struct E0 : RawRepresentable {
+struct E0 : RawRepresentable, Equatable {
   init(_ rawValue: UInt32)
   init(rawValue: UInt32)
   var rawValue: UInt32
 }
 var __E0PrivA: E0 { get }
-struct __PrivE1 : RawRepresentable {
+struct __PrivE1 : RawRepresentable, Equatable {
   init(_ rawValue: UInt32)
   init(rawValue: UInt32)
   var rawValue: UInt32
 }
 var __PrivE1A: __PrivE1 { get }
-struct __PrivE2 : RawRepresentable {
+struct __PrivE2 : RawRepresentable, Equatable {
   init(_ rawValue: UInt32)
   init(rawValue: UInt32)
   var rawValue: UInt32

test/ClangModules/ctypes_parse.swift

@@ -11,12 +11,22 @@ import CoreFoundation
 var cgPointVar: CGPoint
 
 func checkRawRepresentable<T: RawRepresentable>(_: T) {}
+func checkEquatable<T: Equatable>(_: T) -> Bool {}
+func checkEquatablePattern(c: Color) {
+  switch c {
+    case red: return
+    case green: return
+    case blue: return
+  }
+}
 
 func testColor() {
   var c: Color = red
   c = blue
   _ = c.rawValue
   checkRawRepresentable(c)
+  checkEquatable(c)
+  checkEquatablePattern(c)
 }
 
 func testTribool() {

test/IDE/Inputs/mock-sdk/Foo.FooSub.printed.txt

@@ -1,7 +1,7 @@
 @exported import FooHelper
 
 func fooSubFunc1(a: Int32) -> Int32
-struct FooSubEnum1 : RawRepresentable {
+struct FooSubEnum1 : RawRepresentable, Equatable {
   init(_ rawValue: UInt32)
   init(rawValue: UInt32)
   var rawValue: UInt32

test/IDE/Inputs/mock-sdk/Foo.annotated.txt

@@ -3,22 +3,22 @@
 
 
 <decl:Struct>/// Aaa.  FooEnum1.  Bbb.
-struct <loc>FooEnum1</loc> : <ref:Protocol>RawRepresentable</ref> {
+struct <loc>FooEnum1</loc> : <ref:Protocol>RawRepresentable</ref>, <ref:Protocol>Equatable</ref> {
   <decl:Constructor><loc>init(_ rawValue: <ref:Struct>UInt32</ref>)</loc></decl>
   <decl:Constructor><loc>init(rawValue: <ref:Struct>UInt32</ref>)</loc></decl>
   <decl:Var>var <loc>rawValue</loc>: <ref:Struct>UInt32</ref></decl>
 }</decl>
 
 <decl:Var>/// Aaa.  FooEnum1X.  Bbb.
 var <loc>FooEnum1X</loc>: <ref:Struct>FooEnum1</ref> { get }</decl>
-<decl:Struct>struct <loc>FooEnum2</loc> : <ref:Protocol>RawRepresentable</ref> {
+<decl:Struct>struct <loc>FooEnum2</loc> : <ref:Protocol>RawRepresentable</ref>, <ref:Protocol>Equatable</ref> {
   <decl:Constructor><loc>init(_ rawValue: <ref:Struct>UInt32</ref>)</loc></decl>
   <decl:Constructor><loc>init(rawValue: <ref:Struct>UInt32</ref>)</loc></decl>
   <decl:Var>var <loc>rawValue</loc>: <ref:Struct>UInt32</ref></decl>
 }</decl>
 <decl:Var>var <loc>FooEnum2X</loc>: <ref:Struct>FooEnum2</ref> { get }</decl>
 <decl:Var>var <loc>FooEnum2Y</loc>: <ref:Struct>FooEnum2</ref> { get }</decl>
-<decl:Struct>struct <loc>FooEnum3</loc> : <ref:Protocol>RawRepresentable</ref> {
+<decl:Struct>struct <loc>FooEnum3</loc> : <ref:Protocol>RawRepresentable</ref>, <ref:Protocol>Equatable</ref> {
   <decl:Constructor><loc>init(_ rawValue: <ref:Struct>UInt32</ref>)</loc></decl>
   <decl:Constructor><loc>init(rawValue: <ref:Struct>UInt32</ref>)</loc></decl>
   <decl:Var>var <loc>rawValue</loc>: <ref:Struct>UInt32</ref></decl>

test/IDE/Inputs/mock-sdk/Foo.printed.recursive.txt

@@ -3,22 +3,22 @@
 
 
 /// Aaa.  FooEnum1.  Bbb.
-struct FooEnum1 : RawRepresentable {
+struct FooEnum1 : RawRepresentable, Equatable {
   init(_ rawValue: UInt32)
   init(rawValue: UInt32)
   var rawValue: UInt32
 }
 
 /// Aaa.  FooEnum1X.  Bbb.
 var FooEnum1X: FooEnum1 { get }
-struct FooEnum2 : RawRepresentable {
+struct FooEnum2 : RawRepresentable, Equatable {
   init(_ rawValue: UInt32)
   init(rawValue: UInt32)
   var rawValue: UInt32
 }
 var FooEnum2X: FooEnum2 { get }
 var FooEnum2Y: FooEnum2 { get }
-struct FooEnum3 : RawRepresentable {
+struct FooEnum3 : RawRepresentable, Equatable {
   init(_ rawValue: UInt32)
   init(rawValue: UInt32)
   var rawValue: UInt32
@@ -269,7 +269,7 @@ extension FooRepeatedMembers {
 extension FooRepeatedMembers {
 }
 func fooSubFunc1(a: Int32) -> Int32
-struct FooSubEnum1 : RawRepresentable {
+struct FooSubEnum1 : RawRepresentable, Equatable {
   init(_ rawValue: UInt32)
   init(rawValue: UInt32)
   var rawValue: UInt32

test/IDE/Inputs/mock-sdk/Foo.printed.txt

@@ -11,7 +11,7 @@
 // Yo.
 
 /// Aaa.  FooEnum1.  Bbb.
-struct FooEnum1 : RawRepresentable {
+struct FooEnum1 : RawRepresentable, Equatable {
   init(_ rawValue: UInt32)
   init(rawValue: UInt32)
   var rawValue: UInt32
@@ -20,14 +20,14 @@ struct FooEnum1 : RawRepresentable {
 /// Aaa.  FooEnum1X.  Bbb.
 var FooEnum1X: FooEnum1 { get }
 
-struct FooEnum2 : RawRepresentable {
+struct FooEnum2 : RawRepresentable, Equatable {
   init(_ rawValue: UInt32)
   init(rawValue: UInt32)
   var rawValue: UInt32
 }
 var FooEnum2X: FooEnum2 { get }
 var FooEnum2Y: FooEnum2 { get }
-struct FooEnum3 : RawRepresentable {
+struct FooEnum3 : RawRepresentable, Equatable {
   init(_ rawValue: UInt32)
   init(rawValue: UInt32)
   var rawValue: UInt32

test/IDE/Inputs/mock-sdk/FooHelper.FooHelperSub.printed.txt

@@ -1,6 +1,6 @@
 
 func fooHelperSubFunc1(a: Int32) -> Int32
-struct FooHelperSubEnum1 : RawRepresentable {
+struct FooHelperSubEnum1 : RawRepresentable, Equatable {
   init(_ rawValue: UInt32)
   init(rawValue: UInt32)
   var rawValue: UInt32