ClangImporter: use nameless arguments for anonymous struct/unions in constructors

lib/ClangImporter/ImportDecl.cpp

@@ -1087,12 +1087,20 @@ createValueConstructor(ClangImporter::Implementation &Impl,
   // Construct the set of parameters from the list of members.
   SmallVector<ParamDecl *, 8> valueParameters;
   for (auto var : members) {
-    // TODO create value constructor with indirect fields instead of the
-    // generated __Anonymous_field.
-    if (var->hasClangNode() && isa<clang::IndirectFieldDecl>(var->getClangDecl()))
-      continue;
+    bool generateParamName = wantCtorParamNames;
+
+    if (var->hasClangNode()) {
+      // TODO create value constructor with indirect fields instead of the
+      // generated __Anonymous_field.
+      if (isa<clang::IndirectFieldDecl>(var->getClangDecl()))
+        continue;
+
+      if (auto clangField = dyn_cast<clang::FieldDecl>(var->getClangDecl()))
+        if (clangField->isAnonymousStructOrUnion())
+          generateParamName = false;
+    }
 
-    Identifier argName = wantCtorParamNames ? var->getName() : Identifier();
+    Identifier argName = generateParamName ? var->getName() : Identifier();
     auto param = new (context)
         ParamDecl(/*IsLet*/ true, SourceLoc(), SourceLoc(), argName,
                   SourceLoc(), var->getName(), var->getType(), structDecl);

test/ClangImporter/Inputs/custom-modules/IndirectFields.h

@@ -14,3 +14,16 @@ union UnionWithIndirectField {
     };
     int c;
 };
+
+struct DeepIndirectField {
+    union {
+        struct {
+            int a;
+            int b;
+        };
+        struct {
+            int c;
+            int d;
+        };
+    };
+};

test/ClangImporter/indirect_fields.swift

@@ -3,17 +3,25 @@
 import IndirectFields
 
 func build_struct(a: Int32, c: Int32, d: Int32) -> StructWithIndirectField {
-    return StructWithIndirectField(__Anonymous_field0: .init(a: a), c: c, d: d)
+    return StructWithIndirectField(.init(a: a), c: c, d: d)
 }
 
 func build_struct(b: Int32, c: Int32, d: Int32) -> StructWithIndirectField {
-    return StructWithIndirectField(__Anonymous_field0: .init(b: b), c: c, d: d)
+    return StructWithIndirectField(.init(b: b), c: c, d: d)
 }
 
 func build_union(a: Int32, b: Int32) -> UnionWithIndirectField {
-    return UnionWithIndirectField(__Anonymous_field0: .init(a: a, b: b))
+    return UnionWithIndirectField(.init(a: a, b: b))
 }
 
 func build_union(c: Int32) -> UnionWithIndirectField {
     return UnionWithIndirectField(c: c)
 }
+
+func build_deep(a: Int32, b: Int32) -> DeepIndirectField {
+    return DeepIndirectField(.init(.init(a: a, b: b)))
+}
+
+func build_deep(c: Int32, d: Int32) -> DeepIndirectField {
+    return DeepIndirectField(.init(.init(c: c, d: d)))
+}