Sema: Gut synthesizeMemberForLookup()

lib/Sema/TypeCheckDecl.cpp

@@ -5185,25 +5185,25 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     if (decl->isInvalid() || decl->getOverriddenDecl())
       return false;
 
+    // Ignore accessor methods (e.g. getters and setters), they will be handled
+    // when their storage decl is processed.
+    if (isa<AccessorDecl>(decl))
+      return false;
+
     auto *dc = decl->getDeclContext();
 
     auto owningTy = dc->getDeclaredInterfaceType();
     if (!owningTy)
       return false;
 
-    auto classDecl = owningTy->getClassOrBoundGenericClass();
+    auto classDecl = dc->getAsClassOrClassExtensionContext();
     if (!classDecl)
       return false;
 
     Type superclass = classDecl->getSuperclass();
     if (!superclass)
       return false;
 
-    // Ignore accessor methods (e.g. getters and setters), they will be handled
-    // when their storage decl is processed.
-    if (isa<AccessorDecl>(decl))
-      return false;
-
     auto method = dyn_cast<AbstractFunctionDecl>(decl);
     ConstructorDecl *ctor = nullptr;
     if (method)
@@ -5279,12 +5279,6 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
         // visible via dynamic dispatch.
         lookupOptions -= NameLookupFlags::DynamicLookup;
 
-        // Class methods cannot override declarations only
-        // visible as protocol requirements or protocol
-        // extension members.
-        lookupOptions -= NameLookupFlags::ProtocolMembers;
-        lookupOptions -= NameLookupFlags::PerformConformanceCheck;
-
         members = TC.lookupMember(dc, superclass,
                                   name, lookupOptions);
       }
@@ -5298,7 +5292,10 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
         if (member->getKind() != decl->getKind())
           continue;
 
-        if (!dc->getAsClassOrClassExtensionContext())
+        // Class methods cannot override declarations only
+        // visible as protocol requirements or protocol
+        // extension members.
+        if (!member->getDeclContext()->getAsClassOrClassExtensionContext())
           continue;
 
         auto parentDecl = cast<ValueDecl>(member);
@@ -8990,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.
@@ -9014,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) {

test/decl/class/override.swift

@@ -350,3 +350,15 @@ class DerivedWithFilePrivateSetter: BaseWithFilePrivateSetter {
         set { }
     }
 }
+
+protocol HasExtension {}
+
+extension HasExtension {
+  func extensionMethod() {}
+}
+
+class BaseExtended : HasExtension {}
+
+class DerivedExtended : BaseExtended {
+  func extensionMethod() {}
+}