lambdas in modules: handle lambdas in .pcm [de]serialization

[elsteveogrande]

Summary

• Drop a couple of asserts preventing this (in the merge function)
• Merge all fields as usual
• Ensure select fields match, for ODR checking
• add previously-failing test to merge-lambdas.cpp

Test case by Andrew Gallagher

NOTE: depends on D50948

Test Plan:

• Andrew's repro from https://bugs.llvm.org/show_bug.cgi?id=38531 broke before this change, works after.
• Similar repro added here as a test case.

[elsteveogrande]

Rebase atop updated dependency D50948. Small cleanups to this diff.

[elsteveogrande]

rebase atop D50948 (correctly this time) to exclude those changes

include/clang/AST/LambdaCapture.h

public:
   bool isPackExpansion() const { return EllipsisLoc.isValid(); }
 
   /// Retrieve the location of the ellipsis for a capture
   /// that is a pack expansion.
   SourceLocation getEllipsisLoc() const {
     assert(isPackExpansion() && "No ellipsis location for a non-expansion");
     return EllipsisLoc;
   }
+
+  // [In]Equality operators -- primarily for ODR-compliance checking.
+
+  bool operator==(LambdaCapture const &RHS) const {
+    return DeclAndBits == RHS.DeclAndBits;
+  }
+
+  bool operator!=(LambdaCapture const &RHS) const {
+    return !operator==(RHS);
+  }
 };
 
 } // end namespace clang
 
 #endif // LLVM_CLANG_AST_LAMBDACAPTURE_H

lib/Serialization/ASTReaderDecl.cpp

assert(Reader.Lookups.find(MergeDD.Definition) == Reader.Lookups.end() &&
            "already loaded pending lookups for merged definition");
   }
 
   auto PFDI = Reader.PendingFakeDefinitionData.find(&DD);
   if (PFDI != Reader.PendingFakeDefinitionData.end() &&
       PFDI->second == ASTReader::PendingFakeDefinitionKind::Fake) {
     // We faked up this definition data because we found a class for which we'd
     // not yet loaded the definition. Replace it with the real thing now.
-    assert(!DD.hasLambdaData() && !MergeDD.hasLambdaData() &&
-           "faked up lambda definition?");
     PFDI->second = ASTReader::PendingFakeDefinitionKind::FakeLoaded;
 
     // Don't change which declaration is the definition; that is required
     // to be invariant once we select it.
     auto *Def = DD.Definition;
     DD = std::move(MergeDD);
     DD.Definition = Def;
     return;
#undef MATCH_FIELD
   if (MergeDD.ComputedVisibleConversions && !DD.ComputedVisibleConversions) {
     DD.VisibleConversions = std::move(MergeDD.VisibleConversions);
     DD.ComputedVisibleConversions = true;
   }
 
   // FIXME: Issue a diagnostic if FirstFriend doesn't match when we come to
   // lazily load it.
 
-  if (DD.hasLambdaData()) {
-    // FIXME: ODR-checking for merging lambdas (this happens, for instance,
-    // when they occur within the body of a function template specialization).
+  assert (DD.hasLambdaData() == MergeDD.hasLambdaData() &&
+          "Merging definitions, one of which is a lambda, the other not?");
+  if (DD.hasLambdaData() && MergeDD.hasLambdaData()) {
+    auto &LDD = *DD.LambdaData;
+    auto &MergeLDD = *MergeDD.LambdaData;
+
+#define MATCH_LAM_FIELD(Field) \
+                            DetectedOdrViolation |= LDD.Field != MergeLDD.Field;
+    MATCH_LAM_FIELD(Dependent)
+    MATCH_LAM_FIELD(IsGenericLambda)
+    MATCH_LAM_FIELD(CaptureDefault)
+    MATCH_LAM_FIELD(NumCaptures)
+    MATCH_LAM_FIELD(NumExplicitCaptures)
+    MATCH_LAM_FIELD(ManglingNumber)
+#undef MATCH_LAM_FIELD
+
+    auto *C1 = LDD.Captures;
+    auto *C2 = MergeLDD.Captures;
+    for (int I = 0; !DetectedOdrViolation && I < LDD.NumCaptures; ++I) {
+      if (C1[I] != C2[I]) {
+        DetectedOdrViolation = true;
+      }
+    }
+
+    if (LDD.MethodTyInfo || MergeLDD.MethodTyInfo) {
+      if (!LDD.MethodTyInfo ||
+          !MergeLDD.MethodTyInfo ||
+          (LDD.MethodTyInfo->getType().getTypePtrOrNull() !=
+              MergeLDD.MethodTyInfo->getType().getTypePtrOrNull())) {
+        DetectedOdrViolation = true;
+      }
+    }
+
+    // FIXME: Issue a diagnostic if ContextDecl doesn't match when we come to
+    // lazily load it.
   }
 
   if (D->getODRHash() != MergeDD.ODRHash) {
     DetectedOdrViolation = true;
   }
 
   if (DetectedOdrViolation)
     Reader.PendingOdrMergeFailures[DD.Definition].push_back(

test/Modules/merge-lambdas.cpp

 using U = decltype(x2);
 using U = decltype(y2);
 
 using V = decltype(x3);
 using V = decltype(y3);
 
 #pragma clang module import A
 void (*p)() = f<int>();
+
+#pragma clang module build PR38531
+module PR38531 {}
+#pragma clang module contents
+#pragma clang module begin PR38531
+template <typename>
+struct S {};
+struct Fun {
+  template <typename F, typename T=decltype(S<F>())>
+  Fun(F) {}
+};
+template <typename>
+void foo(Fun=[]{}) {}
+struct T {
+  void func() {
+    foo<void>();
+  }
+};
+#pragma clang module end
+#pragma clang module endbuild
+#pragma clang module import PR38531
+S<void> s;