Implement value generics

Some requirement machine work

Rename requirement to Value

Rename more things to Value

Fix integer checking for requirement

some docs and parser changes

Minor fixes

Author: Azoy

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -718,6 +718,8 @@ class ExistentialMetatypeInst : SingleValueInstruction, UnaryInstruction {}
 
 final public class ObjCProtocolInst : SingleValueInstruction {}
 
+final public class TypeValueInst: SingleValueInstruction, UnaryInstruction {}
+
 public class GlobalAccessInstruction : SingleValueInstruction {
   final public var global: GlobalVariable {
     bridged.GlobalAccessInst_getGlobal().globalVar

SwiftCompilerSources/Sources/SIL/Registration.swift

@@ -150,6 +150,7 @@ public func registerSILClasses() {
   register(MetatypeInst.self)
   register(ValueMetatypeInst.self)
   register(ExistentialMetatypeInst.self)
+  register(TypeValueInst.self)
   register(OpenPackElementInst.self)
   register(PackLengthInst.self)
   register(DynamicPackIndexInst.self)

docs/ABI/Mangling.rst

@@ -710,6 +710,10 @@ Types
   type ::= type 'Xm' METATYPE-REPR           // existential metatype with representation
   type ::= 'Xe'                              // error or unresolved type
 
+  #if SWIFT_RUNTIME_VERSION >= 6.TBD
+    type ::= '$' 'n'? NATURAL_ZERO           // integer type
+  #endif
+
   bound-generic-type ::= type 'y' (type* '_')* type* retroactive-conformance* 'G'   // one type-list per nesting level of type
   bound-generic-type ::= substitution
 
@@ -1041,6 +1045,10 @@ 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/ABI/GenericContext.h

@@ -74,6 +74,10 @@ struct TargetGenericContextDescriptorHeader {
   ///   same order as the requirement descriptors which satisfy
   ///   hasKeyArgument().
   ///
+  ///   a sequence of values, in the same order as the parameter descriptors
+  ///   which satisify getKind() == GenericParamKind::Value and
+  ///   hasKeyArgument();
+  ///
   /// The elements above which are packs are precisely those appearing
   /// in the sequence of trailing GenericPackShapeDescriptors.
   uint16_t NumKeyArguments;
@@ -157,6 +161,9 @@ class TargetGenericRequirementDescriptor {
       uint16_t GenericParamIndex;
       InvertibleProtocolSet Protocols;
     } InvertedProtocols;
+
+    /// FIXME ALEX DOCS
+    uint32_t ValueType;
   };
 
   constexpr GenericRequirementFlags getFlags() const {
@@ -248,6 +255,7 @@ class TargetGenericRequirementDescriptor {
     case GenericRequirementKind::SameType:
     case GenericRequirementKind::SameShape:
     case GenericRequirementKind::InvertedProtocols:
+    case GenericRequirementKind::Value:
       return true;
     }
 

include/swift/ABI/MetadataValues.h

@@ -2048,6 +2048,9 @@ enum class GenericParamKind : uint8_t {
   /// A type parameter pack.
   TypePack = 1,
 
+  /// A value type parameter.
+  Value = 2,
+
   Max = 0x3F,
 };
 
@@ -2138,6 +2141,8 @@ enum class GenericRequirementKind : uint8_t {
   /// This is more of an "anti-requirement", specifing which checks don't need
   /// to happen for a given type.
   InvertedProtocols = 5,
+  /// A value requirement.
+  Value = 6,
   /// A layout requirement.
   Layout = 0x1F,
 };

include/swift/AST/ASTBridging.h

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

include/swift/AST/ASTDemangler.h

@@ -231,6 +231,8 @@ class ASTBuilder {
 
   Type createParenType(Type base);
 
+  Type createIntegerType(unsigned value, bool isNegative);
+
   BuiltGenericSignature
   createGenericSignature(ArrayRef<BuiltType> params,
                          ArrayRef<BuiltRequirement> requirements);

include/swift/AST/Attr.h

@@ -2529,98 +2529,92 @@ class MacroRoleAttr final
 /// Specifies the raw storage used by a type.
 class RawLayoutAttr final : public DeclAttribute {
   /// The element type to share size and alignment with, if any.
-  TypeRepr *LikeType;
+  TypeRepr *LikeType = nullptr;
   /// The number of elements in an array to share stride and alignment with,
-  /// or zero if no such size was specified. If `LikeType` is null, this is
-  /// the size in bytes of the raw storage.
-  unsigned SizeOrCount;
+  /// or nullptr if no such size was specified.
+  TypeRepr *CountType = nullptr;
+  /// The size in bytes of the raw storage.
+  unsigned Size = 0;
   /// If `LikeType` is null, the alignment in bytes to use for the raw storage.
-  unsigned Alignment;
+  unsigned Alignment = 0;
   /// If a value of this raw layout type should move like its `LikeType`.
   bool MovesAsLike = false;
   /// The resolved like type.
   mutable Type CachedResolvedLikeType = Type();
+  /// The resolved count type.
+  mutable Type CachedResolvedCountType = Type();
 
-  friend class ResolveRawLayoutLikeTypeRequest;
+  friend class ResolveRawLayoutTypeRequest;
 
 public:
   /// Construct a `@_rawLayout(like: T)` attribute.
   RawLayoutAttr(TypeRepr *LikeType, bool movesAsLike, SourceLoc AtLoc,
                 SourceRange Range)
       : DeclAttribute(DeclAttrKind::RawLayout, AtLoc, Range,
                       /*implicit*/ false),
-        LikeType(LikeType), SizeOrCount(0), Alignment(~0u),
-        MovesAsLike(movesAsLike) {}
+        LikeType(LikeType), MovesAsLike(movesAsLike) {}
 
   /// Construct a `@_rawLayout(likeArrayOf: T, count: N)` attribute.
-  RawLayoutAttr(TypeRepr *LikeType, unsigned Count, bool movesAsLike,
+  RawLayoutAttr(TypeRepr *LikeType, TypeRepr *CountType, bool movesAsLike,
                 SourceLoc AtLoc, SourceRange Range)
       : DeclAttribute(DeclAttrKind::RawLayout, AtLoc, Range,
                       /*implicit*/ false),
-        LikeType(LikeType), SizeOrCount(Count), Alignment(0),
-        MovesAsLike(movesAsLike) {}
+        LikeType(LikeType), CountType(CountType), MovesAsLike(movesAsLike) {}
 
   /// Construct a `@_rawLayout(size: N, alignment: M)` attribute.
   RawLayoutAttr(unsigned Size, unsigned Alignment, SourceLoc AtLoc,
                 SourceRange Range)
       : DeclAttribute(DeclAttrKind::RawLayout, AtLoc, Range,
                       /*implicit*/ false),
-        LikeType(nullptr), SizeOrCount(Size), Alignment(Alignment) {}
+        Size(Size), Alignment(Alignment) {}
 
   /// Return the type whose single-element layout the attribute type should get
   /// its layout from. Returns null if the attribute specifies an array or manual
   /// layout.
   TypeRepr *getScalarLikeType() const {
-    if (!LikeType)
-      return nullptr;
-    if (Alignment != ~0u)
+    if (!LikeType || CountType)
       return nullptr;
     return LikeType;
   }
 
   /// Return the type whose array layout the attribute type should get its
   /// layout from, along with the size of that array. Returns None if the
   /// attribute specifies scalar or manual layout.
-  std::optional<std::pair<TypeRepr *, unsigned>>
+  std::optional<std::pair<TypeRepr *, TypeRepr *>>
   getArrayLikeTypeAndCount() const {
-    if (!LikeType)
-      return std::nullopt;
-    if (Alignment == ~0u)
+    if (!LikeType || !CountType)
       return std::nullopt;
-    return std::make_pair(LikeType, SizeOrCount);
+    return std::make_pair(LikeType, CountType);
   }
 
   /// Return the size and alignment of the attributed type. Returns
   /// None if the attribute specifies layout like some other type.
   std::optional<std::pair<unsigned, unsigned>> getSizeAndAlignment() const {
     if (LikeType)
       return std::nullopt;
-    return std::make_pair(SizeOrCount, Alignment);
+    return std::make_pair(Size, Alignment);
   }
 
   Type getResolvedLikeType(StructDecl *sd) const;
+  Type getResolvedCountType(StructDecl *sd) const;
 
   /// Return the type whose single-element layout the attribute type should get
   /// its layout from. Returns None if the attribute specifies an array or manual
   /// layout.
   std::optional<Type> getResolvedScalarLikeType(StructDecl *sd) const {
-    if (!LikeType)
-      return std::nullopt;
-    if (Alignment != ~0u)
+    if (!LikeType || CountType)
       return std::nullopt;
     return getResolvedLikeType(sd);
   }
 
   /// Return the type whose array layout the attribute type should get its
   /// layout from, along with the size of that array. Returns None if the
   /// attribute specifies scalar or manual layout.
-  std::optional<std::pair<Type, unsigned>>
+  std::optional<std::pair<Type, Type>>
   getResolvedArrayLikeTypeAndCount(StructDecl *sd) const {
-    if (!LikeType)
-      return std::nullopt;
-    if (Alignment == ~0u)
+    if (!LikeType || !CountType)
       return std::nullopt;
-    return std::make_pair(getResolvedLikeType(sd), SizeOrCount);
+    return std::make_pair(getResolvedLikeType(sd), getResolvedCountType(sd));
   }
 
   /// Whether a value of this raw layout should move like its `LikeType`.