AST: Introduce special Builtin.TheTupleType singleton

Author: slavapestov

include/swift/AST/ASTContext.h

@@ -66,6 +66,7 @@ namespace swift {
   enum class Associativity : unsigned char;
   class AvailabilityContext;
   class BoundGenericType;
+  class BuiltinTupleDecl;
   class ClangModuleLoader;
   class ClangNode;
   class ClangTypeConverter;
@@ -953,7 +954,7 @@ class ASTContext final {
   const CanType TheIEEE80Type;            /// 80-bit IEEE floating point
   const CanType TheIEEE128Type;           /// 128-bit IEEE floating point
   const CanType ThePPC128Type;            /// 128-bit PowerPC 2xDouble
-  
+
   /// Adds a search path to SearchPathOpts, unless it is already present.
   ///
   /// Does any proper bookkeeping to keep all module loaders up to date as well.
@@ -1421,6 +1422,13 @@ class ASTContext final {
   /// invocation decoder of the given distributed actor.
   FuncDecl *getDistributedActorArgumentDecodingMethod(NominalTypeDecl *);
 
+  /// The special Builtin.TheTupleType, which parents tuple extensions and
+  /// conformances.
+  BuiltinTupleDecl *getBuiltinTupleDecl();
+
+  /// The declared interface type of Builtin.TheTupleType.
+  BuiltinTupleType *getBuiltinTupleType();
+
 private:
   friend Decl;
 

include/swift/AST/Decl.h

@@ -4755,6 +4755,48 @@ class ProtocolDecl final : public NominalTypeDecl {
   }
 };
 
+/// This is the special singleton Builtin.TheTupleType. It is not directly
+/// visible in the source language, but we use it to attach extensions
+/// and conformances for tuple types.
+///
+/// - The declared interface type is the special TheTupleType singleton.
+/// - The generic parameter list has one pack generic parameter, <Elements...>
+/// - The generic signature has no requirements, <Elements...>
+/// - The self interface type is the tuple type containing a single pack
+///   expansion, (Elements...).
+class BuiltinTupleDecl final : public NominalTypeDecl {
+  TupleType *TupleSelfType = nullptr;
+
+public:
+  BuiltinTupleDecl(Identifier Name, DeclContext *Parent);
+
+  SourceRange getSourceRange() const {
+    return SourceRange();
+  }
+
+  TupleType *getTupleSelfType() const;
+
+  // Implement isa/cast/dyncast/etc.
+  static bool classof(const Decl *D) {
+    return D->getKind() == DeclKind::BuiltinTuple;
+  }
+  static bool classof(const GenericTypeDecl *D) {
+    return D->getKind() == DeclKind::BuiltinTuple;
+  }
+  static bool classof(const NominalTypeDecl *D) {
+    return D->getKind() == DeclKind::BuiltinTuple;
+  }
+  static bool classof(const DeclContext *C) {
+    if (auto D = C->getAsDecl())
+      return classof(D);
+    return false;
+  }
+  static bool classof(const IterableDeclContext *C) {
+    auto NTD = dyn_cast<NominalTypeDecl>(C);
+    return NTD && classof(NTD);
+  }
+};
+
 /// AbstractStorageDecl - This is the common superclass for VarDecl and
 /// SubscriptDecl, representing potentially settable memory locations.
 class AbstractStorageDecl : public ValueDecl {

include/swift/AST/DeclNodes.def

@@ -151,7 +151,8 @@ ABSTRACT_DECL(Value, Decl)
         NOMINAL_TYPE_DECL(Struct, NominalTypeDecl)
         NOMINAL_TYPE_DECL(Class, NominalTypeDecl)
         NOMINAL_TYPE_DECL(Protocol, NominalTypeDecl)
-        DECL_RANGE(NominalType, Enum, Protocol)
+        NOMINAL_TYPE_DECL(BuiltinTuple, NominalTypeDecl)
+        DECL_RANGE(NominalType, Enum, BuiltinTuple)
       GENERIC_VALUE_DECL(OpaqueType, GenericTypeDecl)
       GENERIC_VALUE_DECL(TypeAlias, GenericTypeDecl)
       DECL_RANGE(GenericType, Enum, TypeAlias)

include/swift/AST/KnownIdentifiers.def

@@ -75,6 +75,7 @@ IDENTIFIER_WITH_NAME(PatternMatchVar, "$match")
 IDENTIFIER(dynamicallyCall)
 IDENTIFIER(dynamicMember)
 IDENTIFIER(Element)
+IDENTIFIER(Elements)
 IDENTIFIER_(enclosingInstance)
 IDENTIFIER(Encodable)
 IDENTIFIER(encode)
@@ -313,6 +314,9 @@ IDENTIFIER_WITH_NAME(TypeWrapperProperty, "$_storage")
 IDENTIFIER(storageKeyPath)
 IDENTIFIER(memberwise)
 
+// The singleton instance of TupleTypeDecl in the Builtin module
+IDENTIFIER(TheTupleType)
+
 #undef IDENTIFIER
 #undef IDENTIFIER_
 #undef IDENTIFIER_WITH_NAME

include/swift/AST/TypeNodes.def

@@ -128,7 +128,8 @@ ABSTRACT_TYPE(AnyGeneric, Type)
       TYPE(Struct, NominalType)
       TYPE(Class, NominalType)
       TYPE(Protocol, NominalType)
-      TYPE_RANGE(Nominal, Enum, Protocol)
+      TYPE(BuiltinTuple, NominalType)
+      TYPE_RANGE(Nominal, Enum, BuiltinTuple)
     ABSTRACT_TYPE(BoundGeneric, Type)
       TYPE(BoundGenericClass, BoundGenericType)
       TYPE(BoundGenericEnum, BoundGenericType)

include/swift/AST/Types.h

@@ -58,6 +58,7 @@ class ArgumentList;
 class AssociatedTypeDecl;
 class ASTContext;
 enum BufferPointerTypeKind : unsigned;
+class BuiltinTupleDecl;
 class ClassDecl;
 class ClangModuleLoader;
 class DependentMemberType;
@@ -5489,6 +5490,23 @@ BEGIN_CAN_TYPE_WRAPPER(ExistentialType, Type)
   PROXY_CAN_TYPE_SIMPLE_GETTER(getConstraintType)
 END_CAN_TYPE_WRAPPER(ExistentialType, Type)
 
+
+/// BuiltinTupleType - A singleton nominal type which serves as the declared
+/// interface type of Builtin.TheTupleType.
+class BuiltinTupleType : public NominalType {
+public:
+  // Implement isa/cast/dyncast/etc.
+  static bool classof(const TypeBase *T) {
+    return T->getKind() == TypeKind::BuiltinTuple;
+  }
+
+private:
+  friend class ASTContext;
+  BuiltinTupleType(BuiltinTupleDecl *TheDecl, const ASTContext &Ctx);
+};
+BEGIN_CAN_TYPE_WRAPPER(BuiltinTupleType, NominalType)
+END_CAN_TYPE_WRAPPER(BuiltinTupleType, NominalType)
+
 /// LValueType - An l-value is a handle to a physical object.  The
 /// type of that object uniquely determines the type of an l-value
 /// for it.

lib/AST/ASTContext.cpp

@@ -552,6 +552,12 @@ struct ASTContext::Implementation {
 
   /// Memory allocation arena for the term rewriting system.
   std::unique_ptr<rewriting::RewriteContext> TheRewriteContext;
+
+  /// The singleton Builtin.TheTupleType.
+  BuiltinTupleDecl *TheTupleTypeDecl = nullptr;
+
+  /// The declared interface type of Builtin.TheTupleType.
+  BuiltinTupleType *TheTupleType = nullptr;
 };
 
 ASTContext::Implementation::Implementation()
@@ -4511,6 +4517,11 @@ Type ExistentialType::get(Type constraint) {
                                                 properties);
 }
 
+BuiltinTupleType::BuiltinTupleType(BuiltinTupleDecl *TheDecl,
+                                   const ASTContext &Ctx)
+  : NominalType(TypeKind::BuiltinTuple, &Ctx, TheDecl, Type(),
+                RecursiveTypeProperties()) { }
+
 LValueType *LValueType::get(Type objectTy) {
   assert(!objectTy->is<LValueType>() && !objectTy->is<InOutType>() &&
          "cannot have 'inout' or @lvalue wrapped inside an @lvalue");
@@ -5914,3 +5925,30 @@ bool ASTContext::isASCIIString(StringRef s) const {
   }
   return true;
 }
+
+/// The special Builtin.TheTupleType, which parents tuple extensions and
+/// conformances.
+BuiltinTupleDecl *ASTContext::getBuiltinTupleDecl() {
+  auto &result = getImpl().TheTupleTypeDecl;
+
+  if (result)
+    return result;
+
+  result = new (*this) BuiltinTupleDecl(Id_TheTupleType,
+                                        TheBuiltinModule->getFiles()[0]);
+  result->setAccess(AccessLevel::Public);
+
+  return result;
+}
+
+/// The declared interface type of Builtin.TheTupleType.
+BuiltinTupleType *ASTContext::getBuiltinTupleType() {
+  auto &result = getImpl().TheTupleType;
+
+  if (result)
+    return result;
+
+  result = new (*this) BuiltinTupleType(getBuiltinTupleDecl(), *this);
+
+  return result;
+}

lib/AST/ASTDumper.cpp

@@ -847,6 +847,11 @@ namespace {
       printCommonPost(CD);
     }
 
+    void visitBuiltinTupleDecl(BuiltinTupleDecl *BTD) {
+      printCommon(BTD, "builtin_tuple_decl");
+      printCommonPost(BTD);
+    }
+
     void visitPatternBindingDecl(PatternBindingDecl *PBD) {
       printCommon(PBD, "pattern_binding_decl");
 
@@ -3800,6 +3805,12 @@ namespace {
       PrintWithColorRAII(OS, ParenthesisColor) << ')';
     }
 
+    void visitBuiltinTupleType(BuiltinTupleType *T, StringRef label) {
+      printCommon(label, "builtin_tuple_type");
+      printField("decl", T->getDecl()->printRef());
+      PrintWithColorRAII(OS, ParenthesisColor) << ')';
+    }
+
     void visitMetatypeType(MetatypeType *T, StringRef label) {
       printCommon(label, "metatype_type");
       if (T->hasRepresentation())

lib/AST/ASTMangler.cpp

@@ -1324,6 +1324,9 @@ void ASTMangler::appendType(Type type, GenericSignature sig,
       return appendType(ET->getConstraintType(), sig, forDecl);
     }
 
+    case TypeKind::BuiltinTuple:
+      llvm_unreachable("Not implemented");
+
     case TypeKind::UnboundGeneric:
     case TypeKind::Class:
     case TypeKind::Enum:
@@ -2554,6 +2557,8 @@ void ASTMangler::appendAnyGenericType(const GenericTypeDecl *decl) {
     case DeclKind::Struct:
       appendOperator("V");
       break;
+    case DeclKind::BuiltinTuple:
+      llvm_unreachable("Not implemented");
     }
   }
 

lib/AST/ASTPrinter.cpp

@@ -3673,6 +3673,11 @@ void PrintAST::visitProtocolDecl(ProtocolDecl *decl) {
                        Options.BracketOptions.shouldCloseNominal(decl));
   }
 }
+
+void PrintAST::visitBuiltinTupleDecl(BuiltinTupleDecl *decl) {
+  llvm_unreachable("Not implemented");
+}
+
 static bool isStructOrClassContext(DeclContext *dc) {
   auto *nominal = dc->getSelfNominalTypeDecl();
   if (nominal == nullptr)
@@ -6334,6 +6339,10 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     }
   }
 
+  void visitBuiltinTupleType(BuiltinTupleType *T) {
+    printQualifiedType(T);
+  }
+
   void visitLValueType(LValueType *T) {
     Printer << "@lvalue ";
     visit(T->getObjectType());