WIP Serialize IntegerType

Author: Azoy

include/swift/AST/Types.h

@@ -7741,7 +7741,7 @@ class IntegerType final : public TypeBase, public llvm::FoldingSetNode {
   static IntegerType *get(StringRef value, bool isNegative,
                           const ASTContext &ctx);
 
-  APInt getValue();
+  APInt getValue() const;
 
   StringRef getDigitsText() const {
     return Value;

lib/AST/Type.cpp

@@ -5911,7 +5911,7 @@ SILFunctionType::withPatternSpecialization(CanGenericSignature sig,
                           witnessConformance);
 }
 
-APInt IntegerType::getValue() {
+APInt IntegerType::getValue() const {
   return BuiltinIntegerWidth::arbitrary().parse(getDigitsText(), /*radix*/ 0,
                                                 isNegative());
 }

lib/Sema/TypeCheckAttr.cpp

@@ -3850,8 +3850,10 @@ ResolveRawLayoutTypeRequest::evaluate(Evaluator &evaluator, StructDecl *sd,
     return fixedTy->getType();
   }
 
+  TypeResolutionOptions options(TypeResolverContext::RawLayoutAttr);
+
   // Resolve the type in the struct's context.
-  return TypeResolution::resolveContextualType(typeRepr, sd, std::nullopt,
+  return TypeResolution::resolveContextualType(typeRepr, sd, options,
                                                // Unbound generics and
                                                // placeholders are not allowed
                                                // within this attribute.

lib/Sema/TypeCheckType.cpp

@@ -175,6 +175,7 @@ static unsigned getGenericRequirementKind(TypeResolutionOptions options) {
   case TypeResolverContext::CustomAttr:
   case TypeResolverContext::Inverted:
   case TypeResolverContext::ValueGenericArgument:
+  case TypeResolverContext::RawLayoutAttr:
     break;
   }
 
@@ -4944,11 +4945,12 @@ TypeResolver::resolveDeclRefTypeRepr(DeclRefTypeRepr *repr,
 
   // Referencing a value generic by name, e.g. 'let N' and referencing 'N', is
   // only valid as a generic argument, in generic requirements, when being
-  // used as an expression, and in SIL mode.
+  // used as an expression, inside of the @_rawLayout attribute, and in SIL mode.
   if (result->isValueParameter() &&
       !(options.isGenericArgument() ||
         options.isGenericRequirement() ||
         options.isAnyExpr() ||
+        options.is(TypeResolverContext::RawLayoutAttr) ||
         options.contains(TypeResolutionFlags::SILMode))) {
     if (!options.contains(TypeResolutionFlags::SilenceErrors)) {
       diagnose(repr->getNameLoc(), diag::value_generic_unexpected, result);
@@ -5270,6 +5272,7 @@ NeverNullType TypeResolver::resolveImplicitlyUnwrappedOptionalType(
   case TypeResolverContext::CustomAttr:
   case TypeResolverContext::Inverted:
   case TypeResolverContext::ValueGenericArgument:
+  case TypeResolverContext::RawLayoutAttr:
     doDiag = true;
     break;
   }

lib/Sema/TypeCheckType.h

@@ -210,6 +210,9 @@ enum class TypeResolverContext : uint8_t {
 
   /// Whether this is the argument of an inverted constraint (~).
   Inverted,
+
+  /// Whether this is inside a @_rawLayout attribute.
+  RawLayoutAttr,
 };
 
 /// Options that determine how type resolution should work.
@@ -308,6 +311,7 @@ class TypeResolutionOptions {
     case Context::Inverted:
     case Context::ValueGenericArgument:
     case Context::PatternBindingDecl:
+    case Context::RawLayoutAttr:
       return false;
     }
     llvm_unreachable("unhandled kind");
@@ -353,6 +357,7 @@ class TypeResolutionOptions {
     case Context::AbstractFunctionDecl:
     case Context::CustomAttr:
     case Context::ValueGenericArgument:
+    case Context::RawLayoutAttr:
       return true;
     }
   }
@@ -396,6 +401,7 @@ class TypeResolutionOptions {
     case Context::AbstractFunctionDecl:
     case Context::CustomAttr:
     case Context::ValueGenericArgument:
+    case Context::RawLayoutAttr:
       return false;
     }
   }
@@ -440,6 +446,7 @@ class TypeResolutionOptions {
     case Context::Inverted:
     case Context::GenericParameterInherited:
     case Context::AssociatedTypeInherited:
+    case Context::RawLayoutAttr:
       return false;
     }
   }
@@ -485,6 +492,7 @@ class TypeResolutionOptions {
     case Context::CustomAttr:
     case Context::Inverted:
     case Context::ValueGenericArgument:
+    case Context::RawLayoutAttr:
       return false;
     }
   }

lib/Serialization/DeclTypeRecordNodes.def

@@ -120,6 +120,8 @@ TYPE(SIL_PACK)
 
 TYPE(ERROR)
 
+TYPE(INTEGER)
+
 FIRST_DECL(TYPE_ALIAS, 40)
 DECL(GENERIC_TYPE_PARAM)
 DECL(ASSOCIATED_TYPE)

lib/Serialization/Deserialization.cpp

@@ -7942,6 +7942,17 @@ Expected<Type> DESERIALIZE_TYPE(ERROR_TYPE)(ModuleFile &MF,
     return ErrorType::get(ctx);
   return ErrorType::get(origTy);
 }
+
+Expected<Type> DESERIALIZE_TYPE(INTEGER_TYPE)(ModuleFile &MF,
+                                              SmallVectorImpl<uint64_t> &scratch,
+                                              StringRef blobData) {
+  auto &ctx = MF.getContext();
+  bool isNegative;
+  uint64_t value;
+  decls_block::IntegerTypeLayout::readRecord(scratch, isNegative, value);
+
+  return IntegerType::get(std::to_string(value), isNegative, ctx);
+}
 } // namespace decls_block
 } // namespace serialization
 }

lib/Serialization/ModuleFormat.h

@@ -1469,6 +1469,12 @@ namespace decls_block {
     BCArray<TypeIDField>// component types
   );
 
+  TYPE_LAYOUT(IntegerTypeLayout,
+    INTEGER_TYPE,
+    BCFixed<1>,   // is negative?
+    BCFixed<64>     // integer value
+  );
+
   using TypeAliasLayout = BCRecordLayout<
     TYPE_ALIAS_DECL,
     IdentifierIDField, // name

lib/Serialization/Serialization.cpp

@@ -5893,7 +5893,14 @@ class Serializer::TypeSerializer : public TypeVisitor<TypeSerializer> {
   }
 
   void visitIntegerType(const IntegerType *integer) {
-    llvm_unreachable("implement me");
+    using namespace decls_block;
+
+    uint64_t value = integer->getValue().getZExtValue();
+
+    unsigned abbrCode = S.DeclTypeAbbrCodes[IntegerTypeLayout::Code];
+    IntegerTypeLayout::emitRecord(S.Out, S.ScratchRecord, abbrCode,
+                                  integer->isNegative(),
+                                  value);
   }
 };
 
@@ -6080,6 +6087,7 @@ void Serializer::writeAllDeclsAndTypes() {
   registerDeclTypeAbbr<PackElementTypeLayout>();
   registerDeclTypeAbbr<PackTypeLayout>();
   registerDeclTypeAbbr<SILPackTypeLayout>();
+  registerDeclTypeAbbr<IntegerTypeLayout>();
 
   registerDeclTypeAbbr<ErrorFlagLayout>();
   registerDeclTypeAbbr<ErrorTypeLayout>();

test/Serialization/value_generics.swift

@@ -0,0 +1,19 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend %s -emit-module -enable-experimental-feature RawLayout -parse-as-library -o %t
+// RUN: %target-sil-opt -enable-sil-verify-all %t/value_generics.swiftmodule -o - | %FileCheck %s
+
+// CHECK: @_rawLayout(likeArrayOf: Element, count: Count) struct Vector<Element, let Count : Int> : ~Copyable where Element : ~Copyable {
+@_rawLayout(likeArrayOf: Element, count: Count)
+struct Vector<Element: ~Copyable, let Count: Int>: ~Copyable {}
+
+// CHECK: extension Vector where Element == Int
+extension Vector where Element == Int {
+  func something() {}
+}
+
+extension Vector where Count == 2 {
+  func something2() {}
+}
+
+// CHECK: func something<let N : Int>(_: borrowing Vector<Int, N>)
+func something<let N: Int>(_: borrowing Vector<Int, N>) {}