Merge pull request swiftlang#33385 from apple/revert-33227-unbound-thinout-1

Revert "Sema: Make type resolution for EnumElementPattern less eager"

Author: CodaFi

include/swift/AST/NameLookup.h

@@ -512,14 +512,6 @@ void recordLookupOfTopLevelName(DeclContext *topLevelContext, DeclName name,
 
 } // end namespace namelookup
 
-/// Retrieve the set of nominal type declarations that are directly
-/// referenced in the given \c typeRepr, looking through typealiases.
-/// 
-/// \param dc The \c DeclContext from which to perform lookup.
-TinyPtrVector<NominalTypeDecl *>
-getDirectlyReferencedNominalTypeDecls(ASTContext &ctx, TypeRepr *typeRepr,
-                                      DeclContext *dc, bool &anyObject);
-
 /// Retrieve the set of nominal type declarations that are directly
 /// "inherited" by the given declaration at a particular position in the
 /// list of "inherited" types.

lib/AST/NameLookup.cpp

@@ -861,13 +861,18 @@ SelfBounds SelfBoundsFromWhereClauseRequest::evaluate(
       continue;
 
     // Resolve the right-hand side.
-    if (auto *const typeRepr = req.getConstraintRepr()) {
-      const auto rhsNominals = getDirectlyReferencedNominalTypeDecls(
-          ctx, typeRepr, lookupDC, result.anyObject);
-
-      result.decls.insert(result.decls.end(), rhsNominals.begin(),
-                          rhsNominals.end());
+    DirectlyReferencedTypeDecls rhsDecls;
+    if (auto typeRepr = req.getConstraintRepr()) {
+      rhsDecls = directReferencesForTypeRepr(evaluator, ctx, typeRepr, lookupDC);
     }
+
+    SmallVector<ModuleDecl *, 2> modulesFound;
+    auto rhsNominals = resolveTypeDeclsToNominal(evaluator, ctx, rhsDecls,
+                                                 modulesFound,
+                                                 result.anyObject);
+    result.decls.insert(result.decls.end(),
+                        rhsNominals.begin(),
+                        rhsNominals.end());
   }
 
   return result;
@@ -2134,17 +2139,6 @@ static DirectlyReferencedTypeDecls directReferencesForType(Type type) {
   return { };
 }
 
-TinyPtrVector<NominalTypeDecl *> swift::getDirectlyReferencedNominalTypeDecls(
-    ASTContext &ctx, TypeRepr *typeRepr, DeclContext *dc, bool &anyObject) {
-  const auto referenced =
-      directReferencesForTypeRepr(ctx.evaluator, ctx, typeRepr, dc);
-
-  // Resolve those type declarations to nominal type declarations.
-  SmallVector<ModuleDecl *, 2> modulesFound;
-  return resolveTypeDeclsToNominal(ctx.evaluator, ctx, referenced, modulesFound,
-                                   anyObject);
-}
-
 DirectlyReferencedTypeDecls InheritedDeclsReferencedRequest::evaluate(
     Evaluator &evaluator,
     llvm::PointerUnion<const TypeDecl *, const ExtensionDecl *> decl,
@@ -2266,10 +2260,16 @@ ExtendedNominalRequest::evaluate(Evaluator &evaluator,
     // We must've seen 'extension { ... }' during parsing.
     return nullptr;
 
+  ASTContext &ctx = ext->getASTContext();
+  DirectlyReferencedTypeDecls referenced =
+    directReferencesForTypeRepr(evaluator, ctx, typeRepr, ext->getParent());
+
   // Resolve those type declarations to nominal type declarations.
+  SmallVector<ModuleDecl *, 2> modulesFound;
   bool anyObject = false;
-  const auto nominalTypes = getDirectlyReferencedNominalTypeDecls(
-      ext->getASTContext(), typeRepr, ext->getParent(), anyObject);
+  auto nominalTypes
+    = resolveTypeDeclsToNominal(evaluator, ctx, referenced, modulesFound,
+                                anyObject);
 
   // If there is more than 1 element, we will emit a warning or an error
   // elsewhere, so don't handle that case here.

lib/Sema/CSGen.cpp

@@ -2491,23 +2491,31 @@ namespace {
         if (enumPattern->getParentType() || enumPattern->getParentTypeRepr()) {
           // Resolve the parent type.
           Type parentType = [&]() -> Type {
-            if (const auto resolvedTy = enumPattern->getParentType()) {
-              assert(resolvedTy->hasUnboundGenericType() == false &&
-                     "A pre-resolved type must be fully bound");
-              return resolvedTy;
+            if (auto preTy = enumPattern->getParentType()) {
+              return preTy;
             }
             return resolveTypeReferenceInExpression(
                 enumPattern->getParentTypeRepr(),
-                TypeResolverContext::InExpression,
-                OpenUnboundGenericType(
-                    CS, CS.getConstraintLocator(
-                            locator, {LocatorPathElt::PatternMatch(pattern),
-                                      ConstraintLocator::ParentType})));
+                TypeResolverContext::InExpression, [](auto unboundTy) {
+                  // FIXME: We ought to pass an OpenUnboundGenericType object
+                  // rather than calling CS.openUnboundGenericType below, but
+                  // sometimes the parent type is resolved eagerly in
+                  // ResolvePattern::visitUnresolvedDotExpr, letting unbound
+                  // generics escape.
+                  return unboundTy;
+                });
           }();
 
           if (!parentType)
             return Type();
 
+          parentType = CS.openUnboundGenericTypes(
+              parentType, CS.getConstraintLocator(
+                              locator, {LocatorPathElt::PatternMatch(pattern),
+                                        ConstraintLocator::ParentType}));
+
+          assert(parentType);
+
           // Perform member lookup into the parent's metatype.
           Type parentMetaType = MetatypeType::get(parentType);
           CS.addValueMemberConstraint(

lib/Sema/TypeCheckPattern.cpp

@@ -467,26 +467,31 @@ class ResolvePattern : public ASTVisitor<ResolvePattern,
     if (!ExprToIdentTypeRepr(components, Context).visit(ude->getBase()))
       return nullptr;
 
-    auto *const repr = IdentTypeRepr::create(Context, components);
+    const auto options =
+        TypeResolutionOptions(None) | TypeResolutionFlags::SilenceErrors;
 
-    // See first if the repr unambiguously references an enum declaration.
-    bool anyObject = false;
-    const auto &referencedDecls =
-        getDirectlyReferencedNominalTypeDecls(Context, repr, DC, anyObject);
-    if (referencedDecls.size() != 1)
-      return nullptr;
+    auto *repr = IdentTypeRepr::create(Context, components);
 
-    auto *const enumDecl = dyn_cast<EnumDecl>(referencedDecls.front());
+    // See if the repr resolves to a type.
+    const auto resolution =
+        TypeResolution::forContextual(DC, options, [](auto unboundTy) {
+          // FIXME: Don't let unbound generic types escape type resolution.
+          // For now, just return the unbound generic type.
+          return unboundTy;
+        });
+    const auto ty = resolution.resolveType(repr);
+    auto *enumDecl = dyn_cast_or_null<EnumDecl>(ty->getAnyNominal());
     if (!enumDecl)
       return nullptr;
 
-    EnumElementDecl *referencedElement =
-        lookupEnumMemberElement(DC, enumDecl->getDeclaredInterfaceType(),
-                                ude->getName(), ude->getLoc());
+    EnumElementDecl *referencedElement
+      = lookupEnumMemberElement(DC, ty, ude->getName(), ude->getLoc());
     if (!referencedElement)
       return nullptr;
 
-    auto *const base = new (Context) TypeExpr(repr);
+    auto *base =
+        TypeExpr::createForMemberDecl(repr, ude->getNameLoc(), enumDecl);
+    base->setType(MetatypeType::get(ty));
     return new (Context)
         EnumElementPattern(base, ude->getDotLoc(), ude->getNameLoc(),
                            ude->getName(), referencedElement, nullptr);
@@ -564,31 +569,37 @@ class ResolvePattern : public ASTVisitor<ResolvePattern,
       baseTE = TypeExpr::createImplicit(enumDecl->getDeclaredTypeInContext(),
                                         Context);
     } else {
+      const auto options =
+          TypeResolutionOptions(None) | TypeResolutionFlags::SilenceErrors;
+
       // Otherwise, see whether we had an enum type as the penultimate
       // component, and look up an element inside it.
-      auto *const prefixRepr = IdentTypeRepr::create(Context, components);
-
-      // See first if the repr unambiguously references an enum declaration.
-      bool anyObject = false;
-      const auto &referencedDecls = getDirectlyReferencedNominalTypeDecls(
-          Context, prefixRepr, DC, anyObject);
-      if (referencedDecls.size() != 1)
-        return nullptr;
-
-      auto *const enumDecl = dyn_cast<EnumDecl>(referencedDecls.front());
+      auto *prefixRepr = IdentTypeRepr::create(Context, components);
+
+      // See first if the entire repr resolves to a type.
+      const Type enumTy =
+          TypeResolution::forContextual(DC, options, [](auto unboundTy) {
+            // FIXME: Don't let unbound generic types escape type resolution.
+            // For now, just return the unbound generic type.
+            return unboundTy;
+          }).resolveType(prefixRepr);
+      auto *enumDecl = dyn_cast_or_null<EnumDecl>(enumTy->getAnyNominal());
       if (!enumDecl)
         return nullptr;
 
-      referencedElement = lookupEnumMemberElement(
-          DC, enumDecl->getDeclaredInterfaceType(), tailComponent->getNameRef(),
-          tailComponent->getLoc());
+      referencedElement
+        = lookupEnumMemberElement(DC, enumTy,
+                                  tailComponent->getNameRef(),
+                                  tailComponent->getLoc());
       if (!referencedElement)
         return nullptr;
 
-      baseTE = new (Context) TypeExpr(prefixRepr);
+      baseTE = TypeExpr::createForMemberDecl(
+          prefixRepr, tailComponent->getNameLoc(), enumDecl);
+      baseTE->setType(MetatypeType::get(enumTy));
     }
 
-    assert(baseTE && "Didn't initialize base expression?");
+    assert(baseTE && baseTE->getType() && "Didn't initialize base expression?");
     assert(!isa<GenericIdentTypeRepr>(tailComponent) &&
            "should be handled above");
 
@@ -1426,25 +1437,11 @@ Pattern *TypeChecker::coercePatternToType(ContextualPattern pattern,
 
       enumTy = type;
     } else {
-      // Validate the parent type if we haven't done so yet.
-      if (EEP->getParentType().isNull()) {
-        const auto resolution =
-            TypeResolution::forContextual(dc, options, [](auto unboundTy) {
-              // FIXME: Don't let unbound generic types escape type resolution.
-              // For now, just return the unbound generic type.
-              return unboundTy;
-            });
-        const auto ty = resolution.resolveType(EEP->getParentTypeRepr());
-        EEP->setParentType(ty);
-
-        if (ty->hasError()) {
-          return nullptr;
-        }
-      }
-
       // Check if the explicitly-written enum type matches the type we're
       // coercing to.
-      const Type parentTy = EEP->getParentType();
+      assert(!EEP->getParentType().isNull()
+             && "enum with resolved element doesn't specify parent type?!");
+      auto parentTy = EEP->getParentType();
       // If the type matches exactly, use it.
       if (parentTy->isEqual(type)) {
         enumTy = type;

test/Constraints/enum_cases.swift

@@ -153,3 +153,21 @@ func rdar_49159472() {
     func baz(e: E) {}
   }
 }
+
+struct EnumElementPatternFromContextualType<T> {
+  enum E {
+    case plain
+    case payload(T)
+  }
+
+  func foo(x: Any) where T == EnumElementPatternFromContextualType<Bool>.E {
+    switch x {
+    case T.plain: // Ok
+      break
+    case T.payload(true): // Ok
+      break
+    default:
+      break
+    }
+  }
+}

test/Constraints/patterns.swift

@@ -339,14 +339,10 @@ func rdar32241441() {
 
 // SR-6100
 struct One<Two> { // expected-note{{'Two' declared as parameter to type 'One'}}
-  public enum E: Error {
-    // if you remove associated value, everything works
-    case SomeError(String)
-
-    static func foo(error: Error) {
-      if case SomeError = error {}
+    public enum E: Error {
+        // if you remove associated value, everything works
+        case SomeError(String)
     }
-  }
 }
 
 func testOne() {