AST: Unwrap one-element tuple conformances

Author: slavapestov

lib/AST/ASTContext.cpp

@@ -2731,6 +2731,13 @@ ASTContext::getSpecializedConformance(Type type,
   if (auto result = specializedConformances.FindNodeOrInsertPos(id, insertPos))
     return result;
 
+  // Vanishing tuple conformances must be handled by the caller.
+  if (isa<BuiltinTupleDecl>(generic->getDeclContext()->getSelfNominalTypeDecl())) {
+    assert(type->is<TupleType>() && "Vanishing tuple substitution is not "
+           "here. Did you mean to use ProtocolConformanceRef::subst() "
+           "instead?");
+  }
+
   // Build a new specialized conformance.
   auto result
     = new (*this, arena) SpecializedProtocolConformance(type, generic,

lib/AST/ProtocolConformance.cpp

@@ -25,6 +25,7 @@
 #include "swift/AST/InFlightSubstitution.h"
 #include "swift/AST/LazyResolver.h"
 #include "swift/AST/Module.h"
+#include "swift/AST/PackConformance.h"
 #include "swift/AST/TypeCheckRequests.h"
 #include "swift/AST/Types.h"
 #include "swift/Basic/Statistic.h"
@@ -933,6 +934,38 @@ ProtocolConformance::subst(TypeSubstitutionFn subs,
   return subst(IFS);
 }
 
+/// Check if the replacement is a one-element pack with a scalar type.
+static bool isVanishingTupleConformance(
+    RootProtocolConformance *generic,
+    SubstitutionMap substitutions) {
+  if (!isa<BuiltinTupleDecl>(generic->getDeclContext()->getSelfNominalTypeDecl()))
+    return false;
+
+  auto replacementTypes = substitutions.getReplacementTypes();
+  assert(replacementTypes.size() == 1);
+  auto packType = replacementTypes[0]->castTo<PackType>();
+
+  return (packType->getNumElements() == 1 &&
+          !packType->getElementTypes()[0]->is<PackExpansionType>());
+}
+
+/// Don't form a tuple conformance if the substituted type is unwrapped
+/// from a one-element tuple.
+///
+/// That is, [(repeat each T): P] ⊗ {each T := Pack{U};
+///                                  [each T: P]: Pack{ [U: P] }}
+///                 => [U: P]
+static ProtocolConformanceRef unwrapVanishingTupleConformance(
+    SubstitutionMap substitutions) {
+  auto conformances = substitutions.getConformances();
+  assert(conformances.size() == 1);
+  assert(conformances[0].isPack());
+  auto packConformance = conformances[0].getPack();
+
+  assert(packConformance->getPatternConformances().size() == 1);
+  return packConformance->getPatternConformances()[0];
+}
+
 ProtocolConformanceRef
 ProtocolConformance::subst(InFlightSubstitution &IFS) const {
   auto *mutableThis = const_cast<ProtocolConformance *>(this);
@@ -951,6 +984,9 @@ ProtocolConformance::subst(InFlightSubstitution &IFS) const {
     auto *generic = cast<NormalProtocolConformance>(mutableThis);
     auto subMap = SubstitutionMap::get(getGenericSignature(), IFS);
 
+    if (isVanishingTupleConformance(generic, subMap))
+      return unwrapVanishingTupleConformance(subMap);
+
     auto &ctx = substType->getASTContext();
     auto *concrete = ctx.getSpecializedConformance(substType, generic, subMap);
 
@@ -1016,6 +1052,9 @@ ProtocolConformance::subst(InFlightSubstitution &IFS) const {
     auto *generic = spec->getGenericConformance();
     auto subMap = spec->getSubstitutionMap().subst(IFS);
 
+    if (isVanishingTupleConformance(generic, subMap))
+      return unwrapVanishingTupleConformance(subMap);
+
     auto substType = spec->getType().subst(IFS);
 
     auto &ctx = substType->getASTContext();

test/SILOptimizer/tuple-conformances.swift

@@ -0,0 +1,48 @@
+// RUN: %target-swift-frontend -emit-sil %s -enable-experimental-feature TupleConformances | %FileCheck %s
+
+public typealias Tuple<each T> = (repeat each T)
+
+public protocol P {
+  static func protocolMethod()
+}
+
+extension Tuple: P where repeat each T: P {
+  public static func protocolMethod() {}
+}
+
+extension Int: P {
+  public static func protocolMethod() {}
+}
+
+public func callee<T: P>(t: T.Type) {
+}
+
+@_transparent
+public func transparentCallee<T: P>(t: T.Type) {
+  t.protocolMethod()
+}
+
+@_transparent public func transparentCaller<each T: P>(tuple: (repeat each T).Type) {
+  callee(t: tuple)
+  transparentCallee(t: tuple)
+  tuple.protocolMethod()
+}
+
+// Inlining transparentCaller() into caller() exercises the code path to unwrap
+// a one-element tuple conformance.
+
+public func caller() {
+  transparentCaller(tuple: Int.self)
+}
+
+// CHECK-LABEL: sil @$s4main6calleryyF : $@convention(thin) () -> () {
+// CHECK: [[FN:%.*]] = function_ref @$s4main6callee1tyxm_tAA1PRzlF : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@thick τ_0_0.Type) -> ()
+// CHECK: apply [[FN]]<Int>({{.*}}) : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@thick τ_0_0.Type) -> ()
+
+// FIXME: These should call Int.protocolMethod()!
+
+// CHECK: [[FN:%.*]] = function_ref @$sBT4mainRvzAA1PRzlE14protocolMethodyyFZ : $@convention(method) <each τ_0_0 where repeat each τ_0_0 : P> (@thin (repeat each τ_0_0).Type) -> ()
+// CHECK: apply [[FN]]<Pack{Int}>(%4) : $@convention(method) <each τ_0_0 where repeat each τ_0_0 : P> (@thin (repeat each τ_0_0).Type) -> ()
+
+// CHECK: [[FN:%.*]] = function_ref @$sBT4mainRvzAA1PRzlE14protocolMethodyyFZ : $@convention(method) <each τ_0_0 where repeat each τ_0_0 : P> (@thin (repeat each τ_0_0).Type) -> ()
+// CHECK: apply [[FN]]<Pack{Int}>(%0) : $@convention(method) <each τ_0_0 where repeat each τ_0_0 : P> (@thin (repeat each τ_0_0).Type) -> ()