Collect Fingerprints for Nested Decls

Serialization was reporting that it did not have fingerprints for these declarations. When combined with the driver's new type body fingerprint work for extensions, this effectively hid changes to the bodies of these nested types from the driver's incremental build infrastructure.

Make sure we recur into all of the iterable decl contexts when serializing decls to collect as many fingerprints as we can.

rdar://83469936

Author: CodaFi

lib/Serialization/Serialization.cpp

@@ -5280,6 +5280,7 @@ static void collectInterestingNestedDeclarations(
     Serializer::ObjCMethodTable &objcMethods,
     Serializer::NestedTypeDeclsTable &nestedTypeDecls,
     Serializer::UniquedDerivativeFunctionConfigTable &derivativeConfigs,
+    Serializer::DeclFingerprintsTable &declFingerprints,
     bool isLocal = false) {
   const NominalTypeDecl *nominalParent = nullptr;
 
@@ -5347,10 +5348,15 @@ static void collectInterestingNestedDeclarations(
 
     // Recurse into nested declarations.
     if (auto iterable = dyn_cast<IterableDeclContext>(member)) {
+      if (auto bodyFP = iterable->getBodyFingerprint()) {
+        declFingerprints.insert({S.addDeclRef(member), *bodyFP});
+      }
+
       collectInterestingNestedDeclarations(S, iterable->getAllMembers(),
                                            operatorMethodDecls,
                                            objcMethods, nestedTypeDecls,
                                            derivativeConfigs,
+                                           declFingerprints,
                                            isLocal);
     }
   }
@@ -5432,7 +5438,8 @@ void Serializer::writeAST(ModuleOrSourceFile DC) {
         collectInterestingNestedDeclarations(*this, IDC->getAllMembers(),
                                              operatorMethodDecls, objcMethods,
                                              nestedTypeDecls,
-                                             uniquedDerivativeConfigs);
+                                             uniquedDerivativeConfigs,
+                                             declFingerprints);
       }
     }
 
@@ -5466,6 +5473,7 @@ void Serializer::writeAST(ModuleOrSourceFile DC) {
                                              operatorMethodDecls, objcMethods,
                                              nestedTypeDecls,
                                              uniquedDerivativeConfigs,
+                                             declFingerprints,
                                              /*isLocal=*/true);
       }
     }

test/Incremental/Fingerprints/Inputs/nested-enum-fingerprint/definesAB-after.swift

@@ -0,0 +1,11 @@
+struct S {}
+
+extension S {
+  enum A {
+    case a1
+    var pi: Int {3}
+  }
+  enum B {
+    case a1
+  }
+}

test/Incremental/Fingerprints/Inputs/nested-enum-fingerprint/definesAB-before.swift

@@ -0,0 +1,10 @@
+struct S {}
+
+extension S {
+  enum A {
+    case a1
+  }
+  enum B {
+    case a1
+  }
+}

test/Incremental/Fingerprints/Inputs/nested-enum-fingerprint/main.swift

@@ -0,0 +1 @@
+

test/Incremental/Fingerprints/Inputs/nested-enum-fingerprint/ofm.json

@@ -0,0 +1,22 @@
+{
+  "main.swift": {
+    "object": "./main.o",
+    "swift-dependencies": "./main.swiftdeps"
+  },
+  "definesAB.swift": {
+    "object": "./definesAB.o",
+    "swift-dependencies": "./definesAB.swiftdeps"
+  },
+  "usesA.swift": {
+    "object": "./usesA.o",
+    "swift-dependencies": "./usesA.swiftdeps"
+  },
+  "usesB.swift": {
+    "object": "./usesB.o",
+    "swift-dependencies": "./usesB.swiftdeps"
+  },
+  "": {
+    "swift-dependencies": "./main~buildrecord.swiftdeps"
+  }
+}
+

test/Incremental/Fingerprints/Inputs/nested-enum-fingerprint/usesA.swift

@@ -0,0 +1 @@
+let a = S.A.a1

test/Incremental/Fingerprints/Inputs/nested-enum-fingerprint/usesB.swift

@@ -0,0 +1 @@
+let b = S.B.a1

test/Incremental/Fingerprints/nested-enum-fingerprint.swift

@@ -0,0 +1,34 @@
+// Test per-type-body fingerprints for enums nested in extensions
+//
+
+// Establish status quo
+
+// RUN: %empty-directory(%t)
+// RUN: cp %S/Inputs/nested-enum-fingerprint/* %t
+// RUN: cp %t/definesAB{-before,}.swift
+
+// Seeing weird failure on CI, so set the mod times
+// RUN: touch -t 200101010101 %t/*.swift
+
+// RUN: cd %t && %target-swiftc_driver  -enable-batch-mode -j2 -incremental -driver-show-incremental main.swift definesAB.swift usesA.swift usesB.swift -module-name main -output-file-map ofm.json >&output3
+
+// only-run-for-debugging: cp %t/usesB.swiftdeps %t/usesB3.swiftdeps
+
+
+// Change one type, only uses of that type get recompiled
+
+// RUN: cp %t/definesAB{-after,}.swift
+
+// Seeing weird failure on CI, so ensure that definesAB.swift is newer
+// RUN: touch -t 200201010101 %t/*
+// RUN: touch -t 200101010101 %t/*.swift
+// RUN: touch -t 200301010101 %t/definesAB.swift
+
+// RUN: cd %t && %target-swiftc_driver  -enable-batch-mode -j2 -incremental -driver-show-incremental main.swift definesAB.swift usesA.swift usesB.swift -module-name main -output-file-map ofm.json >&output4
+
+// only-run-for-debugging: cp %t/usesB.swiftdeps %t/usesB4.swiftdeps
+
+// RUN: %FileCheck -check-prefix=CHECK-MAINAB-RECOMPILED %s < %t/output4
+
+// CHECK-MAINAB-RECOMPILED: Queuing (initial): {compile: definesAB.o <= definesAB.swift}
+// CHECK-MAINAB-RECOMPILED: Queuing because of dependencies discovered later: {compile: usesA.o <= usesA.swift}