Add serialization and parser tests for SIL

Azoy · Azoy · commit e0f2b812e87b · 2024-09-04T15:13:47.000-07:00
diff --git a/docs/SIL.rst b/docs/SIL.rst
@@ -7762,6 +7762,20 @@ element value operand is the projected element type of the pack element
 and must be structurally well-typed for the given index and pack type;
 see the structural type matching rules for pack indices.
 
+Value Generics
+~~~~~~~~~~~~~~~~~
+
+type_value
+```````````
+
+::
+
+  sil-instruction ::= 'type_value' sil-type 'for' sil-identifier
+
+Produce the dynamic value of the given value generic, which must be a formal
+value generic type. The value of the instruction has the type of whatever the
+underlying value generic's type is. For right now that is limited to ``Int``.
+
 Unchecked Conversions
 ~~~~~~~~~~~~~~~~~~~~~
 
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
@@ -8023,7 +8023,7 @@ ERROR(integer_type_not_accepted,none,
 ERROR(value_generic_unexpected,none,
       "using value generic %0 here is not allowed", (Type))
 ERROR(missing_value_generic_type,none,
-      "value generic 'let %0' must have an explicit value type declared", (Identifier))
+      "value generic %0 must have an explicit value type declared", (Identifier))
 
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"
diff --git a/lib/AST/ASTDumper.cpp b/lib/AST/ASTDumper.cpp
@@ -1176,6 +1176,19 @@ namespace {
       printCommon(decl, "generic_type_param", label);
       printField(decl->getDepth(), "depth");
       printField(decl->getIndex(), "index");
+
+      switch (decl->getParamKind()) {
+      case GenericTypeParamKind::Type:
+        printField((StringRef)"type", "param_kind");
+        break;
+      case GenericTypeParamKind::Pack:
+        printField((StringRef)"pack", "param_kind");
+        break;
+      case GenericTypeParamKind::Value:
+        printField((StringRef)"value", "param_kind");
+        break;
+      }
+
       printFoot();
     }
 
@@ -4282,10 +4295,18 @@ namespace {
       printField(T->getIndex(), "index");
       if (!T->isCanonical())
         printFieldQuoted(T->getName(), "name");
-      printFlag(T->isParameterPack(), "pack");
 
-      if (T->isValue())
-        printRec(T->getValueType(), "value");
+      switch (T->getParamKind()) {
+      case GenericTypeParamKind::Type:
+        printField((StringRef)"type", "param_kind");
+        break;
+      case GenericTypeParamKind::Pack:
+        printField((StringRef)"pack", "param_kind");
+        break;
+      case GenericTypeParamKind::Value:
+        printField((StringRef)"value", "param_kind");
+        printRec(T->getValueType(), "value_type");
+      }
 
       printFoot();
     }
diff --git a/lib/AST/ASTPrinter.cpp b/lib/AST/ASTPrinter.cpp
@@ -1855,10 +1855,24 @@ void PrintAST::printSingleDepthOfGenericSignature(
                                           GP);
             Printer.printName(GP->getName(),
                               PrintNameContext::GenericParameter);
+
+            if (param->isValue()) {
+              Printer << " : ";
+              printType(param->getValueType());
+            }
+
             Printer.printStructurePost(PrintStructureKind::GenericParameter,
                                        GP);
           } else {
+            if (param->isValue())
+              Printer << "let ";
+
             printType(param);
+
+            if (param->isValue()) {
+              Printer << " : ";
+              printType(param->getValueType());
+            }
           }
         },
         [&] { Printer << ", "; });
@@ -7173,7 +7187,6 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
   void visitGenericTypeParamType(GenericTypeParamType *T) {
     auto printPrefix = [&]{
       if (T->isParameterPack()) printEach();
-      if (T->isValue()) printLet();
     };
 
     if (T->isCanonical()) {
diff --git a/lib/AST/Requirement.cpp b/lib/AST/Requirement.cpp
@@ -154,7 +154,7 @@ CheckRequirementResult Requirement::checkRequirement(
     return CheckRequirementResult::Success;
   }
 
-  case RequirementKind::Superclass: {
+  case RequirementKind::Superclass:
     if (auto packType = firstType->getAs<PackType>()) {
       return expandPackRequirement(packType);
     }
@@ -163,23 +163,20 @@ CheckRequirementResult Requirement::checkRequirement(
       return CheckRequirementResult::Success;
 
     return CheckRequirementResult::RequirementFailure;
-  }
 
-  case RequirementKind::SameType: {
+  case RequirementKind::SameType:
     if (firstType->isEqual(getSecondType()))
       return CheckRequirementResult::Success;
 
     return CheckRequirementResult::RequirementFailure;
-  }
 
-  case RequirementKind::SameShape: {
+  case RequirementKind::SameShape:
     if (firstType->getReducedShape() ==
         getSecondType()->getReducedShape())
       return CheckRequirementResult::Success;
 
     return CheckRequirementResult::RequirementFailure;
   }
-  }
 
   llvm_unreachable("Bad requirement kind");
 }
@@ -253,13 +250,11 @@ int Requirement::compare(const Requirement &other) const {
     abort();
   }
 
-  auto decl1 = getProtocolDecl();
-  auto decl2 = other.getProtocolDecl();
-
-  int compareDecls = TypeDecl::compare(decl1, decl2);
-  assert(compareDecls != 0 && "Duplicate decl requirements");
+  int compareProtos =
+    TypeDecl::compare(getProtocolDecl(), other.getProtocolDecl());
+  assert(compareProtos != 0 && "Duplicate conformance requirements");
 
-  return compareDecls;
+  return compareProtos;
 }
 
 static std::optional<CheckRequirementsResult>
diff --git a/lib/SIL/Parser/ParseSIL.cpp b/lib/SIL/Parser/ParseSIL.cpp
@@ -3097,7 +3097,6 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
     CanType paramType;
     if (parseSILType(Ty) ||
         parseVerbatim("for") ||
-        P.parseToken(tok::sil_dollar, diag::expected_tok_in_sil_instr, "$") ||
         parseASTType(paramType))
       return true;
 
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
@@ -4942,12 +4942,13 @@ TypeResolver::resolveDeclRefTypeRepr(DeclRefTypeRepr *repr,
     result = applyNonEscapingIfNecessary(result, options);
 
   // Referencing a value generic by name, e.g. 'let N' and referencing 'N', is
-  // only valid as a generic argument, in generic requirements, and when being
-  // used as an expression.
+  // only valid as a generic argument, in generic requirements, when being
+  // used as an expression, and in SIL mode.
   if (result->isValueParameter() &&
       !(options.isGenericArgument() ||
         options.isGenericRequirement() ||
-        options.isAnyExpr())) {
+        options.isAnyExpr() ||
+        options.contains(TypeResolutionFlags::SILMode))) {
     if (!options.contains(TypeResolutionFlags::SilenceErrors)) {
       diagnose(repr->getNameLoc(), diag::value_generic_unexpected, result);
     }
diff --git a/lib/Serialization/Deserialization.cpp b/lib/Serialization/Deserialization.cpp
@@ -1598,6 +1598,16 @@ ModuleFile::getGenericSignatureChecked(serialization::GenericSignatureID ID) {
         auto *paramDecl = GenericTypeParamDecl::createDeserialized(
             getAssociatedModule(), name, paramTy->getDepth(),
             paramTy->getIndex(), paramTy->getParamKind());
+
+        // If we're dealing with a value generic, the parameter type already
+        // serializes the value type. Inform the request evaluator that we don't
+        // need to recompute this value for the param decl.
+        if (paramTy->isValue()) {
+          paramDecl->getASTContext().evaluator.cacheOutput(
+              GenericTypeParamDeclGetValueTypeRequest{paramDecl},
+              paramTy->getValueType());
+        }
+
         paramTy = paramDecl->getDeclaredInterfaceType()
                    ->castTo<GenericTypeParamType>();
       }
@@ -3466,27 +3476,37 @@ class DeclDeserializer {
                                   StringRef blobData) {
     IdentifierID nameID;
     bool isImplicit;
-    unsigned rawParamKind;
-    unsigned depth;
-    unsigned index;
+    TypeID interfaceTypeID;
 
     decls_block::GenericTypeParamDeclLayout::readRecord(
-        scratch, nameID, isImplicit, rawParamKind, depth, index);
+        scratch, nameID, isImplicit, interfaceTypeID);
 
-    auto paramKind = getActualParamKind(rawParamKind);
-    if (!paramKind)
-      return MF.diagnoseFatal();
+    auto interfaceTy = MF.getTypeChecked(interfaceTypeID);
+    if (!interfaceTy)
+      return interfaceTy.takeError();
+
+    auto paramTy = interfaceTy.get()->castTo<GenericTypeParamType>();
 
     // Always create GenericTypeParamDecls in the associated file; the real
     // context will reparent them.
     auto *DC = MF.getFile();
     auto *genericParam = GenericTypeParamDecl::createDeserialized(
-        DC, MF.getIdentifier(nameID), depth, index, *paramKind);
+        DC, MF.getIdentifier(nameID), paramTy->getDepth(), paramTy->getIndex(),
+        paramTy->getParamKind());
     declOrOffset = genericParam;
 
     if (isImplicit)
       genericParam->setImplicit();
 
+    // If we're dealing with a value generic, the parameter type already
+    // serializes the value type. Inform the request evaluator that we don't
+    // need to recompute this value for the param decl.
+    if (paramTy->isValue()) {
+      ctx.evaluator.cacheOutput(
+        GenericTypeParamDeclGetValueTypeRequest{genericParam},
+        paramTy->getValueType());
+    }
+
     return genericParam;
   }
 
diff --git a/lib/Serialization/ModuleFormat.h b/lib/Serialization/ModuleFormat.h
@@ -1491,9 +1491,7 @@ namespace decls_block {
   using GenericTypeParamDeclLayout = BCRecordLayout<GENERIC_TYPE_PARAM_DECL,
     IdentifierIDField,     // name
     BCFixed<1>,            // implicit flag
-    GenericParamKindField, // param kind
-    BCVBR<4>,              // depth
-    BCVBR<4>               // index
+    TypeIDField            // interface type
   >;
 
   using AssociatedTypeDeclLayout = BCRecordLayout<
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp
@@ -4198,8 +4198,7 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
         S.Out, S.ScratchRecord, abbrCode,
         S.addDeclBaseNameRef(genericParam->getName()),
         genericParam->isImplicit(),
-        getRawStableGenericParamKind(genericParam->getParamKind()),
-        genericParam->getDepth(), genericParam->getIndex());
+        S.addTypeRef(genericParam->getDeclaredInterfaceType()->getCanonicalType()));
   }
 
   void visitAssociatedTypeDecl(const AssociatedTypeDecl *assocType) {
diff --git a/test/SIL/Parser/basic2.sil b/test/SIL/Parser/basic2.sil
@@ -405,3 +405,12 @@ die:
   dealloc_box [dead_end] %b : ${ var Klass }
   unreachable
 }
+
+// CHECK-LABEL: sil [ossa] @test_type_value : $@convention(thin) <let N : Int> () -> Int {
+// CHECK:         type_value $Int for N
+// CHECK-LABEL: } // end sil function 'test_type_value
+sil [ossa] @test_type_value : $@convention(thin) <let N : Int> () -> Int {
+entry:
+  %val = type_value $Int for N
+  return %val : $Int
+}
diff --git a/test/SIL/Serialization/basic2.sil b/test/SIL/Serialization/basic2.sil
@@ -5,6 +5,7 @@
 // RUN: %target-sil-opt %t/tmp.2.sib -module-name basic2 -emit-sorted-sil | %FileCheck %s
 
 import Builtin
+import Swift
 
 class C {}
 sil @getC : $@convention(thin) () -> (@owned C)
@@ -228,6 +229,16 @@ bb0:
   return %9999 : $()
 }
 
+// CHECK-LABEL: sil [ossa] @test_type_value : $@convention(thin) <let N : Int> () -> Int {
+// CHECK:         [[VAL:%.*]] = type_value $Int for N
+// CHECK:         return [[VAL]] : $Int
+// CHECK-LABEL: } // end sil function 'test_type_value'
+sil [ossa] @test_type_value : $@convention(thin) <let N : Int> () -> Int {
+entry:
+  %val = type_value $Int for N
+  return %val : $Int
+}
+
 // CHECK-LABEL: sil [ossa] @tuple_addr_constructor_assign : $@convention(thin) (@in Builtin.NativeObject, @in (Builtin.NativeObject, Builtin.NativeObject)) -> () {
 // CHECK: bb0([[LHS:%.*]] : $*Builtin.NativeObject,
 // CHECK: [[RHS:%.*]] = alloc_stack $Builtin.NativeObject
diff --git a/test/Sema/value_generics.swift b/test/Sema/value_generics.swift
@@ -2,6 +2,8 @@
 
 protocol P {}
 
+func invalid<let N>() {} // expected-error {{value generic 'N' must have an explicit value type declared}}
+
 struct A<let N: Int> {
   var int: Int {
     N // OK

Original file line number	Diff line number	Diff line change
`@@ -4198,8 +4198,7 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {`
`4198`	`4198`	`S.Out, S.ScratchRecord, abbrCode,`
`4199`	`4199`	`S.addDeclBaseNameRef(genericParam->getName()),`
`4200`	`4200`	`genericParam->isImplicit(),`
`4201`		`- getRawStableGenericParamKind(genericParam->getParamKind()),`
`4202`		`- genericParam->getDepth(), genericParam->getIndex());`
	`4201`	`+ S.addTypeRef(genericParam->getDeclaredInterfaceType()->getCanonicalType()));`
`4203`	`4202`	`}`
`4204`	`4203`
`4205`	`4204`	`void visitAssociatedTypeDecl(const AssociatedTypeDecl *assocType) {`