Merge pull request #67639 from hyp/eng/nested-enums

[cxx-interop] correctly add and lookup enumerators added to enums tha…

Author: hyp

lib/AST/ASTPrinter.cpp

@@ -2399,23 +2399,38 @@ static void addNamespaceMembers(Decl *decl,
         }
       }
 
+      auto lookupAndAddMembers = [&](DeclName name) {
+        auto allResults = evaluateOrDefault(
+            ctx.evaluator, ClangDirectLookupRequest({decl, redecl, name}), {});
+
+        for (auto found : allResults) {
+          auto clangMember = found.get<clang::NamedDecl *>();
+          if (auto importedDecl =
+                  ctx.getClangModuleLoader()->importDeclDirectly(clangMember)) {
+            if (addedMembers.insert(importedDecl).second)
+              members.push_back(importedDecl);
+          }
+        }
+      };
+
       auto namedDecl = dyn_cast<clang::NamedDecl>(member);
       if (!namedDecl)
         continue;
-
       auto name = ctx.getClangModuleLoader()->importName(namedDecl);
       if (!name)
         continue;
-
-      auto allResults = evaluateOrDefault(
-          ctx.evaluator, ClangDirectLookupRequest({decl, redecl, name}), {});
-
-      for (auto found : allResults) {
-        auto clangMember = found.get<clang::NamedDecl *>();
-        if (auto importedDecl =
-                ctx.getClangModuleLoader()->importDeclDirectly(clangMember)) {
-          if (addedMembers.insert(importedDecl).second)
-            members.push_back(importedDecl);
+      lookupAndAddMembers(name);
+
+      // Unscoped enums could have their enumerators present
+      // in the parent namespace.
+      if (auto *ed = dyn_cast<clang::EnumDecl>(member)) {
+        if (!ed->isScoped()) {
+          for (const auto *ecd : ed->enumerators()) {
+            auto name = ctx.getClangModuleLoader()->importName(ecd);
+            if (!name)
+              continue;
+            lookupAndAddMembers(name);
+          }
         }
       }
     }

lib/ClangImporter/ClangImporter.cpp

@@ -4539,15 +4539,24 @@ lookupInClassTemplateSpecialization(
   return found;
 }
 
-static bool isDirectLookupMemberContext(const clang::Decl *memberContext,
+static bool isDirectLookupMemberContext(const clang::Decl *foundClangDecl,
+                                        const clang::Decl *memberContext,
                                         const clang::Decl *parent) {
   if (memberContext->getCanonicalDecl() == parent->getCanonicalDecl())
     return true;
   if (auto namespaceDecl = dyn_cast<clang::NamespaceDecl>(memberContext)) {
     if (namespaceDecl->isInline()) {
       if (auto memberCtxParent =
               dyn_cast<clang::Decl>(namespaceDecl->getParent()))
-        return isDirectLookupMemberContext(memberCtxParent, parent);
+        return isDirectLookupMemberContext(foundClangDecl, memberCtxParent,
+                                           parent);
+    }
+  }
+  // Enum constant decl can be found in the parent context of the enum decl.
+  if (auto *ED = dyn_cast<clang::EnumDecl>(memberContext)) {
+    if (isa<clang::EnumConstantDecl>(foundClangDecl)) {
+      if (auto *firstDecl = dyn_cast<clang::Decl>(ED->getDeclContext()))
+        return firstDecl->getCanonicalDecl() == parent->getCanonicalDecl();
     }
   }
   return false;
@@ -4585,7 +4594,8 @@ ClangDirectLookupRequest::evaluate(Evaluator &evaluator,
                   auto second = cast<clang::DeclContext>(clangDecl);
                   if (auto firstDecl = dyn_cast<clang::Decl>(first)) {
                     if (auto secondDecl = dyn_cast<clang::Decl>(second))
-                      return isDirectLookupMemberContext(firstDecl, secondDecl);
+                      return isDirectLookupMemberContext(foundClangDecl,
+                                                         firstDecl, secondDecl);
                     else
                       return false;
                   }

lib/ClangImporter/ImportDecl.cpp

@@ -2985,7 +2985,7 @@ namespace {
           return nullptr;
 
         // Create the global constant.
-        bool isStatic = enumKind != EnumKind::Unknown && dc->isTypeContext();
+        bool isStatic = dc->isTypeContext();
         auto result = synthesizer.createConstant(
             name, dc, type, clang::APValue(decl->getInitVal()),
             enumKind == EnumKind::Unknown ? ConstantConvertKind::Construction

test/Interop/Cxx/enum/Inputs/module.modulemap

@@ -36,3 +36,8 @@ module CenumsNSOptionsExternC [extern_c] {
 module CFAvailability {
     header "CFAvailability.h"
 }
+
+module NestedEnums {
+    header "nested-enums.h"
+    requires cplusplus
+}

test/Interop/Cxx/enum/Inputs/nested-enums.h

@@ -0,0 +1,27 @@
+#ifndef TEST_INTEROP_CXX_ENUM_INPUTS_NESTED_ENUMS_H
+#define TEST_INTEROP_CXX_ENUM_INPUTS_NESTED_ENUMS_H
+
+namespace ns {
+
+enum EnumInNS {
+  kA = 0,
+  kB
+};
+
+enum class ScopedEnumInNS {
+  scopeA,
+  scopeB
+};
+
+namespace nestedNS {
+
+enum EnumInNestedNS {
+  kNestedA = 0,
+  kNestedB
+};
+
+}
+
+}
+
+#endif // TEST_INTEROP_CXX_ENUM_INPUTS_NESTED_ENUMS_H

test/Interop/Cxx/enum/nested-enums-module-interface.swift

@@ -0,0 +1,18 @@
+// RUN: %target-swift-ide-test -print-module -module-to-print=NestedEnums -I %S/Inputs -source-filename=x -enable-experimental-cxx-interop | %FileCheck %s
+
+// CHECK: enum ns {
+// CHECK:  struct EnumInNS : Equatable, RawRepresentable {
+// CHECK:  }
+// CHECK-NEXT:  static var kA: ns.EnumInNS { get }
+// CHECK-NEXT:  static var kB: ns.EnumInNS { get }
+// CHECK-NEXT:  enum ScopedEnumInNS : Int32 {
+// CHECK:    case scopeA
+// CHECK:    case scopeB
+// CHECK-NEXT:  }
+// CHECK-NEXT:  enum nestedNS {
+// CHECK-NEXT:    struct EnumInNestedNS : Equatable, RawRepresentable {
+// CHECK:    }
+// CHECK-NEXT:    static var kNestedA: ns.nestedNS.EnumInNestedNS { get }
+// CHECK-NEXT:    static var kNestedB: ns.nestedNS.EnumInNestedNS { get }
+// CHECK-NEXT:  }
+// CHECK-NEXT:}

test/Interop/Cxx/enum/nested-enums.swift

@@ -0,0 +1,17 @@
+// RUN: %target-run-simple-swift(-I %S/Inputs -Xfrontend -enable-experimental-cxx-interop)
+
+// REQUIRES: executable_test
+
+import NestedEnums
+import StdlibUnittest
+
+var NestedEnumsTestSuite = TestSuite("Nested Enums")
+
+NestedEnumsTestSuite.test("Make and compare") {
+  let val: ns.EnumInNS = ns.kA
+  expectNotEqual(val, ns.kB)
+  let valNested = ns.nestedNS.kNestedA
+  expectNotEqual(valNested, ns.nestedNS.kNestedB)
+}
+
+runAllTests()