Tiny associated type inference fixes

lib/Sema/TypeCheckProtocol.cpp

@@ -2215,16 +2215,39 @@ ConformanceChecker::getReferencedAssociatedTypes(ValueDecl *req) {
     return known->second;
 
   // Collect the set of associated types rooted on Self in the
-  // signature.
+  // signature. Note that for references to nested types, we only
+  // want to consider the outermost dependent member type.
+  //
+  // For example, a requirement typed '(Iterator.Element) -> ()'
+  // is not considered to reference the associated type 'Iterator'.
   auto &assocTypes = ReferencedAssociatedTypes[req];
-  llvm::SmallPtrSet<AssociatedTypeDecl *, 4> knownAssocTypes;
-  req->getInterfaceType()->getCanonicalType().visit([&](CanType type) {
-      if (auto assocType = getReferencedAssocTypeOfProtocol(type, Proto)) {
-        if (knownAssocTypes.insert(assocType).second) {
-          assocTypes.push_back(assocType);
+
+  class Walker : public TypeWalker {
+    ProtocolDecl *Proto;
+    llvm::SmallVectorImpl<AssociatedTypeDecl *> &assocTypes;
+    llvm::SmallPtrSet<AssociatedTypeDecl *, 4> knownAssocTypes;
+
+  public:
+    Walker(ProtocolDecl *Proto,
+           llvm::SmallVectorImpl<AssociatedTypeDecl *> &assocTypes)
+      : Proto(Proto), assocTypes(assocTypes) {}
+
+    Action walkToTypePre(Type type) override {
+      if (type->is<DependentMemberType>()) {
+        if (auto assocType = getReferencedAssocTypeOfProtocol(type, Proto)) {
+          if (knownAssocTypes.insert(assocType).second)
+            assocTypes.push_back(assocType);
         }
+
+        return Action::SkipChildren;
       }
-    });
+
+      return Action::Continue;
+    }
+  };
+
+  Walker walker(Proto, assocTypes);
+  req->getInterfaceType()->getCanonicalType().walk(walker);
 
   return assocTypes;
 }
@@ -3487,20 +3510,37 @@ ResolveWitnessResult ConformanceChecker::resolveTypeWitnessViaLookup(
                        AssociatedTypeDecl *assocType) {
   // Conformances constructed by the ClangImporter should have explicit type
   // witnesses already.
-  if (isa<ClangModuleUnit>(Conformance->getDeclContext()->getModuleScopeContext())) {
+  if (isa<ClangModuleUnit>(DC->getModuleScopeContext())) {
     llvm::errs() << "Cannot look up associated type for imported conformance:\n";
     Conformance->getType().dump(llvm::errs());
     assocType->dump(llvm::errs());
     abort();
   }
 
+  // If we fail to find a witness via lookup, check for a generic parameter.
+  auto checkForGenericParameter = [&]() {
+    // If there is a generic parameter of the named type, use that.
+    if (auto genericSig = DC->getGenericSignatureOfContext()) {
+      for (auto gp : genericSig->getInnermostGenericParams()) {
+        if (gp->getName() == assocType->getName()) {
+          if (!checkTypeWitness(DC, Proto, assocType, gp)) {
+            recordTypeWitness(assocType, gp, nullptr);
+            return ResolveWitnessResult::Success;
+          }
+        }
+      }
+    }
+
+    return ResolveWitnessResult::Missing;
+  };
+
   // Look for a member type with the same name as the associated type.
   auto candidates = TypeChecker::lookupMemberType(
       DC, Adoptee, assocType->getName(), NameLookupFlags::ProtocolMembers);
 
   // If there aren't any candidates, we're done.
   if (!candidates) {
-    return ResolveWitnessResult::Missing;
+    return checkForGenericParameter();
   }
 
   // Determine which of the candidates is viable.
@@ -3534,7 +3574,7 @@ ResolveWitnessResult ConformanceChecker::resolveTypeWitnessViaLookup(
                      return x.first->getDeclContext()
                         ->getSelfProtocolDecl() == nullptr;
                    }) == nonViable.end())
-    return ResolveWitnessResult::Missing;
+    return checkForGenericParameter();
 
   // If there is a single viable candidate, form a substitution for it.
   if (viable.size() == 1) {

lib/Sema/TypeCheckProtocolInference.cpp

@@ -918,14 +918,6 @@ AssociatedTypeInference::computeAbstractTypeWitness(
       return derivedType;
   }
 
-  // If there is a generic parameter of the named type, use that.
-  if (auto genericSig = dc->getGenericSignatureOfContext()) {
-    for (auto gp : genericSig->getInnermostGenericParams()) {
-      if (gp->getName() == assocType->getName())
-        return dc->mapTypeIntoContext(gp);
-    }
-  }
-
   return Type();
 }
 

lib/Sema/TypeCheckType.cpp

@@ -1406,18 +1406,13 @@ static Type resolveNestedIdentTypeComponent(
 
     // Diagnose a bad conformance reference if we need to.
     if (!options.contains(TypeResolutionFlags::SilenceErrors) &&
-        inferredAssocType && memberType && memberType->hasError()) {
+        inferredAssocType && memberType->hasError()) {
       maybeDiagnoseBadConformanceRef(DC, parentTy, comp->getLoc(),
                                      inferredAssocType);
     }
 
-    // If we found a reference to an associated type or other member type that
-    // was marked invalid, just return ErrorType to silence downstream errors.
-    if (member->isInvalid())
-      return ErrorType::get(ctx);
-
     // At this point, we need to have resolved the type of the member.
-    if (!memberType || memberType->hasError())
+    if (memberType->hasError())
       return memberType;
 
     // If there are generic arguments, apply them now.
@@ -2592,26 +2587,11 @@ Type TypeResolver::resolveSILBoxType(SILBoxTypeRepr *repr,
       auto argTy = resolveType(repr->getGenericArguments()[i], options);
       genericArgMap.insert({params[i], argTy->getCanonicalType()});
     }
-
-    bool ok = true;
+
     subMap = SubstitutionMap::get(
       genericSig,
       QueryTypeSubstitutionMap{genericArgMap},
-      [&](CanType depTy, Type replacement, ProtocolDecl *proto)
-      -> ProtocolConformanceRef {
-        auto result = TypeChecker::conformsToProtocol(
-                                            replacement, proto, DC,
-                                            ConformanceCheckOptions());
-        if (result.isInvalid()) {
-          ok = false;
-          return ProtocolConformanceRef(proto);
-        }
-
-        return result;
-      });
-
-    if (!ok)
-      return ErrorType::get(Context);
+      TypeChecker::LookUpConformance(DC));
   }
 
   auto layout = SILLayout::get(Context, genericSig, fields);

stdlib/public/core/NativeSet.swift

@@ -282,6 +282,9 @@ extension _NativeSet {
 }
 
 extension _NativeSet: _SetBuffer {
+  @usableFromInline
+  internal typealias Element = Element
+
   @usableFromInline
   internal typealias Index = Set<Element>.Index
 

test/decl/nested/protocol.swift

@@ -106,8 +106,7 @@ func testLookup(_ x: OuterForUFI.Inner) {
   x.extMethod()
 }
 
-// N.B. Lookup fails here because OuterForUFI.Inner is marked invalid.
 func testLookup<T: OuterForUFI.Inner>(_ x: T) {
-  x.req() // expected-error {{value of type 'T' has no member 'req'}}
-  x.extMethod() // expected-error {{value of type 'T' has no member 'extMethod'}}
+  x.req()
+  x.extMethod()
 }

test/decl/protocol/req/associated_type_inference_valid.swift

@@ -0,0 +1,56 @@
+// RUN: %target-swift-frontend -emit-silgen %s
+
+// This is a SILGen test to ensure we can completely check these conformances
+// and build valid AST.
+
+protocol P {
+  associatedtype T : Q = S
+  typealias Y = T.X
+
+  func foo(_: T.X)
+}
+
+protocol Q {
+  associatedtype X
+}
+
+struct S : Q {
+  typealias X = ()
+}
+
+struct R : P {
+  let x: Y? = nil
+  func foo(_: Y) {}
+}
+
+// SR-8813
+protocol BaseProtocol {
+  associatedtype Value
+  typealias Closure = () -> Value
+
+  init(closure: Closure)
+}
+
+struct Base<Value>: BaseProtocol {
+  private var closure: Closure?
+
+  init(closure: Closure) {
+    withoutActuallyEscaping(closure) { new in
+      self.closure = new
+    }
+  }
+}
+
+// SR-11407
+protocol _Drivable: AnyObject {
+  typealias Driver = Self
+}
+protocol Configurator {
+  associatedtype Drivable: _Drivable
+  typealias Driver = Drivable.Driver
+  func configure(driver: Driver)
+}
+struct AnyConfigurator<Drivable: _Drivable>: Configurator {
+  private let thing: Driver?
+  func configure(driver: AnyConfigurator.Driver) {}
+}

validation-test/compiler_crashers_2_fixed/sr11052-typealias.swift

@@ -19,7 +19,7 @@ struct Concrete<AType2: ProtoA>: ProtoB {
         fatalError()
     }
 
-    func protoFunc() -> Alias { // expected-error{{unsupported recursion for reference to type alias 'Alias' of type 'Concrete<AType2>'}}
+    func protoFunc() -> Alias {
         fatalError()
     }
 }

validation-test/compiler_crashers_2_fixed/sr11392.swift

@@ -0,0 +1,28 @@
+// RUN: %target-swift-frontend -verify -emit-ir %s
+
+// Ideally this would type check successfully; we should be able to
+// infer that X == Int using the same-type constraint 'A.X == X'.
+
+protocol P1 {
+    associatedtype X
+    // expected-note@-1 {{protocol requires nested type 'X'; do you want to add it?}}
+    associatedtype A: P2 where A.X == X
+}
+
+protocol P2 {
+    associatedtype X
+}
+
+struct S {}
+
+extension S {
+    struct A: P2 {
+        typealias X = Int
+    }
+}
+
+
+extension S: P1 {}
+// expected-error@-1 {{type 'S' does not conform to protocol 'P1'}}
+
+print(S.X.self)