Merge remote-tracking branch 'origin/main' into rebranch

Author: swift-ci

.github/CODEOWNERS

@@ -165,14 +165,15 @@
 /lib/SIL/IR/SILDebug*                               @adrian-prantl
 /lib/SIL/IR/SILLocation*                            @adrian-prantl
 /lib/SIL/IR/SILProfiler.cpp                         @bnbarham @hamishknight @rintaro
-/lib/SILGen/                                        @jckarter
+/lib/SILGen/                                        @jckarter @kavon
 /lib/SILGen/*Availability*                          @tshortli
 /lib/SILGen/*Distributed*                           @ktoso
 /lib/SILOptimizer/                                  @eeckstein
 /lib/SILOptimizer/**/*DebugInfo*                    @adrian-prantl
 /lib/SILOptimizer/Mandatory/ConsumeOperator*        @kavon
 /lib/SILOptimizer/Mandatory/FlowIsolation.cpp       @kavon
 /lib/SILOptimizer/Mandatory/MoveOnly*               @kavon
+/lib/SILOptimizer/Mandatory/AddressLowering*        @kavon
 /lib/SILOptimizer/Utils/Distributed*                @ktoso
 /lib/Sema/                                          @hborla @slavapestov @xedin
 /lib/Sema/*Availability*                            @tshortli

lib/AST/ASTPrinter.cpp

@@ -2738,87 +2738,72 @@ static void addNamespaceMembers(Decl *decl,
       if (declOwner && declOwner != redeclOwner->getTopLevelModule())
         continue;
     }
+    for (auto member : redecl->decls()) {
+      if (auto classTemplate = dyn_cast<clang::ClassTemplateDecl>(member)) {
+        // Add all specializations to a worklist so we don't accidentally mutate
+        // the list of decls we're iterating over.
+        llvm::SmallPtrSet<const clang::ClassTemplateSpecializationDecl *, 16> specWorklist;
+        for (auto spec : classTemplate->specializations())
+          specWorklist.insert(spec);
+        for (auto spec : specWorklist) {
+          if (auto import =
+                  ctx.getClangModuleLoader()->importDeclDirectly(spec))
+            if (addedMembers.insert(import).second)
+              members.push_back(import);
+        }
+      }
 
-    std::function<void(clang::DeclContext *)> addDeclsFromContext =
-        [&](clang::DeclContext *declContext) {
-          for (auto member : declContext->decls()) {
-            if (auto classTemplate =
-                    dyn_cast<clang::ClassTemplateDecl>(member)) {
-              // Add all specializations to a worklist so we don't accidentally
-              // mutate the list of decls we're iterating over.
-              llvm::SmallPtrSet<const clang::ClassTemplateSpecializationDecl *,
-                                16>
-                  specWorklist;
-              for (auto spec : classTemplate->specializations())
-                specWorklist.insert(spec);
-              for (auto spec : specWorklist) {
-                if (auto import =
-                        ctx.getClangModuleLoader()->importDeclDirectly(spec))
-                  if (addedMembers.insert(import).second)
-                    members.push_back(import);
-              }
+      auto lookupAndAddMembers = [&](DeclName name) {
+        auto allResults = evaluateOrDefault(
+            ctx.evaluator, ClangDirectLookupRequest({decl, redecl, name}), {});
+
+        for (auto found : allResults) {
+          auto clangMember = cast<clang::NamedDecl *>(found);
+          if (auto importedDecl =
+                  ctx.getClangModuleLoader()->importDeclDirectly(clangMember)) {
+            if (addedMembers.insert(importedDecl).second) {
+              members.push_back(importedDecl);
+
+              // Handle macro-expanded declarations.
+              importedDecl->visitAuxiliaryDecls([&](Decl *decl) {
+                auto valueDecl = dyn_cast<ValueDecl>(decl);
+                if (!valueDecl)
+                  return;
+
+                // Bail out if the auxiliary decl was not produced by a macro.
+                auto module = decl->getDeclContext()->getParentModule();
+                auto *sf = module->getSourceFileContainingLocation(decl->getLoc());
+                if (!sf || sf->Kind != SourceFileKind::MacroExpansion)
+                  return;
+
+                members.push_back(valueDecl);
+              });
             }
+          }
+        }
+      };
 
-            auto lookupAndAddMembers = [&](clang::NamedDecl *namedDecl) {
-              auto name = ctx.getClangModuleLoader()->importName(namedDecl);
-              if (!name)
-                return;
-
-              auto allResults = evaluateOrDefault(
-                  ctx.evaluator, ClangDirectLookupRequest({decl, redecl, name}),
-                  {});
-
-              for (auto found : allResults) {
-                auto clangMember = cast<clang::NamedDecl *>(found);
-                if (auto importedDecl =
-                        ctx.getClangModuleLoader()->importDeclDirectly(
-                            clangMember)) {
-                  if (addedMembers.insert(importedDecl).second) {
-                    members.push_back(importedDecl);
-
-                    // Handle macro-expanded declarations.
-                    importedDecl->visitAuxiliaryDecls([&](Decl *decl) {
-                      auto valueDecl = dyn_cast<ValueDecl>(decl);
-                      if (!valueDecl)
-                        return;
-
-                      // Bail out if the auxiliary decl was not produced by a
-                      // macro.
-                      auto module = decl->getDeclContext()->getParentModule();
-                      auto *sf = module->getSourceFileContainingLocation(
-                          decl->getLoc());
-                      if (!sf || sf->Kind != SourceFileKind::MacroExpansion)
-                        return;
-
-                      members.push_back(valueDecl);
-                    });
-                  }
-                }
-              }
-            };
-
-            // Look through `extern` blocks.
-            if (auto linkageSpecDecl = dyn_cast<clang::LinkageSpecDecl>(member))
-              addDeclsFromContext(linkageSpecDecl);
-
-            auto namedDecl = dyn_cast<clang::NamedDecl>(member);
-            if (!namedDecl)
+      auto namedDecl = dyn_cast<clang::NamedDecl>(member);
+      if (!namedDecl)
+        continue;
+      auto name = ctx.getClangModuleLoader()->importName(namedDecl);
+      if (!name)
+        continue;
+      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(namedDecl);
-
-            // Unscoped enums could have their enumerators present
-            // in the parent namespace.
-            if (auto *ed = dyn_cast<clang::EnumDecl>(member)) {
-              if (!ed->isScoped()) {
-                for (auto *ecd : ed->enumerators()) {
-                  lookupAndAddMembers(ecd);
-                }
-              }
-            }
+            lookupAndAddMembers(name);
           }
-        };
-
-    addDeclsFromContext(redecl);
+        }
+      }
+    }
   }
 }
 

lib/ClangImporter/ClangImporter.cpp

@@ -5079,11 +5079,6 @@ static bool isDirectLookupMemberContext(const clang::Decl *foundClangDecl,
         return firstDecl->getCanonicalDecl() == parent->getCanonicalDecl();
     }
   }
-  // Look through `extern` blocks.
-  if (auto linkageSpecDecl = dyn_cast<clang::LinkageSpecDecl>(memberContext)) {
-    if (auto parentDecl = dyn_cast<clang::Decl>(linkageSpecDecl->getParent()))
-      return isDirectLookupMemberContext(foundClangDecl, parentDecl, parent);
-  }
   return false;
 }
 

lib/ClangImporter/ImportDecl.cpp

@@ -1156,14 +1156,11 @@ namespace {
         return nullptr;
       // If this is a top-level namespace, don't put it in the module we're
       // importing, put it in the "__ObjC" module that is implicitly imported.
-      auto clangDC = decl->getDeclContext();
-      while (isa<clang::LinkageSpecDecl>(clangDC))
-        clangDC = clangDC->getParent();
-      if (!clangDC->isNamespace())
+      if (!decl->getParent()->isNamespace())
         dc = Impl.ImportedHeaderUnit;
       else {
         // This is a nested namespace, so just lookup it's parent normally.
-        auto parentNS = cast<clang::NamespaceDecl>(clangDC);
+        auto parentNS = cast<clang::NamespaceDecl>(decl->getParent());
         auto parent =
             Impl.importDecl(parentNS, getVersion(), /*UseCanonicalDecl*/ false);
         // The parent namespace might not be imported if it's `swift_private`.

lib/ClangImporter/SwiftLookupTable.cpp

@@ -2035,20 +2035,6 @@ void importer::addEntryToLookupTable(SwiftLookupTable &table,
             namedMember = def;
         addEntryToLookupTable(table, namedMember, nameImporter);
       }
-      if (auto linkageSpecDecl =
-              dyn_cast<clang::LinkageSpecDecl>(canonicalMember)) {
-        std::function<void(clang::DeclContext *)> addDeclsFromContext =
-            [&](clang::DeclContext *declContext) {
-              for (auto nestedDecl : declContext->decls()) {
-                if (auto namedMember = dyn_cast<clang::NamedDecl>(nestedDecl))
-                  addEntryToLookupTable(table, namedMember, nameImporter);
-                else if (auto nestedLinkageSpecDecl =
-                             dyn_cast<clang::LinkageSpecDecl>(nestedDecl))
-                  addDeclsFromContext(nestedLinkageSpecDecl);
-              }
-            };
-        addDeclsFromContext(linkageSpecDecl);
-      }
     }
   }
   if (auto usingDecl = dyn_cast<clang::UsingDecl>(named)) {

test/Interop/Cxx/namespace/Inputs/extern-within-namespace.h

@@ -12,12 +12,6 @@ module ClassesSecondHeader {
   requires cplusplus
 }
 
-module ExternWithinNamespace {
-  header "extern-within-namespace.h"
-  export *
-  requires cplusplus
-}
-
 module FreeFunctions {
   header "free-functions.h"
   requires cplusplus