Merge pull request swiftlang#10163 from slavapestov/fix-generic-typealiases-part-infinity

Sema: Fix a few problems with generic typealiases in protocols

Author: slavapestov

lib/Sema/ConstraintSystem.cpp

@@ -379,7 +379,7 @@ Type ConstraintSystem::openUnboundGenericType(UnboundGenericType *unbound,
 
   if (parentTy) {
     auto subs = parentTy->getContextSubstitutions(
-      parentTy->getAnyNominal());
+      unboundDecl->getDeclContext());
     for (auto pair : subs) {
       auto found = replacements.find(
         cast<GenericTypeParamType>(pair.first));

lib/Sema/TypeCheckType.cpp

@@ -456,14 +456,11 @@ Type TypeChecker::resolveTypeInContext(
             ->castTo<GenericTypeParamType>());
   }
 
-  bool hasDependentType = typeDecl->getDeclaredInterfaceType()
-    ->hasTypeParameter();
-
   // Simple case -- the type is not nested inside of another type.
   // However, it might be nested inside another generic context, so
   // we do want to write the type in terms of interface types or
   // context archetypes, depending on the resolver given to us.
-  if (!selfType || !hasDependentType) {
+  if (!selfType) {
     if (auto *aliasDecl = dyn_cast<TypeAliasDecl>(typeDecl)) {
       // For a generic typealias, return the unbound generic form of the type.
       if (aliasDecl->getGenericParams())
@@ -478,7 +475,7 @@ Type TypeChecker::resolveTypeInContext(
     if (auto *nominalDecl = dyn_cast<NominalTypeDecl>(typeDecl))
       return nominalDecl->getDeclaredType();
 
-    assert(!hasDependentType);
+    assert(isa<ModuleDecl>(typeDecl));
     return typeDecl->getDeclaredInterfaceType();
   }
 
@@ -662,20 +659,28 @@ Type TypeChecker::applyUnboundGenericArguments(
   // generic arguments.
   auto resultType = decl->getDeclaredInterfaceType();
 
+  bool hasTypeParameterOrVariable = false;
+
   // Get the substitutions for outer generic parameters from the parent
-  // type, but skip the step if the result type does not contain any
-  // substitutable type parameters.
-  if (resultType->hasTypeParameter())
-    if (auto parentType = unboundType->getParent())
-      subs = parentType->getContextSubstitutions(decl->getDeclContext());
+  // type.
+  if (auto parentType = unboundType->getParent()) {
+    if (parentType->hasUnboundGenericType()) {
+      assert(!resultType->hasTypeParameter());
+      return resultType;
+    }
+
+    subs = parentType->getContextSubstitutions(decl->getDeclContext());
+
+    hasTypeParameterOrVariable |=
+      (parentType->hasTypeParameter() || parentType->hasTypeVariable());
+  }
 
   SourceLoc noteLoc = decl->getLoc();
   if (noteLoc.isInvalid())
     noteLoc = loc;
 
   // Realize the types of the generic arguments and add them to the
   // substitution map.
-  bool hasTypeParameterOrVariable = false;
   for (unsigned i = 0, e = genericArgs.size(); i < e; i++) {
     auto &genericArg = genericArgs[i];
 

test/decl/typealias/generic.swift

@@ -338,12 +338,64 @@ class AnotherGeneric<T> {}
 
 protocol P {
   associatedtype A
-  typealias G1<T> = MyType<Self, T>
-  typealias G2<T> = MyType<T, A>
+  typealias G1<T> = MyType<Self, T> // expected-note {{did you mean 'G1'?}}
+  typealias G2<T> = MyType<T, A> // expected-note {{did you mean 'G2'?}}
+  typealias G3<T> = () -> () // expected-note {{did you mean 'G3'?}}
+  typealias G4<T> = (T) -> () // expected-note {{did you mean 'G4'?}}
+
+  func firstRequirement(_: G1<Int>)
+  func secondRequirement(_: G2<Int>)
+  func thirdRequirement(_: G3<Int>)
+  func fourthRequirement(_: G4<Int>)
+
+  func firstRequirementGeneric<T>(_: G1<T>)
+  func secondRequirementGeneric<T>(_: G2<T>)
+  func thirdRequirementGeneric<T>(_: G3<T>, _: T)
+  func fourthRequirementGeneric<T>(_: G4<T>)
 }
 
 struct S : P {
   typealias A = Float
+
+  func shouldFail(fn: (Int) -> ()) {
+    thirdRequirement(fn)
+    // expected-error@-1 {{cannot convert value of type '(Int) -> ()' to expected argument type '() -> ()'}}
+  }
+
+  func firstRequirement(_: G1<Int>) {}
+  func secondRequirement(_: G2<Int>) {}
+  func thirdRequirement(_: G3<Int>) {}
+  func fourthRequirement(_: G4<Int>) {}
+
+  func firstRequirementGeneric<T>(_: G1<T>) {
+    _ = G1<T>.self // FIXME // expected-error {{use of unresolved identifier 'G1'}}
+  }
+
+  func secondRequirementGeneric<T>(_: G2<T>) {
+    _ = G2<T>.self // FIXME // expected-error {{use of unresolved identifier 'G2'}}
+  }
+
+  func thirdRequirementGeneric<T>(_: G3<T>, _: T) {
+    _ = G3<T>.self // FIXME // expected-error {{use of unresolved identifier 'G3'}}
+  }
+
+  func fourthRequirementGeneric<T>(_: G4<T>) {
+    _ = G4<T>.self // FIXME // expected-error {{use of unresolved identifier 'G4'}}
+  }
+
+  func expressionContext() {
+    let _: G1 = MyType<S, Int>(a: S(), b: 3)
+    let _: G1<Int> = MyType<S, Int>(a: S(), b: 3)
+
+    let _: S.G1 = MyType<S, Int>(a: S(), b: 3)
+    let _: S.G1<Int> = MyType<S, Int>(a: S(), b: 3)
+
+    let _: G2 = MyType<Int, Float>(a: 3, b: 1.0)
+    let _: G2<Int> = MyType<Int, Float>(a: 3, b: 1.0)
+
+    let _: S.G2 = MyType<Int, Float>(a: 3, b: 1.0)
+    let _: S.G2<Int> = MyType<Int, Float>(a: 3, b: 1.0)
+  }
 }
 
 func takesMyType(x: MyType<S, Int>) {}