Merge pull request #8062 from slavapestov/serialization-cleanup

Serialization cleanup

Author: slavapestov

include/swift/Serialization/ModuleFile.h

@@ -490,9 +490,6 @@ class ModuleFile : public LazyMemberLoader {
 
   ParameterList *readParameterList();
 
-  GenericParamList *maybeGetOrReadGenericParams(serialization::DeclID contextID,
-                                                DeclContext *DC);
-
   /// Reads a generic param list from \c DeclTypeCursor.
   ///
   /// If the record at the cursor is not a generic param list, returns null

lib/Serialization/Deserialization.cpp

@@ -783,25 +783,6 @@ ModuleFile::maybeReadSubstitution(llvm::BitstreamCursor &cursor,
                       getContext().AllocateCopy(conformanceBuf)};
 }
 
-GenericParamList *
-ModuleFile::maybeGetOrReadGenericParams(serialization::DeclID genericContextID,
-                                        DeclContext *DC) {
-  if (genericContextID) {
-    Decl *genericContext = getDecl(genericContextID);
-    assert(genericContext && "loading PolymorphicFunctionType before its decl");
-
-    if (auto fn = dyn_cast<AbstractFunctionDecl>(genericContext))
-      return fn->getGenericParams();
-    if (auto nominal = dyn_cast<NominalTypeDecl>(genericContext))
-      return nominal->getGenericParams();
-    if (auto ext = dyn_cast<ExtensionDecl>(genericContext))
-      return ext->getGenericParams();
-    llvm_unreachable("only functions and nominals can provide generic params");
-  } else {
-    return maybeReadGenericParams(DC);
-  }
-}
-
 GenericParamList *ModuleFile::maybeReadGenericParams(DeclContext *DC,
                                                GenericParamList *outerParams) {
   using namespace decls_block;
@@ -821,7 +802,6 @@ GenericParamList *ModuleFile::maybeReadGenericParams(DeclContext *DC,
     return nullptr;
 
   SmallVector<GenericTypeParamDecl *, 8> params;
-  SmallVector<RequirementRepr, 8> requirements;
 
   while (true) {
     lastRecordOffset.reset();
@@ -3448,9 +3428,12 @@ Decl *ModuleFile::getDecl(DeclID DID, Optional<DeclContext *> ForcedContext) {
     extension->setEarlyAttrValidation();
     declOrOffset = extension;
 
-    // Generic parameters.
-    GenericParamList *genericParams = maybeReadGenericParams(DC);
-    extension->setGenericParams(genericParams);
+    // Generic parameter lists are written from outermost to innermost.
+    // Keep reading until we run out of generic parameter lists.
+    GenericParamList *outerParams = nullptr;
+    while (auto *genericParams = maybeReadGenericParams(DC, outerParams))
+      outerParams = genericParams;
+    extension->setGenericParams(outerParams);
 
     configureGenericEnvironment(extension, genericEnvID);
 
@@ -3478,6 +3461,19 @@ Decl *ModuleFile::getDecl(DeclID DID, Optional<DeclContext *> ForcedContext) {
 
     nominal->addExtension(extension);
 
+#ifndef NDEBUG
+    if (outerParams) {
+      unsigned paramCount = 0;
+      for (auto *paramList = outerParams;
+           paramList != nullptr;
+           paramList = paramList->getOuterParameters()) {
+        paramCount += paramList->size();
+      }
+      assert(paramCount ==
+             extension->getGenericSignature()->getGenericParams().size());
+    }
+#endif
+
     break;
   }
 

lib/Serialization/Serialization.cpp

@@ -447,18 +447,6 @@ DeclID Serializer::addDeclRef(const Decl *D, bool forceSerialization) {
           isa<PrecedenceGroupDecl>(D)) &&
          "cannot cross-reference this decl");
 
-  // Record any generic parameters that come from this decl, so that we can use
-  // the decl to refer to the parameters later.
-  const GenericParamList *paramList = nullptr;
-  if (auto fn = dyn_cast<AbstractFunctionDecl>(D))
-    paramList = fn->getGenericParams();
-  else if (auto nominal = dyn_cast<NominalTypeDecl>(D))
-    paramList = nominal->getGenericParams();
-  else if (auto ext = dyn_cast<ExtensionDecl>(D))
-    paramList = ext->getGenericParams();
-  if (paramList)
-    GenericContexts[paramList] = D;
-
   id = { ++LastDeclID, forceSerialization };
   DeclsAndTypesToWrite.push(D);
   return id.first;
@@ -535,11 +523,6 @@ NormalConformanceID Serializer::addConformanceRef(
   return conformanceID;
 }
 
-const Decl *Serializer::getGenericContext(const GenericParamList *paramList) {
-  auto contextDecl = GenericContexts.lookup(paramList);
-  return contextDecl;
-}
-
 /// Record the name of a block.
 static void emitBlockID(llvm::BitstreamWriter &out, unsigned ID,
                         StringRef name,
@@ -2402,7 +2385,21 @@ void Serializer::writeDecl(const Decl *D) {
                          isa<ProtocolDecl>(baseNominal);
     }
 
-    writeGenericParams(extension->getGenericParams());
+    // Extensions of nested generic types have multiple generic parameter
+    // lists. Collect them all, from the innermost to outermost.
+    SmallVector<GenericParamList *, 2> allGenericParams;
+    for (auto *genericParams = extension->getGenericParams();
+         genericParams != nullptr;
+         genericParams = genericParams->getOuterParameters()) {
+      allGenericParams.push_back(genericParams);
+    }
+
+    // Reverse the list, and write the parameter lists, from outermost
+    // to innermost.
+    std::reverse(allGenericParams.begin(), allGenericParams.end());
+    for (auto *genericParams : allGenericParams)
+      writeGenericParams(genericParams);
+
     writeMembers(extension->getMembers(), isClassExtension);
     writeConformances(conformances, DeclTypeAbbrCodes);
     break;

lib/Serialization/Serialization.h

@@ -100,9 +100,6 @@ class Serializer {
   /// A map from local DeclContexts to their serialized IDs.
   llvm::DenseMap<const DeclContext*, DeclContextID> LocalDeclContextIDs;
 
-  /// A map from generic parameter lists to the decls they come from.
-  llvm::DenseMap<const GenericParamList *, const Decl *> GenericContexts;
-
   /// A map from generic environments to their serialized IDs.
   llvm::DenseMap<const GenericEnvironment *, GenericEnvironmentID>
     GenericEnvironmentIDs;
@@ -120,10 +117,6 @@ class Serializer {
   /// table.
   using DeclTable = llvm::MapVector<Identifier, DeclTableData>;
 
-  /// Returns the declaration the given generic parameter list is associated
-  /// with.
-  const Decl *getGenericContext(const GenericParamList *paramList);
-
   using ObjCMethodTableData = SmallVector<std::tuple<TypeID, bool, DeclID>, 4>;
 
   // In-memory representation of what will eventually be an on-disk

test/Serialization/Inputs/has_generic_subscript.swift

@@ -0,0 +1,25 @@
+public struct GenericSubscript {
+  public init() { }
+
+  public subscript<K, V>(k: K) -> V {
+    get {
+      while true { }
+    }
+    set { }
+  }
+}
+
+public struct Outer<T> {
+  public struct Inner<U> {
+    public init() {}
+  }
+}
+
+extension Outer.Inner {
+  public subscript<K, V>(k: K) -> V {
+    get {
+      while true { }
+    }
+    set { }
+  }
+}

test/Serialization/Inputs/has_nested_generic_extension.swift

@@ -0,0 +1,11 @@
+public struct Outer<T> {
+  public struct Inner<U> {
+    public init() {}
+  }
+}
+
+extension Outer.Inner {
+  public func extensionMethod(t: T) -> U {
+    while true {}
+  }
+}

test/Serialization/generic_subscript.swift

@@ -0,0 +1,12 @@
+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: %target-swift-frontend -emit-module -o %t %S/Inputs/has_generic_subscript.swift
+// RUN: llvm-bcanalyzer %t/has_generic_subscript.swiftmodule | %FileCheck %s
+// RUN: %target-swift-frontend -emit-ir -I %t %s -o /dev/null
+
+// CHECK-NOT: UnknownCode
+
+import has_generic_subscript
+
+var sillyDict = GenericSubscript()
+var value: Int = sillyDict["beer"]

test/Serialization/nested_generic_extension.swift

@@ -0,0 +1,12 @@
+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: %target-swift-frontend -emit-module -o %t %S/Inputs/has_nested_generic_extension.swift
+// RUN: llvm-bcanalyzer %t/has_nested_generic_extension.swiftmodule | %FileCheck %s
+// RUN: %target-swift-frontend -emit-ir -I %t %s -o /dev/null
+
+// CHECK-NOT: UnknownCode
+
+import has_nested_generic_extension
+
+var sillyGeneric = Outer<String>.Inner<Float>()
+let result: Float = sillyGeneric.extensionMethod(t: "square root of two")