Merge pull request #17816 from slavapestov/protocol-superclass-part-3

Protocols with superclass constraints - part 3

Author: slavapestov

lib/AST/NameLookup.cpp

@@ -1711,12 +1711,24 @@ bool DeclContext::lookupQualified(Type type,
   SmallVector<NominalTypeDecl *, 4> stack;
   llvm::SmallPtrSet<NominalTypeDecl *, 4> visited;
 
+  // Note that we don't have to visit the superclass of a protocol.
+  // If we started with an archetype or existential, we'll visit the
+  // superclass because we will have added it to the stack upfront.
+  //
+  // If we started with a concrete class conforming to a protocol
+  // with a superclass, we will visit the superclass from the
+  // concrete type.
+  bool checkProtocolSuperclass = false;
+
   // Handle nominal types.
   bool wantProtocolMembers = (options & NL_ProtocolMembers);
   bool wantLookupInAllClasses = false;
   if (auto nominal = type->getAnyNominal()) {
     visited.insert(nominal);
     stack.push_back(nominal);
+
+    if (isa<ProtocolDecl>(nominal))
+      checkProtocolSuperclass = true;
   }
   // Handle archetypes
   else if (auto archetypeTy = type->getAs<ArchetypeType>()) {
@@ -1746,9 +1758,9 @@ bool DeclContext::lookupQualified(Type type,
     }
 
     if (auto superclass = layout.explicitSuperclass) {
-      auto *nominalDecl = superclass->getClassOrBoundGenericClass();
-      if (visited.insert(nominalDecl).second)
-        stack.push_back(nominalDecl);
+      auto *superclassDecl = superclass->getClassOrBoundGenericClass();
+      if (visited.insert(superclassDecl).second)
+        stack.push_back(superclassDecl);
     }
   } else {
     llvm_unreachable("Bad type for qualified lookup");
@@ -1844,18 +1856,21 @@ bool DeclContext::lookupQualified(Type type,
       }
     }
 
-    if (auto protocolDecl = dyn_cast<ProtocolDecl>(current)) {
-      if (auto superclassDecl = protocolDecl->getSuperclassDecl())
-        if (visited.insert(superclassDecl).second)
-          stack.push_back(superclassDecl);
-    }
-
     // If we're not looking at a protocol and we're not supposed to
     // visit the protocols that this type conforms to, skip the next
     // step.
     if (!wantProtocolMembers && !currentIsProtocol)
       continue;
 
+    if (checkProtocolSuperclass) {
+      if (auto *protoDecl = dyn_cast<ProtocolDecl>(current)) {
+        if (auto superclassDecl = protoDecl->getSuperclassDecl()) {
+          visited.insert(superclassDecl);
+          stack.push_back(superclassDecl);
+        }
+      }
+    }
+
     SmallVector<ProtocolDecl *, 4> protocols;
     for (auto proto : current->getAllProtocols()) {
       if (visited.insert(proto).second) {

lib/AST/Type.cpp

@@ -300,7 +300,15 @@ Type ExistentialLayout::getSuperclass() const {
     return explicitSuperclass;
 
   for (auto proto : getProtocols()) {
-    if (auto superclass = proto->getSuperclass())
+    // If we have a generic signature, check there, because it
+    // will pick up superclass constraints from protocols that we
+    // refine as well.
+    auto *protoDecl = proto->getDecl();
+    if (auto genericSig = protoDecl->getGenericSignature()) {
+      if (auto superclass = genericSig->getSuperclassBound(
+            protoDecl->getSelfInterfaceType()))
+        return superclass;
+    } else if (auto superclass = protoDecl->getSuperclass())
       return superclass;
   }
 
@@ -1465,11 +1473,8 @@ Type TypeBase::getSuperclass() {
     if (auto dynamicSelfTy = getAs<DynamicSelfType>())
       return dynamicSelfTy->getSelfType();
 
-    if (auto protocolTy = getAs<ProtocolType>())
-      return protocolTy->getDecl()->getSuperclass();
-
-    if (auto compositionTy = getAs<ProtocolCompositionType>())
-      return compositionTy->getExistentialLayout().getSuperclass();
+    if (isExistentialType())
+      return getExistentialLayout().getSuperclass();
 
     // No other types have superclasses.
     return Type();
@@ -3205,14 +3210,12 @@ const DependentMemberType *TypeBase::findUnresolvedDependentMemberType() {
 }
 
 static Type getConcreteTypeForSuperclassTraversing(Type t) {
-  if (!t->getAnyNominal()) {
-    if (auto archetype = t->getAs<ArchetypeType>()) {
-      return archetype->getSuperclass();
-    } else if (auto dynamicSelfTy = t->getAs<DynamicSelfType>()) {
-      return dynamicSelfTy->getSelfType();
-    } else if (auto compositionTy = t->getAs<ProtocolCompositionType>()) {
-      return compositionTy->getExistentialLayout().explicitSuperclass;
-    }
+  if (t->isExistentialType()) {
+    return t->getExistentialLayout().getSuperclass();
+  } if (auto archetype = t->getAs<ArchetypeType>()) {
+    return archetype->getSuperclass();
+  } else if (auto dynamicSelfTy = t->getAs<DynamicSelfType>()) {
+    return dynamicSelfTy->getSelfType();
   }
   return t;
 }

lib/Sema/CSApply.cpp

@@ -320,6 +320,9 @@ static bool isNonFinalClass(Type type) {
     if (auto super = archetype->getSuperclass())
       return isNonFinalClass(super);
 
+  if (type->isExistentialType())
+    return true;
+
   return false;
 }
 

test/SILGen/protocol_with_superclass.swift

@@ -0,0 +1,251 @@
+// RUN: %target-swift-emit-silgen -enable-sil-ownership %s | tee /tmp/xxx | %FileCheck %s
+
+// Protocols with superclass-constrained Self.
+
+class Concrete {
+  typealias ConcreteAlias = String
+
+  func concreteMethod(_: ConcreteAlias) {}
+}
+
+class Generic<T> : Concrete {
+  typealias GenericAlias = (T, T)
+
+  func genericMethod(_: GenericAlias) {}
+}
+
+protocol BaseProto {}
+
+protocol ProtoRefinesClass : Generic<Int>, BaseProto {
+  func requirementUsesClassTypes(_: ConcreteAlias, _: GenericAlias)
+}
+
+extension ProtoRefinesClass {
+  // CHECK-LABEL: sil hidden @$S24protocol_with_superclass17ProtoRefinesClassPAAE019extensionMethodUsesF5TypesyySS_Si_SittF : $@convention(method) <Self where Self : ProtoRefinesClass> (@guaranteed String, Int, Int, @guaranteed Self) -> ()
+  func extensionMethodUsesClassTypes(_ x: ConcreteAlias, _ y: GenericAlias) {
+    _ = ConcreteAlias.self
+    _ = GenericAlias.self
+
+    // CHECK:      [[SELF:%.*]] = copy_value %3 : $Self
+    // CHECK-NEXT: [[UPCAST:%.*]] = upcast [[SELF]] : $Self to $Generic<Int>
+    // CHECK-NEXT: [[UPCAST2:%.*]] = upcast [[UPCAST]] : $Generic<Int> to $Concrete
+    // CHECK-NEXT: [[BORROW:%.*]] = begin_borrow [[UPCAST2]] : $Concrete
+    // CHECK-NEXT: [[METHOD:%.*]] = class_method [[BORROW:%.*]] : $Concrete, #Concrete.concreteMethod!1 : (Concrete) -> (String) -> (), $@convention(method) (@guaranteed String, @guaranteed Concrete) -> ()
+    // CHECK-NEXT: apply [[METHOD]](%0, [[BORROW]])
+    // CHECK-NEXT: end_borrow [[BORROW]]
+    // CHECK-NEXT: destroy_value [[UPCAST2]]
+    concreteMethod(x)
+
+    // CHECK:      [[SELF:%.*]] = copy_value %3 : $Self
+    // CHECK-NEXT: [[UPCAST:%.*]] = upcast [[SELF]] : $Self to $Generic<Int>
+    // CHECK-NEXT: [[BORROW:%.*]] = begin_borrow [[UPCAST]] : $Generic<Int>
+    // CHECK:      [[METHOD:%.*]] = class_method [[BORROW:%.*]] : $Generic<Int>, #Generic.genericMethod!1 : <T> (Generic<T>) -> ((T, T)) -> (), $@convention(method) <τ_0_0> (@in_guaranteed τ_0_0, @in_guaranteed τ_0_0, @guaranteed Generic<τ_0_0>) -> ()
+    // CHECK-NEXT: apply [[METHOD]]<Int>({{.*}}, [[BORROW]])
+    // CHECK:      end_borrow [[BORROW]]
+    // CHECK-NEXT: destroy_value [[UPCAST]]
+    genericMethod(y)
+
+    // CHECK:      [[SELF:%.*]] = copy_value %3 : $Self
+    // CHECK-NEXT: [[UPCAST:%.*]] = upcast [[SELF]] : $Self to $Generic<Int>
+    // CHECK-NEXT: destroy_value [[UPCAST]] : $Generic<Int>
+    let _: Generic<Int> = self
+
+    // CHECK:      [[SELF:%.*]] = copy_value %3 : $Self
+    // CHECK-NEXT: [[UPCAST:%.*]] = upcast [[SELF]] : $Self to $Generic<Int>
+    // CHECK-NEXT: [[UPCAST2:%.*]] = upcast [[UPCAST]] : $Generic<Int> to $Concrete
+    // CHECK-NEXT: destroy_value [[UPCAST2]] : $Concrete
+    let _: Concrete = self
+
+    // CHECK:      [[BOX:%.*]] = alloc_stack $BaseProto
+    // CHECK-NEXT: [[ADDR:%.*]] = init_existential_addr [[BOX]] : $*BaseProto, $Self
+    // CHECK-NEXT: [[SELF:%.*]] = copy_value %3 : $Self
+    // CHECK-NEXT: store [[SELF]] to [init] [[ADDR]] : $*Self
+    // CHECK-NEXT: destroy_addr [[BOX]] : $*BaseProto
+    // CHECK-NEXT: dealloc_stack [[BOX]] : $*BaseProto
+    let _: BaseProto = self
+
+    // CHECK:      [[SELF:%.*]] = copy_value %3 : $Self
+    // CHECK-NEXT: [[EXISTENTIAL:%.*]] = init_existential_ref [[SELF]] : $Self : $Self, $Generic<Int> & BaseProto
+    let _: BaseProto & Generic<Int> = self
+    
+    // CHECK:      [[SELF:%.*]] = copy_value %3 : $Self
+    // CHECK-NEXT: [[EXISTENTIAL:%.*]] = init_existential_ref [[SELF]] : $Self : $Self, $Concrete & BaseProto
+    let _: BaseProto & Concrete = self
+
+    // CHECK:      return
+  }
+}
+
+// CHECK-LABEL: sil hidden @$S24protocol_with_superclass22usesProtoRefinesClass1yyAA0eF5Class_pF : $@convention(thin) (@guaranteed ProtoRefinesClass) -> ()
+func usesProtoRefinesClass1(_ t: ProtoRefinesClass) {
+  let x: ProtoRefinesClass.ConcreteAlias = "hi"
+  _ = ProtoRefinesClass.ConcreteAlias.self
+
+  t.concreteMethod(x)
+
+  let y: ProtoRefinesClass.GenericAlias = (1, 2)
+  _ = ProtoRefinesClass.GenericAlias.self
+
+  t.genericMethod(y)
+
+  t.requirementUsesClassTypes(x, y)
+
+  let _: Generic<Int> = t
+  let _: Concrete = t
+  let _: BaseProto = t
+  let _: BaseProto & Generic<Int> = t
+  let _: BaseProto & Concrete = t
+}
+
+// CHECK-LABEL: sil hidden @$S24protocol_with_superclass22usesProtoRefinesClass2yyxAA0eF5ClassRzlF : $@convention(thin) <T where T : ProtoRefinesClass> (@guaranteed T) -> ()
+func usesProtoRefinesClass2<T : ProtoRefinesClass>(_ t: T) {
+  let x: T.ConcreteAlias = "hi"
+  _ = T.ConcreteAlias.self
+
+  t.concreteMethod(x)
+
+  let y: T.GenericAlias = (1, 2)
+  _ = T.GenericAlias.self
+
+  t.genericMethod(y)
+
+  t.requirementUsesClassTypes(x, y)
+
+  let _: Generic<Int> = t
+  let _: Concrete = t
+  let _: BaseProto = t
+  let _: BaseProto & Generic<Int> = t
+  let _: BaseProto & Concrete = t
+}
+
+class GoodConformingClass : Generic<Int>, ProtoRefinesClass {
+  // CHECK-LABEL: sil hidden @$S24protocol_with_superclass19GoodConformingClassC015requirementUsesF5TypesyySS_Si_SittF : $@convention(method) (@guaranteed String, Int, Int, @guaranteed GoodConformingClass) -> ()
+  func requirementUsesClassTypes(_ x: ConcreteAlias, _ y: GenericAlias) {
+    _ = ConcreteAlias.self
+    _ = GenericAlias.self
+
+    concreteMethod(x)
+
+    genericMethod(y)
+  }
+}
+
+protocol ProtoRefinesProtoWithClass : ProtoRefinesClass {}
+
+extension ProtoRefinesProtoWithClass {
+  // CHECK-LABEL: sil hidden @$S24protocol_with_superclass012ProtoRefinesD9WithClassPAAE026anotherExtensionMethodUsesG5TypesyySS_Si_SittF : $@convention(method) <Self where Self : ProtoRefinesProtoWithClass> (@guaranteed String, Int, Int, @guaranteed Self) -> () 
+  func anotherExtensionMethodUsesClassTypes(_ x: ConcreteAlias, _ y: GenericAlias) {
+    _ = ConcreteAlias.self
+    _ = GenericAlias.self
+
+    concreteMethod(x)
+    genericMethod(y)
+
+    let _: Generic<Int> = self
+    let _: Concrete = self
+    let _: BaseProto = self
+    let _: BaseProto & Generic<Int> = self
+    let _: BaseProto & Concrete = self
+  }
+}
+
+// CHECK-LABEL: sil hidden @$S24protocol_with_superclass016usesProtoRefinesE10WithClass1yyAA0efeG5Class_pF : $@convention(thin) (@guaranteed ProtoRefinesProtoWithClass) -> ()
+func usesProtoRefinesProtoWithClass1(_ t: ProtoRefinesProtoWithClass) {
+  let x: ProtoRefinesProtoWithClass.ConcreteAlias = "hi"
+  _ = ProtoRefinesProtoWithClass.ConcreteAlias.self
+
+  t.concreteMethod(x)
+
+  let y: ProtoRefinesProtoWithClass.GenericAlias = (1, 2)
+  _ = ProtoRefinesProtoWithClass.GenericAlias.self
+
+  t.genericMethod(y)
+
+  t.requirementUsesClassTypes(x, y)
+
+  let _: Generic<Int> = t
+  let _: Concrete = t
+  let _: BaseProto = t
+  let _: BaseProto & Generic<Int> = t
+  let _: BaseProto & Concrete = t
+}
+
+// CHECK-LABEL: sil hidden @$S24protocol_with_superclass016usesProtoRefinesE10WithClass2yyxAA0efeG5ClassRzlF : $@convention(thin) <T where T : ProtoRefinesProtoWithClass> (@guaranteed T) -> ()
+func usesProtoRefinesProtoWithClass2<T : ProtoRefinesProtoWithClass>(_ t: T) {
+  let x: T.ConcreteAlias = "hi"
+  _ = T.ConcreteAlias.self
+
+  t.concreteMethod(x)
+
+  let y: T.GenericAlias = (1, 2)
+  _ = T.GenericAlias.self
+
+  t.genericMethod(y)
+
+  t.requirementUsesClassTypes(x, y)
+
+  let _: Generic<Int> = t
+  let _: Concrete = t
+  let _: BaseProto = t
+  let _: BaseProto & Generic<Int> = t
+  let _: BaseProto & Concrete = t
+}
+
+class ClassWithInits<T> {
+  init(notRequiredInit: ()) {}
+
+  required init(requiredInit: ()) {}
+}
+
+protocol ProtocolWithClassInits : ClassWithInits<Int> {}
+
+// CHECK-LABEL: sil hidden @$S24protocol_with_superclass26useProtocolWithClassInits1yyAA0efG5Inits_pXpF : $@convention(thin) (@thick ProtocolWithClassInits.Type) -> ()
+func useProtocolWithClassInits1(_ t: ProtocolWithClassInits.Type) {
+  // CHECK: [[OPENED:%.*]] = open_existential_metatype %0 : $@thick ProtocolWithClassInits.Type
+  // CHECK-NEXT: [[UPCAST:%.*]] = upcast [[OPENED]] : $@thick (@opened("{{.*}}") ProtocolWithClassInits).Type to $@thick ClassWithInits<Int>.Type
+  // CHECK-NEXT: [[METHOD:%.*]] = class_method [[UPCAST]] : $@thick ClassWithInits<Int>.Type, #ClassWithInits.init!allocator.1 : <T> (ClassWithInits<T>.Type) -> (()) -> ClassWithInits<T>, $@convention(method) <τ_0_0> (@thick ClassWithInits<τ_0_0>.Type) -> @owned ClassWithInits<τ_0_0>
+  // CHECK-NEXT: [[RESULT:%.*]] = apply [[METHOD]]<Int>([[UPCAST]])
+  // CHECK-NEXT: [[CAST:%.*]] = unchecked_ref_cast [[RESULT]] : $ClassWithInits<Int> to $@opened("{{.*}}") ProtocolWithClassInits
+  // CHECK-NEXT: [[EXISTENTIAL:%.*]] = init_existential_ref [[CAST]] : $@opened("{{.*}}") ProtocolWithClassInits : $@opened("{{.*}}") ProtocolWithClassInits, $ProtocolWithClassInits
+  // CHECK-NEXT: destroy_value [[EXISTENTIAL]]
+  let _: ProtocolWithClassInits = t.init(requiredInit: ())
+}
+
+// CHECK-LABEL: sil hidden @$S24protocol_with_superclass26useProtocolWithClassInits2yyxmAA0efG5InitsRzlF : $@convention(thin) <T where T : ProtocolWithClassInits> (@thick T.Type) -> ()
+func useProtocolWithClassInits2<T : ProtocolWithClassInits>(_ t: T.Type) {
+  let _: T = T(requiredInit: ())
+
+  let _: T = t.init(requiredInit: ())
+}
+
+protocol ProtocolRefinesClassInits : ProtocolWithClassInits {}
+
+// CHECK-LABEL: sil hidden @$S24protocol_with_superclass29useProtocolRefinesClassInits1yyAA0efG5Inits_pXpF : $@convention(thin) (@thick ProtocolRefinesClassInits.Type) -> ()
+func useProtocolRefinesClassInits1(_ t: ProtocolRefinesClassInits.Type) {
+  let _: ProtocolRefinesClassInits = t.init(requiredInit: ())
+}
+
+// CHECK-LABEL: sil hidden @$S24protocol_with_superclass29useProtocolRefinesClassInits2yyxmAA0efG5InitsRzlF : $@convention(thin) <T where T : ProtocolRefinesClassInits> (@thick T.Type) -> ()
+func useProtocolRefinesClassInits2<T : ProtocolRefinesClassInits>(_ t: T.Type) {
+  let _: T = T(requiredInit: ())
+
+  let _: T = t.init(requiredInit: ())
+}
+
+class ClassWithDefault<T> {
+  func makeT() -> T { }
+}
+
+protocol SillyDefault : ClassWithDefault<Int> {
+  func makeT() -> Int
+}
+
+class ConformsToSillyDefault : ClassWithDefault<Int>, SillyDefault {}
+
+// CHECK-LABEL: sil private [transparent] [thunk] @$S24protocol_with_superclass22ConformsToSillyDefaultCAA0fG0A2aDP5makeTSiyFTW : $@convention(witness_method: SillyDefault) (@guaranteed ConformsToSillyDefault) -> Int
+// CHECK: class_method %1 : $ClassWithDefault<Int>, #ClassWithDefault.makeT!1 : <T> (ClassWithDefault<T>) -> () -> T, $@convention(method) <τ_0_0> (@guaranteed ClassWithDefault<τ_0_0>) -> @out τ_0_0
+// CHECK: return
+
+// CHECK-LABEL: sil_witness_table hidden ConformsToSillyDefault: SillyDefault module protocol_with_superclass {
+// CHECK-NEXT: method #SillyDefault.makeT!1: <Self where Self : SillyDefault> (Self) -> () -> Int : @$S24protocol_with_superclass22ConformsToSillyDefaultCAA0fG0A2aDP5makeTSiyFTW
+// CHECK-NEXT: }