Merge pull request #27857 from slavapestov/tiny-circularity-fixes

A couple of small circularity fixes

Author: slavapestov

lib/AST/Type.cpp

@@ -3572,8 +3572,6 @@ TypeBase::getContextSubstitutions(const DeclContext *dc,
   if (auto *ownerClass = dyn_cast<ClassDecl>(ownerNominal))
     baseTy = baseTy->getSuperclassForDecl(ownerClass);
 
-  assert(ownerNominal == baseTy->getAnyNominal());
-
   // Gather all of the substitutions for all levels of generic arguments.
   auto genericSig = dc->getGenericSignatureOfContext();
   if (!genericSig)
@@ -3583,6 +3581,9 @@ TypeBase::getContextSubstitutions(const DeclContext *dc,
   unsigned n = params.size();
 
   while (baseTy && n > 0) {
+    if (baseTy->is<ErrorType>())
+      break;
+
     // For a bound generic type, gather the generic parameter -> generic
     // argument substitutions.
     if (auto boundGeneric = baseTy->getAs<BoundGenericType>()) {

lib/Sema/TypeCheckDeclOverride.cpp

@@ -77,15 +77,16 @@ Type swift::getMemberTypeForComparison(ASTContext &ctx, ValueDecl *member,
   SubscriptDecl *subscript = dyn_cast_or_null<SubscriptDecl>(abstractStorage);
 
   auto memberType = member->getInterfaceType();
+  if (memberType->is<ErrorType>())
+    return memberType;
+
   if (derivedDecl) {
     auto *dc = derivedDecl->getDeclContext();
     auto owningType = dc->getDeclaredInterfaceType();
     assert(owningType);
 
     memberType = owningType->adjustSuperclassMemberDeclType(member, derivedDecl,
                                                             memberType);
-    if (memberType->hasError())
-      return memberType;
   }
 
   if (method) {

test/SILGen/default_arguments.swift

@@ -383,3 +383,9 @@ func stupidGames(x: Int = 3) -> Int {
   return x
 }
 stupidGames(x:)()
+
+func genericMagic<T : ExpressibleByStringLiteral>(x: T = #file) -> T {
+  return x
+}
+
+let _: String = genericMagic()

test/decl/circularity.swift

@@ -55,3 +55,32 @@ extension SIMD3 {
 extension SIMD3 where SIMD3.Scalar == Float {
     static let pickMe = SIMD3(.pickMe)
 }
+
+// Test case with circular overrides
+protocol P {
+    associatedtype A
+    // expected-note@-1 {{protocol requires nested type 'A'; do you want to add it?}}
+    func run(a: A)
+}
+
+class C1 {
+    func run(a: Int) {}
+}
+
+class C2: C1, P {
+    override func run(a: A) {}
+    // expected-error@-1 {{circular reference}}
+    // expected-note@-2 2{{through reference here}}
+}
+
+// Another crash to the above
+open class G1<A> {
+    open func run(a: A) {}
+}
+
+class C3: G1<A>, P {
+    // expected-error@-1 {{type 'C3' does not conform to protocol 'P'}}
+    // expected-error@-2 {{use of undeclared type 'A'}}
+    override func run(a: A) {}
+    // expected-error@-1 {{method does not override any method from its superclass}}
+}