Sema: Harden 'for ... in ...' with existential type

Avoid calling lookupMemberType() with an existential base
altogether.

With the previous resolveTypeInContext() patch, a compiler_crasher
regressed and hit this, because the behavior of lookupMemberType()
changed to return nullptr in fewer cases.

Author: slavapestov

lib/Sema/TypeCheckConstraints.cpp

@@ -1846,11 +1846,11 @@ bool TypeChecker::typeCheckForEachBinding(DeclContext *dc, ForEachStmt *stmt) {
       cs.addConstraint(ConstraintKind::ConformsTo, SequenceType,
                        sequenceProto->getDeclaredType(), Locator);
 
-      auto generatorLocator =
+      auto iteratorLocator =
         cs.getConstraintLocator(Locator,
                                 ConstraintLocator::SequenceIteratorProtocol);
       auto elementLocator =
-        cs.getConstraintLocator(generatorLocator,
+        cs.getConstraintLocator(iteratorLocator,
                                 ConstraintLocator::GeneratorElementType);
 
       // Collect constraints from the element pattern.
@@ -1859,48 +1859,58 @@ bool TypeChecker::typeCheckForEachBinding(DeclContext *dc, ForEachStmt *stmt) {
       if (!InitType)
         return true;
 
-      // Manually search for the generator witness. If no generator/element pair
+      // Manually search for the iterator witness. If no iterator/element pair
       // exists, solve for them.
-      // FIXME: rename generatorType to iteratorType due to the protocol
-      // renaming
-      Type generatorType;
+      Type iteratorType;
       Type elementType;
 
       NameLookupOptions lookupOptions = defaultMemberTypeLookupOptions;
       if (isa<AbstractFunctionDecl>(cs.DC))
         lookupOptions |= NameLookupFlags::KnownPrivate;
-      auto member = cs.TC.lookupMemberType(cs.DC,
-                                           expr->getType()->getRValueType(),
-                                           tc.Context.Id_Iterator,
-                                           lookupOptions);
+
+      auto sequenceType = expr->getType()->getRValueType();
+
+      // If the sequence type is an existential, we should not attempt to
+      // look up the member type at all, since we cannot represent associated
+      // types of existentials.
+      //
+      // We will diagnose it later.
+      if (!sequenceType->isExistentialType()) {
+        auto member = cs.TC.lookupMemberType(cs.DC,
+                                             sequenceType,
+                                             tc.Context.Id_Iterator,
+                                             lookupOptions);
 
-      if (member) {
-        generatorType = member.front().second;
-        
-        member = cs.TC.lookupMemberType(cs.DC,
-                                        generatorType,
-                                        tc.Context.Id_Element,
-                                        lookupOptions);
-        
-        if (member)
-          elementType = member.front().second;
+        if (member) {
+          iteratorType = member.front().second;
+
+          member = cs.TC.lookupMemberType(cs.DC,
+                                          iteratorType,
+                                          tc.Context.Id_Element,
+                                          lookupOptions);
+
+          if (member)
+            elementType = member.front().second;
+        }
       }
-      
+
+      // If the type lookup failed, just add some constraints we can
+      // try to solve later.
       if (elementType.isNull()) {
 
-        // Determine the generator type of the sequence.
-        generatorType = cs.createTypeVariable(Locator, /*options=*/0);
+        // Determine the iterator type of the sequence.
+        iteratorType = cs.createTypeVariable(Locator, /*options=*/0);
         cs.addConstraint(Constraint::create(
                            cs, ConstraintKind::TypeMember,
-                           SequenceType, generatorType,
-                           tc.Context.Id_Iterator, generatorLocator));
+                           SequenceType, iteratorType,
+                           tc.Context.Id_Iterator, iteratorLocator));
 
-        // Determine the element type of the generator.
+        // Determine the element type of the iterator.
         // FIXME: Should look up the type witness.
         elementType = cs.createTypeVariable(Locator, /*options=*/0);
         cs.addConstraint(Constraint::create(
                            cs, ConstraintKind::TypeMember,
-                           generatorType, elementType,
+                           iteratorType, elementType,
                            tc.Context.Id_Element, elementLocator));
       }
 

test/stmt/foreach.swift

@@ -172,3 +172,9 @@ func testOptionalSequence() {
   }
 }
 
+// Crash with (invalid) for each over an existential
+func testExistentialSequence(s: Sequence) { // expected-error {{protocol 'Sequence' can only be used as a generic constraint because it has Self or associated type requirements}}
+  for x in s { // expected-error {{using 'Sequence' as a concrete type conforming to protocol 'Sequence' is not supported}}
+    _ = x
+  }
+}