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

Author: swift-ci

include/swift/Runtime/Concurrency.h

@@ -670,8 +670,11 @@ void swift_task_enqueue(Job *job, ExecutorRef executor);
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_task_enqueueGlobal(Job *job);
 
+/// A count in nanoseconds.
+using JobDelay = unsigned long long;
+
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-void swift_task_enqueueGlobalWithDelay(unsigned long long delay, Job *job);
+void swift_task_enqueueGlobalWithDelay(JobDelay delay, Job *job);
 
 /// Enqueue the given job on the main executor.
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)

lib/ClangImporter/ClangImporter.cpp

@@ -2527,6 +2527,10 @@ static bool isVisibleFromModule(const ClangModuleUnit *ModuleFilter,
   auto *Importer = static_cast<ClangImporter *>(Ctx.getClangModuleLoader());
   auto ClangNode = Importer->getEffectiveClangNode(VD);
 
+  // Decls in the __ObjC bridging header is always visible.
+  if (VD->getModuleContext() == Importer->getImportedHeaderModule())
+    return true;
+
   // Macros can be "redeclared" by putting an equivalent definition in two
   // different modules. (We don't actually check the equivalence.)
   // FIXME: We're also not checking if the redeclaration is in /this/ module.

lib/ClangImporter/ImportDecl.cpp

@@ -2467,6 +2467,11 @@ namespace {
       for (auto redecl : decl->redecls())
         Impl.ImportedDecls[{redecl, getVersion()}] = enumDecl;
 
+      // Because a namespaces's decl context is the bridging header, make sure
+      // we add them to the bridging header lookup table.
+      addEntryToLookupTable(*Impl.BridgingHeaderLookupTable,
+                            const_cast<clang::NamespaceDecl *>(decl),
+                            Impl.getNameImporter());
       return enumDecl;
     }
 

lib/ClangImporter/ImporterImpl.h

@@ -350,9 +350,6 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
     "<bridging-header-import>";
 
 private:
-  /// The Swift lookup table for the bridging header.
-  std::unique_ptr<SwiftLookupTable> BridgingHeaderLookupTable;
-
   /// The Swift lookup tables, per module.
   ///
   /// Annoyingly, we list this table early so that it gets torn down after
@@ -416,6 +413,9 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   llvm::SmallDenseMap<ModuleDecl *, SourceFile *> ClangSwiftAttrSourceFiles;
 
 public:
+  /// The Swift lookup table for the bridging header.
+  std::unique_ptr<SwiftLookupTable> BridgingHeaderLookupTable;
+
   /// Mapping of already-imported declarations.
   llvm::DenseMap<std::pair<const clang::Decl *, Version>, Decl *> ImportedDecls;
 

stdlib/public/Concurrency/CooperativeGlobalExecutor.inc

@@ -24,44 +24,80 @@
 
 #include <chrono>
 #include <thread>
+#include "swift/Basic/ListMerger.h"
 
-static Job *JobQueue = nullptr;
+namespace {
 
-class DelayedJob {
-public:
-  Job *job;
-  unsigned long long when;
-  DelayedJob *next;
+struct JobQueueTraits {
+  static Job *&storage(Job *cur) {
+    return reinterpret_cast<Job*&>(cur->SchedulerPrivate[0]);
+  }
 
-  DelayedJob(Job *job, unsigned long long when) : job(job), when(when), next(nullptr) {}
+  static Job *getNext(Job *job) {
+    return storage(job);
+  }
+  static void setNext(Job *job, Job *next) {
+    storage(job) = next;
+  }
+  static int compare(Job *lhs, Job *rhs) {
+    return descendingPriorityOrder(lhs->getPriority(), rhs->getPriority());
+  }
 };
+using JobQueueMerger = ListMerger<Job*, JobQueueTraits>;
 
-static DelayedJob *DelayedJobQueue = nullptr;
+using JobDeadline = std::chrono::time_point<std::chrono::steady_clock>;
 
-/// Get the next-in-queue storage slot.
-static Job *&nextInQueue(Job *cur) {
-  return reinterpret_cast<Job*&>(cur->SchedulerPrivate[Job::NextWaitingTaskIndex]);
-}
+template <bool = (sizeof(JobDeadline) <= sizeof(void*) &&
+                  alignof(JobDeadline) <= alignof(void*))>
+struct JobDeadlineStorage;
+
+/// Specialization for when JobDeadline fits in SchedulerPrivate.
+template <>
+struct JobDeadlineStorage<true> {
+  static JobDeadline &storage(Job *job) {
+    return reinterpret_cast<JobDeadline&>(job->SchedulerPrivate[1]);
+  }
+  static JobDeadline get(Job *job) {
+    return storage(job);
+  }
+  static void set(Job *job, JobDeadline deadline) {
+    new(static_cast<void*>(&storage(job))) JobDeadline(deadline);
+  }
+  static void destroy(Job *job) {
+    storage(job).~JobDeadline();
+  }
+};
+
+/// Specialization for when JobDeadline doesn't fit in SchedulerPrivate.
+template <>
+struct JobDeadlineStorage<false> {
+  static JobDeadline *&storage(Job *job) {
+    return reinterpret_cast<JobDeadline*&>(job->SchedulerPrivate[1]);
+  }
+  static JobDeadline get(Job *job) {
+    return *storage(job);
+  }
+  static void set(Job *job, JobDeadline deadline) {
+    storage(job) = new JobDeadline(deadline);
+  }
+  static void destroy(Job *job) {
+    delete storage(job);
+  }
+};
+
+} // end anonymous namespace
+
+static Job *JobQueue = nullptr;
+static Job *DelayedJobQueue = nullptr;
 
 /// Insert a job into the cooperative global queue.
 SWIFT_CC(swift)
 static void swift_task_enqueueGlobalImpl(Job *job) {
   assert(job && "no job provided");
 
-  Job **position = &JobQueue;
-  while (auto cur = *position) {
-    // If we find a job with lower priority, insert here.
-    if (cur->getPriority() < newJob->getPriority()) {
-      nextInQueue(newJob) = cur;
-      *position = newJob;
-      return;
-    }
-
-    // Otherwise, keep advancing through the queue.
-    position = &nextInQueue(cur);
-  }
-  nextInQueue(newJob) = nullptr;
-  *position = newJob;
+  JobQueueMerger merger(JobQueue);
+  merger.insert(job);
+  JobQueue = merger.release();
 }
 
 /// Enqueues a task on the main executor.
@@ -72,60 +108,80 @@ static void swift_task_enqueueMainExecutorImpl(Job *job) {
   swift_task_enqueueGlobalImpl(job);
 }
 
-static unsigned long long currentNanos() {
-  auto now = std::chrono::steady_clock::now();
-  auto nowNanos = std::chrono::time_point_cast<std::chrono::nanoseconds>(now);
-  auto value = std::chrono::duration_cast<std::chrono::nanoseconds>(nowNanos.time_since_epoch());
-  return value.count();
-}
-
 /// Insert a job into the cooperative global queue with a delay.
 SWIFT_CC(swift)
-static void swift_task_enqueueGlobalWithDelayImpl(unsigned long long delay,
-                                                  Job *job) {
-  assert(job && "no job provided");
+static void swift_task_enqueueGlobalWithDelayImpl(JobDelay delay,
+                                                  Job *newJob) {
+  assert(newJob && "no job provided");
 
-  DelayedJob **position = &DelayedJobQueue;
-  DelayedJob *newJob = new DelayedJob(job, currentNanos() + delay);
+  auto deadline = std::chrono::steady_clock::now()
+                + std::chrono::duration_cast<JobDeadline::duration>(
+                    std::chrono::nanoseconds(delay));
+  JobDeadlineStorage<>::set(newJob, deadline);
 
+  Job **position = &DelayedJobQueue;
   while (auto cur = *position) {
-    // If we find a job with lower priority, insert here.
-    if (cur->when > newJob->when) {
-      newJob->next = cur;
+    // If we find a job with a later deadline, insert here.
+    // Note that we maintain FIFO order.
+    if (deadline < JobDeadlineStorage<>::get(cur)) {
+      JobQueueTraits::setNext(newJob, cur);
       *position = newJob;
       return;
     }
 
     // Otherwise, keep advancing through the queue.
-    position = &cur->next;
+    position = &JobQueueTraits::storage(cur);
   }
+  JobQueueTraits::setNext(newJob, nullptr);
   *position = newJob;
 }
 
+/// Recognize jobs in the delayed-jobs queue that are ready to execute
+/// and move them to the primary queue.
+static void recognizeReadyDelayedJobs() {
+  // Process all the delayed jobs.
+  auto nextDelayedJob = DelayedJobQueue;
+  if (!nextDelayedJob) return;
+
+  auto now = std::chrono::steady_clock::now();
+  JobQueueMerger readyJobs(JobQueue);
+
+  // Pull jobs off of the delayed-jobs queue whose deadline has been
+  // reached, and add them to the ready queue.
+  while (nextDelayedJob &&
+         JobDeadlineStorage<>::get(nextDelayedJob) <= now) {
+    // Destroy the storage of the deadline in the job.
+    JobDeadlineStorage<>::destroy(nextDelayedJob);
+
+    auto next = JobQueueTraits::getNext(nextDelayedJob);
+    readyJobs.insert(nextDelayedJob);
+    nextDelayedJob = next;
+  }
+
+  JobQueue = readyJobs.release();
+  DelayedJobQueue = nextDelayedJob;
+}
+
 /// Claim the next job from the cooperative global queue.
 static Job *claimNextFromCooperativeGlobalQueue() {
-  // Check delayed jobs first
   while (true) {
-    if (auto delayedJob = DelayedJobQueue) {
-      if (delayedJob->when < currentNanos()) {
-        DelayedJobQueue = delayedJob->next;
-        auto job = delayedJob->job;
-        
-        delete delayedJob;
-
-        return job;
-      }
-    }
+    // Move any delayed jobs that are now ready into the primary queue.
+    recognizeReadyDelayedJobs();
+
+    // If there's a job in the primary queue, run it.
     if (auto job = JobQueue) {
-      JobQueue = nextInQueue(job);
+      JobQueue = JobQueueTraits::getNext(job);
       return job;
     }
-    // there are only delayed jobs left, but they are not ready,
-    // so we sleep until the first one is
+
+    // If there are only delayed jobs left, sleep until the next deadline.
+    // TODO: should the donator have some say in this?
     if (auto delayedJob = DelayedJobQueue) {
-      std::this_thread::sleep_for(std::chrono::nanoseconds(delayedJob->when - currentNanos()));
+      auto deadline = JobDeadlineStorage<>::get(delayedJob);
+      std::this_thread::sleep_until(deadline);
       continue;
     }
+
     return nullptr;
   }
 }

stdlib/public/Concurrency/DispatchGlobalExecutor.inc

@@ -207,7 +207,7 @@ static void swift_task_enqueueGlobalImpl(Job *job) {
 
 
 SWIFT_CC(swift)
-static void swift_task_enqueueGlobalWithDelayImpl(unsigned long long delay,
+static void swift_task_enqueueGlobalWithDelayImpl(JobDelay delay,
                                                   Job *job) {
   assert(job && "no job provided");
 

stdlib/public/Concurrency/GlobalExecutor.cpp

@@ -67,7 +67,7 @@ void (*swift::swift_task_enqueueGlobal_hook)(
 
 SWIFT_CC(swift)
 void (*swift::swift_task_enqueueGlobalWithDelay_hook)(
-    unsigned long long delay, Job *job,
+    JobDelay delay, Job *job,
     swift_task_enqueueGlobalWithDelay_original original) = nullptr;
 
 SWIFT_CC(swift)
@@ -91,8 +91,7 @@ void swift::swift_task_enqueueGlobal(Job *job) {
     swift_task_enqueueGlobalImpl(job);
 }
 
-void swift::swift_task_enqueueGlobalWithDelay(unsigned long long delay,
-                                              Job *job) {
+void swift::swift_task_enqueueGlobalWithDelay(JobDelay delay, Job *job) {
   if (swift_task_enqueueGlobalWithDelay_hook)
     swift_task_enqueueGlobalWithDelay_hook(
         delay, job, swift_task_enqueueGlobalWithDelayImpl);

stdlib/public/Concurrency/NonDispatchGlobalExecutor.inc

@@ -33,7 +33,7 @@ static void swift_task_enqueueGlobalImpl(Job *job) {
 }
 
 SWIFT_CC(swift)
-static void swift_task_enqueueGlobalWithDelayImpl(unsigned long long delay,
+static void swift_task_enqueueGlobalWithDelayImpl(JobDelay delay,
                                                   Job *job) {
   assert(job && "no job provided");
 

test/IDE/complete_from_clang_framework.swift

@@ -122,6 +122,9 @@ func testSwiftCompletions(foo: SwiftStruct) {
 // CLANG_BAR-DAG: Decl[GlobalVar]/OtherModule[Bar]:    BAR_MACRO_1[#Int32#]{{; name=.+$}}
 // CLANG_BAR-DAG: Decl[Struct]/OtherModule[Bar]:       SomeItemSet[#SomeItemSet#]
 // CLANG_BAR-DAG: Decl[TypeAlias]/OtherModule[Bar]:    SomeEnvironment[#SomeItemSet#]
+// CLANG_BAR-DAG: Decl[TypeAlias]/OtherModule[__ObjC]: __NSConstantString[#__NSConstantString_tag#]; name=__NSConstantString
+// CLANG_BAR-DAG: Decl[TypeAlias]/OtherModule[__ObjC]: __builtin_ms_va_list[#UnsafeMutablePointer<CChar>#]; name=__builtin_ms_va_list
+// CLANG_BAR-DAG: Decl[TypeAlias]/OtherModule[__ObjC]: __builtin_va_list[#(__va_list_tag)#]; name=__builtin_va_list
 // CLANG_BAR: End completions
 
 // CLANG_BOTH_FOO_BAR: Begin completions
@@ -148,12 +151,15 @@ func testCompleteModuleQualifiedFoo2() {
   Foo#^CLANG_QUAL_FOO_2^#
 // If the number of results below changes, then you need to add a result to the
 // list below.
-// CLANG_QUAL_FOO_2: Begin completions, 76 items
+// CLANG_QUAL_FOO_2: Begin completions, 82 items
 // CLANG_QUAL_FOO_2-DAG: Decl[Class]/OtherModule[Foo]:        .FooClassBase[#FooClassBase#]{{; name=.+$}}
 // CLANG_QUAL_FOO_2-DAG: Decl[Class]/OtherModule[Foo]:        .FooClassDerived[#FooClassDerived#]{{; name=.+$}}
 // CLANG_QUAL_FOO_2-DAG: Decl[Class]/OtherModule[Foo]:        .ClassWithInternalProt[#ClassWithInternalProt#]{{; name=.+$}}
 // CLANG_QUAL_FOO_2-DAG: Decl[Struct]/OtherModule[Foo]:       ._InternalStruct[#_InternalStruct#]
 // CLANG_QUAL_FOO_2-DAG: Decl[Class]/OtherModule[Foo]:        .FooClassPropertyOwnership[#FooClassPropertyOwnership#]{{; name=.+$}}
+// CLANG_QUAL_FOO_2-DAG: Decl[TypeAlias]/OtherModule[__ObjC]: .__NSConstantString[#__NSConstantString_tag#]; name=__NSConstantString
+// CLANG_QUAL_FOO_2-DAG: Decl[TypeAlias]/OtherModule[__ObjC]: .__builtin_ms_va_list[#UnsafeMutablePointer<CChar>#]; name=__builtin_ms_va_list
+// CLANG_QUAL_FOO_2-DAG: Decl[TypeAlias]/OtherModule[__ObjC]: .__builtin_va_list[#(__va_list_tag)#]; name=__builtin_va_list
 // CLANG_QUAL_FOO_2-DAG: Decl[FreeFunction]/OtherModule[Foo]: ._internalTopLevelFunc()[#Void#]
 // CLANG_QUAL_FOO_2-DAG: Decl[Enum]/OtherModule[Foo]:         .FooComparisonResult[#FooComparisonResult#]{{; name=.+$}}
 // CLANG_QUAL_FOO_2-DAG: Decl[FreeFunction]/OtherModule[Foo]: .fooFunc1({#(a): Int32#})[#Int32#]{{; name=.+$}}
@@ -217,14 +223,17 @@ func testCompleteModuleQualifiedFoo2() {
 // CLANG_QUAL_FOO_2-DAG:  Decl[Class]/OtherModule[Foo]:        .FooRepeatedMembers[#FooRepeatedMembers#]{{; name=.+$}}
 // CLANG_QUAL_FOO_2-DAG: Decl[Class]/OtherModule[Foo]: .FooClassWithClassProperties[#FooClassWithClassProperties#];
 // CLANG_QUAL_FOO_2-DAG: Decl[Enum]/OtherModule[Foo]: .SCNFilterMode[#SCNFilterMode#];
+// CLANG_QUAL_FOO_2-DAG: Decl[TypeAlias]/OtherModule[__ObjC]: .__NSConstantString[#__NSConstantString_tag#]; name=__NSConstantString
+// CLANG_QUAL_FOO_2-DAG: Decl[TypeAlias]/OtherModule[__ObjC]: .__builtin_ms_va_list[#UnsafeMutablePointer<CChar>#]; name=__builtin_ms_va_list
+// CLANG_QUAL_FOO_2-DAG: Decl[TypeAlias]/OtherModule[__ObjC]: .__builtin_va_list[#(__va_list_tag)#]; name=__builtin_va_list
 // CLANG_QUAL_FOO_2: End completions
 }
 
 func testCompleteModuleQualifiedBar1() {
   Bar.#^CLANG_QUAL_BAR_1^#
 // If the number of results below changes, this is an indication that you need
 // to add a result to the appropriate list.  Do not just bump the number!
-// CLANG_QUAL_BAR_1: Begin completions, 8 items
+// CLANG_QUAL_BAR_1: Begin completions, 11 items
 }
 
 func testCompleteFunctionCall1() {

test/Interop/Cxx/modules/Inputs/bridge-header.h

@@ -0,0 +1,12 @@
+#ifndef TEST_INTEROP_CXX_MODULES_INPUTS_BRIDGE_HEADER_H
+#define TEST_INTEROP_CXX_MODULES_INPUTS_BRIDGE_HEADER_H
+
+struct Parent {
+  struct Child {};
+};
+
+namespace Namespace {
+struct InNamespace {};
+}
+
+#endif // TEST_INTEROP_CXX_MODULES_INPUTS_BRIDGE_HEADER_H

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

@@ -0,0 +1,4 @@
+module Namespace {
+  header "namespace.h"
+  requires cplusplus
+}

test/Interop/Cxx/modules/Inputs/namespace-extension-lib.swift

@@ -0,0 +1,13 @@
+import Namespace
+
+extension Namespace.Parent {
+  public static func test() -> Int { 42 }
+}
+
+extension Namespace.Parent.Child {
+  public static func test() -> Int { 52 }
+}
+
+extension Namespace.NestedNamespace.NestedStruct {
+  public func test() -> Int { 62 }
+}