Sema: Remove the older '@tuple (Int)' syntax

Author: slavapestov

include/swift/AST/Attr.def

@@ -58,7 +58,6 @@ 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

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

include/swift/AST/DiagnosticsSema.def

@@ -5179,8 +5179,6 @@ ERROR(opened_bad_interface_type,none,
       "@opened interface type %0 is not a type parameter", (Type))
 ERROR(sil_function_input_label,PointsToFirstBadToken,
       "SIL function types cannot have labeled inputs", ())
-ERROR(sil_function_output_label,PointsToFirstBadToken,
-      "SIL function types cannot have labeled results", ())
 ERROR(sil_non_coro_yields,PointsToFirstBadToken,
       "non-coroutine SIL function types cannot have @yield results", ())
 ERROR(sil_function_repeat_convention,PointsToFirstBadToken,

lib/AST/ASTPrinter.cpp

@@ -5568,13 +5568,6 @@ 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() &&
-        !T->getElementType(0)->is<PackExpansionType>()) {
-      Printer << "@tuple ";
-    }
-
     Printer << "(";
 
     auto Fields = T->getElements();
@@ -5592,6 +5585,10 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       if (TD.hasName()) {
         Printer.printName(TD.getName(), PrintNameContext::TupleElement);
         Printer << ": ";
+      } else if (e == 1 && !EltType->is<PackExpansionType>()) {
+        // Unlabeled one-element tuples always print the empty label to
+        // distinguish them from the older syntax for ParenType.
+        Printer << "_: ";
       }
       visit(EltType);
     }

lib/AST/TypeRepr.cpp

@@ -261,9 +261,6 @@ 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

@@ -3945,15 +3945,6 @@ 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/SIL/Parser/ParseSIL.cpp

@@ -4736,7 +4736,7 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
         return true;
 
       unsigned Field = 0;
-      TupleType *TT = Val->getType().getAs<TupleType>();
+      TupleType *TT = Val->getType().castTo<TupleType>();
       if (P.Tok.isNot(tok::integer_literal) ||
           parseIntegerLiteral(P.Tok.getText(), 10, Field) ||
           Field >= TT->getNumElements()) {

lib/Sema/TypeCheckType.cpp

@@ -2925,18 +2925,6 @@ 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>() &&
@@ -3780,19 +3768,28 @@ bool TypeResolver::resolveSILResults(TypeRepr *repr,
                                 SmallVectorImpl<SILResultInfo> &ordinaryResults,
                                 Optional<SILResultInfo> &errorResult) {
   if (auto tuple = dyn_cast<TupleTypeRepr>(repr)) {
-    bool hadError = false;
+    // If any of the elements have a label, or an explicit missing label (_:),
+    // resolve the entire result type as a single tuple type.
     for (auto &element : tuple->getElements()) {
-      if (element.UnderscoreLoc.isValid())
-        diagnose(element.UnderscoreLoc, diag::sil_function_output_label);
+      if (element.NameLoc.isValid()) {
+        return resolveSingleSILResult(repr, options,
+                                      yields, ordinaryResults, errorResult);
+      }
     }
+
+    // Otherwise, resolve each tuple element into its own result type.
+    bool hadError = false;
+
     for (auto elt : tuple->getElements()) {
       if (resolveSingleSILResult(elt.Type, options,
                                  yields, ordinaryResults, errorResult))
         hadError = true;
     }
+
     return hadError;
   }
 
+  // Not a tuple type.
   return resolveSingleSILResult(repr, options,
                                 yields, ordinaryResults, errorResult);
 }
@@ -4199,7 +4196,8 @@ NeverNullType TypeResolver::resolveTupleType(TupleTypeRepr *repr,
     diagnose(repr->getLoc(), diag::tuple_duplicate_label);
   }
 
-  if (ctx.LangOpts.hasFeature(Feature::VariadicGenerics)) {
+  if (options.contains(TypeResolutionFlags::SILType) ||
+      ctx.LangOpts.hasFeature(Feature::VariadicGenerics)) {
     if (repr->isParenType())
       return ParenType::get(ctx, elements[0].getType());
   } else {

test/SIL/Parser/one_element_tuple.sil

@@ -4,16 +4,16 @@ 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-LABEL: sil [ossa] @tuple_test : $@convention(thin) ((_: Int)) -> (_: Int) {
+// CHECK:       bb0(%0 : $(_: Int)):
+// CHECK-NEXT:    %1 = tuple_extract %0 : $(_: Int), 0
 // CHECK-NEXT:    %2 = tuple (%1 : $Int)
-// CHECK-NEXT:    return %2 : $@tuple (Int)
+// CHECK-NEXT:    return %2 : $(_: 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)
+sil [ossa] @tuple_test : $@convention(thin) ((_: Int)) -> (_: Int) {
+bb0(%0 : $(_: Int)):
+  %1 = tuple_extract %0 : $(_: Int), 0
+  %2 = tuple $(_: Int) (%1)
+  return %2 : $(_: Int)
 }