Bring back the isOpaqueType parameter for deserialization

Author: Azoy

include/swift/AST/Decl.h

@@ -3789,11 +3789,14 @@ class GenericTypeParamDecl final
   /// \param depth The generic signature depth.
   /// \param index The index of the parameter in the generic signature.
   /// \param paramKind The kind of generic type parameter this is.
+  /// \param isOpaqueType Whether the generic parameter is written as an opaque
+  ///                     parameter e.g 'some Collection'.
   /// \param opaqueTypeRepr The TypeRepr of an opaque generic parameter.
   ///
   GenericTypeParamDecl(DeclContext *dc, Identifier name, SourceLoc nameLoc,
                        SourceLoc specifierLoc, unsigned depth, unsigned index,
-                       GenericTypeParamKind paramKind, TypeRepr *opaqueTypeRepr);
+                       GenericTypeParamKind paramKind, bool isOpaqueType,
+                       TypeRepr *opaqueTypeRepr);
 
   /// Construct a new generic type parameter.
   ///
@@ -3808,12 +3811,15 @@ class GenericTypeParamDecl final
   /// \param depth The generic signature depth.
   /// \param index The index of the parameter in the generic signature.
   /// \param paramKind The kind of generic type parameter this is.
+  /// \param isOpaqueType Whether the generic parameter is written as an opaque
+  ///                     parameter e.g 'some Collection'.
   /// \param opaqueTypeRepr The TypeRepr of an opaque generic parameter.
   ///
   static GenericTypeParamDecl *create(DeclContext *dc, Identifier name,
                                       SourceLoc nameLoc, SourceLoc specifierLoc,
                                       unsigned depth, unsigned index,
                                       GenericTypeParamKind paramKind,
+                                      bool isOpaqueType,
                                       TypeRepr *opaqueTypeRepr);
 
 public:
@@ -3825,7 +3831,7 @@ class GenericTypeParamDecl final
                        SourceLoc specifierLoc, unsigned depth, unsigned index,
                        GenericTypeParamKind paramKind)
       : GenericTypeParamDecl(dc, name, nameLoc, specifierLoc, depth, index,
-                             paramKind, nullptr) {
+                             paramKind, false, nullptr) {
   }
 
   /// Construct a deserialized generic type parameter.
@@ -3838,10 +3844,13 @@ class GenericTypeParamDecl final
   /// \param depth The generic signature depth.
   /// \param index The index of the parameter in the generic signature.
   /// \param paramKind The kind of generic type parameter this is.
+  /// \param isOpaqueType Whether the generic parameter is written as an opaque
+  ///                     parameter e.g 'some Collection'.
   ///
   static GenericTypeParamDecl *
   createDeserialized(DeclContext *dc, Identifier name, unsigned depth,
-                     unsigned index, GenericTypeParamKind paramKind);
+                     unsigned index, GenericTypeParamKind paramKind,
+                     bool isOpaqueType);
 
   /// Construct a new parsed generic type parameter.
   ///

lib/AST/Decl.cpp

@@ -5649,18 +5649,20 @@ GenericTypeParamDecl::GenericTypeParamDecl(DeclContext *dc, Identifier name,
                                            SourceLoc specifierLoc,
                                            unsigned depth, unsigned index,
                                            GenericTypeParamKind paramKind,
+                                           bool isOpaqueType,
                                            TypeRepr *opaqueTypeRepr)
     : TypeDecl(DeclKind::GenericTypeParam, dc, name, nameLoc, {}) {
   ASSERT(!(specifierLoc &&
          !(paramKind == GenericTypeParamKind::Pack || paramKind == GenericTypeParamKind::Value)) &&
     "'each' or 'let' keyword imply a parameter pack or value generic parameter");
+  ASSERT(isOpaqueType || !opaqueTypeRepr);
 
   Bits.GenericTypeParamDecl.Depth = depth;
   assert(Bits.GenericTypeParamDecl.Depth == depth && "Truncation");
   Bits.GenericTypeParamDecl.Index = index;
   assert(Bits.GenericTypeParamDecl.Index == index && "Truncation");
   Bits.GenericTypeParamDecl.ParamKind = (uint8_t) paramKind;
-  Bits.GenericTypeParamDecl.IsOpaqueType = (bool) opaqueTypeRepr;
+  Bits.GenericTypeParamDecl.IsOpaqueType = isOpaqueType;
 
   if (this->isOpaqueType())
     *getTrailingObjects<TypeRepr *>() = opaqueTypeRepr;
@@ -5675,7 +5677,7 @@ GenericTypeParamDecl::GenericTypeParamDecl(DeclContext *dc, Identifier name,
 GenericTypeParamDecl *GenericTypeParamDecl::create(
     DeclContext *dc, Identifier name, SourceLoc nameLoc, SourceLoc specifierLoc,
     unsigned depth, unsigned index, GenericTypeParamKind paramKind,
-    TypeRepr *opaqueTypeRepr) {
+    bool isOpaqueType, TypeRepr *opaqueTypeRepr) {
   auto &ctx = dc->getASTContext();
 
   auto numTypeReprs = 0;
@@ -5694,14 +5696,15 @@ GenericTypeParamDecl *GenericTypeParamDecl::create(
   auto mem = ctx.Allocate(allocSize, alignof(GenericTypeParamDecl));
   return new (mem)
       GenericTypeParamDecl(dc, name, nameLoc, specifierLoc, depth, index,
-                           paramKind, opaqueTypeRepr);
+                           paramKind, isOpaqueType, opaqueTypeRepr);
 }
 
 GenericTypeParamDecl *GenericTypeParamDecl::createDeserialized(
     DeclContext *dc, Identifier name, unsigned depth, unsigned index,
-    GenericTypeParamKind paramKind) {
+    GenericTypeParamKind paramKind, bool isOpaqueType) {
   return GenericTypeParamDecl::create(dc, name, SourceLoc(), SourceLoc(),
                                       depth, index, paramKind,
+                                      isOpaqueType,
                                       /*opaqueRepr*/ nullptr);
 }
 
@@ -5715,7 +5718,7 @@ GenericTypeParamDecl::createParsed(DeclContext *dc, Identifier name,
   // parameter list.
   return GenericTypeParamDecl::create(
       dc, name, nameLoc, specifierLoc, GenericTypeParamDecl::InvalidDepth,
-      index, paramKind, /*opaqueTypeRepr*/ nullptr);
+      index, paramKind, /*isOpaqueType*/ false, /*opaqueTypeRepr*/ nullptr);
 }
 
 GenericTypeParamDecl *GenericTypeParamDecl::createImplicit(
@@ -5724,6 +5727,7 @@ GenericTypeParamDecl *GenericTypeParamDecl::createImplicit(
     SourceLoc specifierLoc) {
   auto *param = GenericTypeParamDecl::create(dc, name, nameLoc, specifierLoc,
                                              depth, index, paramKind,
+                                             (bool)opaqueTypeRepr,
                                              opaqueTypeRepr);
   param->setImplicit();
   return param;

lib/Serialization/Deserialization.cpp

@@ -3466,10 +3466,11 @@ class DeclDeserializer {
                                   StringRef blobData) {
     IdentifierID nameID;
     bool isImplicit;
+    bool isOpaqueType;
     TypeID interfaceTypeID;
 
     decls_block::GenericTypeParamDeclLayout::readRecord(
-        scratch, nameID, isImplicit, interfaceTypeID);
+        scratch, nameID, isImplicit, isOpaqueType, interfaceTypeID);
 
     auto interfaceTy = MF.getTypeChecked(interfaceTypeID);
     if (!interfaceTy)
@@ -3482,7 +3483,7 @@ class DeclDeserializer {
     auto *DC = MF.getFile();
     auto *genericParam = GenericTypeParamDecl::createDeserialized(
         DC, MF.getIdentifier(nameID), paramTy->getDepth(), paramTy->getIndex(),
-        paramTy->getParamKind());
+        paramTy->getParamKind(), isOpaqueType);
     declOrOffset = genericParam;
 
     if (isImplicit)

lib/Serialization/ModuleFormat.h

@@ -1497,6 +1497,7 @@ namespace decls_block {
   using GenericTypeParamDeclLayout = BCRecordLayout<GENERIC_TYPE_PARAM_DECL,
     IdentifierIDField,     // name
     BCFixed<1>,            // implicit flag
+    BCFixed<1>,            // is opaque?
     TypeIDField            // interface type
   >;
 

lib/Serialization/Serialization.cpp

@@ -4198,6 +4198,7 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
         S.Out, S.ScratchRecord, abbrCode,
         S.addDeclBaseNameRef(genericParam->getName()),
         genericParam->isImplicit(),
+        genericParam->isOpaqueType(),
         S.addTypeRef(genericParam->getDeclaredInterfaceType()->getCanonicalType()));
   }