AST: Introduce @tuple (T) syntax for one-element tuples in SIL mode

Author: slavapestov

include/swift/AST/Attr.def

@@ -58,6 +58,7 @@ TYPE_ATTR(Sendable)
 TYPE_ATTR(unchecked)
 TYPE_ATTR(_typeSequence)
 TYPE_ATTR(_local)
+TYPE_ATTR(tuple)
 
 // SIL-specific attributes
 TYPE_ATTR(block_storage)

include/swift/AST/Attr.h

@@ -2504,6 +2504,9 @@ class TypeAttributes {
   };
   Optional<OpaqueReturnTypeRef> OpaqueReturnTypeOf;
 
+  // Force construction of a one-element tuple type.
+  bool IsTuple = false;
+
   TypeAttributes() {}
 
   bool isValid() const { return AtLoc.isValid(); }

lib/AST/ASTPrinter.cpp

@@ -5549,6 +5549,12 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     Printer.callPrintStructurePre(PrintStructureKind::TupleType);
     SWIFT_DEFER { Printer.printStructurePost(PrintStructureKind::TupleType); };
 
+    // Single-element tuples can only appear in SIL mode.
+    if (T->getNumElements() == 1 &&
+        !T->getElement(0).hasName()) {
+      Printer << "@tuple ";
+    }
+
     Printer << "(";
 
     auto Fields = T->getElements();

lib/AST/TypeRepr.cpp

@@ -257,6 +257,9 @@ void AttributedTypeRepr::printAttrs(ASTPrinter &Printer,
     Printer.printSimpleAttr("@async") << " ";
   if (hasAttr(TAK_opened))
     Printer.printSimpleAttr("@opened") << " ";
+
+  if (hasAttr(TAK_tuple))
+    Printer.printSimpleAttr("@tuple") << " ";
 }
 
 IdentTypeRepr *IdentTypeRepr::create(ASTContext &C,

lib/Parse/ParseDecl.cpp

@@ -3798,6 +3798,15 @@ ParserStatus Parser::parseTypeAttribute(TypeAttributes &Attributes,
     Attributes.setOpaqueReturnTypeOf(mangling, index);
     break;
   }
+
+  case TAK_tuple: {
+    if (!isInSILMode()) {
+      diagnose(AtLoc, diag::only_allowed_in_sil, "tuple");
+      return makeParserSuccess();
+    }
+
+    Attributes.IsTuple = true;
+  }
   }
 
   Attributes.setAttr(attr, AtLoc);

lib/Sema/TypeCheckType.cpp

@@ -2860,6 +2860,18 @@ TypeResolver::resolveAttributedType(TypeAttributes &attrs, TypeRepr *repr,
   if (!ty) ty = resolveType(repr, instanceOptions);
   if (!ty || ty->hasError()) return ty;
 
+  // In SIL mode only, build one-element tuples.
+  if (attrs.has(TAK_tuple)) {
+    SmallVector<TupleTypeElt, 1> elements;
+    if (auto *parenTy = dyn_cast<ParenType>(ty.getPointer()))
+      ty = parenTy->getUnderlyingType();
+
+    elements.emplace_back(ty);
+    ty = TupleType::get(elements, getASTContext());
+
+    attrs.clearAttribute(TAK_tuple);
+  }
+
   // Type aliases inside protocols are not yet resolved in the structural
   // stage of type resolution
   if (ty->is<DependentMemberType>() &&

test/SIL/Parser/one_element_tuple.sil

@@ -0,0 +1,19 @@
+// RUN: %target-sil-opt %s | %target-sil-opt | %FileCheck %s
+
+sil_stage canonical
+
+import Swift
+
+// CHECK-LABEL: sil [ossa] @tuple_test : $@convention(thin) (@tuple (Int)) -> @tuple (Int) {
+// CHECK:       bb0(%0 : $@tuple (Int)):
+// CHECK-NEXT:    %1 = tuple_extract %0 : $@tuple (Int), 0
+// CHECK-NEXT:    %2 = tuple (%1 : $Int)
+// CHECK-NEXT:    return %2 : $@tuple (Int)
+// CHECK-NEXT:  }
+
+sil [ossa] @tuple_test : $@convention(thin) (@tuple (Int)) -> @tuple (Int) {
+bb0(%0 : $@tuple (Int)):
+  %1 = tuple_extract %0 : $@tuple (Int), 0
+  %2 = tuple $@tuple (Int) (%1)
+  return %2 : $@tuple (Int)
+}