Duplicate select Swift Concurrency tests for TSan

I am putting these tests into a new `Sanitizers/tsan` subfolder so we
can keep the same test file name (avoid need for `tsan-` prefix).  This
should increase the chance that changes to the tests make it to the TSan
duplicate.

I will move and rename existing sanitizer tests (including ASan) tests
to keep consistency in a follow-up PR.

Author: Julian Lettner

test/Sanitizers/tsan/actor_counters.swift

@@ -0,0 +1,74 @@
+// RUN: %target-run-simple-swift(-Xfrontend -enable-experimental-concurrency %import-libdispatch -parse-as-library)
+
+// REQUIRES: executable_test
+// REQUIRES: concurrency
+// REQUIRES: libdispatch
+
+#if canImport(Darwin)
+import Darwin
+#elseif canImport(Glibc)
+import Glibc
+#endif
+
+actor Counter {
+  private var value = 0
+  private let scratchBuffer: UnsafeMutableBufferPointer<Int>
+
+  init(maxCount: Int) {
+    scratchBuffer = .allocate(capacity: maxCount)
+    scratchBuffer.initialize(repeating: 0)
+  }
+
+  func next() -> Int {
+    let current = value
+
+    // Make sure we haven't produced this value before
+    assert(scratchBuffer[current] == 0)
+    scratchBuffer[current] = 1
+
+    value = value + 1
+    return current
+  }
+}
+
+
+func worker(identity: Int, counters: [Counter], numIterations: Int) async {
+  for i in 0..<numIterations {
+    let counterIndex = Int.random(in: 0 ..< counters.count)
+    let counter = counters[counterIndex]
+    let nextValue = await counter.next()
+    print("Worker \(identity) calling counter \(counterIndex) produced \(nextValue)")
+  }
+}
+
+func runTest(numCounters: Int, numWorkers: Int, numIterations: Int) async {
+  // Create counter actors.
+  var counters: [Counter] = []
+  for i in 0..<numCounters {
+    counters.append(Counter(maxCount: numWorkers * numIterations))
+  }
+
+  // Create a bunch of worker threads.
+  var workers: [Task.Handle<Void, Error>] = []
+  for i in 0..<numWorkers {
+    workers.append(
+      Task.runDetached { [counters] in
+        usleep(UInt32.random(in: 0..<100) * 1000)
+        await worker(identity: i, counters: counters, numIterations: numIterations)
+      }
+    )
+  }
+
+  // Wait until all of the workers have finished.
+  for worker in workers {
+    try! await worker.get()
+  }
+
+  print("DONE!")
+}
+
+@main struct Main {
+  static func main() async {
+    await runTest(numCounters: 10, numWorkers: 100, numIterations: 1000)
+  }
+}

test/Sanitizers/tsan/async_let_fibonacci.swift

@@ -0,0 +1,55 @@
+// RUN: %target-run-simple-swift(-Xfrontend -enable-experimental-concurrency %import-libdispatch -parse-as-library)
+
+// REQUIRES: executable_test
+// REQUIRES: concurrency
+// REQUIRES: libdispatch
+
+#if canImport(Darwin)
+import Darwin
+#elseif canImport(Glibc)
+import Glibc
+#endif
+
+func fib(_ n: Int) -> Int {
+  var first = 0
+  var second = 1
+  for _ in 0..<n {
+    let temp = first
+    first = second
+    second = temp + first
+  }
+  return first
+}
+
+func asyncFib(_ n: Int) async -> Int {
+  if n == 0 || n == 1 {
+    return n
+  }
+
+  async let first = await asyncFib(n-2)
+  async let second = await asyncFib(n-1)
+
+  // Sleep a random amount of time waiting on the result producing a result.
+  usleep(UInt32.random(in: 0..<100) * 1000)
+
+  let result = await first + second
+
+  // Sleep a random amount of time before producing a result.
+  usleep(UInt32.random(in: 0..<100) * 1000)
+
+  return result
+}
+
+func runFibonacci(_ n: Int) async {
+  let result = await asyncFib(n)
+
+  print()
+  print("Async fib = \(result), sequential fib = \(fib(n))")
+  assert(result == fib(n))
+}
+
+@main struct Main {
+  static func main() async {
+    await runFibonacci(10)
+  }
+}

test/Sanitizers/tsan/basic_future.swift

@@ -0,0 +1,84 @@
+// RUN: %target-run-simple-swift(-Xfrontend -enable-experimental-concurrency  %import-libdispatch -parse-as-library)
+
+// REQUIRES: executable_test
+// REQUIRES: concurrency
+// REQUIRES: libdispatch
+
+import Dispatch
+
+#if canImport(Darwin)
+import Darwin
+#elseif canImport(Glibc)
+import Glibc
+#endif
+
+enum HomeworkError: Error, Equatable {
+  case dogAteIt(String)
+}
+
+func formGreeting(name: String) async -> String {
+  return "Hello \(name) from async world"
+}
+
+func testSimple(
+  name: String, dogName: String, shouldThrow: Bool, doSuspend: Bool
+) async {
+  print("Testing name: \(name), dog: \(dogName), shouldThrow: \(shouldThrow) doSuspend: \(doSuspend)")
+
+  var completed = false
+
+  let taskHandle: Task.Handle<String, Error> = Task.runDetached {
+    let greeting = await formGreeting(name: name)
+
+    // If the intent is to test suspending, wait a bit so the second task
+    // can complete.
+    if doSuspend {
+      print("- Future sleeping")
+      sleep(1)
+    }
+
+    if (shouldThrow) {
+      print("- Future throwing")
+      throw HomeworkError.dogAteIt(dogName + " the dog")
+    }
+
+    print("- Future returning normally")
+    return greeting + "!"
+  }
+
+  // If the intent is not to test suspending, wait a bit so the first task
+  // can complete.
+  if !doSuspend {
+    print("+ Reader sleeping")
+    sleep(1)
+  }
+
+  do {
+    print("+ Reader waiting for the result")
+    let result = try await taskHandle.get()
+    completed = true
+    print("+ Normal return: \(result)")
+    assert(result == "Hello \(name) from async world!")
+  } catch HomeworkError.dogAteIt(let badDog) {
+    completed = true
+    print("+ Error return: HomeworkError.dogAteIt(\(badDog))")
+    assert(badDog == dogName + " the dog")
+  } catch {
+    fatalError("Caught a different exception?")
+  }
+
+  assert(completed)
+  print("Finished test")
+}
+
+
+@main struct Main {
+  static func main() async {
+    await testSimple(name: "Ted", dogName: "Hazel", shouldThrow: false, doSuspend: false)
+    await testSimple(name: "Ted", dogName: "Hazel", shouldThrow: true, doSuspend: false)
+    await testSimple(name: "Ted", dogName: "Hazel", shouldThrow: false, doSuspend: true)
+    await testSimple(name: "Ted", dogName: "Hazel", shouldThrow: true, doSuspend: true)
+
+    print("Done")
+  }
+}

test/Sanitizers/tsan/mainactor.swift

@@ -0,0 +1,83 @@
+// RUN: %target-run-simple-swift(-parse-as-library -Xfrontend -enable-experimental-concurrency %import-libdispatch) | %FileCheck %s
+
+// REQUIRES: executable_test
+// REQUIRES: concurrency
+// REQUIRES: libdispatch
+
+import Dispatch
+
+/// @returns true iff the expected answer is actually the case, i.e., correct.
+/// If the current queue does not match expectations, this function may return
+/// false or just crash the program with non-zero exit code, depending on SDK.
+func checkIfMainQueue(expectedAnswer expected: Bool) -> Bool {
+  if #available(macOS 10.12, iOS 10, tvOS 10, watchOS 3, *) {
+    dispatchPrecondition(condition: expected ? .onQueue(DispatchQueue.main) 
+                                             : .notOnQueue(DispatchQueue.main))
+  }
+  return true
+}
+
+actor A {
+  func onCorrectQueue(_ count : Int) -> Int {
+    if checkIfMainQueue(expectedAnswer: false) {
+      print("on actor instance's queue")
+      return count + 1
+    }
+    print("ERROR: not on actor instance's queue")
+    return -10
+  }
+}
+
+@MainActor func checkAnotherFn(_ count : Int) -> Int {
+  if checkIfMainQueue(expectedAnswer: true) {
+    print("on main queue again!")
+    return count + 1
+  } else {
+    print("ERROR: left the main queue?")
+    return -10
+  }
+}
+
+@MainActor func enterMainActor(_ initialCount : Int) async -> Int {
+  if checkIfMainQueue(expectedAnswer: true) {
+    print("hello from main actor!")
+  } else {
+    print("ERROR: not on correct queue!")
+  }
+
+  // try calling a function on another actor.
+  let count = await A().onCorrectQueue(initialCount)
+
+  guard checkIfMainQueue(expectedAnswer: true) else {
+    print("ERROR: did not switch back to main actor!")
+    return -10
+  }
+
+  return checkAnotherFn(count) + 1
+}
+
+@concurrent func someFunc() async -> Int {
+  // NOTE: the "return" counter is just to make sure we're properly returning values.
+  // the expected number should be equal to the number of "plus-one" expressions.
+  // since there are no loops or duplicate function calls
+  return await enterMainActor(0) + 1
+}
+
+
+// CHECK: starting
+// CHECK-NOT: ERROR
+// CHECK: hello from main actor!
+// CHECK-NOT: ERROR
+// CHECK: on actor instance's queue
+// CHECK-NOT: ERROR
+// CHECK: on main queue again!
+// CHECK-NOT: ERROR
+// CHECK: finished with return counter = 4
+
+@main struct RunIt {
+  static func main() async {
+    print("starting")
+    let result = await someFunc()
+    print("finished with return counter = \(result)")
+  }
+}