[cxx-interop] Avoid querying layout of dependent types during symbolic import

In #80786, we started importing certain padded fields as opaque blobs.
Part of this logic involved querying those fields' ASTRecordLayout.
However, dependent types (which are imported symbolically) do not have
an ASTRecordLayout, so calling Clang's getASTRecordLayout() would lead
to an assertion error for class templates where a no_unique_address
field is some kind of dependent C++ record type.

This patch avoids the field padding check during symbolic import mode
because that check is only relevant for codegen anyway.

rdar://150067288

Author: j-hui

lib/ClangImporter/ImportDecl.cpp

@@ -4480,11 +4480,17 @@ namespace {
     }
 
     Decl *VisitFieldDecl(const clang::FieldDecl *decl) {
-      if (decl->hasAttr<clang::NoUniqueAddressAttr>()) {
+      if (!Impl.importSymbolicCXXDecls &&
+          decl->hasAttr<clang::NoUniqueAddressAttr>()) {
         if (const auto *rd = decl->getType()->getAsRecordDecl()) {
           // Clang can store the next field in the padding of this one. Swift
           // does not support this yet so let's not import the field and
           // represent it with an opaque blob in codegen.
+          //
+          // This check is not relevant when importing the decl symbolically
+          // (since that isn't used for codegen). In fact, we need to avoid this
+          // check because symbolic imports can expose us to dependent types
+          // whose ASTRecordLayout cannot be queried.
           const auto &fieldLayout =
               decl->getASTContext().getASTRecordLayout(rd);
           auto &clangCtx = decl->getASTContext();

test/Interop/Cxx/class/Inputs/member-variables.h

@@ -67,6 +67,18 @@ struct ReuseNonStandardLayoutFieldPadding {
   int offset() const { return (char *) &this->c - (char *) this; }
 };
 
+template<typename T>
+struct ReuseDependentFieldPadding {
+  [[no_unique_address]] struct { private: T x; public: char pad_me; } a;
+  char c;
+  char get_c() const { return c; }
+  void set_c(char c) { this->c = c; }
+  // C-style implementation of offsetof() to avoid non-standard-layout warning
+  int offset() const { return (char *) &this->c - (char *) this; }
+};
+
+typedef ReuseDependentFieldPadding<int> ReuseDependentFieldPaddingInt;
+
 inline int takesZeroSizedInCpp(HasZeroSizedField x) {
   return x.a;
 }

test/Interop/Cxx/class/zero-sized-field.swift

@@ -1,4 +1,5 @@
-// RUN: %target-run-simple-swift(-I %S/Inputs/ -Xfrontend -enable-experimental-cxx-interop -Xcc -std=c++20)
+// RUN: %empty-directory(%t/index)
+// RUN: %target-run-simple-swift(-I %S/Inputs/ -Xfrontend -enable-experimental-cxx-interop -Xcc -std=c++20 -Xfrontend -index-store-path -Xfrontend %t/index)
 //
 // REQUIRES: executable_test
 
@@ -68,4 +69,18 @@ FieldsTestSuite.test("Non-standard-layout field padding reused") {
   expectEqual(s2.get_c(), 6)
 }
 
+FieldsTestSuite.test("Non-standard-layout field padding in templated class reused") {
+  var s = ReuseDependentFieldPaddingInt()
+  s.c = 5
+  expectEqual(Int(s.offset()),  MemoryLayout<ReuseDependentFieldPaddingInt>.offset(of: \.c)!)
+  expectEqual(s.c, 5)
+  expectEqual(s.get_c(), 5)
+  s.set_c(6)
+  expectEqual(s.c, 6)
+  expectEqual(s.get_c(), 6)
+  let s2 = s
+  expectEqual(s2.c, 6)
+  expectEqual(s2.get_c(), 6)
+}
+
 runAllTests()