Add a way to just synthesize CodingKeys

Author: CodaFi

include/swift/AST/Decl.h

@@ -467,11 +467,15 @@ class alignas(1 << DeclAlignInBits) Decl {
     IsDebuggerAlias : 1
   );
 
-  SWIFT_INLINE_BITFIELD(NominalTypeDecl, GenericTypeDecl, 1+1+1,
+  SWIFT_INLINE_BITFIELD(NominalTypeDecl, GenericTypeDecl, 1+1+1+1,
     /// Whether we have already added implicitly-defined initializers
     /// to this declaration.
     AddedImplicitInitializers : 1,
 
+    /// Whether we have already added the phantom CodingKeys
+    /// nested requirement to this declaration.
+    AddedPhantomCodingKeys : 1,
+
     /// Whether there is are lazily-loaded conformances for this nominal type.
     HasLazyConformances : 1,
 
@@ -3323,6 +3327,7 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
     IterableDeclContext(IterableDeclContextKind::NominalTypeDecl)
   {
     Bits.NominalTypeDecl.AddedImplicitInitializers = false;
+    Bits.NominalTypeDecl.AddedPhantomCodingKeys = false;
     ExtensionGeneration = 0;
     Bits.NominalTypeDecl.HasLazyConformances = false;
     Bits.NominalTypeDecl.IsComputingSemanticMembers = false;
@@ -3363,6 +3368,18 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
     Bits.NominalTypeDecl.AddedImplicitInitializers = true;
   }
 
+  /// Determine whether we have already attempted to add the
+  /// phantom CodingKeys type to this declaration.
+  bool addedPhantomCodingKeys() const {
+    return Bits.NominalTypeDecl.AddedPhantomCodingKeys;
+  }
+
+  /// Note that we have attempted to add the phantom CodingKeys type
+  /// to this declaration.
+  void setAddedPhantomCodingKeys() {
+    Bits.NominalTypeDecl.AddedPhantomCodingKeys = true;
+  }
+
   /// getDeclaredType - Retrieve the type declared by this entity, without
   /// any generic parameters bound if this is a generic type.
   Type getDeclaredType() const;

lib/Sema/DerivedConformanceCodable.cpp

@@ -1139,3 +1139,21 @@ ValueDecl *DerivedConformance::deriveDecodable(ValueDecl *requirement) {
 
   return nullptr;
 }
+
+TypeDecl *DerivedConformance::derivePhantomCodingKeysRequirement() {
+  // We can only synthesize CodingKeys for structs and classes.
+  if (!isa<StructDecl>(Nominal) && !isa<ClassDecl>(Nominal))
+    return nullptr;
+
+  // Pull out a user-defined CodingKeys declaration.
+  auto result = Nominal->lookupDirect(DeclName(Context.Id_CodingKeys));
+  TypeDecl *keysDecl = nullptr;
+  if (!result.empty()) {
+    return dyn_cast<TypeDecl>(result.front());
+  } else {
+    // That failed, try to synthesize one.
+    keysDecl = synthesizeCodingKeysEnum(*this);
+  }
+
+  return keysDecl;
+}

lib/Sema/DerivedConformances.h

@@ -189,6 +189,9 @@ class DerivedConformance {
   /// \returns the derived member, which will also be added to the type.
   ValueDecl *deriveDecodable(ValueDecl *requirement);
 
+  /// Derive the CodingKeys requirement for a value type.
+  TypeDecl *derivePhantomCodingKeysRequirement();
+
   /// Declare a read-only property.
   std::pair<VarDecl *, PatternBindingDecl *>
   declareDerivedProperty(Identifier name, Type propertyInterfaceType,

lib/Sema/TypeCheckProtocol.cpp

@@ -3391,6 +3391,14 @@ ResolveWitnessResult ConformanceChecker::resolveWitnessViaDerivation(
     return ResolveWitnessResult::Missing;
   }
 
+  // If the protocol has a phantom nested type requirement, resolve it now.
+  auto &attrs = Proto->getAttrs();
+  if (auto *IARA =
+          attrs.getAttribute<ImplicitlySynthesizesNestedRequirementAttr>()) {
+    (void)TypeChecker::derivePhantomWitness(DC, derivingTypeDecl,
+                                            Proto, IARA->Value);
+  }
+
   // Attempt to derive the witness.
   auto derived =
       TypeChecker::deriveProtocolRequirement(DC, derivingTypeDecl, requirement);
@@ -5403,6 +5411,34 @@ Type TypeChecker::deriveTypeWitness(DeclContext *DC,
   }
 }
 
+
+TypeDecl *TypeChecker::derivePhantomWitness(DeclContext *DC,
+                                            NominalTypeDecl *nominal,
+                                            ProtocolDecl *proto,
+                                            const StringRef Name) {
+  assert(proto->getASTContext().Id_CodingKeys.is(Name) &&
+         "CodingKeys is the only supported phantom requirement");
+
+  if (nominal->addedPhantomCodingKeys())
+    return nullptr;
+  nominal->setAddedPhantomCodingKeys();
+
+  auto knownKind = proto->getKnownProtocolKind();
+  if (!knownKind)
+    return nullptr;
+
+  auto Decl = DC->getInnermostDeclarationDeclContext();
+
+  DerivedConformance derived(nominal->getASTContext(), Decl, nominal, proto);
+  switch (*knownKind) {
+  case KnownProtocolKind::Decodable:
+  case KnownProtocolKind::Encodable:
+    return derived.derivePhantomCodingKeysRequirement();
+  default:
+    return nullptr;
+  }
+}
+
 namespace {
   class DefaultWitnessChecker : public WitnessChecker {
 

lib/Sema/TypeChecker.h

@@ -1214,6 +1214,17 @@ class TypeChecker final {
   static Type deriveTypeWitness(DeclContext *DC, NominalTypeDecl *nominal,
                                 AssociatedTypeDecl *assocType);
 
+  /// Derive an implicit type witness for a given "phantom" nested type
+  /// requirement that is known to the compiler but unstated as a
+  /// formal type requirement.
+  ///
+  /// This exists to support Codable and only Codable. Do not expand its
+  /// usage outside of that domain.
+  static TypeDecl *derivePhantomWitness(DeclContext *DC,
+                                        NominalTypeDecl *nominal,
+                                        ProtocolDecl *proto,
+                                        const StringRef Name);
+
   /// \name Name lookup
   ///
   /// Routines that perform name lookup.

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

@@ -162,7 +162,6 @@ struct NonConformingStruct : Codable { // expected-error {{type 'NonConformingSt
   // These lines have to be within the NonConformingStruct type because
   // CodingKeys should be private.
   func foo() {
-    // They should not get a CodingKeys type.
     let _ = NonConformingStruct.CodingKeys.self
     let _ = NonConformingStruct.CodingKeys.x
     let _ = NonConformingStruct.CodingKeys.y