CS: Use TypeResolutionStage::Interface for applying generic arguments in 'openUnboundGenericType'

Author: AnthonyLatsis

include/swift/Sema/ConstraintSystem.h

@@ -4037,9 +4037,12 @@ class ConstraintSystem {
   /// parent type by introducing fresh type variables for generic parameters
   /// and constructing a bound generic type from these type variables.
   ///
+  /// \param isTypeResolution Whether we are in the process of resolving a type.
+  ///
   /// \returns The opened type.
   Type openUnboundGenericType(GenericTypeDecl *decl, Type parentTy,
-                              ConstraintLocatorBuilder locator);
+                              ConstraintLocatorBuilder locator,
+                              bool isTypeResolution);
 
   /// Replace placeholder types with fresh type variables, and unbound generic
   /// types with bound generic types whose generic args are fresh type
@@ -5275,7 +5278,8 @@ class OpenUnboundGenericType {
 
   Type operator()(UnboundGenericType *unboundTy) const {
     return cs.openUnboundGenericType(unboundTy->getDecl(),
-                                     unboundTy->getParent(), locator);
+                                     unboundTy->getParent(), locator,
+                                     /*isTypeResolution=*/true);
   }
 };
 

lib/Sema/CSBindings.cpp

@@ -1818,9 +1818,10 @@ bool TypeVarBindingProducer::computeNext() {
       // always preserved.
       auto *BGT = type->castTo<BoundGenericType>();
       auto dstLocator = TypeVar->getImpl().getLocator();
-      auto newType = CS.openUnboundGenericType(BGT->getDecl(), BGT->getParent(),
-                                               dstLocator)
-                         ->reconstituteSugar(/*recursive=*/false);
+      auto newType =
+          CS.openUnboundGenericType(BGT->getDecl(), BGT->getParent(),
+                                    dstLocator, /*isTypeResolution=*/false)
+              ->reconstituteSugar(/*recursive=*/false);
       addNewBinding(binding.withType(newType));
     }
 

lib/Sema/ConstraintSystem.cpp

@@ -628,8 +628,10 @@ Optional<std::pair<unsigned, Expr *>> ConstraintSystem::getExprDepthAndParent(
   return None;
 }
 
-Type ConstraintSystem::openUnboundGenericType(
-    GenericTypeDecl *decl, Type parentTy, ConstraintLocatorBuilder locator) {
+Type ConstraintSystem::openUnboundGenericType(GenericTypeDecl *decl,
+                                              Type parentTy,
+                                              ConstraintLocatorBuilder locator,
+                                              bool isTypeResolution) {
   if (parentTy) {
     parentTy = replaceInferableTypesWithTypeVars(parentTy, locator);
   }
@@ -642,7 +644,15 @@ Type ConstraintSystem::openUnboundGenericType(
   recordOpenedTypes(locator, replacements);
 
   if (parentTy) {
-    auto subs = parentTy->getContextSubstitutions(decl->getDeclContext());
+    const auto parentTyInContext =
+        isTypeResolution
+            // Type resolution produces interface types, so we have to map
+            // the parent type into context before binding type variables.
+            ? DC->mapTypeIntoContext(parentTy)
+            : parentTy;
+
+    const auto subs =
+        parentTyInContext->getContextSubstitutions(decl->getDeclContext());
     for (auto pair : subs) {
       auto found = replacements.find(
         cast<GenericTypeParamType>(pair.first));
@@ -670,9 +680,17 @@ Type ConstraintSystem::openUnboundGenericType(
   // pointing at a generic TypeAliasDecl here. If we find a way to
   // handle generic TypeAliases elsewhere, this can just become a
   // call to BoundGenericType::get().
-  return TypeResolution::forContextual(DC, None, /*unboundTyOpener*/ nullptr,
-                                       /*placeholderHandler*/ nullptr)
-      .applyUnboundGenericArguments(decl, parentTy, SourceLoc(), arguments);
+  auto result =
+      TypeResolution::forInterface(
+          DC, None,
+          [](auto) -> Type { llvm_unreachable("should not be used"); },
+          [](auto &, auto) -> Type { llvm_unreachable("should not be used"); })
+          .applyUnboundGenericArguments(decl, parentTy, SourceLoc(), arguments);
+  if (!parentTy && !isTypeResolution) {
+    result = DC->mapTypeIntoContext(result);
+  }
+
+  return result;
 }
 
 static void checkNestedTypeConstraints(ConstraintSystem &cs, Type type,
@@ -756,15 +774,13 @@ static void checkNestedTypeConstraints(ConstraintSystem &cs, Type type,
 
 Type ConstraintSystem::replaceInferableTypesWithTypeVars(
     Type type, ConstraintLocatorBuilder locator) {
-  assert(!type->getCanonicalType()->hasTypeParameter());
-
   if (!type->hasUnboundGenericType() && !type->hasPlaceholder())
     return type;
 
   type = type.transform([&](Type type) -> Type {
       if (auto unbound = type->getAs<UnboundGenericType>()) {
         return openUnboundGenericType(unbound->getDecl(), unbound->getParent(),
-                                      locator);
+                                      locator, /*isTypeResolution=*/false);
       } else if (auto *placeholderTy = type->getAs<PlaceholderType>()) {
         if (auto *placeholderRepr = placeholderTy->getOriginator()
                                         .dyn_cast<PlaceholderTypeRepr *>()) {

test/Constraints/generics.swift

@@ -930,3 +930,14 @@ func rdar79757320() {
   // expected-error@-1 {{cannot infer contextual base in reference to member 'a'}}
   // expected-error@-2 {{cannot infer contextual base in reference to member 'b'}}
 }
+
+protocol P_eaf0300ff7a {}
+do {
+  struct Outer<T: P_eaf0300ff7a> {
+    struct Inner<U> {}
+
+    func container<T>() -> Inner<T> {
+      return Inner()
+    }
+  }
+}

test/decl/typealias/generic.swift

@@ -132,6 +132,11 @@ class GenericClass<T> {
   typealias TA<U> = MyType<T, U>
   typealias TAI<U> = MyType<Int, U>
 
+  func testNestedUnbound(t: T) {
+    typealias Nested<X, Y> = MyType<X, Y>
+    _ = Nested(a: t, b: t)
+  }
+
   func testCapture<S>(s: S, t: T) -> TA<S> {
     return TA<S>(a: t, b: s)
   }