Remove Value requirement Add GenericTypeParamKind

Author: Azoy

docs/ABI/Mangling.rst

@@ -1012,11 +1012,18 @@ now codified into the ABI; the index 0 is therefore reserved.
 
 ::
 
-  generic-signature ::= requirement* generic-param-pack-marker* 'l'     // one generic parameter
-  generic-signature ::= requirement* generic-param-pack-marker* 'r' GENERIC-PARAM-COUNT* 'l'
+  generic-signature ::= requirement* generic-param-marker 'l'     // one generic parameter
+  generic-signature ::= requirement* generic-param-marker* 'r' GENERIC-PARAM-COUNT* 'l'
+
+  generic-param-marker ::= generic-param-pack-marker
+  generic-param-marker ::= generic-param-value-marker
 
   generic-param-pack-marker ::= 'Rv' GENERIC_PARAM-INDEX   // generic parameter pack marker
 
+#if SWIFT_RUNTIME_VERSION >= 6.TBD
+  generic-param-value-marker ::= type 'RV' GENERIC-PARAM-INDEX // generic parameter value marker
+#endif
+
   GENERIC-PARAM-COUNT ::= 'z'                // zero parameters
   GENERIC-PARAM-COUNT ::= INDEX              // N+1 parameters
 
@@ -1045,10 +1052,6 @@ now codified into the ABI; the index 0 is therefore reserved.
 
   requirement ::= type 'Rh' GENERIC-PARAM-INDEX                     // same-shape requirement (only supported on a generic parameter)
 
-#if SWIFT_RUNTIME_VERSION >= 6.TBD
-  requirement ::= type 'RV' GENERIC-PARAM-INDEX                     // value requirement
-#endif
-
   GENERIC-PARAM-INDEX ::= 'z'                // depth = 0,   idx = 0
   GENERIC-PARAM-INDEX ::= INDEX              // depth = 0,   idx = N+1
   GENERIC-PARAM-INDEX ::= 'd' INDEX INDEX    // depth = M+1, idx = N

include/swift/AST/ASTBridging.h

@@ -1896,11 +1896,11 @@ BridgedGenericParamList BridgedGenericParamList_createParsed(
     BridgedSourceLoc cRightAngleLoc);
 
 SWIFT_NAME(
-    "BridgedGenericTypeParamDecl.createParsed(_:declContext:eachKeywordLoc:"
-    "letKeywordLoc:name:nameLoc:inheritedType:index:)")
+    "BridgedGenericTypeParamDecl.createParsed(_:declContext:specifierLoc:"
+    "name:nameLoc:inheritedType:index:)")
 BridgedGenericTypeParamDecl BridgedGenericTypeParamDecl_createParsed(
     BridgedASTContext cContext, BridgedDeclContext cDeclContext,
-    BridgedSourceLoc cEachLoc, BridgedSourceLoc cLetLoc, BridgedIdentifier cName,
+    BridgedSourceLoc cSpecifierLoc, BridgedIdentifier cName,
     BridgedSourceLoc cNameLoc, BridgedNullableTypeRepr opaqueInheritedType,
     size_t index);
 

include/swift/AST/Decl.h

@@ -587,13 +587,10 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
 
   SWIFT_INLINE_BITFIELD_EMPTY(TypeDecl, ValueDecl);
 
-  SWIFT_INLINE_BITFIELD_FULL(GenericTypeParamDecl, TypeDecl, 16+16+1+1+1,
-    : NumPadBits,
-
+  SWIFT_INLINE_BITFIELD_FULL(GenericTypeParamDecl, TypeDecl, 16+16+8+1,
     Depth : 16,
     Index : 16,
-    ParameterPack : 1,
-    Value : 1,
+    ParamKind : 8,
 
     /// Whether this generic parameter represents an opaque type.
     IsOpaqueType : 1
@@ -3772,17 +3769,11 @@ class GenericTypeParamDecl final
   }
 
   size_t numTrailingObjects(OverloadToken<SourceLoc>) const {
-    auto numSourceLocs = 0;
-
-    if (isParameterPack()) {
-      numSourceLocs += 1;
-    }
-
-    if (isValue()) {
-      numSourceLocs += 1;
+    if (isParameterPack() || isValue()) {
+      return 1;
     }
 
-    return numSourceLocs;
+    return 0;
   }
 
   /// Construct a new generic type parameter.
@@ -3793,24 +3784,16 @@ class GenericTypeParamDecl final
   ///
   /// \param name The name of the generic parameter.
   /// \param nameLoc The location of the name.
-  /// \param eachLoc The location of the 'each' keyword for a type parameter
-  ///                pack.
-  /// \param letLoc The location of the 'let' keyword for a variable type
-  ///               parameter.
+  /// \param specifierLoc The location of the 'each' or 'let' keyword for pack
+  ///                     or value parameters.
   /// \param depth The generic signature depth.
   /// \param index The index of the parameter in the generic signature.
-  /// \param isParameterPack Whether the generic parameter is for a type
-  ///                        parameter pack, denoted by \c <each T>.
-  /// \param isValue Whether the generic parameter is for a value type
-  ///                parameter, denoted by \c <let N: Int>.
-  /// \param isOpaqueType Whether the generic parameter is written as an opaque
-  ///                     parameter e.g 'some Collection'.
+  /// \param paramKind The kind of generic type parameter this is.
   /// \param opaqueTypeRepr The TypeRepr of an opaque generic parameter.
   ///
   GenericTypeParamDecl(DeclContext *dc, Identifier name, SourceLoc nameLoc,
-                       SourceLoc eachLoc, SourceLoc letLoc, unsigned depth,
-                       unsigned index, bool isParameterPack, bool isValue,
-                       bool isOpaqueType, TypeRepr *opaqueTypeRepr);
+                       SourceLoc specifierLoc, unsigned depth, unsigned index,
+                       GenericTypeParamKind paramKind, TypeRepr *opaqueTypeRepr);
 
   /// Construct a new generic type parameter.
   ///
@@ -3820,25 +3803,17 @@ class GenericTypeParamDecl final
   ///
   /// \param name The name of the generic parameter.
   /// \param nameLoc The location of the name.
-  /// \param eachLoc The location of the 'each' keyword for a type parameter
-  ///                pack.
-  /// \param letLoc The location of the 'let' keyword for a variable type
-  ///               parameter.
+  /// \param specifierLoc The location of the 'each' or 'let' keyword for pack
+  ///                     or value parameters.
   /// \param depth The generic signature depth.
   /// \param index The index of the parameter in the generic signature.
-  /// \param isParameterPack Whether the generic parameter is for a type
-  ///                        parameter pack, denoted by \c <each T>.
-  /// \param isValue Whether the generic parameter is for a value type
-  ///                parameter, denoted by \c <let N: Int>.
-  /// \param isOpaqueType Whether the generic parameter is written as an opaque
-  ///                     parameter e.g 'some Collection'.
+  /// \param paramKind The kind of generic type parameter this is.
   /// \param opaqueTypeRepr The TypeRepr of an opaque generic parameter.
   ///
   static GenericTypeParamDecl *create(DeclContext *dc, Identifier name,
-                                      SourceLoc nameLoc, SourceLoc eachLoc,
-                                      SourceLoc letLoc, unsigned depth,
-                                      unsigned index, bool isParameterPack,
-                                      bool isValue, bool isOpaqueType,
+                                      SourceLoc nameLoc, SourceLoc specifierLoc,
+                                      unsigned depth, unsigned index,
+                                      GenericTypeParamKind paramKind,
                                       TypeRepr *opaqueTypeRepr);
 
 public:
@@ -3847,11 +3822,10 @@ class GenericTypeParamDecl final
   /// Construct a new generic type parameter. This should only be used by the
   /// ClangImporter, use \c GenericTypeParamDecl::create[...] instead.
   GenericTypeParamDecl(DeclContext *dc, Identifier name, SourceLoc nameLoc,
-                       SourceLoc eachLoc, SourceLoc letLoc, unsigned depth,
-                       unsigned index, bool isParameterPack, bool isValue)
-      : GenericTypeParamDecl(dc, name, nameLoc, eachLoc, letLoc, depth, index,
-                             isParameterPack, isValue, /*isOpaqueType*/ false,
-                             nullptr) {
+                       SourceLoc specifierLoc, unsigned depth, unsigned index,
+                       GenericTypeParamKind paramKind)
+      : GenericTypeParamDecl(dc, name, nameLoc, specifierLoc, depth, index,
+                             paramKind, nullptr) {
   }
 
   /// Construct a deserialized generic type parameter.
@@ -3863,17 +3837,11 @@ class GenericTypeParamDecl final
   /// \param name The name of the generic parameter.
   /// \param depth The generic signature depth.
   /// \param index The index of the parameter in the generic signature.
-  /// \param isParameterPack Whether the generic parameter is for a type
-  ///                        parameter pack, denoted by \c <each T>.
-  /// \param isValue Whether the generic parameter is for a variable type
-  ///                parameter, denoted by \c <let N: Int>.
-  /// \param isOpaqueType Whether the generic parameter is written as an opaque
-  ///                     parameter e.g 'some Collection'.
+  /// \param paramKind The kind of generic type parameter this is.
   ///
   static GenericTypeParamDecl *
   createDeserialized(DeclContext *dc, Identifier name, unsigned depth,
-                     unsigned index, bool isParameterPack, bool isValue,
-                     bool isOpaqueType);
+                     unsigned index, GenericTypeParamKind paramKind);
 
   /// Construct a new parsed generic type parameter.
   ///
@@ -3883,22 +3851,16 @@ class GenericTypeParamDecl final
   ///
   /// \param name The name of the generic parameter.
   /// \param nameLoc The location of the name.
-  /// \param eachLoc The location of the 'each' keyword for a type parameter
-  ///                pack.
-  /// \param letLoc The location of the 'let' keyword for a variable type
-  ///               parameter.
+  /// \param specifierLoc The location of the 'each' or 'let' keyword for pack
+  ///                     or value parameters.
   /// \param index The index of the parameter in the generic signature.
-  /// \param isParameterPack Whether the generic parameter is for a type
-  ///                        parameter pack, denoted by \c <each T>.
-  /// \param isValue Whether the generic parameter is for a variable type
-  ///                parameter, denoted by \c <let N: Int>.
+  /// \param paramKind The kind of generic type parameter this is.
   ///
   static GenericTypeParamDecl *createParsed(DeclContext *dc, Identifier name,
                                             SourceLoc nameLoc,
-                                            SourceLoc eachLoc, SourceLoc letLoc,
+                                            SourceLoc specifierLoc,
                                             unsigned index,
-                                            bool isParameterPack,
-                                            bool isValue);
+                                            GenericTypeParamKind paramKind);
 
   /// Construct a new implicit generic type parameter.
   ///
@@ -3909,25 +3871,17 @@ class GenericTypeParamDecl final
   /// \param name The name of the generic parameter.
   /// \param depth The generic signature depth.
   /// \param index The index of the parameter in the generic signature.
-  /// \param isParameterPack Whether the generic parameter is for a type
-  ///                        parameter pack, denoted by \c <each T>.
-  /// \param isValue Whether the generic parameter is for a variable type
-  ///                parameter, denoted by \c <let N: Int>.
-  /// \param isOpaqueType Whether the generic parameter is written as an opaque
-  ///                     parameter e.g 'some Collection'.
+  /// \param paramKind The kind of generic type parameter this is.
   /// \param opaqueTypeRepr The TypeRepr of an opaque generic parameter.
   /// \param nameLoc The location of the name.
-  /// \param eachLoc The location of the 'each' keyword for a type parameter
-  ///                pack.
-  /// \param letLoc The location of the 'let' keyword for a variable type
-  ///               parameter.
+  /// \param specifierLoc The location of the 'each' or 'let' keyword for pack
+  ///                     or value parameters.
   ///
   static GenericTypeParamDecl *
   createImplicit(DeclContext *dc, Identifier name, unsigned depth,
-                 unsigned index, bool isParameterPack = false,
-                 bool isValue = false, bool isOpaqueType = false,
+                 unsigned index, GenericTypeParamKind paramKind,
                  TypeRepr *opaqueTypeRepr = nullptr, SourceLoc nameLoc = {},
-                 SourceLoc eachLoc = {}, SourceLoc letLoc = {});
+                 SourceLoc specifierLoc = {});
 
   /// The depth of this generic type parameter, i.e., the number of outer
   /// levels of generic parameter lists that enclose this type parameter.
@@ -3949,14 +3903,21 @@ class GenericTypeParamDecl final
     assert(Bits.GenericTypeParamDecl.Depth == depth && "Truncation");
   }
 
+  /// The kind of generic type parameter this is.
+  GenericTypeParamKind getParamKind() const {
+    return (GenericTypeParamKind) Bits.GenericTypeParamDecl.ParamKind;
+  }
+
   /// Returns \c true if this generic type parameter is declared as a type
   /// parameter pack.
   ///
   /// \code
   /// func foo<each T>(_ : for each T) { }
   /// struct Foo<each T> { }
   /// \endcode
-  bool isParameterPack() const { return Bits.GenericTypeParamDecl.ParameterPack; }
+  bool isParameterPack() const {
+    return getParamKind() == GenericTypeParamKind::Pack;
+  }
 
   /// Returns \c true if this generic type parameter is declared as a value
   /// type parameter.
@@ -3965,9 +3926,13 @@ class GenericTypeParamDecl final
   /// struct Vector<Element, let N: Int>
   /// \endcode
   bool isValue() const {
-    return Bits.GenericTypeParamDecl.Value;
+    return getParamKind() == GenericTypeParamKind::Value;
   }
 
+  /// Returns the underlying value type associated with this generic value
+  /// parameter. E.g. if this is 'let N: Int' returns 'Int'.
+  Type getValueType() const;
+
   /// Determine whether this generic parameter represents an opaque type.
   ///
   /// \code
@@ -4004,14 +3969,31 @@ class GenericTypeParamDecl final
   /// Here 'T' and 'U' have indexes 0 and 1, respectively. 'V' has index 0.
   unsigned getIndex() const { return Bits.GenericTypeParamDecl.Index; }
 
-  /// Retrieve the 'each' keyword location for a type parameter pack \c each T
+  /// Retrieve either the 'each' keyword or the 'let' keyword location for this
+  /// generic parameter depending on if it's a parameter pack or a value.
+  SourceLoc getSpecifierLoc() const {
+    if (!isParameterPack() && !isValue())
+      return SourceLoc();
+
+    return *getTrailingObjects<SourceLoc>();
+  }
+
+  /// Retrieve the 'each' keyword location for a type parameter pack \c each T.
   SourceLoc getEachLoc() const {
     if (!isParameterPack())
       return SourceLoc();
 
     return *getTrailingObjects<SourceLoc>();
   }
 
+  /// Retrieve the 'let' keyword location for a value parameter \c let N.
+  SourceLoc getLetLoc() const {
+    if (!isValue())
+      return SourceLoc();
+
+    return *getTrailingObjects<SourceLoc>();
+  }
+
   SourceLoc getStartLoc() const { return getNameLoc(); }
   SourceRange getSourceRange() const;
 

include/swift/AST/DiagnosticsSema.def

@@ -8009,8 +8009,7 @@ NOTE(invalid_value_value_generic_requirement,none,
      "requirement specified as %0 == %1%2",
      (Type, Type, StringRef))
 ERROR(cannot_pass_type_for_value_generic,none,
-      "cannot pass type %1 as a value for generic value of %2",
-      (Type, Type, Type))
+      "cannot pass type %0 as a value for generic value %1", (Type, Type))
 ERROR(value_type_used_in_type_parameter,none,
       "cannot use value type %0 for generic argument %1", (Type, Type))
 ERROR(cannot_self_value_generic,none,
@@ -8019,6 +8018,10 @@ ERROR(invalid_value_type_value_generic,none,
       "%0 is not a supported value type for %1", (Type, Type))
 ERROR(invalid_value_generic_conformance,none,
       "value generic type %0 cannot conform to protocol %1", (Type, Type))
+ERROR(invalid_value_generic_same_type,none,
+      "cannot constrain value parameter %0 to be type %1", (Type, Type))
+ERROR(integer_type_not_accepted,none,
+      "integer unexpectedly used in a type position", ())
 
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/GenericSignature.h

@@ -179,8 +179,6 @@ class GenericSignature {
     LayoutConstraint layout;
 
     Type packShape;
-
-    Type valueType;
   };
 
 private:

include/swift/AST/GenericTypeParamKind.h

@@ -0,0 +1,33 @@
+//===--- GenericTypeParamKind.h ---------------------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2024 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 GenericTypeParamKind enum.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_GENERICTYPEPARAMKIND_H
+#define SWIFT_AST_GENERICTYPEPARAMKIND_H
+
+namespace swift {
+/// Describes the kind of a generic type parameter that occurs within generic
+/// parameter lists.
+enum class GenericTypeParamKind: uint8_t {
+  /// A regular generic type parameter: 'T'
+  Type,
+  /// A generic parameter pack: 'each T'
+  Pack,
+  /// A generic value parameter: 'let T'
+  Value
+};
+
+} // namespace swift
+#endif // #ifndef SWIFT_AST_GENERICTYPEPARAMKIND_H