Sema: synthesizeMemberForLookup() doesn't have to handle Codable requirements

Since init(from:) and encode(to:) are protocol requirements, any
name lookup of them will find the protocol requirement, and if
the witness is not present we will synthesize it on the spot.

Only CodingKeys requires special handling here, since it is not
a protocol requirement, but has to get synthesized anyway.

Author: slavapestov

lib/Sema/TypeCheckDecl.cpp

@@ -8987,6 +8987,8 @@ void TypeChecker::addImplicitConstructors(NominalTypeDecl *decl) {
 void TypeChecker::synthesizeMemberForLookup(NominalTypeDecl *target,
                                             DeclName member) {
   auto baseName = member.getBaseName();
+  if (baseName != Context.Id_CodingKeys)
+    return;
 
   // Checks whether the target conforms to the given protocol. If the
   // conformance is incomplete, force the conformance.
@@ -9011,48 +9013,20 @@ void TypeChecker::synthesizeMemberForLookup(NominalTypeDecl *target,
     return false;
   };
 
-  if (member.isSimpleName() && !baseName.isSpecial()) {
-    if (baseName.getIdentifier() == Context.Id_CodingKeys) {
-      // CodingKeys is a special type which may be synthesized as part of
-      // Encodable/Decodable conformance. If the target conforms to either
-      // protocol and would derive conformance to either, the type may be
-      // synthesized.
-      // If the target conforms to either and the conformance has not yet been
-      // evaluated, then we should do that here.
-      //
-      // Try to synthesize Decodable first. If that fails, try to synthesize
-      // Encodable. If either succeeds and CodingKeys should have been
-      // synthesized, it will be synthesized.
-      auto *decodableProto = Context.getProtocol(KnownProtocolKind::Decodable);
-      auto *encodableProto = Context.getProtocol(KnownProtocolKind::Encodable);
-      if (!evaluateTargetConformanceTo(decodableProto))
-        (void)evaluateTargetConformanceTo(encodableProto);
-    }
-  } else {
-    auto argumentNames = member.getArgumentNames();
-    if (argumentNames.size() != 1)
-      return;
-
-    auto argumentName = argumentNames.front();
-    if (baseName == DeclBaseName::createConstructor() &&
-        argumentName == Context.Id_from) {
-      // init(from:) may be synthesized as part of derived conformance to the
-      // Decodable protocol.
-      // If the target should conform to the Decodable protocol, check the
-      // conformance here to attempt synthesis.
-      auto *decodableProto = Context.getProtocol(KnownProtocolKind::Decodable);
-      (void)evaluateTargetConformanceTo(decodableProto);
-    } else if (!baseName.isSpecial() &&
-               baseName.getIdentifier() == Context.Id_encode &&
-               argumentName == Context.Id_to) {
-      // encode(to:) may be synthesized as part of derived conformance to the
-      // Encodable protocol.
-      // If the target should conform to the Encodable protocol, check the
-      // conformance here to attempt synthesis.
-      auto *encodableProto = Context.getProtocol(KnownProtocolKind::Encodable);
-      (void)evaluateTargetConformanceTo(encodableProto);
-    }
-  }
+  // CodingKeys is a special type which may be synthesized as part of
+  // Encodable/Decodable conformance. If the target conforms to either
+  // protocol and would derive conformance to either, the type may be
+  // synthesized.
+  // If the target conforms to either and the conformance has not yet been
+  // evaluated, then we should do that here.
+  //
+  // Try to synthesize Decodable first. If that fails, try to synthesize
+  // Encodable. If either succeeds and CodingKeys should have been
+  // synthesized, it will be synthesized.
+  auto *decodableProto = Context.getProtocol(KnownProtocolKind::Decodable);
+  auto *encodableProto = Context.getProtocol(KnownProtocolKind::Encodable);
+  if (!evaluateTargetConformanceTo(decodableProto))
+    (void)evaluateTargetConformanceTo(encodableProto);
 }
 
 void TypeChecker::defineDefaultConstructor(NominalTypeDecl *decl) {