Merge pull request swiftlang#60726 from slavapestov/variadic-generics-bits

AST: Plumbing for pack conformances and a few other variadic generics bits

Author: slavapestov

include/swift/AST/ASTContext.h

@@ -1346,6 +1346,13 @@ class ASTContext final {
   CanGenericSignature getOpenedExistentialSignature(Type type,
                                                     GenericSignature parentSig);
 
+  /// Get a generic signature where the generic parameter τ_d_i represents
+  /// the element of the pack generic parameter τ_d_i… in \p baseGenericSig.
+  ///
+  /// This drops the @_typeSequence attribute from each generic parameter,
+  /// and converts same-element requirements to same-type requirements.
+  CanGenericSignature getOpenedElementSignature(CanGenericSignature baseGenericSig);
+
   GenericSignature getOverrideGenericSignature(const ValueDecl *base,
                                                const ValueDecl *derived);
 

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(); }

include/swift/AST/DiagnosticsSema.def

@@ -2344,10 +2344,10 @@ NOTE(protocol_witness_type_conflict,none,
      "candidate has non-matching type %0%1", (Type, StringRef))
 NOTE(protocol_witness_missing_requirement,none,
      "candidate would match if %0 %select{conformed to|subclassed|"
-     "was the same type as}2 %1", (Type, Type, unsigned))
+     "was the same type as|%error|%error}2 %1", (Type, Type, unsigned))
 NOTE(protocol_type_witness_missing_requirement,none,
      "candidate would match if the conformance required that %0 "
-     "%select{conformed to|subclassed|was the same type as}2 %1",
+     "%select{conformed to|subclassed|was the same type as|%error|%error}2 %1",
      (Type, Type, unsigned))
 
 NOTE(protocol_witness_optionality_conflict,none,

include/swift/AST/PackConformance.h

@@ -0,0 +1,99 @@
+//===--- PackConformance.h - Variadic Protocol Conformance ------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the PackConformance structure, which describes the
+// conformance of a type pack parameter to a protocol.
+//
+//===----------------------------------------------------------------------===//
+#ifndef SWIFT_AST_PACKCONFORMANCE_H
+#define SWIFT_AST_PACKCONFORMANCE_H
+
+#include "swift/AST/ASTAllocated.h"
+#include "swift/AST/ProtocolConformanceRef.h"
+#include "swift/AST/Type.h"
+#include "swift/AST/TypeAlignments.h"
+#include "swift/Basic/Compiler.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/FoldingSet.h"
+#include "llvm/Support/TrailingObjects.h"
+
+namespace swift {
+
+class PackType;
+
+class alignas(1 << DeclAlignInBits) PackConformance final
+  : public ASTAllocated<PackConformance>,
+    public llvm::FoldingSetNode,
+    private llvm::TrailingObjects<PackConformance, ProtocolConformanceRef> {
+  friend class ASTContext;
+  friend TrailingObjects;
+
+  /// The pack type conforming to the protocol.
+  PackType *ConformingType;
+
+  /// The conformed-to protocol.
+  ProtocolDecl *Protocol;
+
+public:
+  void Profile(llvm::FoldingSetNodeID &ID) const;
+  static void Profile(llvm::FoldingSetNodeID &ID,
+                      PackType *conformingType,
+                      ProtocolDecl *protocol,
+                      ArrayRef<ProtocolConformanceRef> conformances);
+
+private:
+  PackConformance(PackType *conformingType,
+                  ProtocolDecl *protocol,
+                  ArrayRef<ProtocolConformanceRef> conformances);
+
+  size_t numTrailingObjects(OverloadToken<ProtocolConformanceRef>) const;
+
+public:
+  static PackConformance *get(PackType *conformingType,
+                              ProtocolDecl *protocol,
+                              ArrayRef<ProtocolConformanceRef> conformances);
+
+  PackType *getType() const { return ConformingType; }
+
+  ProtocolDecl *getProtocol() const { return Protocol; }
+
+  ArrayRef<ProtocolConformanceRef> getPatternConformances() const;
+
+  bool isCanonical() const;
+
+  PackConformance *getCanonicalConformance() const;
+
+  PackType *getAssociatedType(Type assocType) const;
+
+  PackConformance *
+  getAssociatedConformance(Type assocType, ProtocolDecl *protocol) const;
+
+  /// The ProtocolConformanceRef either stores a pack conformance, or
+  /// it is invalid in the case of substitution failure.
+  ProtocolConformanceRef subst(SubstitutionMap subMap,
+                               SubstOptions options=None) const;
+
+  /// The ProtocolConformanceRef either stores a pack conformance, or
+  /// it is invalid in the case of substitution failure.
+  ProtocolConformanceRef subst(TypeSubstitutionFn subs,
+                               LookupConformanceFn conformances,
+                               SubstOptions options=None) const;
+
+  SWIFT_DEBUG_DUMP;
+  void dump(llvm::raw_ostream &out, unsigned indent = 0) const;
+};
+
+void simple_display(llvm::raw_ostream &out, PackConformance *conformance);
+
+} // end namespace swift
+
+#endif  // SWIFT_AST_PACKCONFORMANCE_H

include/swift/AST/Pattern.h

@@ -260,9 +260,6 @@ class ParenPattern : public Pattern {
 ///
 /// The fully general form of this is something like:
 ///    label: (pattern) = initexpr
-///
-/// The Init and DefArgKind fields are only used in argument lists for
-/// functions.  They are not parsed as part of normal pattern grammar.
 class TuplePatternElt {
   Identifier Label;
   SourceLoc LabelLoc;
@@ -277,10 +274,6 @@ class TuplePatternElt {
 
   Identifier getLabel() const { return Label; }
   SourceLoc getLabelLoc() const { return LabelLoc; }
-  void setLabel(Identifier I, SourceLoc Loc) {
-    Label = I;
-    LabelLoc = Loc;
-  }
 
   Pattern *getPattern() { return ThePattern; }
   const Pattern *getPattern() const {

include/swift/AST/ProtocolConformanceRef.h

@@ -33,6 +33,7 @@ namespace swift {
 
 class BuiltinProtocolConformance;
 class ConcreteDeclRef;
+class PackConformance;
 class ProtocolConformance;
 enum class EffectKind : uint8_t;
 
@@ -50,7 +51,9 @@ enum class EffectKind : uint8_t;
 /// ProtocolConformanceRef allows the efficient recovery of the protocol
 /// even when the conformance is abstract.
 class ProtocolConformanceRef {
-  using UnionType = llvm::PointerUnion<ProtocolDecl*, ProtocolConformance*>;
+  using UnionType = llvm::PointerUnion<ProtocolDecl *,
+                                       ProtocolConformance *,
+                                       PackConformance *>;
   UnionType Union;
 
   explicit ProtocolConformanceRef(UnionType value) : Union(value) {}
@@ -68,6 +71,12 @@ class ProtocolConformanceRef {
            "cannot construct ProtocolConformanceRef with null");
   }
 
+  /// Create a pack protocol conformance reference.
+  explicit ProtocolConformanceRef(PackConformance *conf) : Union(conf) {
+    assert(conf != nullptr &&
+           "cannot construct ProtocolConformanceRef with null");
+  }
+
   ProtocolConformanceRef(std::nullptr_t = nullptr)
       : Union((ProtocolDecl *)nullptr) {}
 
@@ -98,6 +107,13 @@ class ProtocolConformanceRef {
     return Union.get<ProtocolConformance*>();
   }
 
+  bool isPack() const {
+    return !isInvalid() && Union.is<PackConformance*>();
+  }
+  PackConformance *getPack() const {
+    return Union.get<PackConformance*>();
+  }
+
   bool isAbstract() const {
     return !isInvalid() && Union.is<ProtocolDecl*>();
   }

include/swift/AST/Requirement.h

@@ -58,6 +58,7 @@ class Requirement
   Requirement subst(Args &&...args) const {
     auto newFirst = getFirstType().subst(std::forward<Args>(args)...);
     switch (getKind()) {
+    case RequirementKind::SameCount:
     case RequirementKind::Conformance:
     case RequirementKind::Superclass:
     case RequirementKind::SameType: {

include/swift/AST/RequirementBase.h

@@ -36,8 +36,11 @@ enum class RequirementKind : unsigned {
   /// A layout bound T : L, where T is a type that depends on a generic
   /// parameter and L is some layout specification that should bound T.
   Layout,
+  /// A same-count requirement T.count == U.count, where T and U are pack
+  /// parameters.
+  SameCount
 
-  // Note: there is code that packs this enum in a 2-bit bitfield.  Audit users
+  // Note: there is code that packs this enum in a 3-bit bitfield.  Audit users
   // when adding enumerators.
 };
 
@@ -102,6 +105,7 @@ class RequirementBase {
         hash_value(requirement.FirstTypeAndKind.getOpaqueValue());
     llvm::hash_code second;
     switch (requirement.getKind()) {
+    case RequirementKind::SameCount:
     case RequirementKind::Conformance:
     case RequirementKind::Superclass:
     case RequirementKind::SameType:
@@ -123,6 +127,7 @@ class RequirementBase {
       return false;
 
     switch (lhs.getKind()) {
+    case RequirementKind::SameCount:
     case RequirementKind::Conformance:
     case RequirementKind::Superclass:
     case RequirementKind::SameType:

include/swift/AST/TypeAlignments.h

@@ -46,6 +46,7 @@ namespace swift {
   class NormalProtocolConformance;
   class OpaqueValueExpr;
   class OperatorDecl;
+  class PackConformance;
   class Pattern;
   class ProtocolDecl;
   class ProtocolConformance;
@@ -133,6 +134,7 @@ LLVM_DECLARE_TYPE_ALIGNMENT(swift::Expr, swift::ExprAlignInBits)
 LLVM_DECLARE_TYPE_ALIGNMENT(swift::CaptureListExpr, swift::ExprAlignInBits)
 LLVM_DECLARE_TYPE_ALIGNMENT(swift::AbstractClosureExpr, swift::ExprAlignInBits)
 LLVM_DECLARE_TYPE_ALIGNMENT(swift::OpaqueValueExpr, swift::ExprAlignInBits)
+LLVM_DECLARE_TYPE_ALIGNMENT(swift::PackConformance, swift::DeclAlignInBits)
 LLVM_DECLARE_TYPE_ALIGNMENT(swift::ProtocolConformance, swift::DeclAlignInBits)
 LLVM_DECLARE_TYPE_ALIGNMENT(swift::NormalProtocolConformance,
                             swift::DeclAlignInBits)