Merge pull request #38754 from slavapestov/requirement-machine-concrete-type-with-self-substitution

RequirementMachine: Fix another bug in getTypeFromSubstitutionSchema()

Author: slavapestov

lib/AST/RequirementMachine/PropertyMap.cpp

@@ -155,15 +155,24 @@ static Type getTypeFromSubstitutionSchema(Type schema,
   return schema.transformRec([&](Type t) -> Optional<Type> {
     if (t->is<GenericTypeParamType>()) {
       auto index = getGenericParamIndex(t);
+      auto substitution = substitutions[index];
 
-      // Prepend the prefix of the lookup key to the substitution, skipping
-      // creation of a new MutableTerm in the case where the prefix is empty.
+      // Prepend the prefix of the lookup key to the substitution.
       if (prefix.empty()) {
-        return ctx.getTypeForTerm(substitutions[index], genericParams, protos);
-      } else {
-        MutableTerm substitution(prefix);
-        substitution.append(substitutions[index]);
+        // Skip creation of a new MutableTerm in the case where the
+        // prefix is empty.
         return ctx.getTypeForTerm(substitution, genericParams, protos);
+      } else if (substitution.size() == 1 &&
+                 substitution[0].getKind() == Symbol::Kind::Protocol) {
+        // If the prefix is non-empty and the substitution is the
+        // protocol 'Self' type for some protocol, just use the prefix.
+        return ctx.getTypeForTerm(prefix, genericParams, protos);
+      } else {
+        // Otherwise build a new term by appending the substitution
+        // to the prefix.
+        MutableTerm result(prefix);
+        result.append(substitution);
+        return ctx.getTypeForTerm(result, genericParams, protos);
       }
     }
 

test/Generics/concrete_type_property_of_suffix.swift

@@ -14,3 +14,15 @@ func foo<X : P, Y : P>(_: X, _: Y) {
   // Y.T is Optional<Y.U>.
   sameType(Y.T.self, Y.U?.self)
 }
+
+protocol Q {
+  associatedtype T where T == Self?
+}
+
+func foo<X : Q, Y : Q>(_: X, _: Y) {
+  // X.T is Optional<X>.
+  sameType(X.T.self, X?.self)
+
+  // Y.T is Optional<Y>.
+  sameType(Y.T.self, Y?.self)
+}