Merge remote-tracking branch 'origin/master' into master-next

test/SourceKit/DocSupport/doc_clang_module.swift.response

@@ -5259,6 +5259,11 @@ var FooSubUnnamedEnumeratorA1: Int { get }
         key.length: 31,
         key.fully_annotated_decl: "<decl.function.constructor><syntaxtype.keyword>init</syntaxtype.keyword>(<decl.var.parameter><decl.var.parameter.argument_label>rawValue</decl.var.parameter.argument_label>: <decl.var.parameter.type><ref.struct usr=\"s:s6UInt32V\">UInt32</ref.struct></decl.var.parameter.type></decl.var.parameter>)</decl.function.constructor>",
         key.conforms: [
+          {
+            key.kind: source.lang.swift.ref.function.constructor,
+            key.name: "init(rawValue:)",
+            key.usr: "s:s16RawRepresentablePxSg0A5ValueQz03rawC0_tcfc"
+          },
           {
             key.kind: source.lang.swift.ref.function.constructor,
             key.name: "init(rawValue:)",
@@ -5283,6 +5288,11 @@ var FooSubUnnamedEnumeratorA1: Int { get }
         key.length: 20,
         key.fully_annotated_decl: "<decl.var.instance><syntaxtype.keyword>var</syntaxtype.keyword> <decl.name>rawValue</decl.name>: <decl.var.type><ref.struct usr=\"s:s6UInt32V\">UInt32</ref.struct></decl.var.type></decl.var.instance>",
         key.conforms: [
+          {
+            key.kind: source.lang.swift.ref.var.instance,
+            key.name: "rawValue",
+            key.usr: "s:s16RawRepresentableP8rawValue0aD0Qzv"
+          },
           {
             key.kind: source.lang.swift.ref.var.instance,
             key.name: "rawValue",
@@ -5372,6 +5382,11 @@ var FooSubUnnamedEnumeratorA1: Int { get }
         key.length: 31,
         key.fully_annotated_decl: "<decl.function.constructor><syntaxtype.keyword>init</syntaxtype.keyword>(<decl.var.parameter><decl.var.parameter.argument_label>rawValue</decl.var.parameter.argument_label>: <decl.var.parameter.type><ref.struct usr=\"s:s6UInt32V\">UInt32</ref.struct></decl.var.parameter.type></decl.var.parameter>)</decl.function.constructor>",
         key.conforms: [
+          {
+            key.kind: source.lang.swift.ref.function.constructor,
+            key.name: "init(rawValue:)",
+            key.usr: "s:s16RawRepresentablePxSg0A5ValueQz03rawC0_tcfc"
+          },
           {
             key.kind: source.lang.swift.ref.function.constructor,
             key.name: "init(rawValue:)",
@@ -5396,6 +5411,11 @@ var FooSubUnnamedEnumeratorA1: Int { get }
         key.length: 20,
         key.fully_annotated_decl: "<decl.var.instance><syntaxtype.keyword>var</syntaxtype.keyword> <decl.name>rawValue</decl.name>: <decl.var.type><ref.struct usr=\"s:s6UInt32V\">UInt32</ref.struct></decl.var.type></decl.var.instance>",
         key.conforms: [
+          {
+            key.kind: source.lang.swift.ref.var.instance,
+            key.name: "rawValue",
+            key.usr: "s:s16RawRepresentableP8rawValue0aD0Qzv"
+          },
           {
             key.kind: source.lang.swift.ref.var.instance,
             key.name: "rawValue",
@@ -5492,6 +5512,11 @@ var FooSubUnnamedEnumeratorA1: Int { get }
         key.length: 31,
         key.fully_annotated_decl: "<decl.function.constructor><syntaxtype.keyword>init</syntaxtype.keyword>(<decl.var.parameter><decl.var.parameter.argument_label>rawValue</decl.var.parameter.argument_label>: <decl.var.parameter.type><ref.struct usr=\"s:s6UInt32V\">UInt32</ref.struct></decl.var.parameter.type></decl.var.parameter>)</decl.function.constructor>",
         key.conforms: [
+          {
+            key.kind: source.lang.swift.ref.function.constructor,
+            key.name: "init(rawValue:)",
+            key.usr: "s:s16RawRepresentablePxSg0A5ValueQz03rawC0_tcfc"
+          },
           {
             key.kind: source.lang.swift.ref.function.constructor,
             key.name: "init(rawValue:)",
@@ -5516,6 +5541,11 @@ var FooSubUnnamedEnumeratorA1: Int { get }
         key.length: 20,
         key.fully_annotated_decl: "<decl.var.instance><syntaxtype.keyword>var</syntaxtype.keyword> <decl.name>rawValue</decl.name>: <decl.var.type><ref.struct usr=\"s:s6UInt32V\">UInt32</ref.struct></decl.var.type></decl.var.instance>",
         key.conforms: [
+          {
+            key.kind: source.lang.swift.ref.var.instance,
+            key.name: "rawValue",
+            key.usr: "s:s16RawRepresentableP8rawValue0aD0Qzv"
+          },
           {
             key.kind: source.lang.swift.ref.var.instance,
             key.name: "rawValue",
@@ -8017,6 +8047,11 @@ var FooSubUnnamedEnumeratorA1: Int { get }
         key.length: 31,
         key.fully_annotated_decl: "<decl.function.constructor><syntaxtype.keyword>init</syntaxtype.keyword>(<decl.var.parameter><decl.var.parameter.argument_label>rawValue</decl.var.parameter.argument_label>: <decl.var.parameter.type><ref.struct usr=\"s:s6UInt32V\">UInt32</ref.struct></decl.var.parameter.type></decl.var.parameter>)</decl.function.constructor>",
         key.conforms: [
+          {
+            key.kind: source.lang.swift.ref.function.constructor,
+            key.name: "init(rawValue:)",
+            key.usr: "s:s16RawRepresentablePxSg0A5ValueQz03rawC0_tcfc"
+          },
           {
             key.kind: source.lang.swift.ref.function.constructor,
             key.name: "init(rawValue:)",
@@ -8041,6 +8076,11 @@ var FooSubUnnamedEnumeratorA1: Int { get }
         key.length: 20,
         key.fully_annotated_decl: "<decl.var.instance><syntaxtype.keyword>var</syntaxtype.keyword> <decl.name>rawValue</decl.name>: <decl.var.type><ref.struct usr=\"s:s6UInt32V\">UInt32</ref.struct></decl.var.type></decl.var.instance>",
         key.conforms: [
+          {
+            key.kind: source.lang.swift.ref.var.instance,
+            key.name: "rawValue",
+            key.usr: "s:s16RawRepresentableP8rawValue0aD0Qzv"
+          },
           {
             key.kind: source.lang.swift.ref.var.instance,
             key.name: "rawValue",

test/decl/protocol/special/coding/Inputs/class_codable_simple_multi1.swift

@@ -0,0 +1,21 @@
+// Simple classes with all Codable properties should get derived conformance to
+// Codable.
+class SimpleClass : Codable {
+  var x: Int = 1
+  var y: Double = .pi
+  static var z: String = "foo"
+
+  // These lines have to be within the SimpleClass type because CodingKeys
+  // should be private.
+  func foo() {
+    // They should receive a synthesized CodingKeys enum.
+    let _ = SimpleClass.CodingKeys.self
+
+    // The enum should have a case for each of the vars.
+    let _ = SimpleClass.CodingKeys.x
+    let _ = SimpleClass.CodingKeys.y
+
+    // Static vars should not be part of the CodingKeys enum.
+    let _ = SimpleClass.CodingKeys.z // expected-error {{type 'SimpleClass.CodingKeys' has no member 'z'}}
+  }
+}

test/decl/protocol/special/coding/Inputs/class_codable_simple_multi2.swift

@@ -0,0 +1,10 @@
+// These are wrapped in a dummy function to avoid binding a global variable.
+func foo() {
+  // They should receive synthesized init(from:) and an encode(to:).
+  let _ = SimpleClass.init(from:)
+  let _ = SimpleClass.encode(to:)
+
+  // The synthesized CodingKeys type should not be accessible from outside the
+  // class.
+  let _ = SimpleClass.CodingKeys.self // expected-error {{'CodingKeys' is inaccessible due to 'private' protection level}}
+}

test/decl/protocol/special/coding/Inputs/enum_coding_key_extension_multi1.swift

@@ -0,0 +1,11 @@
+enum NoRawTypeKey {
+  case a, b, c
+}
+
+enum StringKey : String {
+  case a = "A", b, c = "Foo"
+}
+
+enum IntKey : Int {
+  case a = 3, b, c = 1
+}

test/decl/protocol/special/coding/Inputs/enum_coding_key_extension_multi2.swift

@@ -0,0 +1,3 @@
+extension NoRawTypeKey : CodingKey {}
+extension StringKey : CodingKey {}
+extension IntKey : CodingKey {}

test/decl/protocol/special/coding/Inputs/enum_coding_key_extension_multi3.swift

@@ -0,0 +1,16 @@
+func foo() {
+  let _ = NoRawTypeKey.a.stringValue
+  let _ = NoRawTypeKey(stringValue: "a")
+  let _ = NoRawTypeKey.a.intValue
+  let _ = NoRawTypeKey(intValue: 0)
+
+  let _ = StringKey.a.stringValue
+  let _ = StringKey(stringValue: "A")
+  let _ = StringKey.a.intValue
+  let _ = StringKey(intValue: 0)
+
+  let _ = IntKey.a.stringValue
+  let _ = IntKey(stringValue: "a")
+  let _ = IntKey.a.intValue
+  let _ = IntKey(intValue: 3)
+}

test/decl/protocol/special/coding/Inputs/enum_coding_key_multi1.swift

@@ -0,0 +1,11 @@
+enum NoRawTypeKey : CodingKey {
+    case a, b, c
+}
+
+enum StringKey : String, CodingKey {
+    case a = "A", b, c = "Foo"
+}
+
+enum IntKey : Int, CodingKey {
+    case a = 3, b, c = 1
+}

test/decl/protocol/special/coding/Inputs/enum_coding_key_multi2.swift

@@ -0,0 +1,16 @@
+func foo() {
+  let _ = NoRawTypeKey.a.stringValue
+  let _ = NoRawTypeKey(stringValue: "a")
+  let _ = NoRawTypeKey.a.intValue
+  let _ = NoRawTypeKey(intValue: 0)
+
+  let _ = StringKey.a.stringValue
+  let _ = StringKey(stringValue: "A")
+  let _ = StringKey.a.intValue
+  let _ = StringKey(intValue: 0)
+
+  let _ = IntKey.a.stringValue
+  let _ = IntKey(stringValue: "a")
+  let _ = IntKey.a.intValue
+  let _ = IntKey(intValue: 3)
+}

test/decl/protocol/special/coding/Inputs/struct_codable_simple_multi1.swift

@@ -0,0 +1,23 @@
+// RUN: %target-typecheck-verify-swift
+
+// Simple structs with all Codable properties should get derived conformance to
+// Codable.
+struct SimpleStruct : Codable {
+  var x: Int
+  var y: Double
+  static var z: String = "foo"
+
+  // These lines have to be within the SimpleStruct type because CodingKeys
+  // should be private.
+  func foo() {
+    // They should receive a synthesized CodingKeys enum.
+    let _ = SimpleStruct.CodingKeys.self
+
+    // The enum should have a case for each of the vars.
+    let _ = SimpleStruct.CodingKeys.x
+    let _ = SimpleStruct.CodingKeys.y
+
+    // Static vars should not be part of the CodingKeys enum.
+    let _ = SimpleStruct.CodingKeys.z // expected-error {{type 'SimpleStruct.CodingKeys' has no member 'z'}}
+  }
+}

test/decl/protocol/special/coding/Inputs/struct_codable_simple_multi2.swift

@@ -0,0 +1,10 @@
+// These are wrapped in a dummy function to avoid binding a global variable.
+func foo() {
+  // They should receive synthesized init(from:) and an encode(to:).
+  let _ = SimpleStruct.init(from:)
+  let _ = SimpleStruct.encode(to:)
+
+  // The synthesized CodingKeys type should not be accessible from outside the
+  // struct.
+  let _ = SimpleStruct.CodingKeys.self // expected-error {{'CodingKeys' is inaccessible due to 'private' protection level}}
+}

test/decl/protocol/special/coding/class_codable_computed_vars.swift

@@ -0,0 +1,39 @@
+// RUN: %target-typecheck-verify-swift -verify-ignore-unknown
+
+// Classes with computed members should get synthesized conformance to Codable,
+// but their lazy and computed members should be skipped as part of the
+// synthesis.
+class ClassWithComputedMembers : Codable {
+  var x: Int = 1
+  lazy var y: Double = .pi
+  var z: String {
+    return "foo"
+  }
+
+  // These lines have to be within the ClassWithComputedMembers type because
+  // CodingKeys should be private.
+  func foo() {
+    // They should receive a synthesized CodingKeys enum.
+    let _ = ClassWithComputedMembers.CodingKeys.self
+
+    // The enum should have a case for each of the vars.
+    let _ = ClassWithComputedMembers.CodingKeys.x
+
+    // Lazy vars should not be part of the CodingKeys enum.
+    let _ = ClassWithComputedMembers.CodingKeys.y // expected-error {{type 'ClassWithComputedMembers.CodingKeys' has no member 'y'}}
+
+    // Computed vars should not be part of the CodingKeys enum.
+    let _ = ClassWithComputedMembers.CodingKeys.z // expected-error {{type 'ClassWithComputedMembers.CodingKeys' has no member 'z'}}
+  }
+}
+
+// These are wrapped in a dummy function to avoid binding a global variable.
+func foo() {
+  // They should receive synthesized init(from:) and an encode(to:).
+  let _ = ClassWithComputedMembers.init(from:)
+  let _ = ClassWithComputedMembers.encode(to:)
+
+  // The synthesized CodingKeys type should not be accessible from outside the
+  // class.
+  let _ = ClassWithComputedMembers.CodingKeys.self // expected-error {{'CodingKeys' is inaccessible due to 'private' protection level}}
+}

test/decl/protocol/special/coding/class_codable_inheritance.swift

@@ -0,0 +1,55 @@
+// RUN: %target-typecheck-verify-swift -verify-ignore-unknown
+
+class SimpleClass : Codable {
+  var x: Int = 1
+  var y: Double = .pi
+  static var z: String = "foo"
+}
+
+// The synthesized CodingKeys type should not be accessible from outside the
+// class.
+let _ = SimpleClass.CodingKeys.self // expected-error {{'CodingKeys' is inaccessible due to 'private' protection level}}
+
+// Classes which inherit from classes that are codable should synthesize Codable
+// conformance as well.
+class SimpleChildClass : SimpleClass {
+  var w: Bool = true
+
+  // NOTE: These tests will fail in the future as Codable classes are updated
+  //       to derive Codable conformance instead of inheriting their
+  //       superclass's. Classes currently inherit their parent's Codable
+  //       conformance and we never get the chance to derive a CodingKeys
+  //       type, nor overridden methods.
+
+  // These lines have to be within the SimpleChildClass type because
+  // CodingKeys should be private.
+  func foo() {
+    // They should receive a synthesized CodingKeys enum.
+    // NOTE: This expected error will need to be removed in the future.
+    let _ = SimpleChildClass.CodingKeys.self // expected-error {{'CodingKeys' is inaccessible due to 'private' protection level}}
+
+    // The enum should have a case for each of the vars.
+    // NOTE: This expectedxerror will need to be removed in the future.
+    let _ = SimpleChildClass.CodingKeys.w // expected-error {{'CodingKeys' is inaccessible due to 'private' protection level}}
+
+    // Inherited vars should not be part of the CodingKeys enum.
+    // NOTE: This expected error will need to be updated in the future.
+    //       Should be `type 'SimpleClass.CodingKeys' has no member 'x'`
+    let _ = SimpleChildClass.CodingKeys.x // expected-error {{'CodingKeys' is inaccessible due to 'private' protection level}}
+
+    // NOTE: This expected error will need to be updated in the future.
+    //       Should be `type 'SimpleClass.CodingKeys' has no member 'y'`
+    let _ = SimpleChildClass.CodingKeys.y // expected-error {{'CodingKeys' is inaccessible due to 'private' protection level}}
+  }
+}
+
+// These are wrapped in a dummy function to avoid binding a global variable.
+func foo() {
+  // They should receive synthesized init(from:) and an encode(to:).
+  let _ = SimpleChildClass.init(from:)
+  let _ = SimpleChildClass.encode(to:)
+
+  // The synthesized CodingKeys type should not be accessible from outside the
+  // class.
+  let _ = SimpleChildClass.CodingKeys.self // expected-error {{'CodingKeys' is inaccessible due to 'private' protection level}}
+}

test/decl/protocol/special/coding/class_codable_simple.swift

@@ -0,0 +1,34 @@
+// RUN: %target-typecheck-verify-swift -verify-ignore-unknown
+
+// Simple classes with all Codable properties should get derived conformance to
+// Codable.
+class SimpleClass : Codable {
+  var x: Int = 1
+  var y: Double = .pi
+  static var z: String = "foo"
+
+  // These lines have to be within the SimpleClass type because CodingKeys
+  // should be private.
+  func foo() {
+    // They should receive a synthesized CodingKeys enum.
+    let _ = SimpleClass.CodingKeys.self
+
+    // The enum should have a case for each of the vars.
+    let _ = SimpleClass.CodingKeys.x
+    let _ = SimpleClass.CodingKeys.y
+
+    // Static vars should not be part of the CodingKeys enum.
+    let _ = SimpleClass.CodingKeys.z // expected-error {{type 'SimpleClass.CodingKeys' has no member 'z'}}
+  }
+}
+
+// These are wrapped in a dummy function to avoid binding a global variable.
+func foo() {
+  // They should receive synthesized init(from:) and an encode(to:).
+  let _ = SimpleClass.init(from:)
+  let _ = SimpleClass.encode(to:)
+
+  // The synthesized CodingKeys type should not be accessible from outside the
+  // class.
+  let _ = SimpleClass.CodingKeys.self // expected-error {{'CodingKeys' is inaccessible due to 'private' protection level}}
+}

test/decl/protocol/special/coding/class_codable_simple_extension.swift

@@ -0,0 +1,36 @@
+// RUN: %target-typecheck-verify-swift -verify-ignore-unknown
+
+// Simple classes where Codable conformance is added in extensions should still
+// derive conformance.
+class SimpleClass {
+  var x: Int = 1
+  var y: Double = .pi
+  static var z: String = "foo"
+
+  // These lines have to be within the SimpleClass type because CodingKeys
+  // should be private.
+  func foo() {
+    // They should receive a synthesized CodingKeys enum.
+    let _ = SimpleClass.CodingKeys.self
+
+    // The enum should have a case for each of the vars.
+    let _ = SimpleClass.CodingKeys.x
+    let _ = SimpleClass.CodingKeys.y
+
+    // Static vars should not be part of the CodingKeys enum.
+    let _ = SimpleClass.CodingKeys.z // expected-error {{type 'SimpleClass.CodingKeys' has no member 'z'}}
+  }
+}
+
+extension SimpleClass : Codable {}
+
+// These are wrapped in a dummy function to avoid binding a global variable.
+func foo() {
+  // They should receive synthesized init(from:) and an encode(to:).
+  let _ = SimpleClass.init(from:)
+  let _ = SimpleClass.encode(to:)
+
+  // The synthesized CodingKeys type should not be accessible from outside the
+  // class.
+  let _ = SimpleClass.CodingKeys.self // expected-error {{'CodingKeys' is inaccessible due to 'private' protection level}}
+}

test/decl/protocol/special/coding/class_codable_simple_multi.swift

@@ -0,0 +1,2 @@
+// RUN: %target-typecheck-verify-swift -verify-ignore-unknown %S/Inputs/class_codable_simple_multi1.swift %S/Inputs/class_codable_simple_multi2.swift
+// RUN: %target-typecheck-verify-swift -verify-ignore-unknown %S/Inputs/class_codable_simple_multi2.swift %S/Inputs/class_codable_simple_multi1.swift

test/decl/protocol/special/coding/enum_coding_key.swift

@@ -0,0 +1,99 @@
+// RUN: %target-typecheck-verify-swift -verify-ignore-unknown
+
+// Enums with no raw type conforming to CodingKey should get implicit derived
+// conformance of methods.
+enum NoRawTypeKey : CodingKey {
+    case a, b, c
+}
+
+let _ = NoRawTypeKey.a.stringValue
+let _ = NoRawTypeKey(stringValue: "a")
+let _ = NoRawTypeKey.a.intValue
+let _ = NoRawTypeKey(intValue: 0)
+
+// Enums with raw type of String conforming to CodingKey should get implicit
+// derived conformance of methods.
+enum StringKey : String, CodingKey {
+    case a = "A", b, c = "Foo"
+}
+
+let _ = StringKey.a.stringValue
+let _ = StringKey(stringValue: "A")
+let _ = StringKey.a.intValue
+let _ = StringKey(intValue: 0)
+
+// Enums with raw type of Int conforming to CodingKey should get implicit
+// derived conformance of methods.
+enum IntKey : Int, CodingKey {
+    case a = 3, b, c = 1
+}
+
+let _ = IntKey.a.stringValue
+let _ = IntKey(stringValue: "a")
+let _ = IntKey.a.intValue
+let _ = IntKey(intValue: 3)
+
+// Enums with a different raw value conforming to CodingKey should not get
+// implicit derived conformance.
+enum Int8Key : Int8, CodingKey { // expected-error {{type 'Int8Key' does not conform to protocol 'CodingKey'}}
+    case a = -1, b = 0, c = 1
+}
+
+// Structs conforming to CodingKey should not get implicit derived conformance.
+struct StructKey : CodingKey { // expected-error {{type 'StructKey' does not conform to protocol 'CodingKey'}}
+  // expected-note@-1 {{candidate has non-matching type '()'}}
+  // expected-note@-2 {{candidate has non-matching type '()'}}
+}
+
+// Classes conforming to CodingKey should not get implict derived conformance.
+class ClassKey : CodingKey { //expected-error {{type 'ClassKey' does not conform to protocol 'CodingKey'}}
+  // expected-note@-1 {{candidate has non-matching type '()'}}
+  // expected-note@-2 {{candidate has non-matching type '()'}}
+}
+
+// Types which are valid for CodingKey derived conformance should not get that
+// derivation unless they explicitly conform to CodingKey.
+enum X          { case a }
+enum Y : String { case a } // expected-note {{did you mean the implicitly-synthesized property 'rawValue'?}}
+enum Z : Int    { case a } // expected-note {{did you mean the implicitly-synthesized property 'rawValue'?}}
+
+let _ = X.a.stringValue // expected-error {{value of type 'X' has no member 'stringValue'}}
+let _ = Y.a.stringValue // expected-error {{value of type 'Y' has no member 'stringValue'}}
+let _ = Z.a.stringValue // expected-error {{value of type 'Z' has no member 'stringValue'}}
+
+let _ = X(stringValue: "a") // expected-error {{'X' cannot be constructed because it has no accessible initializers}}
+let _ = Y(stringValue: "a") // expected-error {{incorrect argument label in call (have 'stringValue:', expected 'rawValue:')}}
+let _ = Z(stringValue: "a") // expected-error {{incorrect argument label in call (have 'stringValue:', expected 'rawValue:')}}
+
+let _ = X.a.intValue // expected-error {{value of type 'X' has no member 'intValue'}}
+let _ = Y.a.intValue // expected-error {{value of type 'Y' has no member 'intValue'}}
+let _ = Z.a.intValue // expected-error {{value of type 'Z' has no member 'intValue'}}
+
+let _ = X(intValue: 0) // expected-error {{'X' cannot be constructed because it has no accessible initializers}}
+let _ = Y(intValue: 0) // expected-error {{incorrect argument label in call (have 'intValue:', expected 'rawValue:')}}
+let _ = Z(intValue: 0) // expected-error {{incorrect argument label in call (have 'intValue:', expected 'rawValue:')}}
+
+// Types which are valid for CodingKey derived conformance should get derivation
+// through extensions.
+enum X2          { case a }
+enum Y2 : String { case a }
+enum Z2 : Int    { case a }
+extension X2 : CodingKey {}
+extension Y2 : CodingKey {}
+extension Z2 : CodingKey {}
+
+let _ = X2.a.stringValue
+let _ = Y2.a.stringValue
+let _ = Z2.a.stringValue
+
+let _ = X2(stringValue: "a")
+let _ = Y2(stringValue: "a")
+let _ = Z2(stringValue: "a")
+
+let _ = X2.a.intValue
+let _ = Y2.a.intValue
+let _ = Z2.a.intValue
+
+let _ = X2(intValue: 0)
+let _ = Y2(intValue: 0)
+let _ = Z2(intValue: 0)

test/decl/protocol/special/coding/enum_coding_key_empty.swift

@@ -0,0 +1,10 @@
+// RUN: %target-run-simple-swift
+
+// REQUIRES: executable_test
+
+// Cannot create an enum with a raw value but no cases.
+enum EmptyEnum : CodingKey {}
+
+// Cannot check accessors since there are no instances of EmptyEnum to test on.
+guard EmptyEnum(stringValue: "") == nil else { fatalError() }
+guard EmptyEnum(intValue: 0) == nil else { fatalError() }

test/decl/protocol/special/coding/enum_coding_key_extension.swift

@@ -0,0 +1,36 @@
+// RUN: %target-typecheck-verify-swift
+
+// Enums where CodingKey conformance is added in extensions should still derive
+// conformance.
+enum NoRawTypeKey {
+    case a, b, c
+}
+
+extension NoRawTypeKey : CodingKey {}
+
+let _ = NoRawTypeKey.a.stringValue
+let _ = NoRawTypeKey(stringValue: "a")
+let _ = NoRawTypeKey.a.intValue
+let _ = NoRawTypeKey(intValue: 0)
+
+enum StringKey : String {
+    case a = "A", b, c = "Foo"
+}
+
+extension StringKey : CodingKey {}
+
+let _ = StringKey.a.stringValue
+let _ = StringKey(stringValue: "A")
+let _ = StringKey.a.intValue
+let _ = StringKey(intValue: 0)
+
+enum IntKey : Int {
+    case a = 3, b, c = 1
+}
+
+extension IntKey : CodingKey {}
+
+let _ = IntKey.a.stringValue
+let _ = IntKey(stringValue: "a")
+let _ = IntKey.a.intValue
+let _ = IntKey(intValue: 3)

test/decl/protocol/special/coding/enum_coding_key_extension_multi.swift

@@ -0,0 +1,6 @@
+// RUN: %target-swift-frontend -typecheck -verify %S/Inputs/enum_coding_key_extension_multi1.swift %S/Inputs/enum_coding_key_extension_multi2.swift %S/Inputs/enum_coding_key_extension_multi3.swift
+// RUN: %target-swift-frontend -typecheck -verify %S/Inputs/enum_coding_key_extension_multi1.swift %S/Inputs/enum_coding_key_extension_multi3.swift %S/Inputs/enum_coding_key_extension_multi2.swift
+// RUN: %target-swift-frontend -typecheck -verify %S/Inputs/enum_coding_key_extension_multi2.swift %S/Inputs/enum_coding_key_extension_multi1.swift %S/Inputs/enum_coding_key_extension_multi3.swift
+// RUN: %target-swift-frontend -typecheck -verify %S/Inputs/enum_coding_key_extension_multi2.swift %S/Inputs/enum_coding_key_extension_multi3.swift %S/Inputs/enum_coding_key_extension_multi1.swift
+// RUN: %target-swift-frontend -typecheck -verify %S/Inputs/enum_coding_key_extension_multi3.swift %S/Inputs/enum_coding_key_extension_multi1.swift %S/Inputs/enum_coding_key_extension_multi2.swift
+// RUN: %target-swift-frontend -typecheck -verify %S/Inputs/enum_coding_key_extension_multi3.swift %S/Inputs/enum_coding_key_extension_multi2.swift %S/Inputs/enum_coding_key_extension_multi1.swift

test/decl/protocol/special/coding/enum_coding_key_int_raw_type.swift

@@ -0,0 +1,49 @@
+// RUN: %target-run-simple-swift
+
+// REQUIRES: executable_test
+
+enum IntKey : Int, CodingKey {
+    case a = 3
+    case b // Implicitly 4
+    case c = 1
+}
+
+for (val, str, idx) in [(IntKey.a, "a", 3), (.b, "b", 4), (.c, "c", 1)] {
+    // Keys with a raw type of Int should get a stringValue which matches the
+    // case name.
+    guard val.stringValue == str else { fatalError() }
+    guard IntKey(stringValue: str) == val else { fatalError() }
+
+    // Keys with a raw type of Int should get an intValue based on their
+    // rawValue.
+    guard val.intValue == idx else { fatalError() }
+    guard IntKey(intValue: idx) == val else { fatalError() }
+}
+
+enum PartialIntKey : Int, CodingKey {
+    case a = 3
+    case b // Implicitly 4
+    case c = 1
+
+    var intValue: Int? {
+        return self.rawValue + 1
+    }
+
+    var stringValue: String {
+        switch self {
+        case .a: return "A"
+        case .b: return "B"
+        case .c: return "C"
+        }
+    }
+}
+
+for (val, str, idx) in [(PartialIntKey.a, "a", 3), (.b, "b", 4), (.c, "c", 1)] {
+    guard val.stringValue == str.uppercased() else { fatalError() }
+    guard val.intValue == idx + 1 else { fatalError() }
+
+    // Keys which define some methods should still get derived conformance
+    // to the others.
+    guard PartialIntKey(stringValue: str) == val else { fatalError() }
+    guard PartialIntKey(intValue: idx) == val else { fatalError() }
+}

test/decl/protocol/special/coding/enum_coding_key_multi.swift

@@ -0,0 +1,2 @@
+// RUN: %target-swift-frontend -typecheck -verify %S/Inputs/enum_coding_key_multi1.swift %S/Inputs/enum_coding_key_multi2.swift
+// RUN: %target-swift-frontend -typecheck -verify %S/Inputs/enum_coding_key_multi2.swift %S/Inputs/enum_coding_key_multi1.swift

test/decl/protocol/special/coding/enum_coding_key_no_raw_type.swift

@@ -0,0 +1,48 @@
+// RUN: %target-run-simple-swift
+
+// REQUIRES: executable_test
+
+enum ImplicitKey : CodingKey {
+    case a, b, c
+}
+
+for (index, (val, str)) in [(ImplicitKey.a, "a"), (.b, "b"), (.c, "c")].enumerated() {
+    // Keys with no raw type should get a stringValue which matches the case
+    // name.
+    guard val.stringValue == str else { fatalError() }
+    guard ImplicitKey(stringValue: str) == val else { fatalError() }
+
+    // They should not have an intValue.
+    guard val.intValue == nil else { fatalError() }
+    guard ImplicitKey(intValue: index) == nil else { fatalError() }
+}
+
+enum PartialImplicitKey : CodingKey {
+    case a, b, c
+
+    var intValue: Int? {
+        switch self {
+        case .a: return 1
+        case .b: return 2
+        case .c: return 3
+        }
+    }
+
+    var stringValue: String {
+        switch self {
+        case .a: return "A"
+        case .b: return "B"
+        case .c: return "C"
+        }
+    }
+}
+
+for (val, str, idx) in [(PartialImplicitKey.a, "a", 1), (.b, "b", 2), (.c, "c", 3)] {
+    guard val.stringValue == str.uppercased() else { fatalError() }
+    guard val.intValue == idx else { fatalError() }
+
+    // Keys which define some methods should still get derived conformance
+    // to the others.
+    guard PartialImplicitKey(stringValue: str) == val else { fatalError() }
+    guard PartialImplicitKey(intValue: idx) == nil else { fatalError() }
+}

test/decl/protocol/special/coding/enum_coding_key_partial_implementation.swift

@@ -0,0 +1,147 @@
+// RUN: %target-typecheck-verify-swift
+
+// Enums which conform to CodingKey and which should derive conformance should
+// get all synthesized methods that they do not implement themselves.
+enum NoRawTypeKey1 : CodingKey {
+    case a, b, c
+}
+
+let _ = NoRawTypeKey1.a.stringValue
+let _ = NoRawTypeKey1(stringValue: "a")
+let _ = NoRawTypeKey1.a.intValue
+let _ = NoRawTypeKey1(intValue: 0)
+
+enum NoRawTypeKey2 : CodingKey {
+    case a, b, c
+    var stringValue: String { return "" }
+}
+
+let _ = NoRawTypeKey2.a.stringValue
+let _ = NoRawTypeKey2(stringValue: "a")
+let _ = NoRawTypeKey2.a.intValue
+let _ = NoRawTypeKey2(intValue: 0)
+
+enum NoRawTypeKey3 : CodingKey {
+    case a, b, c
+    var intValue: Int? { return nil }
+}
+
+let _ = NoRawTypeKey3.a.stringValue
+let _ = NoRawTypeKey3(stringValue: "a")
+let _ = NoRawTypeKey3.a.intValue
+let _ = NoRawTypeKey3(intValue: 0)
+
+enum NoRawTypeKey4 : CodingKey {
+    case a, b, c
+    init?(stringValue: String) { return nil }
+}
+
+let _ = NoRawTypeKey4.a.stringValue
+let _ = NoRawTypeKey4(stringValue: "a")
+let _ = NoRawTypeKey4.a.intValue
+let _ = NoRawTypeKey4(intValue: 0)
+
+enum NoRawTypeKey5 : CodingKey {
+    case a, b, c
+    init?(intValue: Int) { return nil }
+}
+
+let _ = NoRawTypeKey5.a.stringValue
+let _ = NoRawTypeKey5(stringValue: "a")
+let _ = NoRawTypeKey5.a.intValue
+let _ = NoRawTypeKey5(intValue: 0)
+
+enum NoRawTypeKey6 : CodingKey {
+    case a, b, c
+    var stringValue: String { return "" }
+    var intValue: Int? { return nil }
+}
+
+let _ = NoRawTypeKey6.a.stringValue
+let _ = NoRawTypeKey6(stringValue: "a")
+let _ = NoRawTypeKey6.a.intValue
+let _ = NoRawTypeKey6(intValue: 0)
+
+enum NoRawTypeKey7 : CodingKey {
+    case a, b, c
+    var stringValue: String { return "" }
+    init?(stringValue: String) { return nil }
+}
+
+let _ = NoRawTypeKey7.a.stringValue
+let _ = NoRawTypeKey7(stringValue: "a")
+let _ = NoRawTypeKey7.a.intValue
+let _ = NoRawTypeKey7(intValue: 0)
+
+enum NoRawTypeKey8 : CodingKey {
+    case a, b, c
+    var stringValue: String { return "" }
+    init?(intValue: Int) { return nil }
+}
+
+let _ = NoRawTypeKey8.a.stringValue
+let _ = NoRawTypeKey8(stringValue: "a")
+let _ = NoRawTypeKey8.a.intValue
+let _ = NoRawTypeKey8(intValue: 0)
+
+enum NoRawTypeKey9 : CodingKey {
+    case a, b, c
+    var intValue: Int? { return nil }
+    init?(stringValue: String) { return nil }
+}
+
+let _ = NoRawTypeKey9.a.stringValue
+let _ = NoRawTypeKey9(stringValue: "a")
+let _ = NoRawTypeKey9.a.intValue
+let _ = NoRawTypeKey9(intValue: 0)
+
+enum NoRawTypeKey10 : CodingKey {
+    case a, b, c
+    var intValue: Int? { return nil }
+    init?(intValue: Int) { return nil }
+}
+
+let _ = NoRawTypeKey10.a.stringValue
+let _ = NoRawTypeKey10(stringValue: "a")
+let _ = NoRawTypeKey10.a.intValue
+let _ = NoRawTypeKey10(intValue: 0)
+
+enum NoRawTypeKey11 : CodingKey {
+    case a, b, c
+    var stringValue: String { return "" }
+    var intValue: Int? { return nil }
+    init?(stringValue: String) { return nil }
+}
+
+let _ = NoRawTypeKey11.a.stringValue
+let _ = NoRawTypeKey11(stringValue: "a")
+let _ = NoRawTypeKey11.a.intValue
+let _ = NoRawTypeKey11(intValue: 0)
+
+enum NoRawTypeKey12 : CodingKey {
+    case a, b, c
+    var stringValue: String { return "" }
+    var intValue: Int? { return nil }
+    init?(intValue: Int) { return nil }
+}
+
+let _ = NoRawTypeKey12.a.stringValue
+let _ = NoRawTypeKey12(stringValue: "a")
+let _ = NoRawTypeKey12.a.intValue
+let _ = NoRawTypeKey12(intValue: 0)
+
+// Enums which provide implementations for all CodingKey methods should not
+// derive conformance (but derived conformance should not interfere with the
+// existing methods).
+enum NoRawTypeKey13 : CodingKey {
+    case a, b, c
+    var stringValue: String { return "" }
+    var intValue: Int? { return nil }
+    init?(stringValue: String) { return nil }
+    init?(intValue: Int) { return nil }
+}
+
+let _ = NoRawTypeKey13.a.stringValue
+let _ = NoRawTypeKey13(stringValue: "a")
+let _ = NoRawTypeKey13.a.intValue
+let _ = NoRawTypeKey13(intValue: 0)

test/decl/protocol/special/coding/enum_coding_key_string_raw_type.swift

@@ -0,0 +1,52 @@
+// RUN: %target-run-simple-swift
+
+// REQUIRES: executable_test
+
+enum StringKey : String, CodingKey {
+    case a = "A"
+    case b // Implicitly "b"
+    case c = "Foo"
+}
+
+for (index, (val, str)) in [(StringKey.a, "A"), (.b, "b"), (.c, "Foo")].enumerated() {
+    // Keys with a raw type of String should get a stringValue based on their
+    // rawValue.
+    guard val.stringValue == str else { fatalError() }
+    guard StringKey(stringValue: str) == val else { fatalError() }
+
+    // They should not have an intValue.
+    guard val.intValue == nil else { fatalError() }
+    guard StringKey(intValue: index) == nil else { fatalError() }
+}
+
+enum PartialStringKey : String, CodingKey {
+    case a = "A"
+    case b // Implicitly "b"
+    case c = "Foo"
+
+    var intValue: Int? {
+        switch self {
+        case .a: return 1
+        case .b: return 2
+        case .c: return 3
+        }
+    }
+
+    var stringValue: String {
+        switch self {
+        case .a: return "x"
+        case .b: return "y"
+        case .c: return "z"
+        }
+    }
+}
+
+for (val, realStr, str, idx) in [(PartialStringKey.a, "A", "x", 1), (.b, "b", "y", 2), (.c, "Foo", "z", 3)] {
+    guard val.stringValue == str else { fatalError() }
+    guard val.intValue == idx else { fatalError() }
+
+    // Keys which define some methods should still get derived conformance
+    // to the others.
+    guard PartialStringKey(stringValue: realStr) == val else { fatalError() }
+    guard PartialStringKey(intValue: idx) == nil else { fatalError() }
+}

test/decl/protocol/special/coding/struct_codable_computed_vars.swift

@@ -0,0 +1,36 @@
+// RUN: %target-typecheck-verify-swift -verify-ignore-unknown
+
+// Structs with computed members should get synthesized conformance to Codable,
+// but their lazy and computed members should be skipped as part of the
+// synthesis.
+struct StructWithComputedMembers : Codable {
+    var x: Int
+    lazy var y: Double = Double.pi
+    var z: String {
+        return "foo"
+    }
+
+    // These lines have to be within the StructWithComputedMembers type because
+    // CodingKeys should be private.
+    func foo() {
+        // They should receive a synthesized CodingKeys enum.
+        let _ = StructWithComputedMembers.CodingKeys.self
+
+        // The enum should have a case for each of the vars.
+        let _ = StructWithComputedMembers.CodingKeys.x
+
+        // Lazy vars should not be part of the CodingKeys enum.
+        let _ = StructWithComputedMembers.CodingKeys.y // expected-error {{type 'StructWithComputedMembers.CodingKeys' has no member 'y'}}
+
+        // Computed vars should not be part of the CodingKeys enum.
+        let _ = StructWithComputedMembers.CodingKeys.z // expected-error {{type 'StructWithComputedMembers.CodingKeys' has no member 'z'}}
+    }
+}
+
+// They should receive synthesized init(from:) and an encode(to:).
+let _ = StructWithComputedMembers.init(from:)
+let _ = StructWithComputedMembers.encode(to:)
+
+// The synthesized CodingKeys type should not be accessible from outside the
+// struct.
+let _ = StructWithComputedMembers.CodingKeys.self // expected-error {{'CodingKeys' is inaccessible due to 'private' protection level}}

test/decl/protocol/special/coding/struct_codable_simple.swift

@@ -0,0 +1,31 @@
+// RUN: %target-typecheck-verify-swift -verify-ignore-unknown
+
+// Simple structs with all Codable properties should get derived conformance to
+// Codable.
+struct SimpleStruct : Codable {
+    var x: Int
+    var y: Double
+    static var z: String = "foo"
+
+    // These lines have to be within the SimpleStruct type because CodingKeys
+    // should be private.
+    func foo() {
+        // They should receive a synthesized CodingKeys enum.
+        let _ = SimpleStruct.CodingKeys.self
+
+        // The enum should have a case for each of the vars.
+        let _ = SimpleStruct.CodingKeys.x
+        let _ = SimpleStruct.CodingKeys.y
+
+        // Static vars should not be part of the CodingKeys enum.
+        let _ = SimpleStruct.CodingKeys.z // expected-error {{type 'SimpleStruct.CodingKeys' has no member 'z'}}
+    }
+}
+
+// They should receive synthesized init(from:) and an encode(to:).
+let _ = SimpleStruct.init(from:)
+let _ = SimpleStruct.encode(to:)
+
+// The synthesized CodingKeys type should not be accessible from outside the
+// struct.
+let _ = SimpleStruct.CodingKeys.self // expected-error {{'CodingKeys' is inaccessible due to 'private' protection level}}

test/decl/protocol/special/coding/struct_codable_simple_extension.swift

@@ -0,0 +1,36 @@
+// RUN: %target-typecheck-verify-swift -verify-ignore-unknown
+
+// Simple structs where Codable conformance is added in extensions should still
+// derive conformance.
+struct SimpleStruct {
+  var x: Int
+  var y: Double
+  static var z: String = "foo"
+
+  // These lines have to be within the SimpleStruct type because CodingKeys
+  // should be private.
+  func foo() {
+    // They should receive synthesized init(from:) and an encode(to:).
+    let _ = SimpleStruct.init(from:)
+    let _ = SimpleStruct.encode(to:)
+
+    // They should receive a synthesized CodingKeys enum.
+    let _ = SimpleStruct.CodingKeys.self
+
+    // The enum should have a case for each of the vars.
+    let _ = SimpleStruct.CodingKeys.x
+    let _ = SimpleStruct.CodingKeys.y
+
+    // Static vars should not be part of the CodingKeys enum.
+    let _ = SimpleStruct.CodingKeys.z // expected-error {{type 'SimpleStruct.CodingKeys' has no member 'z'}}
+  }
+}
+
+extension SimpleStruct : Codable {}
+
+// These are wrapped in a dummy function to avoid binding a global variable.
+func foo() {
+  // The synthesized CodingKeys type should not be accessible from outside the
+  // struct.
+  let _ = SimpleStruct.CodingKeys.self // expected-error {{'CodingKeys' is inaccessible due to 'private' protection level}}
+}

test/decl/protocol/special/coding/struct_codable_simple_multi.swift

@@ -0,0 +1,2 @@
+// RUN: %target-typecheck-verify-swift -verify-ignore-unknown %S/Inputs/struct_codable_simple_multi1.swift %S/Inputs/struct_codable_simple_multi2.swift
+// RUN: %target-typecheck-verify-swift -verify-ignore-unknown %S/Inputs/struct_codable_simple_multi2.swift %S/Inputs/struct_codable_simple_multi1.swift