AST: Fix name lookup for protocols with superclasses

Also, start adding some tests now that basic things seem to work.

Author: slavapestov

lib/AST/NameLookup.cpp

@@ -1713,12 +1713,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>()) {
@@ -1748,9 +1760,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");
@@ -1849,18 +1861,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;
 }

test/decl/protocol/protocol_with_superclass.swift

@@ -0,0 +1,198 @@
+// RUN: %target-typecheck-verify-swift
+
+// 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)
+  // expected-note@-1 {{protocol requires function 'requirementUsesClassTypes' with type '(Generic<Int>.ConcreteAlias, Generic<Int>.GenericAlias) -> ()' (aka '(String, (Int, Int)) -> ()'); do you want to add a stub?}}
+}
+
+func duplicateOverload<T : ProtoRefinesClass>(_: T) {}
+// expected-note@-1 {{'duplicateOverload' previously declared here}}
+
+func duplicateOverload<T : ProtoRefinesClass & Generic<Int>>(_: T) {}
+// expected-error@-1 {{invalid redeclaration of 'duplicateOverload'}}
+// expected-warning@-2 {{redundant superclass constraint 'T' : 'Generic<Int>'}}
+// expected-note@-3 {{superclass constraint 'T' : 'Generic<Int>' implied here}}
+
+extension ProtoRefinesClass {
+  func extensionMethodUsesClassTypes(_ 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
+
+    let _: Generic<String> = self
+    // expected-error@-1 {{cannot convert value of type 'Self' to specified type 'Generic<String>'}}
+  }
+}
+
+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
+
+  let _: Generic<String> = t
+  // expected-error@-1 {{cannot convert value of type 'ProtoRefinesClass' to specified type 'Generic<String>'}}
+}
+
+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
+
+  let _: Generic<String> = t
+  // expected-error@-1 {{cannot convert value of type 'T' to specified type 'Generic<String>'}}
+}
+
+class BadConformingClass1 : ProtoRefinesClass {
+  // expected-error@-1 {{'ProtoRefinesClass' requires that 'BadConformingClass1' inherit from 'Generic<Int>'}}
+  // expected-note@-2 {{requirement specified as 'Self' : 'Generic<Int>' [with Self = BadConformingClass1]}}
+  func requirementUsesClassTypes(_: ConcreteAlias, _: GenericAlias) {
+    // expected-error@-1 {{use of undeclared type 'ConcreteAlias'}}
+    // expected-error@-2 {{use of undeclared type 'GenericAlias'}}
+
+    _ = ConcreteAlias.self
+    // expected-error@-1 {{use of unresolved identifier 'ConcreteAlias'}}
+    _ = GenericAlias.self
+    // expected-error@-1 {{use of unresolved identifier 'GenericAlias'}}
+  }
+}
+
+class BadConformingClass2 : Generic<String>, ProtoRefinesClass {
+  // expected-error@-1 {{'ProtoRefinesClass' requires that 'BadConformingClass2' inherit from 'Generic<Int>'}}
+  // expected-note@-2 {{requirement specified as 'Self' : 'Generic<Int>' [with Self = BadConformingClass2]}}
+  // expected-error@-3 {{type 'BadConformingClass2' does not conform to protocol 'ProtoRefinesClass'}}
+  func requirementUsesClassTypes(_: ConcreteAlias, _: GenericAlias) {
+    // expected-note@-1 {{candidate has non-matching type '(BadConformingClass2.ConcreteAlias, BadConformingClass2.GenericAlias) -> ()' (aka '(String, (String, String)) -> ()')}}
+    _ = ConcreteAlias.self
+    _ = GenericAlias.self
+  }
+}
+
+class GoodConformingClass : Generic<Int>, ProtoRefinesClass {
+  func requirementUsesClassTypes(_ x: ConcreteAlias, _ y: GenericAlias) {
+    _ = ConcreteAlias.self
+    _ = GenericAlias.self
+
+    concreteMethod(x)
+
+    genericMethod(y)
+  }
+}
+
+protocol ProtoRefinesProtoWithClass : ProtoRefinesClass {}
+
+extension ProtoRefinesProtoWithClass {
+  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
+
+    let _: Generic<String> = self
+    // expected-error@-1 {{cannot convert value of type 'Self' to specified type 'Generic<String>'}}
+  }
+}
+
+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
+
+  let _: Generic<String> = t
+  // expected-error@-1 {{cannot convert value of type 'ProtoRefinesProtoWithClass' to specified type 'Generic<String>'}}
+}
+
+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
+
+  let _: Generic<String> = t
+  // expected-error@-1 {{cannot convert value of type 'T' to specified type 'Generic<String>'}}
+}

test/type/subclass_composition.swift

@@ -443,27 +443,6 @@ func conformsTo<T1 : P2, T2 : Base<Int> & P2>(
   conformsToBaseIntAndP2WithWhereClause(baseAndP2Archetype)
 }
 
-//
-// Protocols with superclass-constrained Self -- not supported yet.
-//
-
-protocol ProtoConstraintsSelfToClass where Self : Base<Int> {}
-
-protocol ProtoRefinesClass : Base<Int> {}
-protocol ProtoRefinesClassAndProtocolAlias : BaseIntAndP2 {}
-protocol ProtoRefinesClassAndProtocolDirect : Base<Int> & P2 {}
-protocol ProtoRefinesClassAndProtocolExpanded : Base<Int>, P2 {}
-
-class ClassConformsToClassProtocolBad1 : ProtoConstraintsSelfToClass {}
-// expected-error@-1 {{'ProtoConstraintsSelfToClass' requires that 'ClassConformsToClassProtocolBad1' inherit from 'Base<Int>'}}
-// expected-note@-2 {{requirement specified as 'Self' : 'Base<Int>' [with Self = ClassConformsToClassProtocolBad1]}}
-class ClassConformsToClassProtocolGood1 : Derived, ProtoConstraintsSelfToClass {}
-
-class ClassConformsToClassProtocolBad2 : ProtoRefinesClass {}
-// expected-error@-1 {{'ProtoRefinesClass' requires that 'ClassConformsToClassProtocolBad2' inherit from 'Base<Int>'}}
-// expected-note@-2 {{requirement specified as 'Self' : 'Base<Int>' [with Self = ClassConformsToClassProtocolBad2]}}
-class ClassConformsToClassProtocolGood2 : Derived, ProtoRefinesClass {}
-
 // Subclass existentials inside inheritance clauses
 class CompositionInClassInheritanceClauseAlias : BaseIntAndP2 {
   required init(classInit: ()) {