[cxx-interop] Support calling functions in inline namespaces

include/swift/ClangImporter/ClangModule.h

@@ -141,6 +141,8 @@ class ClangModuleUnit final : public LoadedFile {
   }
 };
 
+bool isInlineNamespaceInside(const NominalType *outer,
+                             const NominalType *inner);
 }
 
 #endif

lib/AST/ASTVerifier.cpp

@@ -38,8 +38,10 @@
 #include "swift/AST/Stmt.h"
 #include "swift/AST/TypeCheckRequests.h"
 #include "swift/AST/TypeRepr.h"
+#include "swift/AST/Types.h"
 #include "swift/Basic/Assertions.h"
 #include "swift/Basic/SourceManager.h"
+#include "swift/ClangImporter/ClangModule.h"
 #include "swift/Subsystems.h"
 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/ADT/SmallString.h"
@@ -3606,6 +3608,10 @@ class Verifier : public ASTWalker {
                              const char *what) {
       if (srcTy->isEqual(destTy)) return;
 
+      if (isInlineNamespaceInside(srcTy->getAs<NominalType>(),
+                                  destTy->getAs<NominalType>()))
+        return;
+
       if (auto srcMetatype = srcTy->getAs<AnyMetatypeType>()) {
         if (auto destMetatype = destTy->getAs<AnyMetatypeType>()) {
           return checkTrivialSubtype(E,

lib/ClangImporter/ClangImporter.cpp

@@ -8870,3 +8870,20 @@ swift::importer::getCxxRefConventionWithAttrs(const clang::Decl *decl) {
 
   return std::nullopt;
 }
+
+bool swift::isInlineNamespaceInside(const NominalType *outer,
+                                    const NominalType *inner) {
+  if (!outer || !inner)
+    return false;
+  auto CDOuter = outer->getDecl()->getClangDecl();
+  if (!isa_and_nonnull<clang::NamespaceDecl>(CDOuter))
+    return false;
+
+  auto CDInner = inner->getDecl()->getClangDecl();
+  while (isa_and_nonnull<clang::NamespaceDecl>(CDInner) &&
+         cast<clang::NamespaceDecl>(CDInner)->isInline()) {
+    CDInner = cast<clang::Decl>(CDInner->getDeclContext());
+  }
+
+  return CDInner->getCanonicalDecl() == CDOuter->getCanonicalDecl();
+}

lib/SILGen/SILGenExpr.cpp

@@ -46,6 +46,7 @@
 #include "swift/Basic/Defer.h"
 #include "swift/Basic/SourceManager.h"
 #include "swift/Basic/type_traits.h"
+#include "swift/ClangImporter/ClangModule.h"
 #include "swift/SIL/Consumption.h"
 #include "swift/SIL/DynamicCasts.h"
 #include "swift/SIL/SILArgument.h"
@@ -1503,6 +1504,18 @@ RValue RValueEmitter::visitMetatypeConversionExpr(MetatypeConversionExpr *E,
   SILValue metaBase =
     SGF.emitRValueAsSingleValue(E->getSubExpr()).getUnmanagedValue();
 
+  if (isInlineNamespaceInside(E->getSubExpr()
+                                  ->getType()
+                                  ->getAs<AnyMetatypeType>()
+                                  ->getInstanceType()
+                                  ->getAs<NominalType>(),
+                              E->getType()
+                                  ->getAs<AnyMetatypeType>()
+                                  ->getInstanceType()
+                                  ->getAs<NominalType>()))
+    return RValue(SGF, E,
+                  ManagedValue::forObjectRValueWithoutOwnership(metaBase));
+
   // Metatype conversion casts in the AST might not be reflected as
   // such in the SIL type system, for example, a cast from DynamicSelf.Type
   // directly to its own Self.Type.

lib/Sema/CSSimplify.cpp

@@ -38,10 +38,13 @@
 #include "swift/Basic/StringExtras.h"
 #include "swift/ClangImporter/ClangModule.h"
 #include "swift/Sema/CSFix.h"
+#include "swift/Sema/Constraint.h"
 #include "swift/Sema/ConstraintSystem.h"
 #include "swift/Sema/IDETypeChecking.h"
 #include "swift/Sema/PreparedOverload.h"
+#include "clang/AST/Decl.h"
 #include "llvm/ADT/SetVector.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 
 using namespace swift;
@@ -7570,6 +7573,15 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
     case TypeKind::Class: {
       auto nominal1 = cast<NominalType>(desugar1);
       auto nominal2 = cast<NominalType>(desugar2);
+
+      if (isa<EnumType>(nominal1) && kind == ConstraintKind::Bind) {
+        // Check for C++ inline namespaces
+        if (isInlineNamespaceInside(nominal1, nominal2)) {
+          nominal2 = nominal1;
+          type2 = type1;
+        }
+      }
+
       if (nominal1->getDecl() == nominal2->getDecl())
         conversionsOrFixes.push_back(ConversionRestrictionKind::DeepEquality);
 

test/Interop/Cxx/namespace/inline-namespace-function-call-broken.swift → test/Interop/Cxx/namespace/inline-namespace-function-call.swift

@@ -1,6 +1,6 @@
 // RUN: rm -rf %t
 // RUN: split-file %s %t
-// RUN: %target-swift-frontend -typecheck -verify -verify-ignore-unknown -I %t/Inputs  %t/test.swift  -enable-experimental-cxx-interop
+// RUN: %target-swift-frontend -c -verify -verify-ignore-unknown -I %t/Inputs  %t/test.swift  -enable-experimental-cxx-interop
 
 //--- Inputs/module.modulemap
 module namespaces {
@@ -22,5 +22,5 @@ import namespaces;
 
 // Swift's typechecker currently doesn't allow calling a function from inline namespace when it's referenced through the parent namespace.
 func test() {
-  Parent.functionInInlineChild() // expected-error {{type of expression is ambiguous without a type annotation}}
+  Parent.functionInInlineChild()
 }