Merge pull request #33227 from AnthonyLatsis/unbound-thinout-1

AnthonyLatsis · web-flow · commit 337501eb7e2d · 2020-08-01T16:14:14.000+03:00
Sema: Make type resolution for EnumElementPattern less eager
diff --git a/include/swift/AST/NameLookup.h b/include/swift/AST/NameLookup.h
@@ -512,6 +512,14 @@ 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.
diff --git a/lib/AST/NameLookup.cpp b/lib/AST/NameLookup.cpp
@@ -861,18 +861,13 @@ SelfBounds SelfBoundsFromWhereClauseRequest::evaluate(
       continue;
 
     // Resolve the right-hand side.
-    DirectlyReferencedTypeDecls rhsDecls;
-    if (auto typeRepr = req.getConstraintRepr()) {
-      rhsDecls = directReferencesForTypeRepr(evaluator, ctx, typeRepr, lookupDC);
-    }
+    if (auto *const typeRepr = req.getConstraintRepr()) {
+      const auto rhsNominals = getDirectlyReferencedNominalTypeDecls(
+          ctx, typeRepr, lookupDC, result.anyObject);
 
-    SmallVector<ModuleDecl *, 2> modulesFound;
-    auto rhsNominals = resolveTypeDeclsToNominal(evaluator, ctx, rhsDecls,
-                                                 modulesFound,
-                                                 result.anyObject);
-    result.decls.insert(result.decls.end(),
-                        rhsNominals.begin(),
-                        rhsNominals.end());
+      result.decls.insert(result.decls.end(), rhsNominals.begin(),
+                          rhsNominals.end());
+    }
   }
 
   return result;
@@ -2139,6 +2134,17 @@ 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,
@@ -2260,16 +2266,10 @@ 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;
-  auto nominalTypes
-    = resolveTypeDeclsToNominal(evaluator, ctx, referenced, modulesFound,
-                                anyObject);
+  const auto nominalTypes = getDirectlyReferencedNominalTypeDecls(
+      ext->getASTContext(), typeRepr, ext->getParent(), anyObject);
 
   // If there is more than 1 element, we will emit a warning or an error
   // elsewhere, so don't handle that case here.
diff --git a/lib/Sema/CSGen.cpp b/lib/Sema/CSGen.cpp
@@ -2501,31 +2501,23 @@ namespace {
         if (enumPattern->getParentType() || enumPattern->getParentTypeRepr()) {
           // Resolve the parent type.
           Type parentType = [&]() -> Type {
-            if (auto preTy = enumPattern->getParentType()) {
-              return preTy;
+            if (const auto resolvedTy = enumPattern->getParentType()) {
+              assert(resolvedTy->hasUnboundGenericType() == false &&
+                     "A pre-resolved type must be fully bound");
+              return resolvedTy;
             }
             return resolveTypeReferenceInExpression(
                 enumPattern->getParentTypeRepr(),
-                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;
-                });
+                TypeResolverContext::InExpression,
+                OpenUnboundGenericType(
+                    CS, CS.getConstraintLocator(
+                            locator, {LocatorPathElt::PatternMatch(pattern),
+                                      ConstraintLocator::ParentType})));
           }();
 
           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(
@@ -3038,21 +3030,14 @@ namespace {
     Type visitCoerceExpr(CoerceExpr *expr) {
       // Validate the resulting type.
       auto *const repr = expr->getCastTypeRepr();
-      const auto type = resolveTypeReferenceInExpression(
-          repr, TypeResolverContext::ExplicitCastExpr, [](auto unboundTy) {
-            // FIXME: We ought to pass an OpenUnboundGenericType object rather
-            // than calling CS.openUnboundGenericType after resolving, but
-            // sometimes the type expression is resolved eagerly in
-            // PreCheckExpression::simplifyTypeConstructionWithLiteralArg,
-            // letting unbound generics escape.
-            return unboundTy;
-          });
-      if (!type)
+      const auto toType = resolveTypeReferenceInExpression(
+          repr, TypeResolverContext::ExplicitCastExpr,
+          // Introduce type variables for unbound generics.
+          OpenUnboundGenericType(CS, CS.getConstraintLocator(expr)));
+      if (!toType)
         return nullptr;
 
-      // Open the type we're casting to.
-      const auto toType =
-          CS.openUnboundGenericTypes(type, CS.getConstraintLocator(expr));
+      // Cache the type we're casting to.
       if (repr) CS.setType(repr, toType);
 
       auto fromType = CS.getType(expr->getSubExpr());
diff --git a/lib/Sema/TypeCheckPattern.cpp b/lib/Sema/TypeCheckPattern.cpp
@@ -467,31 +467,26 @@ class ResolvePattern : public ASTVisitor<ResolvePattern,
     if (!ExprToIdentTypeRepr(components, Context).visit(ude->getBase()))
       return nullptr;
 
-    const auto options =
-        TypeResolutionOptions(None) | TypeResolutionFlags::SilenceErrors;
+    auto *const repr = IdentTypeRepr::create(Context, components);
 
-    auto *repr = IdentTypeRepr::create(Context, components);
+    // 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;
 
-    // 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());
+    auto *const enumDecl = dyn_cast<EnumDecl>(referencedDecls.front());
     if (!enumDecl)
       return nullptr;
 
-    EnumElementDecl *referencedElement
-      = lookupEnumMemberElement(DC, ty, ude->getName(), ude->getLoc());
+    EnumElementDecl *referencedElement =
+        lookupEnumMemberElement(DC, enumDecl->getDeclaredInterfaceType(),
+                                ude->getName(), ude->getLoc());
     if (!referencedElement)
       return nullptr;
 
-    auto *base =
-        TypeExpr::createForMemberDecl(repr, ude->getNameLoc(), enumDecl);
-    base->setType(MetatypeType::get(ty));
+    auto *const base = new (Context) TypeExpr(repr);
     return new (Context)
         EnumElementPattern(base, ude->getDotLoc(), ude->getNameLoc(),
                            ude->getName(), referencedElement, nullptr);
@@ -569,37 +564,31 @@ 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 *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());
+      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());
       if (!enumDecl)
         return nullptr;
 
-      referencedElement
-        = lookupEnumMemberElement(DC, enumTy,
-                                  tailComponent->getNameRef(),
-                                  tailComponent->getLoc());
+      referencedElement = lookupEnumMemberElement(
+          DC, enumDecl->getDeclaredInterfaceType(), tailComponent->getNameRef(),
+          tailComponent->getLoc());
       if (!referencedElement)
         return nullptr;
 
-      baseTE = TypeExpr::createForMemberDecl(
-          prefixRepr, tailComponent->getNameLoc(), enumDecl);
-      baseTE->setType(MetatypeType::get(enumTy));
+      baseTE = new (Context) TypeExpr(prefixRepr);
     }
 
-    assert(baseTE && baseTE->getType() && "Didn't initialize base expression?");
+    assert(baseTE && "Didn't initialize base expression?");
     assert(!isa<GenericIdentTypeRepr>(tailComponent) &&
            "should be handled above");
 
@@ -1437,11 +1426,25 @@ 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.
-      assert(!EEP->getParentType().isNull()
-             && "enum with resolved element doesn't specify parent type?!");
-      auto parentTy = EEP->getParentType();
+      const Type parentTy = EEP->getParentType();
       // If the type matches exactly, use it.
       if (parentTy->isEqual(type)) {
         enumTy = type;
diff --git a/test/Constraints/patterns.swift b/test/Constraints/patterns.swift
@@ -343,10 +343,14 @@ 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)
+  public enum E: Error {
+    // if you remove associated value, everything works
+    case SomeError(String)
+
+    static func foo(error: Error) {
+      if case SomeError = error {}
     }
+  }
 }
 
 func testOne() {
