Sema: Diagnose invalid overrides involving contextual where clauses

Author: AnthonyLatsis

lib/AST/ASTContext.cpp

@@ -4470,19 +4470,22 @@ ASTContext::getOverrideGenericSignature(const ValueDecl *base,
   assert(isa<AbstractFunctionDecl>(base) || isa<SubscriptDecl>(base));
   assert(isa<AbstractFunctionDecl>(derived) || isa<SubscriptDecl>(derived));
 
-  auto baseClass = base->getDeclContext()->getSelfClassDecl();
-  auto derivedClass = derived->getDeclContext()->getSelfClassDecl();
+  const auto baseClass = base->getDeclContext()->getSelfClassDecl();
+  const auto derivedClass = derived->getDeclContext()->getSelfClassDecl();
 
   assert(baseClass != nullptr);
   assert(derivedClass != nullptr);
 
-  auto baseGenericSig = base->getAsGenericContext()->getGenericSignature();
-  auto derivedGenericSig = derived->getAsGenericContext()->getGenericSignature();
+  const auto baseGenericSig =
+      base->getAsGenericContext()->getGenericSignature();
+  const auto derivedGenericSig =
+      derived->getAsGenericContext()->getGenericSignature();
 
   if (base == derived)
     return derivedGenericSig;
 
-  if (derivedClass->getSuperclass().isNull())
+  const auto derivedSuperclass = derivedClass->getSuperclass();
+  if (derivedSuperclass.isNull())
     return nullptr;
 
   if (derivedGenericSig.isNull())
@@ -4491,12 +4494,6 @@ ASTContext::getOverrideGenericSignature(const ValueDecl *base,
   if (baseGenericSig.isNull())
     return derivedGenericSig;
 
-  auto baseClassSig = baseClass->getGenericSignature();
-  auto subMap = derivedClass->getSuperclass()->getContextSubstitutionMap(
-      derivedClass->getModuleContext(), baseClass);
-
-  unsigned derivedDepth = 0;
-
   auto key = OverrideSignatureKey(baseGenericSig,
                                   derivedGenericSig,
                                   derivedClass);
@@ -4506,22 +4503,25 @@ ASTContext::getOverrideGenericSignature(const ValueDecl *base,
     return getImpl().overrideSigCache.lookup(key);
   }
 
-  if (auto derivedSig = derivedClass->getGenericSignature())
-    derivedDepth = derivedSig->getGenericParams().back()->getDepth() + 1;
+  const auto derivedClassSig = derivedClass->getGenericSignature();
+
+  unsigned derivedDepth = 0;
+  unsigned baseDepth = 0;
+  if (derivedClassSig)
+    derivedDepth = derivedClassSig->getGenericParams().back()->getDepth() + 1;
+  if (const auto baseClassSig = baseClass->getGenericSignature())
+    baseDepth = baseClassSig->getGenericParams().back()->getDepth() + 1;
 
   SmallVector<GenericTypeParamType *, 2> addedGenericParams;
-  if (auto *gpList = derived->getAsGenericContext()->getGenericParams()) {
+  if (const auto *gpList = derived->getAsGenericContext()->getGenericParams()) {
     for (auto gp : *gpList) {
       addedGenericParams.push_back(
           gp->getDeclaredInterfaceType()->castTo<GenericTypeParamType>());
     }
   }
 
-  unsigned baseDepth = 0;
-
-  if (baseClassSig) {
-    baseDepth = baseClassSig->getGenericParams().back()->getDepth() + 1;
-  }
+  const auto subMap = derivedSuperclass->getContextSubstitutionMap(
+      derivedClass->getModuleContext(), baseClass);
 
   auto substFn = [&](SubstitutableType *type) -> Type {
     auto *gp = cast<GenericTypeParamType>(type);
@@ -4553,7 +4553,7 @@ ASTContext::getOverrideGenericSignature(const ValueDecl *base,
   auto genericSig = evaluateOrDefault(
       evaluator,
       AbstractGenericSignatureRequest{
-        derivedClass->getGenericSignature().getPointer(),
+        derivedClassSig.getPointer(),
         std::move(addedGenericParams),
         std::move(addedRequirements)},
       GenericSignature());

test/attr/attr_override.swift

@@ -579,6 +579,60 @@ class SR_4206_DerivedGeneric_6<T>: SR_4206_BaseConcrete_6 {
   override func foo<T: SR_4206_Protocol_1>(arg: T) {} // expected-error {{overridden method 'foo' has generic signature <T, T where T : SR_4206_Protocol_1> which is incompatible with base method's generic signature <T where T : SR_4206_Protocol_2>; expected generic signature to be <T, T where T : SR_4206_Protocol_2>}}
 }
 
+// Where clauses on contextually generic declarations
+
+class SR_4206_Base_7<T> {
+  func foo1() where T: SR_4206_Protocol_1 {} // expected-note {{overridden declaration is here}}
+  func foo2() where T: SR_4206_Protocol_1 {}
+}
+
+class SR_4206_Derived_7<T>: SR_4206_Base_7<T> {
+  override func foo1() where T: SR_4206_Protocol_2 {} // expected-error {{overridden method 'foo1' has generic signature <T where T : SR_4206_Protocol_2> which is incompatible with base method's generic signature <T where T : SR_4206_Protocol_1>; expected generic signature to be <T where τ_0_0 : SR_4206_Protocol_1>}}
+
+  override func foo2() {} // OK
+}
+
+// Subclass with new constraint on inherited generic param
+
+class SR_4206_Base_8<T> {
+  func foo() where T: SR_4206_Protocol_1 {}
+}
+class SR_4206_Derived_8<T: SR_4206_Protocol_2, U>: SR_4206_Base_8<T> {
+  override func foo() where T: SR_4206_Protocol_1 {} // OK
+}
+
+// Same-type to conformance visibility reabstraction
+
+class SR_4206_Base_9<T> {
+  func foo() where T == Int {}
+}
+class SR_4206_Derived_9<T>: SR_4206_Base_9<T> {
+  override func foo() where T: FixedWidthInteger {} // OK
+}
+
+// Override with constraint on a non-inherited generic param
+
+class SR_4206_Base_10<T> {
+  func foo() where T: SR_4206_Protocol_1 {} // expected-note {{overridden declaration is here}}
+}
+class SR_4206_Derived_10<T, U>: SR_4206_Base_10<T> {
+  override func foo() where U: SR_4206_Protocol_1 {} // expected-error {{overridden method 'foo' has generic signature <T, U where U : SR_4206_Protocol_1> which is incompatible with base method's generic signature <T where T : SR_4206_Protocol_1>; expected generic signature to be <T, U where τ_0_0 : SR_4206_Protocol_1>}}
+}
+
+// Override with return type specialization
+
+class SR_4206_Base_11<T> {
+  // The fact that the return type matches the substitution
+  // for T must hold across overrides.
+  func foo() -> T where T: FixedWidthInteger { fatalError() } // expected-note {{potential overridden instance method 'foo()' here}}
+}
+class SR_4206_Derived_11: SR_4206_Base_11<Int> {
+  override func foo() -> Int { return .zero } // OK
+}
+class SR_4206_Derived2_11: SR_4206_Base_11<Bool> {
+  override func foo() -> Int { return .zero } // expected-error {{method does not override any method from its superclass}}
+}
+
 // Misc //
 
 protocol SR_4206_Key {}