Bump version to 0.7.0

CocoaPods doesn't support multiple Swift modules in the same pod.
Build COpenCombineHelpers sources together with OpenCombine sources
as a single module.

Previously COpenCombineHelpers was a separate pod. This was suboptimal,
as it made making changes in both targets very hard: you'd have to
push COpenCombineHelpers to trunk in order to pass validation.

.circleci/config.yml

@@ -1,8 +1,8 @@
 version: 2
 jobs:
-  "Execute tests on macOS 10.15.0 (Xcode 11.2.1, Swift 5.1.2)":
+  "Execute tests on macOS 10.15.0 (Xcode 11.2.0, Swift 5.1.2)":
     macos:
-      xcode: "11.2.1"
+      xcode: "11.2.0"
     environment:
       SWIFT_VERSION: "5.1.2"
     steps:
@@ -60,9 +60,9 @@ jobs:
           command: |
             bash <(curl -s https://codecov.io/bash) -D DerivedData
 
-  "Execute compatibility tests on iOS 13.2.2 (Xcode 11.2.1, Swift 5.1.2)":
+  "Execute compatibility tests on iOS 13.2.2 (Xcode 11.2.0, Swift 5.1.2)":
     macos:
-      xcode: "11.2.1"
+      xcode: "11.2.0"
     environment:
       SWIFT_VERSION: "5.1.2"
     steps:
@@ -158,135 +158,6 @@ jobs:
           command: |
             bash <(curl -s https://codecov.io/bash) -D DerivedData
 
-  "Execute tests on iOS 11.4 (Xcode 11.1.0, Swift 5.1.0)":
-    macos:
-      xcode: "11.1.0"
-    environment:
-      SWIFT_VERSION: "5.1.0"
-    steps:
-      - checkout
-      - run:
-          name: Generating Xcode project
-          command: |
-            make generate-xcodeproj
-            xcodebuild -scheme OpenCombine-Package -showdestinations
-      - run:
-           name: Building for testing on iOS 11.4 with xcodebuild
-           command: |
-             set -o pipefail \
-               && xcodebuild build-for-testing \
-                    -scheme OpenCombine-Package \
-                    -destination "platform=iOS Simulator,name=iPhone X,OS=11.4" \
-                    -derivedDataPath DerivedData \
-               | tee xcodebuild_build-for-testing.log \
-               | xcpretty
-      - store_artifacts:
-          path: xcodebuild_build-for-testing.log
-      - run:
-          name: Testing on iOS 11.4 with xcodebuild
-          command: |
-            set -o pipefail \
-              && xcodebuild test-without-building \
-                   -scheme OpenCombine-Package \
-                   -destination "platform=iOS Simulator,name=iPhone X,OS=11.4" \
-                   -derivedDataPath DerivedData \
-              | tee xcodebuild_test-without-building.log \
-              | xcpretty --report junit -o build/reports/results.xml
-      - store_artifacts:
-          path: xcodebuild_test-without-building.log
-      - store_test_results:
-          path: build/reports
-      - run:
-          name: Uploading code coverage
-          command: |
-            bash <(curl -s https://codecov.io/bash) -D DerivedData
-
-  "Execute tests on iOS 12.2 (Xcode 11.2.1, Swift 5.1.2)":
-    macos:
-      xcode: "11.2.1"
-    environment:
-      SWIFT_VERSION: "5.1.2"
-    steps:
-      - checkout
-      - run:
-          name: Generating Xcode project
-          command: |
-            make generate-xcodeproj
-            xcodebuild -scheme OpenCombine-Package -showdestinations
-      - run:
-           name: Building for testing on iOS 12.2 with xcodebuild
-           command: |
-             set -o pipefail \
-               && xcodebuild build-for-testing \
-                    -scheme OpenCombine-Package \
-                    -destination "platform=iOS Simulator,name=iPhone X,OS=12.2" \
-                    -derivedDataPath DerivedData \
-               | tee xcodebuild_build-for-testing.log \
-               | xcpretty
-      - store_artifacts:
-          path: xcodebuild_build-for-testing.log
-      - run:
-          name: Testing on iOS 12.2 with xcodebuild
-          command: |
-            set -o pipefail \
-              && xcodebuild test-without-building \
-                   -scheme OpenCombine-Package \
-                   -destination "platform=iOS Simulator,name=iPhone X,OS=12.2" \
-                   -derivedDataPath DerivedData \
-              | tee xcodebuild_test-without-building.log \
-              | xcpretty --report junit -o build/reports/results.xml
-      - store_artifacts:
-          path: xcodebuild_test-without-building.log
-      - store_test_results:
-          path: build/reports
-      - run:
-          name: Uploading code coverage
-          command: |
-            bash <(curl -s https://codecov.io/bash) -D DerivedData
-
-  "Execute tests on iOS 13.2.2 (Xcode 11.2.1, Swift 5.1.2)":
-    macos:
-      xcode: "11.2.1"
-    environment:
-      SWIFT_VERSION: "5.1.2"
-    steps:
-      - checkout
-      - run:
-          name: Generating Xcode project
-          command: |
-            make generate-xcodeproj
-            xcodebuild -scheme OpenCombine-Package -showdestinations
-      - run:
-           name: Building for testing on iOS 13.2.2 with xcodebuild
-           command: |
-             set -o pipefail \
-               && xcodebuild build-for-testing \
-                    -scheme OpenCombine-Package \
-                    -destination "platform=iOS Simulator,name=iPhone 11,OS=13.2.2" \
-                    -derivedDataPath DerivedData \
-               | tee xcodebuild_build-for-testing.log \
-               | xcpretty
-      - store_artifacts:
-          path: xcodebuild_build-for-testing.log
-      - run:
-          name: Testing on iOS 13.2.2 with xcodebuild
-          command: |
-            set -o pipefail \
-              && xcodebuild test-without-building \
-                   -scheme OpenCombine-Package \
-                   -destination "platform=iOS Simulator,name=iPhone 11,OS=13.2.2" \
-                   -derivedDataPath DerivedData \
-              | tee xcodebuild_test-without-building.log \
-              | xcpretty --report junit -o build/reports/results.xml
-      - store_artifacts:
-          path: xcodebuild_test-without-building.log
-      - store_test_results:
-          path: build/reports
-      - run:
-          name: Uploading code coverage
-          command: |
-            bash <(curl -s https://codecov.io/bash) -D DerivedData
-
   "Execute tests on Ubuntu 18.04 (Swift 5.1.1)":
     docker:
       - image: swift:5.1.1-bionic
@@ -379,16 +250,13 @@ workflows:
   version: 2
   "OpenCombine: execute tests on macOS":
     jobs:
-      - "Execute tests on macOS 10.15.0 (Xcode 11.2.1, Swift 5.1.2)"
+      - "Execute tests on macOS 10.15.0 (Xcode 11.2.0, Swift 5.1.2)"
   "OpenCombine: execute compatibility tests":
     jobs:
-      - "Execute compatibility tests on iOS 13.2.2 (Xcode 11.2.1, Swift 5.1.2)"
+      - "Execute compatibility tests on iOS 13.2.2 (Xcode 11.2.0, Swift 5.1.2)"
   "OpenCombine: execute tests on iOS":
     jobs:
       - "Execute tests on iOS 9.3 (Xcode 10.2.1, Swift 5.0.1)"
-      - "Execute tests on iOS 11.4 (Xcode 11.1.0, Swift 5.1.0)"
-      - "Execute tests on iOS 12.2 (Xcode 11.2.1, Swift 5.1.2)"
-      - "Execute tests on iOS 13.2.2 (Xcode 11.2.1, Swift 5.1.2)"
   "OpenCombine: execute tests on Linux":
     jobs:
       - "Execute tests on Ubuntu 18.04 (Swift 5.1.1)"

.xcconfigs/OpenCombineSPM.xcconfig

@@ -1,3 +0,0 @@
-SWIFT_VERSION = 5.0
-OTHER_LDFLAGS = $(inherited) -L"$(TOOLCHAIN_DIR)/usr/lib/swift-$(SWIFT_VERSION)/$(PLATFORM_NAME)" -lobjc -lswiftCore
-HEADER_SEARCH_PATHS = $(SRCROOT)/Sources/COpenCombineHelpers

COpenCombineHelpers.podspec

@@ -1,28 +0,0 @@
-Pod::Spec.new do |spec|
-  spec.name          = "COpenCombineHelpers"
-  spec.version       = "0.5.0"
-  spec.summary       = "C++ Helpers for OpenCombine"
-
-  spec.description   = <<-DESC
-  C++ helpers necessary for the implementation of OpenCombine
-  DESC
-
-  spec.homepage      = "https://github.com/broadwaylamb/OpenCombine/"
-  spec.license       = "MIT"
-
-  spec.authors       = { "Sergej Jaskiewicz" => "jaskiewiczs@icloud.com" }
-  spec.source        = { :git => "https://github.com/broadwaylamb/OpenCombine.git", :tag => "#{spec.version}" }
-
-  spec.osx.deployment_target     = "10.10"
-  spec.ios.deployment_target     = "8.0"
-  spec.watchos.deployment_target = "2.0"
-  spec.tvos.deployment_target    = "9.0"
-
-  spec.header_mappings_dir       = "Sources/COpenCombineHelpers/include"
-  spec.source_files              = "Sources/COpenCombineHelpers/**/*.{cpp,h}"
-  spec.libraries                 = "c++"
-  
-  spec.pod_target_xcconfig = {
-    "DEFINES_MODULE" => "YES"
-  }
-end

Combine-Compatibility.xcconfig

@@ -1,2 +1 @@
 OTHER_SWIFT_FLAGS = $(inherited) -DOPENCOMBINE_COMPATIBILITY_TEST
-#include "OpenCombineSPM.xcconfig"

Makefile

@@ -8,10 +8,8 @@ debug:
 release:
 	$(SWIFT_EXE) build -c release $(SWIFT_BUILD_FLAGS)
 
-test-debug: export ASAN_OPTIONS=detect_leaks=0
-
 test-debug:
-	$(SWIFT_EXE) test -c debug --sanitize address $(SWIFT_BUILD_FLAGS) $(SWIFT_TEST_FLAGS)
+	$(SWIFT_EXE) test -c debug $(SWIFT_BUILD_FLAGS) $(SWIFT_TEST_FLAGS)
 
 test-debug-sanitize-thread:
 	$(SWIFT_EXE) test -c debug --sanitize thread $(SWIFT_BUILD_FLAGS) $(SWIFT_TEST_FLAGS)
@@ -26,14 +24,11 @@ test-compatibility:
 	$(SWIFT_EXE) test -Xswiftc -DOPENCOMBINE_COMPATIBILITY_TEST
 
 generate-compatibility-xcodeproj:
-	$(SWIFT_EXE) package generate-xcodeproj \
-		--xcconfig-overrides .xcconfigs/Combine-Compatibility.xcconfig; \
+	$(SWIFT_EXE) package generate-xcodeproj --xcconfig-overrides Combine-Compatibility.xcconfig; \
 	open OpenCombine.xcodeproj
 
 generate-xcodeproj:
-	$(SWIFT_EXE) package $(SWIFT_BUILD_FLAGS) generate-xcodeproj \
-		--enable-code-coverage  \
-		--xcconfig-overrides .xcconfigs/OpenCombineSPM.xcconfig
+	$(SWIFT_EXE) package $(SWIFT_BUILD_FLAGS) generate-xcodeproj --enable-code-coverage
 
 gyb:
 	$(shell ./utils/recursively_gyb.sh)

OpenCombine.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |spec|
   spec.name          = "OpenCombine"
-  spec.version       = "0.5.0"
+  spec.version       = "0.7.0"
   spec.summary       = "Open source implementation of Apple's Combine framework for processing values over time."
 
   spec.description   = <<-DESC
@@ -20,6 +20,8 @@ Pod::Spec.new do |spec|
   spec.watchos.deployment_target = "2.0"
   spec.tvos.deployment_target    = "9.0"
 
-  spec.source_files = "Sources/OpenCombine/**/*.swift"
-  spec.dependency     "COpenCombineHelpers"
+  spec.source_files        = "Sources/COpenCombineHelpers/**/*.{h,cpp}", "Sources/OpenCombine/**/*.swift"
+  spec.public_header_files = "Sources/COpenCombineHelpers/include/*.h"
+
+  spec.libraries = "c++"
 end

OpenCombineDispatch.podspec

@@ -1,10 +1,10 @@
 Pod::Spec.new do |spec|
   spec.name          = "OpenCombineDispatch"
-  spec.version       = "0.5.0"
-  spec.summary       = "OpenCombine Dispatching"
+  spec.version       = "0.7.0"
+  spec.summary       = "OpenCombine + Dispatch interoperability"
 
   spec.description   = <<-DESC
-  Extends `DispatchQueue` with new methods and nested types.
+  Extends `DispatchQueue` with conformance to the `Scheduler` protocol
   DESC
 
   spec.homepage      = "https://github.com/broadwaylamb/OpenCombine/"
@@ -21,5 +21,5 @@ Pod::Spec.new do |spec|
   spec.tvos.deployment_target    = "9.0"
 
   spec.source_files = "Sources/OpenCombineDispatch/**/*.swift"
-  spec.dependency     "OpenCombine"
+  spec.dependency     "OpenCombine", '>= 0.6'
 end

Package.swift

@@ -9,7 +9,7 @@ let package = Package(
         .library(name: "OpenCombineDispatch", targets: ["OpenCombineDispatch"]),
     ],
     targets: [
-        .target(name: "COpenCombineHelpers", cxxSettings: [.headerSearchPath(".")]),
+        .target(name: "COpenCombineHelpers"),
         .target(name: "OpenCombine", dependencies: ["COpenCombineHelpers"]),
         .target(name: "OpenCombineDispatch", dependencies: ["OpenCombine"]),
         .testTarget(name: "OpenCombineTests",
@@ -17,5 +17,5 @@ let package = Package(
                                    "OpenCombineDispatch"],
                     swiftSettings: [.unsafeFlags(["-enable-testing"])])
     ],
-    cxxLanguageStandard: .cxx14
+    cxxLanguageStandard: .cxx1z
 )

README.md

@@ -3,6 +3,7 @@
 [![codecov](https://codecov.io/gh/broadwaylamb/OpenCombine/branch/master/graph/badge.svg)](https://codecov.io/gh/broadwaylamb/OpenCombine)
 ![Language](https://img.shields.io/badge/Swift-5.0-orange.svg)
 ![Platform](https://img.shields.io/badge/platform-Linux%20%7C%20macOS%20%7C%20iOS%20%7C%20watchOS%20%7C%20tvOS-lightgrey.svg)
+![Cocoapods](https://img.shields.io/cocoapods/v/OpenCombine?color=blue)
 [<img src="https://img.shields.io/badge/slack-OpenCombine-yellow.svg?logo=slack">](https://join.slack.com/t/opencombine/shared_invite/enQtNzE2MjE5NzkxODI0LTYxMjkzNDUxZWViZWI1Njc2YjBhODgxNjRjOTdkZTcxOGU2ZjJjZjYxMGI3NWZkN2RkNGFmZTUzNmU3MGE2ZWM)
 
 Open-source implementation of Apple's [Combine](https://developer.apple.com/documentation/combine) framework for processing values over time.
@@ -22,7 +23,7 @@ To add `OpenCombine` to your [SPM](https://swift.org/package-manager/) package,
 
 ```swift
 dependencies: [
-    .package(url: "https://github.com/broadwaylamb/OpenCombine.git", from: "0.5.0")
+    .package(url: "https://github.com/broadwaylamb/OpenCombine.git", from: "0.7.0")
 ],
 targets: [
     .target(name: "MyAwesomePackage", dependencies: ["OpenCombine", "OpenCombineDispatch"])
@@ -43,8 +44,8 @@ To do so, open Xcode, use **File** → **Swift Packages** → **Add Package Depe
 To add `OpenCombine` to a project using [CocoaPods](https://cocoapods.org/), add `OpenCombine` and `OpenCombineDispatch` to the list of target dependencies in your `Podfile`. 
 
 ```ruby
-pod 'OpenCombine', '~> 0.5.0'
-pod 'OpenCombineDispatch', '~> 0.5.0'
+pod 'OpenCombine', '~> 0.7'
+pod 'OpenCombineDispatch', '~> 0.7'
 ```
 
 ### Contributing

RemainingCombineInterface.swift

@@ -2,173 +2,6 @@
 // Please remove the corresponding piece from this file if you implement something,
 // and complement this file as features are added in Apple's Combine
 
-extension Publishers {
-
-    /// A publisher that receives elements from an upstream publisher on a specific scheduler.
-    public struct SubscribeOn<Upstream, Context> : Publisher where Upstream : Publisher, Context : Scheduler {
-
-        /// The kind of values published by this publisher.
-        public typealias Output = Upstream.Output
-
-        /// The kind of errors this publisher might publish.
-        ///
-        /// Use `Never` if this `Publisher` does not publish errors.
-        public typealias Failure = Upstream.Failure
-
-        /// The publisher from which this publisher receives elements.
-        public let upstream: Upstream
-
-        /// The scheduler the publisher should use to receive elements.
-        public let scheduler: Context
-
-        /// Scheduler options that customize the delivery of elements.
-        public let options: Context.SchedulerOptions?
-
-        public init(upstream: Upstream, scheduler: Context, options: Context.SchedulerOptions?)
-
-        /// This function is called to attach the specified `Subscriber` to this `Publisher` by `subscribe(_:)`
-        ///
-        /// - SeeAlso: `subscribe(_:)`
-        /// - Parameters:
-        ///     - subscriber: The subscriber to attach to this `Publisher`.
-        ///                   once attached it can begin to receive values.
-        public func receive<S>(subscriber: S) where S : Subscriber, Upstream.Failure == S.Failure, Upstream.Output == S.Input
-    }
-}
-
-extension Publisher {
-
-    /// Specifies the scheduler on which to perform subscribe, cancel, and request operations.
-    ///
-    /// In contrast with `receive(on:options:)`, which affects downstream messages, `subscribe(on:)` changes the execution context of upstream messages. In the following example, requests to `jsonPublisher` are performed on `backgroundQueue`, but elements received from it are performed on `RunLoop.main`.
-    ///
-    ///     let ioPerformingPublisher == // Some publisher.
-    ///     let uiUpdatingSubscriber == // Some subscriber that updates the UI.
-    ///
-    ///     ioPerformingPublisher
-    ///         .subscribe(on: backgroundQueue)
-    ///         .receiveOn(on: RunLoop.main)
-    ///         .subscribe(uiUpdatingSubscriber)
-    ///
-    /// - Parameters:
-    ///   - scheduler: The scheduler on which to receive upstream messages.
-    ///   - options: Options that customize the delivery of elements.
-    /// - Returns: A publisher which performs upstream operations on the specified scheduler.
-    public func subscribe<S>(on scheduler: S, options: S.SchedulerOptions? = nil) -> Publishers.SubscribeOn<Self, S> where S : Scheduler
-}
-
-extension Publishers {
-
-    /// A publisher that measures and emits the time interval between events received from an upstream publisher.
-    public struct MeasureInterval<Upstream, Context> : Publisher where Upstream : Publisher, Context : Scheduler {
-
-        /// The kind of values published by this publisher.
-        public typealias Output = Context.SchedulerTimeType.Stride
-
-        /// The kind of errors this publisher might publish.
-        ///
-        /// Use `Never` if this `Publisher` does not publish errors.
-        public typealias Failure = Upstream.Failure
-
-        /// The publisher from which this publisher receives elements.
-        public let upstream: Upstream
-
-        /// The scheduler on which to deliver elements.
-        public let scheduler: Context
-
-        public init(upstream: Upstream, scheduler: Context)
-
-        /// This function is called to attach the specified `Subscriber` to this `Publisher` by `subscribe(_:)`
-        ///
-        /// - SeeAlso: `subscribe(_:)`
-        /// - Parameters:
-        ///     - subscriber: The subscriber to attach to this `Publisher`.
-        ///                   once attached it can begin to receive values.
-        public func receive<S>(subscriber: S) where S : Subscriber, Upstream.Failure == S.Failure, S.Input == Context.SchedulerTimeType.Stride
-    }
-}
-
-extension Publisher {
-
-    /// Measures and emits the time interval between events received from an upstream publisher.
-    ///
-    /// The output type of the returned scheduler is the time interval of the provided scheduler.
-    /// - Parameters:
-    ///   - scheduler: The scheduler on which to deliver elements.
-    ///   - options: Options that customize the delivery of elements.
-    /// - Returns: A publisher that emits elements representing the time interval between the elements it receives.
-    public func measureInterval<S>(using scheduler: S, options: S.SchedulerOptions? = nil) -> Publishers.MeasureInterval<Self, S> where S : Scheduler
-}
-
-extension Publishers {
-
-    /// A publisher that raises a debugger signal when a provided closure needs to stop the process in the debugger.
-    ///
-    /// When any of the provided closures returns `true`, this publisher raises the `SIGTRAP` signal to stop the process in the debugger.
-    /// Otherwise, this publisher passes through values and completions as-is.
-    public struct Breakpoint<Upstream> : Publisher where Upstream : Publisher {
-
-        /// The kind of values published by this publisher.
-        public typealias Output = Upstream.Output
-
-        /// The kind of errors this publisher might publish.
-        ///
-        /// Use `Never` if this `Publisher` does not publish errors.
-        public typealias Failure = Upstream.Failure
-
-        /// The publisher from which this publisher receives elements.
-        public let upstream: Upstream
-
-        /// A closure that executes when the publisher receives a subscription, and can raise a debugger signal by returning a true Boolean value.
-        public let receiveSubscription: ((Subscription) -> Bool)?
-
-        /// A closure that executes when the publisher receives output from the upstream publisher, and can raise a debugger signal by returning a true Boolean value.
-        public let receiveOutput: ((Upstream.Output) -> Bool)?
-
-        /// A closure that executes when the publisher receives completion, and can raise a debugger signal by returning a true Boolean value.
-        public let receiveCompletion: ((Subscribers.Completion<Upstream.Failure>) -> Bool)?
-
-        /// Creates a breakpoint publisher with the provided upstream publisher and breakpoint-raising closures.
-        ///
-        /// - Parameters:
-        ///   - upstream: The publisher from which this publisher receives elements.
-        ///   - receiveSubscription: A closure that executes when the publisher receives a subscription, and can raise a debugger signal by returning a true Boolean value.
-        ///   - receiveOutput: A closure that executes when the publisher receives output from the upstream publisher, and can raise a debugger signal by returning a true Boolean value.
-        ///   - receiveCompletion: A closure that executes when the publisher receives completion, and can raise a debugger signal by returning a true Boolean value.
-        public init(upstream: Upstream, receiveSubscription: ((Subscription) -> Bool)? = nil, receiveOutput: ((Upstream.Output) -> Bool)? = nil, receiveCompletion: ((Subscribers.Completion<Publishers.Breakpoint<Upstream>.Failure>) -> Bool)? = nil)
-
-        /// This function is called to attach the specified `Subscriber` to this `Publisher` by `subscribe(_:)`
-        ///
-        /// - SeeAlso: `subscribe(_:)`
-        /// - Parameters:
-        ///     - subscriber: The subscriber to attach to this `Publisher`.
-        ///                   once attached it can begin to receive values.
-        public func receive<S>(subscriber: S) where S : Subscriber, Upstream.Failure == S.Failure, Upstream.Output == S.Input
-    }
-}
-
-extension Publisher {
-
-    /// Raises a debugger signal when a provided closure needs to stop the process in the debugger.
-    ///
-    /// When any of the provided closures returns `true`, this publisher raises the `SIGTRAP` signal to stop the process in the debugger.
-    /// Otherwise, this publisher passes through values and completions as-is.
-    ///
-    /// - Parameters:
-    ///   - receiveSubscription: A closure that executes when when the publisher receives a subscription. Return `true` from this closure to raise `SIGTRAP`, or false to continue.
-    ///   - receiveOutput: A closure that executes when when the publisher receives a value. Return `true` from this closure to raise `SIGTRAP`, or false to continue.
-    ///   - receiveCompletion: A closure that executes when when the publisher receives a completion. Return `true` from this closure to raise `SIGTRAP`, or false to continue.
-    /// - Returns: A publisher that raises a debugger signal when one of the provided closures returns `true`.
-    public func breakpoint(receiveSubscription: ((Subscription) -> Bool)? = nil, receiveOutput: ((Self.Output) -> Bool)? = nil, receiveCompletion: ((Subscribers.Completion<Self.Failure>) -> Bool)? = nil) -> Publishers.Breakpoint<Self>
-
-    /// Raises a debugger signal upon receiving a failure.
-    ///
-    /// When the upstream publisher fails with an error, this publisher raises the `SIGTRAP` signal, which stops the process in the debugger.
-    /// Otherwise, this publisher passes through values and completions as-is.
-    /// - Returns: A publisher that raises a debugger signal upon receiving a failure.
-    public func breakpointOnError() -> Publishers.Breakpoint<Self>
-}
-
 extension Publishers {
 
     /// A publisher that receives and combines the latest elements from two publishers.
@@ -424,62 +257,6 @@ extension Publisher {
     public func collect<S>(_ strategy: Publishers.TimeGroupingStrategy<S>, options: S.SchedulerOptions? = nil) -> Publishers.CollectByTime<Self, S> where S : Scheduler
 }
 
-extension Publishers {
-
-    /// A publisher that delivers elements to its downstream subscriber on a specific scheduler.
-    public struct ReceiveOn<Upstream, Context> : Publisher where Upstream : Publisher, Context : Scheduler {
-
-        /// The kind of values published by this publisher.
-        public typealias Output = Upstream.Output
-
-        /// The kind of errors this publisher might publish.
-        ///
-        /// Use `Never` if this `Publisher` does not publish errors.
-        public typealias Failure = Upstream.Failure
-
-        /// The publisher from which this publisher receives elements.
-        public let upstream: Upstream
-
-        /// The scheduler the publisher is to use for element delivery.
-        public let scheduler: Context
-
-        /// Scheduler options that customize the delivery of elements.
-        public let options: Context.SchedulerOptions?
-
-        public init(upstream: Upstream, scheduler: Context, options: Context.SchedulerOptions?)
-
-        /// This function is called to attach the specified `Subscriber` to this `Publisher` by `subscribe(_:)`
-        ///
-        /// - SeeAlso: `subscribe(_:)`
-        /// - Parameters:
-        ///     - subscriber: The subscriber to attach to this `Publisher`.
-        ///                   once attached it can begin to receive values.
-        public func receive<S>(subscriber: S) where S : Subscriber, Upstream.Failure == S.Failure, Upstream.Output == S.Input
-    }
-}
-
-extension Publisher {
-
-    /// Specifies the scheduler on which to receive elements from the publisher.
-    ///
-    /// You use the `receive(on:options:)` operator to receive results on a specific scheduler, such as performing UI work on the main run loop.
-    /// In contrast with `subscribe(on:options:)`, which affects upstream messages, `receive(on:options:)` changes the execution context of downstream messages. In the following example, requests to `jsonPublisher` are performed on `backgroundQueue`, but elements received from it are performed on `RunLoop.main`.
-    ///
-    ///     let jsonPublisher = MyJSONLoaderPublisher() // Some publisher.
-    ///     let labelUpdater = MyLabelUpdateSubscriber() // Some subscriber that updates the UI.
-    ///
-    ///     jsonPublisher
-    ///         .subscribe(on: backgroundQueue)
-    ///         .receiveOn(on: RunLoop.main)
-    ///         .subscribe(labelUpdater)
-    ///
-    /// - Parameters:
-    ///   - scheduler: The scheduler the publisher is to use for element delivery.
-    ///   - options: Scheduler options that customize the element delivery.
-    /// - Returns: A publisher that delivers elements using the specified scheduler.
-    public func receive<S>(on scheduler: S, options: S.SchedulerOptions? = nil) -> Publishers.ReceiveOn<Self, S> where S : Scheduler
-}
-
 extension Publishers {
 
     public struct PrefixUntilOutput<Upstream, Other> : Publisher where Upstream : Publisher, Other : Publisher {
@@ -1205,127 +982,6 @@ extension Publisher {
     public func drop<P>(untilOutputFrom publisher: P) -> Publishers.DropUntilOutput<Self, P> where P : Publisher, Self.Failure == P.Failure
 }
 
-extension Publishers {
-
-    /// A publisher that performs the specified closures when publisher events occur.
-    public struct HandleEvents<Upstream> : Publisher where Upstream : Publisher {
-
-        /// The kind of values published by this publisher.
-        public typealias Output = Upstream.Output
-
-        /// The kind of errors this publisher might publish.
-        ///
-        /// Use `Never` if this `Publisher` does not publish errors.
-        public typealias Failure = Upstream.Failure
-
-        /// The publisher from which this publisher receives elements.
-        public let upstream: Upstream
-
-        /// A closure that executes when the publisher receives the subscription from the upstream publisher.
-        public var receiveSubscription: ((Subscription) -> Void)?
-
-        ///  A closure that executes when the publisher receives a value from the upstream publisher.
-        public var receiveOutput: ((Upstream.Output) -> Void)?
-
-        /// A closure that executes when the publisher receives the completion from the upstream publisher.
-        public var receiveCompletion: ((Subscribers.Completion<Upstream.Failure>) -> Void)?
-
-        ///  A closure that executes when the downstream receiver cancels publishing.
-        public var receiveCancel: (() -> Void)?
-
-        /// A closure that executes when the publisher receives a request for more elements.
-        public var receiveRequest: ((Subscribers.Demand) -> Void)?
-
-        public init(upstream: Upstream, receiveSubscription: ((Subscription) -> Void)? = nil, receiveOutput: ((Publishers.HandleEvents<Upstream>.Output) -> Void)? = nil, receiveCompletion: ((Subscribers.Completion<Publishers.HandleEvents<Upstream>.Failure>) -> Void)? = nil, receiveCancel: (() -> Void)? = nil, receiveRequest: ((Subscribers.Demand) -> Void)?)
-
-        /// This function is called to attach the specified `Subscriber` to this `Publisher` by `subscribe(_:)`
-        ///
-        /// - SeeAlso: `subscribe(_:)`
-        /// - Parameters:
-        ///     - subscriber: The subscriber to attach to this `Publisher`.
-        ///                   once attached it can begin to receive values.
-        public func receive<S>(subscriber: S) where S : Subscriber, Upstream.Failure == S.Failure, Upstream.Output == S.Input
-    }
-}
-
-extension Publisher {
-
-    /// Performs the specified closures when publisher events occur.
-    ///
-    /// - Parameters:
-    ///   - receiveSubscription: A closure that executes when the publisher receives the  subscription from the upstream publisher. Defaults to `nil`.
-    ///   - receiveOutput: A closure that executes when the publisher receives a value from the upstream publisher. Defaults to `nil`.
-    ///   - receiveCompletion: A closure that executes when the publisher receives the completion from the upstream publisher. Defaults to `nil`.
-    ///   - receiveCancel: A closure that executes when the downstream receiver cancels publishing. Defaults to `nil`.
-    ///   - receiveRequest: A closure that executes when the publisher receives a request for more elements. Defaults to `nil`.
-    /// - Returns: A publisher that performs the specified closures when publisher events occur.
-    public func handleEvents(receiveSubscription: ((Subscription) -> Void)? = nil, receiveOutput: ((Self.Output) -> Void)? = nil, receiveCompletion: ((Subscribers.Completion<Self.Failure>) -> Void)? = nil, receiveCancel: (() -> Void)? = nil, receiveRequest: ((Subscribers.Demand) -> Void)? = nil) -> Publishers.HandleEvents<Self>
-}
-
-extension Publishers {
-
-    /// A publisher that emits all of one publisher’s elements before those from another publisher.
-    public struct Concatenate<Prefix, Suffix> : Publisher where Prefix : Publisher, Suffix : Publisher, Prefix.Failure == Suffix.Failure, Prefix.Output == Suffix.Output {
-
-        /// The kind of values published by this publisher.
-        public typealias Output = Suffix.Output
-
-        /// The kind of errors this publisher might publish.
-        ///
-        /// Use `Never` if this `Publisher` does not publish errors.
-        public typealias Failure = Suffix.Failure
-
-        /// The publisher to republish, in its entirety, before republishing elements from `suffix`.
-        public let prefix: Prefix
-
-        /// The publisher to republish only after `prefix` finishes.
-        public let suffix: Suffix
-
-        public init(prefix: Prefix, suffix: Suffix)
-
-        /// This function is called to attach the specified `Subscriber` to this `Publisher` by `subscribe(_:)`
-        ///
-        /// - SeeAlso: `subscribe(_:)`
-        /// - Parameters:
-        ///     - subscriber: The subscriber to attach to this `Publisher`.
-        ///                   once attached it can begin to receive values.
-        public func receive<S>(subscriber: S) where S : Subscriber, Suffix.Failure == S.Failure, Suffix.Output == S.Input
-    }
-}
-
-extension Publisher {
-
-    /// Prefixes a `Publisher`'s output with the specified sequence.
-    /// - Parameter elements: The elements to publish before this publisher’s elements.
-    /// - Returns: A publisher that prefixes the specified elements prior to this publisher’s elements.
-    public func prepend(_ elements: Self.Output...) -> Publishers.Concatenate<Publishers.Sequence<[Self.Output], Self.Failure>, Self>
-
-    /// Prefixes a `Publisher`'s output with the specified sequence.
-    /// - Parameter elements: A sequence of elements to publish before this publisher’s elements.
-    /// - Returns: A publisher that prefixes the sequence of elements prior to this publisher’s elements.
-    public func prepend<S>(_ elements: S) -> Publishers.Concatenate<Publishers.Sequence<S, Self.Failure>, Self> where S : Sequence, Self.Output == S.Element
-
-    /// Prefixes this publisher’s output with the elements emitted by the given publisher.
-    ///
-    /// The resulting publisher doesn’t emit any elements until the prefixing publisher finishes.
-    /// - Parameter publisher: The prefixing publisher.
-    /// - Returns: A publisher that prefixes the prefixing publisher’s elements prior to this publisher’s elements.
-    public func prepend<P>(_ publisher: P) -> Publishers.Concatenate<P, Self> where P : Publisher, Self.Failure == P.Failure, Self.Output == P.Output
-
-    /// Append a `Publisher`'s output with the specified sequence.
-    public func append(_ elements: Self.Output...) -> Publishers.Concatenate<Self, Publishers.Sequence<[Self.Output], Self.Failure>>
-
-    /// Appends a `Publisher`'s output with the specified sequence.
-    public func append<S>(_ elements: S) -> Publishers.Concatenate<Self, Publishers.Sequence<S, Self.Failure>> where S : Sequence, Self.Output == S.Element
-
-    /// Appends this publisher’s output with the elements emitted by the given publisher.
-    ///
-    /// This operator produces no elements until this publisher finishes. It then produces this publisher’s elements, followed by the given publisher’s elements. If this publisher fails with an error, the prefixing publisher does not publish the provided publisher’s elements.
-    /// - Parameter publisher: The appending publisher.
-    /// - Returns: A publisher that appends the appending publisher’s elements after this publisher’s elements.
-    public func append<P>(_ publisher: P) -> Publishers.Concatenate<Self, P> where P : Publisher, Self.Failure == P.Failure, Self.Output == P.Output
-}
-
 extension Publishers {
 
     /// A publisher that publishes elements only after a specified time interval elapses between events.
@@ -1795,68 +1451,6 @@ extension Publisher {
     public func tryCatch<P>(_ handler: @escaping (Self.Failure) throws -> P) -> Publishers.TryCatch<Self, P> where P : Publisher, Self.Output == P.Output
 }
 
-extension Publishers {
-
-    /// A publisher that delays delivery of elements and completion to the downstream receiver.
-    public struct Delay<Upstream, Context> : Publisher where Upstream : Publisher, Context : Scheduler {
-
-        /// The kind of values published by this publisher.
-        public typealias Output = Upstream.Output
-
-        /// The kind of errors this publisher might publish.
-        ///
-        /// Use `Never` if this `Publisher` does not publish errors.
-        public typealias Failure = Upstream.Failure
-
-        /// The publisher that this publisher receives elements from.
-        public let upstream: Upstream
-
-        /// The amount of time to delay.
-        public let interval: Context.SchedulerTimeType.Stride
-
-        /// The allowed tolerance in firing delayed events.
-        public let tolerance: Context.SchedulerTimeType.Stride
-
-        /// The scheduler to deliver the delayed events.
-        public let scheduler: Context
-
-        public let options: Context.SchedulerOptions?
-
-        public init(upstream: Upstream, interval: Context.SchedulerTimeType.Stride, tolerance: Context.SchedulerTimeType.Stride, scheduler: Context, options: Context.SchedulerOptions? = nil)
-
-        /// This function is called to attach the specified `Subscriber` to this `Publisher` by `subscribe(_:)`
-        ///
-        /// - SeeAlso: `subscribe(_:)`
-        /// - Parameters:
-        ///     - subscriber: The subscriber to attach to this `Publisher`.
-        ///                   once attached it can begin to receive values.
-        public func receive<S>(subscriber: S) where S : Subscriber, Upstream.Failure == S.Failure, Upstream.Output == S.Input
-    }
-}
-
-extension Publisher {
-
-    /// Delays delivery of all output to the downstream receiver by a specified amount of time on a particular scheduler.
-    ///
-    /// The delay affects the delivery of elements and completion, but not of the original subscription.
-    /// - Parameters:
-    ///   - interval: The amount of time to delay.
-    ///   - tolerance: The allowed tolerance in firing delayed events.
-    ///   - scheduler: The scheduler to deliver the delayed events.
-    /// - Returns: A publisher that delays delivery of elements and completion to the downstream receiver.
-    public func delay<S>(for interval: S.SchedulerTimeType.Stride, tolerance: S.SchedulerTimeType.Stride? = nil, scheduler: S, options: S.SchedulerOptions? = nil) -> Publishers.Delay<Self, S> where S : Scheduler
-}
-
-extension Just {
-
-    public func prepend(_ elements: Output...) -> Publishers.Sequence<[Output], Just<Output>.Failure>
-
-    public func prepend<S>(_ elements: S) -> Publishers.Sequence<[Output], Just<Output>.Failure> where Output == S.Element, S : Sequence
-
-    public func append(_ elements: Output...) -> Publishers.Sequence<[Output], Just<Output>.Failure>
-
-    public func append<S>(_ elements: S) -> Publishers.Sequence<[Output], Just<Output>.Failure> where Output == S.Element, S : Sequence
-}
 
 extension Publishers.CombineLatest : Equatable where A : Equatable, B : Equatable {
 
@@ -2035,17 +1629,6 @@ extension Publishers.DropUntilOutput : Equatable where Upstream : Equatable, Oth
     public static func == (lhs: Publishers.DropUntilOutput<Upstream, Other>, rhs: Publishers.DropUntilOutput<Upstream, Other>) -> Bool
 }
 
-extension Publishers.Concatenate : Equatable where Prefix : Equatable, Suffix : Equatable {
-
-    /// Returns a Boolean value that indicates whether two publishers are equivalent.
-    ///
-    /// - Parameters:
-    ///   - lhs: A concatenate publisher to compare for equality.
-    ///   - rhs: Another concatenate publisher to compare for equality.
-    /// - Returns: `true` if the two publishers’ prefix and suffix properties are equal, `false` otherwise.
-    public static func == (lhs: Publishers.Concatenate<Prefix, Suffix>, rhs: Publishers.Concatenate<Prefix, Suffix>) -> Bool
-}
-
 extension Publishers.Zip : Equatable where A : Equatable, B : Equatable {
 
     /// Returns a Boolean value that indicates whether two publishers are equivalent.

Sources/COpenCombineHelpers/BackDeployment.cpp

@@ -1,34 +0,0 @@
-//
-//  BackDeployment.cpp
-//  
-//
-//  Created by Sergej Jaskiewicz on 31.10.2019.
-//
-
-// The content of this file is based on
-// https://github.com/apple/swift/blob/master/stdlib/public/runtime/BackDeployment.cpp
-// and must be updated accordingly.
-
-#if defined(__APPLE__) && defined(__MACH__)
-#include "swift/Runtime/Config.h"
-
-/// Returns true if the current OS version, at runtime, is a back-deployment
-/// version.
-static bool isBackDeploying() {
-    if (__builtin_available(macOS 10.14.4, watchOS 5.2.0, iOS 12.2.0, tvOS 12.2.0, *)) {
-        return false;
-    } else {
-        // We're in a pre-ABI-stable world
-        return true;
-    }
-}
-
-static unsigned long long computeIsSwiftMask() {
-    return isBackDeploying() ? 1ULL : 2ULL;
-}
-
-namespace opencombine {
-unsigned long long classIsSwiftMask = computeIsSwiftMask();
-}
-
-#endif

Sources/COpenCombineHelpers/COpenCombineHelpers.cpp

@@ -1,5 +1,5 @@
 //
-//  Locking.cpp
+//  COpenCombineHelpers.cpp
 //  
 //
 //  Created by Sergej Jaskiewicz on 23/09/2019.

Sources/COpenCombineHelpers/Demangler.cpp

@@ -1,42 +0,0 @@
-//===--- Demangler.cpp - String to Node-Tree Demangling -------------------===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
-//
-//===----------------------------------------------------------------------===//
-//
-//  This file implements new Swift de-mangler.
-//
-//===----------------------------------------------------------------------===//
-
-// MODIFICATION NOTE:
-// This file has been modified for the OpenCombine open source project.
-// - Some functions have been removed.
-// - The swift namespace is wrapped in the opencombine namespace.
-
-#include "swift/Demangling/Demangle.h"
-
-using namespace opencombine;
-using namespace swift;
-
-string_view
-swift::Demangle::makeSymbolicMangledNameStringRef(const char *base) {
-  if (!base)
-    return {};
-
-  auto end = base;
-  while (*end != '\0') {
-    // Skip over symbolic references.
-    if (*end >= '\x01' && *end <= '\x17')
-      end += sizeof(uint32_t);
-    else if (*end >= '\x18' && *end <= '\x1F')
-      end += sizeof(void*);
-    ++end;
-  }
-  return { base, size_t(end - base) };
-}

Sources/COpenCombineHelpers/EnumerateFields.cpp

@@ -1,119 +0,0 @@
-//
-//  EnumerateFields.cpp
-//  
-//
-//  Created by Sergej Jaskiewicz on 25.10.2019.
-//
-
-#include "COpenCombineHelpers.h"
-#include "swift/ABI/Metadata.h"
-#include "swift/Runtime/Metadata.h"
-#include "swift/Reflection/Records.h"
-#include "stl_polyfill/string_view.h"
-
-using namespace opencombine;
-using namespace swift;
-using namespace reflection;
-
-// This function is defined in the Swift runtime.
-OPENCOMBINE_SWIFT_CALLING_CONVENTION
-extern "C"
-const Metadata *
-swift_getTypeByMangledNameInContext(const char* typeNameStart,
-                                    size_t typeNameLength,
-                                    const ContextDescriptor* context,
-                                    const Metadata* const* genericArgs);
-
-namespace {
-const Metadata* getTypeMetadata(const FieldRecord& record,
-                                const Metadata* fieldOwner) {
-    string_view mangledTypeName = record.getMangledTypeName(0);
-    return swift_getTypeByMangledNameInContext(mangledTypeName.data(),
-                                               mangledTypeName.size(),
-                                               fieldOwner->getTypeContextDescriptor(),
-                                               fieldOwner->getGenericArgs());
-}
-
-string_view nextTupleLabel(const char*& labels) {
-    const char* start = labels;
-    while (true) {
-        char current = *labels++;
-        if (current == ' ' || current == '\0') {
-            break;
-        }
-    }
-    return { start, size_t(labels - start - 1) };
-}
-
-} // end anonymous namespace
-
-bool opencombine_enumerate_fields(const void* opaqueMetadataPtr,
-                                        bool allowResilientSuperclasses,
-                                        void* enumeratorContext,
-                                        OpenCombineFieldEnumerator enumerator) {
-
-    auto enumerateFields = [&](const auto* metadata,
-                               const TypeContextDescriptor* description) -> bool {
-        const auto* fieldOffsets = metadata->getFieldOffsets();
-        const FieldDescriptor& fieldDescriptor = *description->Fields;
-
-        for (const FieldRecord& fieldRecord : fieldDescriptor) {
-            if (!enumerator(enumeratorContext,
-                            fieldRecord.getFieldName(0).data(),
-                            *fieldOffsets++,
-                            getTypeMetadata(fieldRecord, metadata))) {
-                return false;
-            }
-        }
-
-        return true;
-    };
-
-    const Metadata* metadata = static_cast<const Metadata*>(opaqueMetadataPtr);
-
-    if (metadata->isClassObject()) {
-        auto anyClassMetadata = static_cast<const AnyClassMetadata*>(metadata);
-        if (!anyClassMetadata->isTypeMetadata()) {
-            return true;
-        }
-        auto classMetadata = static_cast<const ClassMetadata*>(anyClassMetadata);
-
-        const ClassDescriptor* description = classMetadata->getDescription();
-
-        if (!allowResilientSuperclasses && description->hasResilientSuperclass()) {
-            return false;
-        }
-
-        if (auto superclassMetadata = classMetadata->Superclass) {
-            if (!opencombine_enumerate_fields(superclassMetadata,
-                                              allowResilientSuperclasses,
-                                              enumeratorContext,
-                                              enumerator)) {
-                return false;
-            }
-        }
-
-        return enumerateFields(classMetadata, description);
-    }
-
-    if (const auto* structMetadata = llvm::dyn_cast<StructMetadata>(metadata)) {
-        return enumerateFields(structMetadata, structMetadata->getDescription());
-    }
-
-    if (const auto* tupleMetadata = llvm::dyn_cast<TupleTypeMetadata>(metadata)) {
-        const char* labels = tupleMetadata->Labels;
-        for (TupleTypeMetadata::StoredSize i = 0; i < tupleMetadata->NumElements; ++i) {
-            const TupleTypeMetadata::Element& element = tupleMetadata->getElement(i);
-            string_view nextLabel = nextTupleLabel(labels);
-            std::string label(nextLabel.data(), nextLabel.size());
-            if (!enumerator(enumeratorContext,
-                            label.c_str(),
-                            element.Offset,
-                            element.Type)) {
-                return false;
-            }
-        }
-    }
-
-    return false;
-}

Sources/COpenCombineHelpers/Metadata.cpp

@@ -1,123 +0,0 @@
-//===--- Metadata.cpp - Swift Language ABI Metadata Support ---------------===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
-//
-//===----------------------------------------------------------------------===//
-//
-// Implementations of the metadata ABI functions.
-//
-//===----------------------------------------------------------------------===//
-
-// MODIFICATION NOTE:
-// This file has been modified for the OpenCombine open source project.
-// - Some functions have been removed.
-// - The swift namespace is wrapped in the opencombine namespace.
-
-#include "swift/Runtime/Metadata.h"
-
-using namespace opencombine;
-using namespace swift;
-
-#if OPENCOMBINE_SWIFT_OBJC_INTEROP
-static ClassMetadataBounds computeMetadataBoundsForObjCClass(Class cls) {
-  cls = swift_getInitializedObjCClass(cls);
-  auto metadata = reinterpret_cast<const ClassMetadata *>(cls);
-  return metadata->getClassBoundsAsSwiftSuperclass();
-}
-#endif
-
-static ClassMetadataBounds
-computeMetadataBoundsForSuperclass(const void *ref,
-                                   TypeReferenceKind refKind) {
-  switch (refKind) {
-  case TypeReferenceKind::IndirectTypeDescriptor: {
-    auto description = *reinterpret_cast<const ClassDescriptor * const *>(ref);
-    if (!description) {
-//      swift::fatalError(0, "instantiating class metadata for class with "
-//                           "missing weak-linked ancestor");
-        abort();
-    }
-    return description->getMetadataBounds();
-  }
-
-  case TypeReferenceKind::DirectTypeDescriptor: {
-    auto description = reinterpret_cast<const ClassDescriptor *>(ref);
-    return description->getMetadataBounds();
-  }
-
-  case TypeReferenceKind::DirectObjCClassName: {
-#if OPENCOMBINE_SWIFT_OBJC_INTEROP
-    auto cls = objc_lookUpClass(reinterpret_cast<const char *>(ref));
-    return computeMetadataBoundsForObjCClass(cls);
-#else
-    break;
-#endif
-  }
-
-  case TypeReferenceKind::IndirectObjCClass: {
-#if OPENCOMBINE_SWIFT_OBJC_INTEROP
-    auto cls = *reinterpret_cast<const Class *>(ref);
-    return computeMetadataBoundsForObjCClass(cls);
-#else
-    break;
-#endif
-  }
-  }
-  opencombine_swift_runtime_unreachable("unsupported superclass reference kind");
-}
-
-static ClassMetadataBounds computeMetadataBoundsFromSuperclass(
-                                      const ClassDescriptor *description,
-                                      StoredClassMetadataBounds &storedBounds) {
-  ClassMetadataBounds bounds;
-
-  // Compute the bounds for the superclass, extending it to the minimum
-  // bounds of a Swift class.
-  if (const void *superRef = description->getResilientSuperclass()) {
-    bounds = computeMetadataBoundsForSuperclass(superRef,
-                           description->getResilientSuperclassReferenceKind());
-  } else {
-    bounds = ClassMetadataBounds::forSwiftRootClass();
-  }
-
-  // Add the subclass's immediate members.
-  bounds.adjustForSubclass(description->areImmediateMembersNegative(),
-                           description->NumImmediateMembers);
-
-  // Cache before returning.
-  storedBounds.initialize(bounds);
-  return bounds;
-}
-
-ClassMetadataBounds
-swift::getResilientMetadataBounds(const ClassDescriptor *description) {
-  assert(description->hasResilientSuperclass());
-  auto &storedBounds = *description->ResilientMetadataBounds.get();
-
-  ClassMetadataBounds bounds;
-  if (storedBounds.tryGet(bounds)) {
-    return bounds;
-  }
-
-  return computeMetadataBoundsFromSuperclass(description, storedBounds);
-}
-
-int32_t
-swift::getResilientImmediateMembersOffset(const ClassDescriptor *description) {
-  assert(description->hasResilientSuperclass());
-  auto &storedBounds = *description->ResilientMetadataBounds.get();
-
-  ptrdiff_t result;
-  if (storedBounds.tryGetImmediateMembersOffset(result)) {
-    return result / sizeof(void*);
-  }
-
-  auto bounds = computeMetadataBoundsFromSuperclass(description, storedBounds);
-  return bounds.ImmediateMembersOffset / sizeof(void*);
-}

Sources/COpenCombineHelpers/include/COpenCombineHelpers.h

@@ -9,8 +9,7 @@
 #define COPENCOMBINEHELPERS_H
 
 #include <stdint.h>
-#include <stddef.h>
-#include <stdbool.h>
+#include <signal.h>
 
 #if __has_attribute(swift_name)
 # define OPENCOMBINE_SWIFT_NAME(_name) __attribute__((swift_name(#_name)))
@@ -18,6 +17,12 @@
 # define OPENCOMBINE_SWIFT_NAME(_name)
 #endif
 
+#if __has_attribute(always_inline)
+# define OPENCOMBINE_ALWAYS_INLINE __attribute__((always_inline))
+#else
+# define OPENCOMBINE_ALWAYS_INLINE
+#endif
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -25,67 +30,59 @@ extern "C" {
 #pragma mark - CombineIdentifier
 
 uint64_t opencombine_next_combine_identifier(void)
-    OPENCOMBINE_SWIFT_NAME(nextCombineIdentifier());
+    OPENCOMBINE_SWIFT_NAME(__nextCombineIdentifier());
 
 #pragma mark - OpenCombineUnfairLock
 
 /// A wrapper around an opaque pointer for type safety in Swift.
 typedef struct OpenCombineUnfairLock {
     void* _Nonnull opaque;
-} OPENCOMBINE_SWIFT_NAME(UnfairLock) OpenCombineUnfairLock;
+} OPENCOMBINE_SWIFT_NAME(__UnfairLock) OpenCombineUnfairLock;
 
 /// Allocates a lock object. The allocated object must be destroyed by calling
 /// the destroy() method.
 OpenCombineUnfairLock opencombine_unfair_lock_alloc(void)
-    OPENCOMBINE_SWIFT_NAME(UnfairLock.allocate());
+    OPENCOMBINE_SWIFT_NAME(__UnfairLock.allocate());
 
 void opencombine_unfair_lock_lock(OpenCombineUnfairLock)
-    OPENCOMBINE_SWIFT_NAME(UnfairLock.lock(self:));
+    OPENCOMBINE_SWIFT_NAME(__UnfairLock.lock(self:));
 
 void opencombine_unfair_lock_unlock(OpenCombineUnfairLock)
-    OPENCOMBINE_SWIFT_NAME(UnfairLock.unlock(self:));
+    OPENCOMBINE_SWIFT_NAME(__UnfairLock.unlock(self:));
 
 void opencombine_unfair_lock_assert_owner(OpenCombineUnfairLock mutex)
-    OPENCOMBINE_SWIFT_NAME(UnfairLock.assertOwner(self:));
+    OPENCOMBINE_SWIFT_NAME(__UnfairLock.assertOwner(self:));
 
 void opencombine_unfair_lock_dealloc(OpenCombineUnfairLock lock)
-    OPENCOMBINE_SWIFT_NAME(UnfairLock.deallocate(self:));
+    OPENCOMBINE_SWIFT_NAME(__UnfairLock.deallocate(self:));
 
 #pragma mark - OpenCombineUnfairRecursiveLock
 
 /// A wrapper around an opaque pointer for type safety in Swift.
 typedef struct OpenCombineUnfairRecursiveLock {
     void* _Nonnull opaque;
-} OPENCOMBINE_SWIFT_NAME(UnfairRecursiveLock) OpenCombineUnfairRecursiveLock;
+} OPENCOMBINE_SWIFT_NAME(__UnfairRecursiveLock) OpenCombineUnfairRecursiveLock;
 
 OpenCombineUnfairRecursiveLock opencombine_unfair_recursive_lock_alloc(void)
-    OPENCOMBINE_SWIFT_NAME(UnfairRecursiveLock.allocate());
+    OPENCOMBINE_SWIFT_NAME(__UnfairRecursiveLock.allocate());
 
 void opencombine_unfair_recursive_lock_lock(OpenCombineUnfairRecursiveLock)
-    OPENCOMBINE_SWIFT_NAME(UnfairRecursiveLock.lock(self:));
+    OPENCOMBINE_SWIFT_NAME(__UnfairRecursiveLock.lock(self:));
 
 void opencombine_unfair_recursive_lock_unlock(OpenCombineUnfairRecursiveLock)
-    OPENCOMBINE_SWIFT_NAME(UnfairRecursiveLock.unlock(self:));
+    OPENCOMBINE_SWIFT_NAME(__UnfairRecursiveLock.unlock(self:));
 
 void opencombine_unfair_recursive_lock_dealloc(OpenCombineUnfairRecursiveLock lock)
-    OPENCOMBINE_SWIFT_NAME(UnfairRecursiveLock.deallocate(self:));
+    OPENCOMBINE_SWIFT_NAME(__UnfairRecursiveLock.deallocate(self:));
 
-#pragma mark - Type metadata
+#pragma mark - Breakpoint
 
-typedef bool(*_Nonnull OpenCombineFieldEnumerator)(
-    void* _Nullable enumeratorContext,
-    const char* _Nonnull fieldName,
-    size_t fieldOffset,
-    const void* _Nonnull fieldTypeMetadataPtr
-);
+OPENCOMBINE_ALWAYS_INLINE
+inline void opencombine_stop_in_debugger(void) OPENCOMBINE_SWIFT_NAME(__stopInDebugger());
 
-bool
-opencombine_enumerate_fields(
-    const void* _Nonnull type_metadata,
-    bool allowResilientSuperclasses,
-    void* _Nullable enumerator_context,
-    OpenCombineFieldEnumerator enumerator
-) OPENCOMBINE_SWIFT_NAME(enumerateFields(typeMetadata:allowResilientSuperclasses:enumeratorContext:enumerator:));
+void opencombine_stop_in_debugger(void) {
+    raise(SIGTRAP);
+}
 
 #ifdef __cplusplus
 } // extern "C"

Sources/COpenCombineHelpers/llvm/ADT/None.h

@@ -1,32 +0,0 @@
-//===-- None.h - Simple null value for implicit construction ------*- C++ -*-=//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-//  This file provides None, an enumerator for use in implicit constructors
-//  of various (usually templated) types to make such construction more
-//  terse.
-//
-//===----------------------------------------------------------------------===//
-
-// MODIFICATION NOTE:
-// This file has been modified for the OpenCombine open source project.
-// - The llvm namespace is wrapped in the opencombine namespace.
-
-#ifndef OPENCOMBINE_LLVM_ADT_NONE_H
-#define OPENCOMBINE_LLVM_ADT_NONE_H
-
-namespace opencombine {
-namespace llvm {
-/// A simple null object to allow implicit construction of Optional<T>
-/// and similar types without having to spell out the specialization's name.
-// (constant value 1 in an attempt to workaround MSVC build issue... )
-enum class NoneType { None = 1 };
-const NoneType None = NoneType::None;
-}
-}
-
-#endif

Sources/COpenCombineHelpers/llvm/ADT/Optional.h

@@ -1,435 +0,0 @@
-//===- Optional.h - Simple variant for passing optional values --*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-//  This file provides Optional, a template class modeled in the spirit of
-//  OCaml's 'opt' variant.  The idea is to strongly type whether or not
-//  a value can be optional.
-//
-//===----------------------------------------------------------------------===//
-
-// MODIFICATION NOTE:
-// This file has been modified for the OpenCombine open source project.
-// - The llvm namespace is wrapped in the opencombine namespace.
-
-#ifndef OPENCOMBINE_LLVM_ADT_OPTIONAL_H
-#define OPENCOMBINE_LLVM_ADT_OPTIONAL_H
-
-#include "llvm/ADT/None.h"
-#include "llvm/Support/Compiler.h"
-#include "llvm/Support/type_traits.h"
-#include <cassert>
-#include <memory>
-#include <new>
-#include <utility>
-
-namespace opencombine {
-namespace llvm {
-
-class raw_ostream;
-
-namespace optional_detail {
-
-struct in_place_t {};
-
-/// Storage for any type.
-template <typename T, bool = is_trivially_copyable<T>::value>
-class OptionalStorage {
-  union {
-    char empty;
-    T value;
-  };
-  bool hasVal;
-
-public:
-  ~OptionalStorage() { reset(); }
-
-  OptionalStorage() noexcept : empty(), hasVal(false) {}
-
-  OptionalStorage(OptionalStorage const &other) : OptionalStorage() {
-    if (other.hasValue()) {
-      emplace(other.value);
-    }
-  }
-  OptionalStorage(OptionalStorage &&other) : OptionalStorage() {
-    if (other.hasValue()) {
-      emplace(std::move(other.value));
-    }
-  }
-
-  template <class... Args>
-  explicit OptionalStorage(in_place_t, Args &&... args)
-      : value(std::forward<Args>(args)...), hasVal(true) {}
-
-  void reset() noexcept {
-    if (hasVal) {
-      value.~T();
-      hasVal = false;
-    }
-  }
-
-  bool hasValue() const noexcept { return hasVal; }
-
-  T &getValue() LLVM_LVALUE_FUNCTION noexcept {
-    assert(hasVal);
-    return value;
-  }
-  T const &getValue() const LLVM_LVALUE_FUNCTION noexcept {
-    assert(hasVal);
-    return value;
-  }
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
-  T &&getValue() && noexcept {
-    assert(hasVal);
-    return std::move(value);
-  }
-#endif
-
-  template <class... Args> void emplace(Args &&... args) {
-    reset();
-    ::new ((void *)std::addressof(value)) T(std::forward<Args>(args)...);
-    hasVal = true;
-  }
-
-  OptionalStorage &operator=(T const &y) {
-    if (hasValue()) {
-      value = y;
-    } else {
-      ::new ((void *)std::addressof(value)) T(y);
-      hasVal = true;
-    }
-    return *this;
-  }
-  OptionalStorage &operator=(T &&y) {
-    if (hasValue()) {
-      value = std::move(y);
-    } else {
-      ::new ((void *)std::addressof(value)) T(std::move(y));
-      hasVal = true;
-    }
-    return *this;
-  }
-
-  OptionalStorage &operator=(OptionalStorage const &other) {
-    if (other.hasValue()) {
-      if (hasValue()) {
-        value = other.value;
-      } else {
-        ::new ((void *)std::addressof(value)) T(other.value);
-        hasVal = true;
-      }
-    } else {
-      reset();
-    }
-    return *this;
-  }
-
-  OptionalStorage &operator=(OptionalStorage &&other) {
-    if (other.hasValue()) {
-      if (hasValue()) {
-        value = std::move(other.value);
-      } else {
-        ::new ((void *)std::addressof(value)) T(std::move(other.value));
-        hasVal = true;
-      }
-    } else {
-      reset();
-    }
-    return *this;
-  }
-};
-
-template <typename T> class OptionalStorage<T, true> {
-  union {
-    char empty;
-    T value;
-  };
-  bool hasVal = false;
-
-public:
-  ~OptionalStorage() = default;
-
-  OptionalStorage() noexcept : empty{} {}
-
-  OptionalStorage(OptionalStorage const &other) = default;
-  OptionalStorage(OptionalStorage &&other) = default;
-
-  OptionalStorage &operator=(OptionalStorage const &other) = default;
-  OptionalStorage &operator=(OptionalStorage &&other) = default;
-
-  template <class... Args>
-  explicit OptionalStorage(in_place_t, Args &&... args)
-      : value(std::forward<Args>(args)...), hasVal(true) {}
-
-  void reset() noexcept {
-    if (hasVal) {
-      value.~T();
-      hasVal = false;
-    }
-  }
-
-  bool hasValue() const noexcept { return hasVal; }
-
-  T &getValue() LLVM_LVALUE_FUNCTION noexcept {
-    assert(hasVal);
-    return value;
-  }
-  T const &getValue() const LLVM_LVALUE_FUNCTION noexcept {
-    assert(hasVal);
-    return value;
-  }
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
-  T &&getValue() && noexcept {
-    assert(hasVal);
-    return std::move(value);
-  }
-#endif
-
-  template <class... Args> void emplace(Args &&... args) {
-    reset();
-    ::new ((void *)std::addressof(value)) T(std::forward<Args>(args)...);
-    hasVal = true;
-  }
-
-  OptionalStorage &operator=(T const &y) {
-    if (hasValue()) {
-      value = y;
-    } else {
-      ::new ((void *)std::addressof(value)) T(y);
-      hasVal = true;
-    }
-    return *this;
-  }
-  OptionalStorage &operator=(T &&y) {
-    if (hasValue()) {
-      value = std::move(y);
-    } else {
-      ::new ((void *)std::addressof(value)) T(std::move(y));
-      hasVal = true;
-    }
-    return *this;
-  }
-};
-
-} // namespace optional_detail
-
-template <typename T> class Optional {
-  optional_detail::OptionalStorage<T> Storage;
-
-public:
-  using value_type = T;
-
-  constexpr Optional() {}
-  constexpr Optional(NoneType) {}
-
-  Optional(const T &y) : Storage(optional_detail::in_place_t{}, y) {}
-  Optional(const Optional &O) = default;
-
-  Optional(T &&y) : Storage(optional_detail::in_place_t{}, std::move(y)) {}
-  Optional(Optional &&O) = default;
-
-  Optional &operator=(T &&y) {
-    Storage = std::move(y);
-    return *this;
-  }
-  Optional &operator=(Optional &&O) = default;
-
-  /// Create a new object by constructing it in place with the given arguments.
-  template <typename... ArgTypes> void emplace(ArgTypes &&... Args) {
-    Storage.emplace(std::forward<ArgTypes>(Args)...);
-  }
-
-  static inline Optional create(const T *y) {
-    return y ? Optional(*y) : Optional();
-  }
-
-  Optional &operator=(const T &y) {
-    Storage = y;
-    return *this;
-  }
-  Optional &operator=(const Optional &O) = default;
-
-  void reset() { Storage.reset(); }
-
-  const T *getPointer() const { return &Storage.getValue(); }
-  T *getPointer() { return &Storage.getValue(); }
-  const T &getValue() const LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
-  T &getValue() LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
-
-  explicit operator bool() const { return hasValue(); }
-  bool hasValue() const { return Storage.hasValue(); }
-  const T *operator->() const { return getPointer(); }
-  T *operator->() { return getPointer(); }
-  const T &operator*() const LLVM_LVALUE_FUNCTION { return getValue(); }
-  T &operator*() LLVM_LVALUE_FUNCTION { return getValue(); }
-
-  template <typename U>
-  constexpr T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION {
-    return hasValue() ? getValue() : std::forward<U>(value);
-  }
-
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
-  T &&getValue() && { return std::move(Storage.getValue()); }
-  T &&operator*() && { return std::move(Storage.getValue()); }
-
-  template <typename U>
-  T getValueOr(U &&value) && {
-    return hasValue() ? std::move(getValue()) : std::forward<U>(value);
-  }
-#endif
-};
-
-template <typename T, typename U>
-bool operator==(const Optional<T> &X, const Optional<U> &Y) {
-  if (X && Y)
-    return *X == *Y;
-  return X.hasValue() == Y.hasValue();
-}
-
-template <typename T, typename U>
-bool operator!=(const Optional<T> &X, const Optional<U> &Y) {
-  return !(X == Y);
-}
-
-template <typename T, typename U>
-bool operator<(const Optional<T> &X, const Optional<U> &Y) {
-  if (X && Y)
-    return *X < *Y;
-  return X.hasValue() < Y.hasValue();
-}
-
-template <typename T, typename U>
-bool operator<=(const Optional<T> &X, const Optional<U> &Y) {
-  return !(Y < X);
-}
-
-template <typename T, typename U>
-bool operator>(const Optional<T> &X, const Optional<U> &Y) {
-  return Y < X;
-}
-
-template <typename T, typename U>
-bool operator>=(const Optional<T> &X, const Optional<U> &Y) {
-  return !(X < Y);
-}
-
-template<typename T>
-bool operator==(const Optional<T> &X, NoneType) {
-  return !X;
-}
-
-template<typename T>
-bool operator==(NoneType, const Optional<T> &X) {
-  return X == None;
-}
-
-template<typename T>
-bool operator!=(const Optional<T> &X, NoneType) {
-  return !(X == None);
-}
-
-template<typename T>
-bool operator!=(NoneType, const Optional<T> &X) {
-  return X != None;
-}
-
-template <typename T> bool operator<(const Optional<T> &X, NoneType) {
-  return false;
-}
-
-template <typename T> bool operator<(NoneType, const Optional<T> &X) {
-  return X.hasValue();
-}
-
-template <typename T> bool operator<=(const Optional<T> &X, NoneType) {
-  return !(None < X);
-}
-
-template <typename T> bool operator<=(NoneType, const Optional<T> &X) {
-  return !(X < None);
-}
-
-template <typename T> bool operator>(const Optional<T> &X, NoneType) {
-  return None < X;
-}
-
-template <typename T> bool operator>(NoneType, const Optional<T> &X) {
-  return X < None;
-}
-
-template <typename T> bool operator>=(const Optional<T> &X, NoneType) {
-  return None <= X;
-}
-
-template <typename T> bool operator>=(NoneType, const Optional<T> &X) {
-  return X <= None;
-}
-
-template <typename T> bool operator==(const Optional<T> &X, const T &Y) {
-  return X && *X == Y;
-}
-
-template <typename T> bool operator==(const T &X, const Optional<T> &Y) {
-  return Y && X == *Y;
-}
-
-template <typename T> bool operator!=(const Optional<T> &X, const T &Y) {
-  return !(X == Y);
-}
-
-template <typename T> bool operator!=(const T &X, const Optional<T> &Y) {
-  return !(X == Y);
-}
-
-template <typename T> bool operator<(const Optional<T> &X, const T &Y) {
-  return !X || *X < Y;
-}
-
-template <typename T> bool operator<(const T &X, const Optional<T> &Y) {
-  return Y && X < *Y;
-}
-
-template <typename T> bool operator<=(const Optional<T> &X, const T &Y) {
-  return !(Y < X);
-}
-
-template <typename T> bool operator<=(const T &X, const Optional<T> &Y) {
-  return !(Y < X);
-}
-
-template <typename T> bool operator>(const Optional<T> &X, const T &Y) {
-  return Y < X;
-}
-
-template <typename T> bool operator>(const T &X, const Optional<T> &Y) {
-  return Y < X;
-}
-
-template <typename T> bool operator>=(const Optional<T> &X, const T &Y) {
-  return !(X < Y);
-}
-
-template <typename T> bool operator>=(const T &X, const Optional<T> &Y) {
-  return !(X < Y);
-}
-
-raw_ostream &operator<<(raw_ostream &OS, NoneType);
-
-template <typename T, typename = decltype(std::declval<raw_ostream &>()
-                                          << std::declval<const T &>())>
-raw_ostream &operator<<(raw_ostream &OS, const Optional<T> &O) {
-  if (O)
-    OS << *O;
-  else
-    OS << None;
-  return OS;
-}
-
-} // end namespace llvm
-} // end namespace opencombine
-
-#endif // OPENCOMBINE_LLVM_ADT_OPTIONAL_H

Sources/COpenCombineHelpers/llvm/Support/AlignOf.h

@@ -1,61 +0,0 @@
-//===--- AlignOf.h - Portable calculation of type alignment -----*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines the AlignedCharArrayUnion class.
-//
-//===----------------------------------------------------------------------===//
-
-// MODIFICATION NOTE:
-// This file has been modified for the OpenCombine open source project.
-// - The llvm namespace is wrapped in the opencombine namespace.
-
-#ifndef OPENCOMBINE_LLVM_SUPPORT_ALIGNOF_H
-#define OPENCOMBINE_LLVM_SUPPORT_ALIGNOF_H
-
-#include "llvm/Support/Compiler.h"
-#include <cstddef>
-
-namespace opencombine {
-namespace llvm {
-
-namespace detail {
-
-template <typename T, typename... Ts> class AlignerImpl {
-  T t;
-  AlignerImpl<Ts...> rest;
-  AlignerImpl() = delete;
-};
-
-template <typename T> class AlignerImpl<T> {
-  T t;
-  AlignerImpl() = delete;
-};
-
-template <typename T, typename... Ts> union SizerImpl {
-  char arr[sizeof(T)];
-  SizerImpl<Ts...> rest;
-};
-
-template <typename T> union SizerImpl<T> { char arr[sizeof(T)]; };
-} // end namespace detail
-
-/// A suitably aligned and sized character array member which can hold elements
-/// of any type.
-///
-/// These types may be arrays, structs, or any other types. This exposes a
-/// `buffer` member which can be used as suitable storage for a placement new of
-/// any of these types.
-template <typename T, typename... Ts> struct AlignedCharArrayUnion {
-  alignas(detail::AlignerImpl<T, Ts...>) char buffer[sizeof(
-      llvm::detail::SizerImpl<T, Ts...>)];
-};
-
-} // end namespace llvm
-} // end namespace opencombine
-
-#endif // OPENCOMBINE_LLVM_SUPPORT_ALIGNOF_H

Sources/COpenCombineHelpers/llvm/Support/Alignment.h

@@ -1,409 +0,0 @@
-//===-- llvm/Support/Alignment.h - Useful alignment functions ---*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains types to represent alignments.
-// They are instrumented to guarantee some invariants are preserved and prevent
-// invalid manipulations.
-//
-// - Align represents an alignment in bytes, it is always set and always a valid
-// power of two, its minimum value is 1 which means no alignment requirements.
-//
-// - MaybeAlign is an optional type, it may be undefined or set. When it's set
-// you can get the underlying Align type by using the getValue() method.
-//
-//===----------------------------------------------------------------------===//
-
-// MODIFICATION NOTE:
-// This file has been modified for the OpenCombine open source project.
-// - The llvm namespace is wrapped in the opencombine namespace.
-
-#ifndef OPENCOMBINE_LLVM_SUPPORT_ALIGNMENT_H_
-#define OPENCOMBINE_LLVM_SUPPORT_ALIGNMENT_H_
-
-#include "llvm/ADT/Optional.h"
-#include "llvm/Support/Compiler.h"
-#include "llvm/Support/MathExtras.h"
-#include <cassert>
-#include <limits>
-
-namespace opencombine {
-namespace llvm {
-
-#define ALIGN_CHECK_ISPOSITIVE(decl)                                           \
-  assert(decl > 0 && (#decl " should be defined"))
-#define ALIGN_CHECK_ISSET(decl)                                                \
-  assert(decl.hasValue() && (#decl " should be defined"))
-
-/// This struct is a compact representation of a valid (non-zero power of two)
-/// alignment.
-/// It is suitable for use as static global constants.
-struct Align {
-private:
-  uint8_t ShiftValue = 0; /// The log2 of the required alignment.
-                          /// ShiftValue is less than 64 by construction.
-
-  friend struct MaybeAlign;
-  friend unsigned Log2(Align);
-  friend bool operator==(Align Lhs, Align Rhs);
-  friend bool operator!=(Align Lhs, Align Rhs);
-  friend bool operator<=(Align Lhs, Align Rhs);
-  friend bool operator>=(Align Lhs, Align Rhs);
-  friend bool operator<(Align Lhs, Align Rhs);
-  friend bool operator>(Align Lhs, Align Rhs);
-  friend unsigned encode(struct MaybeAlign A);
-  friend struct MaybeAlign decodeMaybeAlign(unsigned Value);
-
-  /// A trivial type to allow construction of constexpr Align.
-  /// This is currently needed to workaround a bug in GCC 5.3 which prevents
-  /// definition of constexpr assign operators.
-  /// https://stackoverflow.com/questions/46756288/explicitly-defaulted-function-cannot-be-declared-as-constexpr-because-the-implic
-  /// FIXME: Remove this, make all assign operators constexpr and introduce user
-  /// defined literals when we don't have to support GCC 5.3 anymore.
-  /// https://llvm.org/docs/GettingStarted.html#getting-a-modern-host-c-toolchain
-  struct LogValue {
-    uint8_t Log;
-  };
-
-public:
-  /// Default is byte-aligned.
-  constexpr Align() = default;
-  /// Do not perform checks in case of copy/move construct/assign, because the
-  /// checks have been performed when building `Other`.
-  constexpr Align(const Align &Other) = default;
-  constexpr Align(Align &&Other) = default;
-  Align &operator=(const Align &Other) = default;
-  Align &operator=(Align &&Other) = default;
-
-  explicit Align(uint64_t Value) {
-    assert(Value > 0 && "Value must not be 0");
-    assert(llvm::isPowerOf2_64(Value) && "Alignment is not a power of 2");
-    ShiftValue = Log2_64(Value);
-    assert(ShiftValue < 64 && "Broken invariant");
-  }
-
-  /// This is a hole in the type system and should not be abused.
-  /// Needed to interact with C for instance.
-  uint64_t value() const { return uint64_t(1) << ShiftValue; }
-
-  /// Returns a default constructed Align which corresponds to no alignment.
-  /// This is useful to test for unalignment as it conveys clear semantic.
-  /// `if (A != Align::None())`
-  /// would be better than
-  /// `if (A > Align(1))`
-  constexpr static const Align None() { return Align(); }
-
-  /// Allow constructions of constexpr Align.
-  template <size_t kValue> constexpr static LogValue Constant() {
-    return LogValue{static_cast<uint8_t>(CTLog2<kValue>())};
-  }
-
-  /// Allow constructions of constexpr Align from types.
-  /// Compile time equivalent to Align(alignof(T)).
-  template <typename T> constexpr static LogValue Of() {
-    return Constant<std::alignment_of<T>::value>();
-  }
-
-  /// Constexpr constructor from LogValue type.
-  constexpr Align(LogValue CA) : ShiftValue(CA.Log) {}
-};
-
-/// Treats the value 0 as a 1, so Align is always at least 1.
-inline Align assumeAligned(uint64_t Value) {
-  return Value ? Align(Value) : Align();
-}
-
-/// This struct is a compact representation of a valid (power of two) or
-/// undefined (0) alignment.
-struct MaybeAlign : public llvm::Optional<Align> {
-private:
-  using UP = llvm::Optional<Align>;
-
-public:
-  /// Default is undefined.
-  MaybeAlign() = default;
-  /// Do not perform checks in case of copy/move construct/assign, because the
-  /// checks have been performed when building `Other`.
-  MaybeAlign(const MaybeAlign &Other) = default;
-  MaybeAlign &operator=(const MaybeAlign &Other) = default;
-  MaybeAlign(MaybeAlign &&Other) = default;
-  MaybeAlign &operator=(MaybeAlign &&Other) = default;
-
-  /// Use llvm::Optional<Align> constructor.
-  using UP::UP;
-
-  explicit MaybeAlign(uint64_t Value) {
-    assert((Value == 0 || llvm::isPowerOf2_64(Value)) &&
-           "Alignment is neither 0 nor a power of 2");
-    if (Value)
-      emplace(Value);
-  }
-
-  /// For convenience, returns a valid alignment or 1 if undefined.
-  Align valueOrOne() const { return hasValue() ? getValue() : Align(); }
-};
-
-/// Checks that SizeInBytes is a multiple of the alignment.
-inline bool isAligned(Align Lhs, uint64_t SizeInBytes) {
-  return SizeInBytes % Lhs.value() == 0;
-}
-
-/// Checks that SizeInBytes is a multiple of the alignment.
-/// Returns false if the alignment is undefined.
-inline bool isAligned(MaybeAlign Lhs, uint64_t SizeInBytes) {
-  ALIGN_CHECK_ISSET(Lhs);
-  return SizeInBytes % (*Lhs).value() == 0;
-}
-
-/// Checks that Addr is a multiple of the alignment.
-inline bool isAddrAligned(Align Lhs, const void *Addr) {
-  return isAligned(Lhs, reinterpret_cast<uintptr_t>(Addr));
-}
-
-/// Returns a multiple of A needed to store `Size` bytes.
-inline uint64_t alignTo(uint64_t Size, Align A) {
-  const uint64_t value = A.value();
-  // The following line is equivalent to `(Size + value - 1) / value * value`.
-
-  // The division followed by a multiplication can be thought of as a right
-  // shift followed by a left shift which zeros out the extra bits produced in
-  // the bump; `~(value - 1)` is a mask where all those bits being zeroed out
-  // are just zero.
-
-  // Most compilers can generate this code but the pattern may be missed when
-  // multiple functions gets inlined.
-  return (Size + value - 1) & ~(value - 1);
-}
-
-/// Returns a multiple of A needed to store `Size` bytes.
-/// Returns `Size` if current alignment is undefined.
-inline uint64_t alignTo(uint64_t Size, MaybeAlign A) {
-  return A ? alignTo(Size, A.getValue()) : Size;
-}
-
-/// Aligns `Addr` to `Alignment` bytes, rounding up.
-inline uintptr_t alignAddr(const void *Addr, Align Alignment) {
-  uintptr_t ArithAddr = reinterpret_cast<uintptr_t>(Addr);
-  assert(static_cast<uintptr_t>(ArithAddr + Alignment.value() - 1) >=
-             ArithAddr && "Overflow");
-  return alignTo(ArithAddr, Alignment);
-}
-
-/// Returns the offset to the next integer (mod 2**64) that is greater than
-/// or equal to \p Value and is a multiple of \p Align.
-inline uint64_t offsetToAlignment(uint64_t Value, Align Alignment) {
-  return alignTo(Value, Alignment) - Value;
-}
-
-/// Returns the necessary adjustment for aligning `Addr` to `Alignment`
-/// bytes, rounding up.
-inline uint64_t offsetToAlignedAddr(const void *Addr, Align Alignment) {
-  return offsetToAlignment(reinterpret_cast<uintptr_t>(Addr), Alignment);
-}
-
-/// Returns the log2 of the alignment.
-inline unsigned Log2(Align A) { return A.ShiftValue; }
-
-/// Returns the log2 of the alignment.
-/// \pre A must be defined.
-inline unsigned Log2(MaybeAlign A) {
-  ALIGN_CHECK_ISSET(A);
-  return Log2(A.getValue());
-}
-
-/// Returns the alignment that satisfies both alignments.
-/// Same semantic as MinAlign.
-inline Align commonAlignment(Align A, Align B) { return std::min(A, B); }
-
-/// Returns the alignment that satisfies both alignments.
-/// Same semantic as MinAlign.
-inline Align commonAlignment(Align A, uint64_t Offset) {
-  return Align(MinAlign(A.value(), Offset));
-}
-
-/// Returns the alignment that satisfies both alignments.
-/// Same semantic as MinAlign.
-inline MaybeAlign commonAlignment(MaybeAlign A, MaybeAlign B) {
-  return A && B ? commonAlignment(*A, *B) : A ? A : B;
-}
-
-/// Returns the alignment that satisfies both alignments.
-/// Same semantic as MinAlign.
-inline MaybeAlign commonAlignment(MaybeAlign A, uint64_t Offset) {
-  return MaybeAlign(MinAlign((*A).value(), Offset));
-}
-
-/// Returns a representation of the alignment that encodes undefined as 0.
-inline unsigned encode(MaybeAlign A) { return A ? A->ShiftValue + 1 : 0; }
-
-/// Dual operation of the encode function above.
-inline MaybeAlign decodeMaybeAlign(unsigned Value) {
-  if (Value == 0)
-    return MaybeAlign();
-  Align Out;
-  Out.ShiftValue = Value - 1;
-  return Out;
-}
-
-/// Returns a representation of the alignment, the encoded value is positive by
-/// definition.
-inline unsigned encode(Align A) { return encode(MaybeAlign(A)); }
-
-/// Comparisons between Align and scalars. Rhs must be positive.
-inline bool operator==(Align Lhs, uint64_t Rhs) {
-  ALIGN_CHECK_ISPOSITIVE(Rhs);
-  return Lhs.value() == Rhs;
-}
-inline bool operator!=(Align Lhs, uint64_t Rhs) {
-  ALIGN_CHECK_ISPOSITIVE(Rhs);
-  return Lhs.value() != Rhs;
-}
-inline bool operator<=(Align Lhs, uint64_t Rhs) {
-  ALIGN_CHECK_ISPOSITIVE(Rhs);
-  return Lhs.value() <= Rhs;
-}
-inline bool operator>=(Align Lhs, uint64_t Rhs) {
-  ALIGN_CHECK_ISPOSITIVE(Rhs);
-  return Lhs.value() >= Rhs;
-}
-inline bool operator<(Align Lhs, uint64_t Rhs) {
-  ALIGN_CHECK_ISPOSITIVE(Rhs);
-  return Lhs.value() < Rhs;
-}
-inline bool operator>(Align Lhs, uint64_t Rhs) {
-  ALIGN_CHECK_ISPOSITIVE(Rhs);
-  return Lhs.value() > Rhs;
-}
-
-/// Comparisons between MaybeAlign and scalars.
-inline bool operator==(MaybeAlign Lhs, uint64_t Rhs) {
-  return Lhs ? (*Lhs).value() == Rhs : Rhs == 0;
-}
-inline bool operator!=(MaybeAlign Lhs, uint64_t Rhs) {
-  return Lhs ? (*Lhs).value() != Rhs : Rhs != 0;
-}
-inline bool operator<=(MaybeAlign Lhs, uint64_t Rhs) {
-  ALIGN_CHECK_ISSET(Lhs);
-  ALIGN_CHECK_ISPOSITIVE(Rhs);
-  return (*Lhs).value() <= Rhs;
-}
-inline bool operator>=(MaybeAlign Lhs, uint64_t Rhs) {
-  ALIGN_CHECK_ISSET(Lhs);
-  ALIGN_CHECK_ISPOSITIVE(Rhs);
-  return (*Lhs).value() >= Rhs;
-}
-inline bool operator<(MaybeAlign Lhs, uint64_t Rhs) {
-  ALIGN_CHECK_ISSET(Lhs);
-  ALIGN_CHECK_ISPOSITIVE(Rhs);
-  return (*Lhs).value() < Rhs;
-}
-inline bool operator>(MaybeAlign Lhs, uint64_t Rhs) {
-  ALIGN_CHECK_ISSET(Lhs);
-  ALIGN_CHECK_ISPOSITIVE(Rhs);
-  return (*Lhs).value() > Rhs;
-}
-
-/// Comparisons operators between Align.
-inline bool operator==(Align Lhs, Align Rhs) {
-  return Lhs.ShiftValue == Rhs.ShiftValue;
-}
-inline bool operator!=(Align Lhs, Align Rhs) {
-  return Lhs.ShiftValue != Rhs.ShiftValue;
-}
-inline bool operator<=(Align Lhs, Align Rhs) {
-  return Lhs.ShiftValue <= Rhs.ShiftValue;
-}
-inline bool operator>=(Align Lhs, Align Rhs) {
-  return Lhs.ShiftValue >= Rhs.ShiftValue;
-}
-inline bool operator<(Align Lhs, Align Rhs) {
-  return Lhs.ShiftValue < Rhs.ShiftValue;
-}
-inline bool operator>(Align Lhs, Align Rhs) {
-  return Lhs.ShiftValue > Rhs.ShiftValue;
-}
-
-/// Comparisons operators between Align and MaybeAlign.
-inline bool operator==(Align Lhs, MaybeAlign Rhs) {
-  ALIGN_CHECK_ISSET(Rhs);
-  return Lhs.value() == (*Rhs).value();
-}
-inline bool operator!=(Align Lhs, MaybeAlign Rhs) {
-  ALIGN_CHECK_ISSET(Rhs);
-  return Lhs.value() != (*Rhs).value();
-}
-inline bool operator<=(Align Lhs, MaybeAlign Rhs) {
-  ALIGN_CHECK_ISSET(Rhs);
-  return Lhs.value() <= (*Rhs).value();
-}
-inline bool operator>=(Align Lhs, MaybeAlign Rhs) {
-  ALIGN_CHECK_ISSET(Rhs);
-  return Lhs.value() >= (*Rhs).value();
-}
-inline bool operator<(Align Lhs, MaybeAlign Rhs) {
-  ALIGN_CHECK_ISSET(Rhs);
-  return Lhs.value() < (*Rhs).value();
-}
-inline bool operator>(Align Lhs, MaybeAlign Rhs) {
-  ALIGN_CHECK_ISSET(Rhs);
-  return Lhs.value() > (*Rhs).value();
-}
-
-/// Comparisons operators between MaybeAlign and Align.
-inline bool operator==(MaybeAlign Lhs, Align Rhs) {
-  ALIGN_CHECK_ISSET(Lhs);
-  return Lhs && (*Lhs).value() == Rhs.value();
-}
-inline bool operator!=(MaybeAlign Lhs, Align Rhs) {
-  ALIGN_CHECK_ISSET(Lhs);
-  return Lhs && (*Lhs).value() != Rhs.value();
-}
-inline bool operator<=(MaybeAlign Lhs, Align Rhs) {
-  ALIGN_CHECK_ISSET(Lhs);
-  return Lhs && (*Lhs).value() <= Rhs.value();
-}
-inline bool operator>=(MaybeAlign Lhs, Align Rhs) {
-  ALIGN_CHECK_ISSET(Lhs);
-  return Lhs && (*Lhs).value() >= Rhs.value();
-}
-inline bool operator<(MaybeAlign Lhs, Align Rhs) {
-  ALIGN_CHECK_ISSET(Lhs);
-  return Lhs && (*Lhs).value() < Rhs.value();
-}
-inline bool operator>(MaybeAlign Lhs, Align Rhs) {
-  ALIGN_CHECK_ISSET(Lhs);
-  return Lhs && (*Lhs).value() > Rhs.value();
-}
-
-inline Align operator/(Align Lhs, uint64_t Divisor) {
-  assert(llvm::isPowerOf2_64(Divisor) &&
-         "Divisor must be positive and a power of 2");
-  assert(Lhs != 1 && "Can't halve byte alignment");
-  return Align(Lhs.value() / Divisor);
-}
-
-inline MaybeAlign operator/(MaybeAlign Lhs, uint64_t Divisor) {
-  assert(llvm::isPowerOf2_64(Divisor) &&
-         "Divisor must be positive and a power of 2");
-  return Lhs ? Lhs.getValue() / Divisor : MaybeAlign();
-}
-
-inline Align max(MaybeAlign Lhs, Align Rhs) {
-  return Lhs && *Lhs > Rhs ? *Lhs : Rhs;
-}
-
-inline Align max(Align Lhs, MaybeAlign Rhs) {
-  return Rhs && *Rhs > Lhs ? *Rhs : Lhs;
-}
-
-#undef ALIGN_CHECK_ISPOSITIVE
-#undef ALIGN_CHECK_ISSET
-
-} // namespace llvm
-} // namespace opencombine
-
-#endif // OPENCOMBINE_LLVM_SUPPORT_ALIGNMENT_H_

Sources/COpenCombineHelpers/llvm/Support/Casting.h

@@ -1,414 +0,0 @@
-//===- llvm/Support/Casting.h - Allow flexible, checked, casts --*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines the isa<X>(), cast<X>(), dyn_cast<X>(), cast_or_null<X>(),
-// and dyn_cast_or_null<X>() templates.
-//
-//===----------------------------------------------------------------------===//
-
-// MODIFICATION NOTE:
-// This file has been modified for the OpenCombine open source project.
-// - The llvm namespace is wrapped in the opencombine namespace.
-
-#ifndef OPENCOMBINE_LLVM_SUPPORT_CASTING_H
-#define OPENCOMBINE_LLVM_SUPPORT_CASTING_H
-
-#include "llvm/Support/Compiler.h"
-#include "llvm/Support/type_traits.h"
-#include <cassert>
-#include <memory>
-#include <type_traits>
-
-namespace opencombine {
-namespace llvm {
-
-//===----------------------------------------------------------------------===//
-//                          isa<x> Support Templates
-//===----------------------------------------------------------------------===//
-
-// Define a template that can be specialized by smart pointers to reflect the
-// fact that they are automatically dereferenced, and are not involved with the
-// template selection process...  the default implementation is a noop.
-//
-template<typename From> struct simplify_type {
-  using SimpleType = From; // The real type this represents...
-
-  // An accessor to get the real value...
-  static SimpleType &getSimplifiedValue(From &Val) { return Val; }
-};
-
-template<typename From> struct simplify_type<const From> {
-  using NonConstSimpleType = typename simplify_type<From>::SimpleType;
-  using SimpleType =
-      typename add_const_past_pointer<NonConstSimpleType>::type;
-  using RetType =
-      typename add_lvalue_reference_if_not_pointer<SimpleType>::type;
-
-  static RetType getSimplifiedValue(const From& Val) {
-    return simplify_type<From>::getSimplifiedValue(const_cast<From&>(Val));
-  }
-};
-
-// The core of the implementation of isa<X> is here; To and From should be
-// the names of classes.  This template can be specialized to customize the
-// implementation of isa<> without rewriting it from scratch.
-template <typename To, typename From, typename Enabler = void>
-struct isa_impl {
-  static inline bool doit(const From &Val) {
-    return To::classof(&Val);
-  }
-};
-
-/// Always allow upcasts, and perform no dynamic check for them.
-template <typename To, typename From>
-struct isa_impl<
-    To, From, typename std::enable_if<std::is_base_of<To, From>::value>::type> {
-  static inline bool doit(const From &) { return true; }
-};
-
-template <typename To, typename From> struct isa_impl_cl {
-  static inline bool doit(const From &Val) {
-    return isa_impl<To, From>::doit(Val);
-  }
-};
-
-template <typename To, typename From> struct isa_impl_cl<To, const From> {
-  static inline bool doit(const From &Val) {
-    return isa_impl<To, From>::doit(Val);
-  }
-};
-
-template <typename To, typename From>
-struct isa_impl_cl<To, const std::unique_ptr<From>> {
-  static inline bool doit(const std::unique_ptr<From> &Val) {
-    assert(Val && "isa<> used on a null pointer");
-    return isa_impl_cl<To, From>::doit(*Val);
-  }
-};
-
-template <typename To, typename From> struct isa_impl_cl<To, From*> {
-  static inline bool doit(const From *Val) {
-    assert(Val && "isa<> used on a null pointer");
-    return isa_impl<To, From>::doit(*Val);
-  }
-};
-
-template <typename To, typename From> struct isa_impl_cl<To, From*const> {
-  static inline bool doit(const From *Val) {
-    assert(Val && "isa<> used on a null pointer");
-    return isa_impl<To, From>::doit(*Val);
-  }
-};
-
-template <typename To, typename From> struct isa_impl_cl<To, const From*> {
-  static inline bool doit(const From *Val) {
-    assert(Val && "isa<> used on a null pointer");
-    return isa_impl<To, From>::doit(*Val);
-  }
-};
-
-template <typename To, typename From> struct isa_impl_cl<To, const From*const> {
-  static inline bool doit(const From *Val) {
-    assert(Val && "isa<> used on a null pointer");
-    return isa_impl<To, From>::doit(*Val);
-  }
-};
-
-template<typename To, typename From, typename SimpleFrom>
-struct isa_impl_wrap {
-  // When From != SimplifiedType, we can simplify the type some more by using
-  // the simplify_type template.
-  static bool doit(const From &Val) {
-    return isa_impl_wrap<To, SimpleFrom,
-      typename simplify_type<SimpleFrom>::SimpleType>::doit(
-                          simplify_type<const From>::getSimplifiedValue(Val));
-  }
-};
-
-template<typename To, typename FromTy>
-struct isa_impl_wrap<To, FromTy, FromTy> {
-  // When From == SimpleType, we are as simple as we are going to get.
-  static bool doit(const FromTy &Val) {
-    return isa_impl_cl<To,FromTy>::doit(Val);
-  }
-};
-
-// isa<X> - Return true if the parameter to the template is an instance of the
-// template type argument.  Used like this:
-//
-//  if (isa<Type>(myVal)) { ... }
-//
-template <class X, class Y> LLVM_NODISCARD inline bool isa(const Y &Val) {
-  return isa_impl_wrap<X, const Y,
-                       typename simplify_type<const Y>::SimpleType>::doit(Val);
-}
-
-// isa_and_nonnull<X> - Functionally identical to isa, except that a null value
-// is accepted.
-//
-template <class X, class Y>
-LLVM_NODISCARD inline bool isa_and_nonnull(const Y &Val) {
-  if (!Val)
-    return false;
-  return isa<X>(Val);
-}
-
-//===----------------------------------------------------------------------===//
-//                          cast<x> Support Templates
-//===----------------------------------------------------------------------===//
-
-template<class To, class From> struct cast_retty;
-
-// Calculate what type the 'cast' function should return, based on a requested
-// type of To and a source type of From.
-template<class To, class From> struct cast_retty_impl {
-  using ret_type = To &;       // Normal case, return Ty&
-};
-template<class To, class From> struct cast_retty_impl<To, const From> {
-  using ret_type = const To &; // Normal case, return Ty&
-};
-
-template<class To, class From> struct cast_retty_impl<To, From*> {
-  using ret_type = To *;       // Pointer arg case, return Ty*
-};
-
-template<class To, class From> struct cast_retty_impl<To, const From*> {
-  using ret_type = const To *; // Constant pointer arg case, return const Ty*
-};
-
-template<class To, class From> struct cast_retty_impl<To, const From*const> {
-  using ret_type = const To *; // Constant pointer arg case, return const Ty*
-};
-
-template <class To, class From>
-struct cast_retty_impl<To, std::unique_ptr<From>> {
-private:
-  using PointerType = typename cast_retty_impl<To, From *>::ret_type;
-  using ResultType = typename std::remove_pointer<PointerType>::type;
-
-public:
-  using ret_type = std::unique_ptr<ResultType>;
-};
-
-template<class To, class From, class SimpleFrom>
-struct cast_retty_wrap {
-  // When the simplified type and the from type are not the same, use the type
-  // simplifier to reduce the type, then reuse cast_retty_impl to get the
-  // resultant type.
-  using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
-};
-
-template<class To, class FromTy>
-struct cast_retty_wrap<To, FromTy, FromTy> {
-  // When the simplified type is equal to the from type, use it directly.
-  using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
-};
-
-template<class To, class From>
-struct cast_retty {
-  using ret_type = typename cast_retty_wrap<
-      To, From, typename simplify_type<From>::SimpleType>::ret_type;
-};
-
-// Ensure the non-simple values are converted using the simplify_type template
-// that may be specialized by smart pointers...
-//
-template<class To, class From, class SimpleFrom> struct cast_convert_val {
-  // This is not a simple type, use the template to simplify it...
-  static typename cast_retty<To, From>::ret_type doit(From &Val) {
-    return cast_convert_val<To, SimpleFrom,
-      typename simplify_type<SimpleFrom>::SimpleType>::doit(
-                          simplify_type<From>::getSimplifiedValue(Val));
-  }
-};
-
-template<class To, class FromTy> struct cast_convert_val<To,FromTy,FromTy> {
-  // This _is_ a simple type, just cast it.
-  static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
-    typename cast_retty<To, FromTy>::ret_type Res2
-     = (typename cast_retty<To, FromTy>::ret_type)const_cast<FromTy&>(Val);
-    return Res2;
-  }
-};
-
-template <class X> struct is_simple_type {
-  static const bool value =
-      std::is_same<X, typename simplify_type<X>::SimpleType>::value;
-};
-
-// cast<X> - Return the argument parameter cast to the specified type.  This
-// casting operator asserts that the type is correct, so it does not return null
-// on failure.  It does not allow a null argument (use cast_or_null for that).
-// It is typically used like this:
-//
-//  cast<Instruction>(myVal)->getParent()
-//
-template <class X, class Y>
-inline typename std::enable_if<!is_simple_type<Y>::value,
-                               typename cast_retty<X, const Y>::ret_type>::type
-cast(const Y &Val) {
-  assert(isa<X>(Val) && "cast<Ty>() argument of incompatible type!");
-  return cast_convert_val<
-      X, const Y, typename simplify_type<const Y>::SimpleType>::doit(Val);
-}
-
-template <class X, class Y>
-inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
-  assert(isa<X>(Val) && "cast<Ty>() argument of incompatible type!");
-  return cast_convert_val<X, Y,
-                          typename simplify_type<Y>::SimpleType>::doit(Val);
-}
-
-template <class X, class Y>
-inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
-  assert(isa<X>(Val) && "cast<Ty>() argument of incompatible type!");
-  return cast_convert_val<X, Y*,
-                          typename simplify_type<Y*>::SimpleType>::doit(Val);
-}
-
-template <class X, class Y>
-inline typename cast_retty<X, std::unique_ptr<Y>>::ret_type
-cast(std::unique_ptr<Y> &&Val) {
-  assert(isa<X>(Val.get()) && "cast<Ty>() argument of incompatible type!");
-  using ret_type = typename cast_retty<X, std::unique_ptr<Y>>::ret_type;
-  return ret_type(
-      cast_convert_val<X, Y *, typename simplify_type<Y *>::SimpleType>::doit(
-          Val.release()));
-}
-
-// cast_or_null<X> - Functionally identical to cast, except that a null value is
-// accepted.
-//
-template <class X, class Y>
-LLVM_NODISCARD inline
-    typename std::enable_if<!is_simple_type<Y>::value,
-                            typename cast_retty<X, const Y>::ret_type>::type
-    cast_or_null(const Y &Val) {
-  if (!Val)
-    return nullptr;
-  assert(isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!");
-  return cast<X>(Val);
-}
-
-template <class X, class Y>
-LLVM_NODISCARD inline
-    typename std::enable_if<!is_simple_type<Y>::value,
-                            typename cast_retty<X, Y>::ret_type>::type
-    cast_or_null(Y &Val) {
-  if (!Val)
-    return nullptr;
-  assert(isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!");
-  return cast<X>(Val);
-}
-
-template <class X, class Y>
-LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
-cast_or_null(Y *Val) {
-  if (!Val) return nullptr;
-  assert(isa<X>(Val) && "cast_or_null<Ty>() argument of incompatible type!");
-  return cast<X>(Val);
-}
-
-template <class X, class Y>
-inline typename cast_retty<X, std::unique_ptr<Y>>::ret_type
-cast_or_null(std::unique_ptr<Y> &&Val) {
-  if (!Val)
-    return nullptr;
-  return cast<X>(std::move(Val));
-}
-
-// dyn_cast<X> - Return the argument parameter cast to the specified type.  This
-// casting operator returns null if the argument is of the wrong type, so it can
-// be used to test for a type as well as cast if successful.  This should be
-// used in the context of an if statement like this:
-//
-//  if (const Instruction *I = dyn_cast<Instruction>(myVal)) { ... }
-//
-
-template <class X, class Y>
-LLVM_NODISCARD inline
-    typename std::enable_if<!is_simple_type<Y>::value,
-                            typename cast_retty<X, const Y>::ret_type>::type
-    dyn_cast(const Y &Val) {
-  return isa<X>(Val) ? cast<X>(Val) : nullptr;
-}
-
-template <class X, class Y>
-LLVM_NODISCARD inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
-  return isa<X>(Val) ? cast<X>(Val) : nullptr;
-}
-
-template <class X, class Y>
-LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
-  return isa<X>(Val) ? cast<X>(Val) : nullptr;
-}
-
-// dyn_cast_or_null<X> - Functionally identical to dyn_cast, except that a null
-// value is accepted.
-//
-template <class X, class Y>
-LLVM_NODISCARD inline
-    typename std::enable_if<!is_simple_type<Y>::value,
-                            typename cast_retty<X, const Y>::ret_type>::type
-    dyn_cast_or_null(const Y &Val) {
-  return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
-}
-
-template <class X, class Y>
-LLVM_NODISCARD inline
-    typename std::enable_if<!is_simple_type<Y>::value,
-                            typename cast_retty<X, Y>::ret_type>::type
-    dyn_cast_or_null(Y &Val) {
-  return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
-}
-
-template <class X, class Y>
-LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
-dyn_cast_or_null(Y *Val) {
-  return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
-}
-
-// unique_dyn_cast<X> - Given a unique_ptr<Y>, try to return a unique_ptr<X>,
-// taking ownership of the input pointer iff isa<X>(Val) is true.  If the
-// cast is successful, From refers to nullptr on exit and the casted value
-// is returned.  If the cast is unsuccessful, the function returns nullptr
-// and From is unchanged.
-template <class X, class Y>
-LLVM_NODISCARD inline auto unique_dyn_cast(std::unique_ptr<Y> &Val)
-    -> decltype(cast<X>(Val)) {
-  if (!isa<X>(Val))
-    return nullptr;
-  return cast<X>(std::move(Val));
-}
-
-template <class X, class Y>
-LLVM_NODISCARD inline auto unique_dyn_cast(std::unique_ptr<Y> &&Val)
-    -> decltype(cast<X>(Val)) {
-  return unique_dyn_cast<X, Y>(Val);
-}
-
-// dyn_cast_or_null<X> - Functionally identical to unique_dyn_cast, except that
-// a null value is accepted.
-template <class X, class Y>
-LLVM_NODISCARD inline auto unique_dyn_cast_or_null(std::unique_ptr<Y> &Val)
-    -> decltype(cast<X>(Val)) {
-  if (!Val)
-    return nullptr;
-  return unique_dyn_cast<X, Y>(Val);
-}
-
-template <class X, class Y>
-LLVM_NODISCARD inline auto unique_dyn_cast_or_null(std::unique_ptr<Y> &&Val)
-    -> decltype(cast<X>(Val)) {
-  return unique_dyn_cast_or_null<X, Y>(Val);
-}
-
-} // end namespace llvm
-} // end namespace opencombine
-
-#endif // OPENCOMBINE_LLVM_SUPPORT_CASTING_H

Sources/COpenCombineHelpers/llvm/Support/Compiler.h

@@ -1,590 +0,0 @@
-//===-- llvm/Support/Compiler.h - Compiler abstraction support --*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines several macros, based on the current compiler.  This allows
-// use of compiler-specific features in a way that remains portable. This header
-// can be included from either C or C++.
-//
-//===----------------------------------------------------------------------===//
-
-// MODIFICATION NOTE:
-// This file has been modified for the OpenCombine open source project.
-// - The llvm namespace is wrapped in the opencombine namespace.
-// - Some macros have been removed.
-
-#ifndef OPENCOMBINE_LLVM_SUPPORT_COMPILER_H
-#define OPENCOMBINE_LLVM_SUPPORT_COMPILER_H
-
-#ifdef __cplusplus
-#include <new>
-#endif
-#include <stddef.h>
-
-#if defined(_MSC_VER)
-#include <sal.h>
-#endif
-
-#ifndef __has_feature
-# define __has_feature(x) 0
-#endif
-
-#ifndef __has_extension
-# define __has_extension(x) 0
-#endif
-
-#ifndef __has_attribute
-# define __has_attribute(x) 0
-#endif
-
-#ifndef __has_builtin
-# define __has_builtin(x) 0
-#endif
-
-// Only use __has_cpp_attribute in C++ mode. GCC defines __has_cpp_attribute in
-// C mode, but the :: in __has_cpp_attribute(scoped::attribute) is invalid.
-#ifndef LLVM_HAS_CPP_ATTRIBUTE
-#if defined(__cplusplus) && defined(__has_cpp_attribute)
-# define LLVM_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
-#else
-# define LLVM_HAS_CPP_ATTRIBUTE(x) 0
-#endif
-#endif
-
-/// \macro LLVM_GNUC_PREREQ
-/// Extend the default __GNUC_PREREQ even if glibc's features.h isn't
-/// available.
-#ifndef LLVM_GNUC_PREREQ
-# if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
-#  define LLVM_GNUC_PREREQ(maj, min, patch) \
-    ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) + __GNUC_PATCHLEVEL__ >= \
-     ((maj) << 20) + ((min) << 10) + (patch))
-# elif defined(__GNUC__) && defined(__GNUC_MINOR__)
-#  define LLVM_GNUC_PREREQ(maj, min, patch) \
-    ((__GNUC__ << 20) + (__GNUC_MINOR__ << 10) >= ((maj) << 20) + ((min) << 10))
-# else
-#  define LLVM_GNUC_PREREQ(maj, min, patch) 0
-# endif
-#endif
-
-/// \macro LLVM_MSC_PREREQ
-/// Is the compiler MSVC of at least the specified version?
-/// The common \param version values to check for are:
-/// * 1910: VS2017, version 15.1 & 15.2
-/// * 1911: VS2017, version 15.3 & 15.4
-/// * 1912: VS2017, version 15.5
-/// * 1913: VS2017, version 15.6
-/// * 1914: VS2017, version 15.7
-/// * 1915: VS2017, version 15.8
-/// * 1916: VS2017, version 15.9
-/// * 1920: VS2019, version 16.0
-/// * 1921: VS2019, version 16.1
-#ifdef _MSC_VER
-#define LLVM_MSC_PREREQ(version) (_MSC_VER >= (version))
-
-// We require at least MSVC 2017.
-#if !LLVM_MSC_PREREQ(1910)
-#error LLVM requires at least MSVC 2017.
-#endif
-
-#else
-#define LLVM_MSC_PREREQ(version) 0
-#endif
-
-/// Does the compiler support ref-qualifiers for *this?
-///
-/// Sadly, this is separate from just rvalue reference support because GCC
-/// and MSVC implemented this later than everything else.
-#if __has_feature(cxx_rvalue_references) || LLVM_GNUC_PREREQ(4, 8, 1)
-#define LLVM_HAS_RVALUE_REFERENCE_THIS 1
-#else
-#define LLVM_HAS_RVALUE_REFERENCE_THIS 0
-#endif
-
-/// Expands to '&' if ref-qualifiers for *this are supported.
-///
-/// This can be used to provide lvalue/rvalue overrides of member functions.
-/// The rvalue override should be guarded by LLVM_HAS_RVALUE_REFERENCE_THIS
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
-#define LLVM_LVALUE_FUNCTION &
-#else
-#define LLVM_LVALUE_FUNCTION
-#endif
-
-/// LLVM_LIBRARY_VISIBILITY - If a class marked with this attribute is linked
-/// into a shared library, then the class should be private to the library and
-/// not accessible from outside it.  Can also be used to mark variables and
-/// functions, making them private to any shared library they are linked into.
-/// On PE/COFF targets, library visibility is the default, so this isn't needed.
-#if (__has_attribute(visibility) || LLVM_GNUC_PREREQ(4, 0, 0)) &&              \
-    !defined(__MINGW32__) && !defined(__CYGWIN__) && !defined(_WIN32)
-#define LLVM_LIBRARY_VISIBILITY __attribute__ ((visibility("hidden")))
-#else
-#define LLVM_LIBRARY_VISIBILITY
-#endif
-
-#if defined(__GNUC__)
-#define LLVM_PREFETCH(addr, rw, locality) __builtin_prefetch(addr, rw, locality)
-#else
-#define LLVM_PREFETCH(addr, rw, locality)
-#endif
-
-#if __has_attribute(used) || LLVM_GNUC_PREREQ(3, 1, 0)
-#define LLVM_ATTRIBUTE_USED __attribute__((__used__))
-#else
-#define LLVM_ATTRIBUTE_USED
-#endif
-
-/// LLVM_NODISCARD - Warn if a type or return value is discarded.
-
-// Use the 'nodiscard' attribute in C++17 or newer mode.
-#if __cplusplus > 201402L && LLVM_HAS_CPP_ATTRIBUTE(nodiscard)
-#define LLVM_NODISCARD [[nodiscard]]
-#elif LLVM_HAS_CPP_ATTRIBUTE(clang::warn_unused_result)
-#define LLVM_NODISCARD [[clang::warn_unused_result]]
-// Clang in C++14 mode claims that it has the 'nodiscard' attribute, but also
-// warns in the pedantic mode that 'nodiscard' is a C++17 extension (PR33518).
-// Use the 'nodiscard' attribute in C++14 mode only with GCC.
-// TODO: remove this workaround when PR33518 is resolved.
-#elif defined(__GNUC__) && LLVM_HAS_CPP_ATTRIBUTE(nodiscard)
-#define LLVM_NODISCARD [[nodiscard]]
-#else
-#define LLVM_NODISCARD
-#endif
-
-// Indicate that a non-static, non-const C++ member function reinitializes
-// the entire object to a known state, independent of the previous state of
-// the object.
-//
-// The clang-tidy check bugprone-use-after-move recognizes this attribute as a
-// marker that a moved-from object has left the indeterminate state and can be
-// reused.
-#if LLVM_HAS_CPP_ATTRIBUTE(clang::reinitializes)
-#define LLVM_ATTRIBUTE_REINITIALIZES [[clang::reinitializes]]
-#else
-#define LLVM_ATTRIBUTE_REINITIALIZES
-#endif
-
-// Some compilers warn about unused functions. When a function is sometimes
-// used or not depending on build settings (e.g. a function only called from
-// within "assert"), this attribute can be used to suppress such warnings.
-//
-// However, it shouldn't be used for unused *variables*, as those have a much
-// more portable solution:
-//   (void)unused_var_name;
-// Prefer cast-to-void wherever it is sufficient.
-#if __has_attribute(unused) || LLVM_GNUC_PREREQ(3, 1, 0)
-#define LLVM_ATTRIBUTE_UNUSED __attribute__((__unused__))
-#else
-#define LLVM_ATTRIBUTE_UNUSED
-#endif
-
-// FIXME: Provide this for PE/COFF targets.
-#if (__has_attribute(weak) || LLVM_GNUC_PREREQ(4, 0, 0)) &&                    \
-    (!defined(__MINGW32__) && !defined(__CYGWIN__) && !defined(_WIN32))
-#define LLVM_ATTRIBUTE_WEAK __attribute__((__weak__))
-#else
-#define LLVM_ATTRIBUTE_WEAK
-#endif
-
-// Prior to clang 3.2, clang did not accept any spelling of
-// __has_attribute(const), so assume it is supported.
-#if defined(__clang__) || defined(__GNUC__)
-// aka 'CONST' but following LLVM Conventions.
-#define LLVM_READNONE __attribute__((__const__))
-#else
-#define LLVM_READNONE
-#endif
-
-#if __has_attribute(pure) || defined(__GNUC__)
-// aka 'PURE' but following LLVM Conventions.
-#define LLVM_READONLY __attribute__((__pure__))
-#else
-#define LLVM_READONLY
-#endif
-
-#if __has_builtin(__builtin_expect) || LLVM_GNUC_PREREQ(4, 0, 0)
-#define LLVM_LIKELY(EXPR) __builtin_expect((bool)(EXPR), true)
-#define LLVM_UNLIKELY(EXPR) __builtin_expect((bool)(EXPR), false)
-#else
-#define LLVM_LIKELY(EXPR) (EXPR)
-#define LLVM_UNLIKELY(EXPR) (EXPR)
-#endif
-
-/// LLVM_ATTRIBUTE_NOINLINE - On compilers where we have a directive to do so,
-/// mark a method "not for inlining".
-#if __has_attribute(noinline) || LLVM_GNUC_PREREQ(3, 4, 0)
-#define LLVM_ATTRIBUTE_NOINLINE __attribute__((noinline))
-#elif defined(_MSC_VER)
-#define LLVM_ATTRIBUTE_NOINLINE __declspec(noinline)
-#else
-#define LLVM_ATTRIBUTE_NOINLINE
-#endif
-
-/// LLVM_ATTRIBUTE_ALWAYS_INLINE - On compilers where we have a directive to do
-/// so, mark a method "always inline" because it is performance sensitive. GCC
-/// 3.4 supported this but is buggy in various cases and produces unimplemented
-/// errors, just use it in GCC 4.0 and later.
-#if __has_attribute(always_inline) || LLVM_GNUC_PREREQ(4, 0, 0)
-#define LLVM_ATTRIBUTE_ALWAYS_INLINE __attribute__((always_inline))
-#elif defined(_MSC_VER)
-#define LLVM_ATTRIBUTE_ALWAYS_INLINE __forceinline
-#else
-#define LLVM_ATTRIBUTE_ALWAYS_INLINE
-#endif
-
-#ifdef __GNUC__
-#define LLVM_ATTRIBUTE_NORETURN __attribute__((noreturn))
-#elif defined(_MSC_VER)
-#define LLVM_ATTRIBUTE_NORETURN __declspec(noreturn)
-#else
-#define LLVM_ATTRIBUTE_NORETURN
-#endif
-
-#if __has_attribute(returns_nonnull) || LLVM_GNUC_PREREQ(4, 9, 0)
-#define LLVM_ATTRIBUTE_RETURNS_NONNULL __attribute__((returns_nonnull))
-#elif defined(_MSC_VER)
-#define LLVM_ATTRIBUTE_RETURNS_NONNULL _Ret_notnull_
-#else
-#define LLVM_ATTRIBUTE_RETURNS_NONNULL
-#endif
-
-/// \macro LLVM_ATTRIBUTE_RETURNS_NOALIAS Used to mark a function as returning a
-/// pointer that does not alias any other valid pointer.
-#ifdef __GNUC__
-#define LLVM_ATTRIBUTE_RETURNS_NOALIAS __attribute__((__malloc__))
-#elif defined(_MSC_VER)
-#define LLVM_ATTRIBUTE_RETURNS_NOALIAS __declspec(restrict)
-#else
-#define LLVM_ATTRIBUTE_RETURNS_NOALIAS
-#endif
-
-/// LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
-#if __cplusplus > 201402L && LLVM_HAS_CPP_ATTRIBUTE(fallthrough)
-#define LLVM_FALLTHROUGH [[fallthrough]]
-#elif LLVM_HAS_CPP_ATTRIBUTE(gnu::fallthrough)
-#define LLVM_FALLTHROUGH [[gnu::fallthrough]]
-#elif __has_attribute(fallthrough)
-#define LLVM_FALLTHROUGH __attribute__((fallthrough))
-#elif LLVM_HAS_CPP_ATTRIBUTE(clang::fallthrough)
-#define LLVM_FALLTHROUGH [[clang::fallthrough]]
-#else
-#define LLVM_FALLTHROUGH
-#endif
-
-/// LLVM_REQUIRE_CONSTANT_INITIALIZATION - Apply this to globals to ensure that
-/// they are constant initialized.
-#if LLVM_HAS_CPP_ATTRIBUTE(clang::require_constant_initialization)
-#define LLVM_REQUIRE_CONSTANT_INITIALIZATION                                   \
-  [[clang::require_constant_initialization]]
-#else
-#define LLVM_REQUIRE_CONSTANT_INITIALIZATION
-#endif
-
-/// LLVM_EXTENSION - Support compilers where we have a keyword to suppress
-/// pedantic diagnostics.
-#ifdef __GNUC__
-#define LLVM_EXTENSION __extension__
-#else
-#define LLVM_EXTENSION
-#endif
-
-// LLVM_ATTRIBUTE_DEPRECATED(decl, "message")
-#if __has_feature(attribute_deprecated_with_message)
-# define LLVM_ATTRIBUTE_DEPRECATED(decl, message) \
-  decl __attribute__((deprecated(message)))
-#elif defined(__GNUC__)
-# define LLVM_ATTRIBUTE_DEPRECATED(decl, message) \
-  decl __attribute__((deprecated))
-#elif defined(_MSC_VER)
-# define LLVM_ATTRIBUTE_DEPRECATED(decl, message) \
-  __declspec(deprecated(message)) decl
-#else
-# define LLVM_ATTRIBUTE_DEPRECATED(decl, message) \
-  decl
-#endif
-
-/// LLVM_BUILTIN_UNREACHABLE - On compilers which support it, expands
-/// to an expression which states that it is undefined behavior for the
-/// compiler to reach this point.  Otherwise is not defined.
-#if __has_builtin(__builtin_unreachable) || LLVM_GNUC_PREREQ(4, 5, 0)
-# define LLVM_BUILTIN_UNREACHABLE __builtin_unreachable()
-#elif defined(_MSC_VER)
-# define LLVM_BUILTIN_UNREACHABLE __assume(false)
-#endif
-
-/// LLVM_BUILTIN_TRAP - On compilers which support it, expands to an expression
-/// which causes the program to exit abnormally.
-#if __has_builtin(__builtin_trap) || LLVM_GNUC_PREREQ(4, 3, 0)
-# define LLVM_BUILTIN_TRAP __builtin_trap()
-#elif defined(_MSC_VER)
-// The __debugbreak intrinsic is supported by MSVC, does not require forward
-// declarations involving platform-specific typedefs (unlike RaiseException),
-// results in a call to vectored exception handlers, and encodes to a short
-// instruction that still causes the trapping behavior we want.
-# define LLVM_BUILTIN_TRAP __debugbreak()
-#else
-# define LLVM_BUILTIN_TRAP *(volatile int*)0x11 = 0
-#endif
-
-/// LLVM_BUILTIN_DEBUGTRAP - On compilers which support it, expands to
-/// an expression which causes the program to break while running
-/// under a debugger.
-#if __has_builtin(__builtin_debugtrap)
-# define LLVM_BUILTIN_DEBUGTRAP __builtin_debugtrap()
-#elif defined(_MSC_VER)
-// The __debugbreak intrinsic is supported by MSVC and breaks while
-// running under the debugger, and also supports invoking a debugger
-// when the OS is configured appropriately.
-# define LLVM_BUILTIN_DEBUGTRAP __debugbreak()
-#else
-// Just continue execution when built with compilers that have no
-// support. This is a debugging aid and not intended to force the
-// program to abort if encountered.
-# define LLVM_BUILTIN_DEBUGTRAP
-#endif
-
-/// \macro LLVM_ASSUME_ALIGNED
-/// Returns a pointer with an assumed alignment.
-#if __has_builtin(__builtin_assume_aligned) || LLVM_GNUC_PREREQ(4, 7, 0)
-# define LLVM_ASSUME_ALIGNED(p, a) __builtin_assume_aligned(p, a)
-#elif defined(LLVM_BUILTIN_UNREACHABLE)
-// As of today, clang does not support __builtin_assume_aligned.
-# define LLVM_ASSUME_ALIGNED(p, a) \
-           (((uintptr_t(p) % (a)) == 0) ? (p) : (LLVM_BUILTIN_UNREACHABLE, (p)))
-#else
-# define LLVM_ASSUME_ALIGNED(p, a) (p)
-#endif
-
-/// \macro LLVM_PACKED
-/// Used to specify a packed structure.
-/// LLVM_PACKED(
-///    struct A {
-///      int i;
-///      int j;
-///      int k;
-///      long long l;
-///   });
-///
-/// LLVM_PACKED_START
-/// struct B {
-///   int i;
-///   int j;
-///   int k;
-///   long long l;
-/// };
-/// LLVM_PACKED_END
-#ifdef _MSC_VER
-# define LLVM_PACKED(d) __pragma(pack(push, 1)) d __pragma(pack(pop))
-# define LLVM_PACKED_START __pragma(pack(push, 1))
-# define LLVM_PACKED_END   __pragma(pack(pop))
-#else
-# define LLVM_PACKED(d) d __attribute__((packed))
-# define LLVM_PACKED_START _Pragma("pack(push, 1)")
-# define LLVM_PACKED_END   _Pragma("pack(pop)")
-#endif
-
-/// \macro LLVM_PTR_SIZE
-/// A constant integer equivalent to the value of sizeof(void*).
-/// Generally used in combination with alignas or when doing computation in the
-/// preprocessor.
-#ifdef __SIZEOF_POINTER__
-# define LLVM_PTR_SIZE __SIZEOF_POINTER__
-#elif defined(_WIN64)
-# define LLVM_PTR_SIZE 8
-#elif defined(_WIN32)
-# define LLVM_PTR_SIZE 4
-#elif defined(_MSC_VER)
-# error "could not determine LLVM_PTR_SIZE as a constant int for MSVC"
-#else
-# define LLVM_PTR_SIZE sizeof(void *)
-#endif
-
-/// \macro LLVM_MEMORY_SANITIZER_BUILD
-/// Whether LLVM itself is built with MemorySanitizer instrumentation.
-#if __has_feature(memory_sanitizer)
-# define LLVM_MEMORY_SANITIZER_BUILD 1
-# include <sanitizer/msan_interface.h>
-#else
-# define LLVM_MEMORY_SANITIZER_BUILD 0
-# define __msan_allocated_memory(p, size)
-# define __msan_unpoison(p, size)
-#endif
-
-/// \macro LLVM_ADDRESS_SANITIZER_BUILD
-/// Whether LLVM itself is built with AddressSanitizer instrumentation.
-#if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
-# define LLVM_ADDRESS_SANITIZER_BUILD 1
-# include <sanitizer/asan_interface.h>
-#else
-# define LLVM_ADDRESS_SANITIZER_BUILD 0
-# define __asan_poison_memory_region(p, size)
-# define __asan_unpoison_memory_region(p, size)
-#endif
-
-/// \macro LLVM_THREAD_SANITIZER_BUILD
-/// Whether LLVM itself is built with ThreadSanitizer instrumentation.
-#if __has_feature(thread_sanitizer) || defined(__SANITIZE_THREAD__)
-# define LLVM_THREAD_SANITIZER_BUILD 1
-#else
-# define LLVM_THREAD_SANITIZER_BUILD 0
-#endif
-
-#if LLVM_THREAD_SANITIZER_BUILD
-// Thread Sanitizer is a tool that finds races in code.
-// See http://code.google.com/p/data-race-test/wiki/DynamicAnnotations .
-// tsan detects these exact functions by name.
-#ifdef __cplusplus
-extern "C" {
-#endif
-void AnnotateHappensAfter(const char *file, int line, const volatile void *cv);
-void AnnotateHappensBefore(const char *file, int line, const volatile void *cv);
-void AnnotateIgnoreWritesBegin(const char *file, int line);
-void AnnotateIgnoreWritesEnd(const char *file, int line);
-#ifdef __cplusplus
-}
-#endif
-
-// This marker is used to define a happens-before arc. The race detector will
-// infer an arc from the begin to the end when they share the same pointer
-// argument.
-# define TsanHappensBefore(cv) AnnotateHappensBefore(__FILE__, __LINE__, cv)
-
-// This marker defines the destination of a happens-before arc.
-# define TsanHappensAfter(cv) AnnotateHappensAfter(__FILE__, __LINE__, cv)
-
-// Ignore any races on writes between here and the next TsanIgnoreWritesEnd.
-# define TsanIgnoreWritesBegin() AnnotateIgnoreWritesBegin(__FILE__, __LINE__)
-
-// Resume checking for racy writes.
-# define TsanIgnoreWritesEnd() AnnotateIgnoreWritesEnd(__FILE__, __LINE__)
-#else
-# define TsanHappensBefore(cv)
-# define TsanHappensAfter(cv)
-# define TsanIgnoreWritesBegin()
-# define TsanIgnoreWritesEnd()
-#endif
-
-/// \macro LLVM_NO_SANITIZE
-/// Disable a particular sanitizer for a function.
-#if __has_attribute(no_sanitize)
-#define LLVM_NO_SANITIZE(KIND) __attribute__((no_sanitize(KIND)))
-#else
-#define LLVM_NO_SANITIZE(KIND)
-#endif
-
-/// Mark debug helper function definitions like dump() that should not be
-/// stripped from debug builds.
-/// Note that you should also surround dump() functions with
-/// `#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)` so they do always
-/// get stripped in release builds.
-// FIXME: Move this to a private config.h as it's not usable in public headers.
-#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
-#define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE LLVM_ATTRIBUTE_USED
-#else
-#define LLVM_DUMP_METHOD LLVM_ATTRIBUTE_NOINLINE
-#endif
-
-/// \macro LLVM_PRETTY_FUNCTION
-/// Gets a user-friendly looking function signature for the current scope
-/// using the best available method on each platform.  The exact format of the
-/// resulting string is implementation specific and non-portable, so this should
-/// only be used, for example, for logging or diagnostics.
-#if defined(_MSC_VER)
-#define LLVM_PRETTY_FUNCTION __FUNCSIG__
-#elif defined(__GNUC__) || defined(__clang__)
-#define LLVM_PRETTY_FUNCTION __PRETTY_FUNCTION__
-#else
-#define LLVM_PRETTY_FUNCTION __func__
-#endif
-
-/// \macro LLVM_THREAD_LOCAL
-/// A thread-local storage specifier which can be used with globals,
-/// extern globals, and static globals.
-///
-/// This is essentially an extremely restricted analog to C++11's thread_local
-/// support, and uses that when available. However, it falls back on
-/// platform-specific or vendor-provided extensions when necessary. These
-/// extensions don't support many of the C++11 thread_local's features. You
-/// should only use this for PODs that you can statically initialize to
-/// some constant value. In almost all circumstances this is most appropriate
-/// for use with a pointer, integer, or small aggregation of pointers and
-/// integers.
-#if LLVM_ENABLE_THREADS
-#if __has_feature(cxx_thread_local)
-#define LLVM_THREAD_LOCAL thread_local
-#elif defined(_MSC_VER)
-// MSVC supports this with a __declspec.
-#define LLVM_THREAD_LOCAL __declspec(thread)
-#else
-// Clang, GCC, and other compatible compilers used __thread prior to C++11 and
-// we only need the restricted functionality that provides.
-#define LLVM_THREAD_LOCAL __thread
-#endif
-#else // !LLVM_ENABLE_THREADS
-// If threading is disabled entirely, this compiles to nothing and you get
-// a normal global variable.
-#define LLVM_THREAD_LOCAL
-#endif
-
-/// \macro LLVM_ENABLE_EXCEPTIONS
-/// Whether LLVM is built with exception support.
-#if __has_feature(cxx_exceptions)
-#define LLVM_ENABLE_EXCEPTIONS 1
-#elif defined(__GNUC__) && defined(__EXCEPTIONS)
-#define LLVM_ENABLE_EXCEPTIONS 1
-#elif defined(_MSC_VER) && defined(_CPPUNWIND)
-#define LLVM_ENABLE_EXCEPTIONS 1
-#endif
-
-#ifdef __cplusplus
-namespace opencombine {
-namespace llvm {
-
-/// Allocate a buffer of memory with the given size and alignment.
-///
-/// When the compiler supports aligned operator new, this will use it to to
-/// handle even over-aligned allocations.
-///
-/// However, this doesn't make any attempt to leverage the fancier techniques
-/// like posix_memalign due to portability. It is mostly intended to allow
-/// compatibility with platforms that, after aligned allocation was added, use
-/// reduced default alignment.
-inline void *allocate_buffer(size_t Size, size_t Alignment) {
-  return ::operator new(Size
-#ifdef __cpp_aligned_new
-                        ,
-                        std::align_val_t(Alignment)
-#endif
-  );
-}
-
-/// Deallocate a buffer of memory with the given size and alignment.
-///
-/// If supported, this will used the sized delete operator. Also if supported,
-/// this will pass the alignment to the delete operator.
-///
-/// The pointer must have been allocated with the corresponding new operator,
-/// most likely using the above helper.
-inline void deallocate_buffer(void *Ptr, size_t Size, size_t Alignment) {
-  ::operator delete(Ptr
-#ifdef __cpp_sized_deallocation
-                    ,
-                    Size
-#endif
-#ifdef __cpp_aligned_new
-                    ,
-                    std::align_val_t(Alignment)
-#endif
-  );
-}
-
-} // End namespace llvm
-} // End namespace opencombine
-
-#endif // __cplusplus
-#endif

Sources/COpenCombineHelpers/llvm/Support/DataTypes.h

@@ -1,94 +0,0 @@
-/*===-- include/llvm-c/DataTypes.h - Define fixed size types ------*- C -*-===*\
-|*                                                                            *|
-|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
-|* Exceptions.                                                                *|
-|* See https://llvm.org/LICENSE.txt for license information.                  *|
-|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
-|*                                                                            *|
-|*===----------------------------------------------------------------------===*|
-|*                                                                            *|
-|* This file contains definitions to figure out the size of _HOST_ data types.*|
-|* This file is important because different host OS's define different macros,*|
-|* which makes portability tough.  This file exports the following            *|
-|* definitions:                                                               *|
-|*                                                                            *|
-|*   [u]int(32|64)_t : typedefs for signed and unsigned 32/64 bit system types*|
-|*   [U]INT(8|16|32|64)_(MIN|MAX) : Constants for the min and max values.     *|
-|*                                                                            *|
-|* No library is required when using these functions.                         *|
-|*                                                                            *|
-|*===----------------------------------------------------------------------===*/
-
-/* Please leave this file C-compatible. */
-
-// MODIFICATION NOTE:
-// This file has been modified for the OpenCombine open source project.
-// - The llvm namespace is wrapped in the opencombine namespace.
-
-#ifndef OPENCOMBINE_LLVM_C_DATATYPES_H
-#define OPENCOMBINE_LLVM_C_DATATYPES_H
-
-#ifdef __cplusplus
-#include <cmath>
-#else
-#include <math.h>
-#endif
-
-#include <inttypes.h>
-#include <stdint.h>
-
-#ifndef _MSC_VER
-
-#if !defined(UINT32_MAX)
-# error "The standard header <cstdint> is not C++11 compliant. Must #define "\
-        "__STDC_LIMIT_MACROS before #including llvm-c/DataTypes.h"
-#endif
-
-#if !defined(UINT32_C)
-# error "The standard header <cstdint> is not C++11 compliant. Must #define "\
-        "__STDC_CONSTANT_MACROS before #including llvm-c/DataTypes.h"
-#endif
-
-/* Note that <inttypes.h> includes <stdint.h>, if this is a C99 system. */
-#include <sys/types.h>
-
-#ifdef _AIX
-// GCC is strict about defining large constants: they must have LL modifier.
-#undef INT64_MAX
-#undef INT64_MIN
-#endif
-
-#else /* _MSC_VER */
-#ifdef __cplusplus
-#include <cstddef>
-#include <cstdlib>
-#else
-#include <stddef.h>
-#include <stdlib.h>
-#endif
-#include <sys/types.h>
-
-#if defined(_WIN64)
-typedef signed __int64 ssize_t;
-#else
-typedef signed int ssize_t;
-#endif /* _WIN64 */
-
-#endif /* _MSC_VER */
-
-/* Set defaults for constants which we cannot find. */
-#if !defined(INT64_MAX)
-# define INT64_MAX 9223372036854775807LL
-#endif
-#if !defined(INT64_MIN)
-# define INT64_MIN ((-INT64_MAX)-1)
-#endif
-#if !defined(UINT64_MAX)
-# define UINT64_MAX 0xffffffffffffffffULL
-#endif
-
-#ifndef HUGE_VALF
-#define HUGE_VALF (float)HUGE_VAL
-#endif
-
-#endif /* OPENCOMBINE_LLVM_C_DATATYPES_H */

Sources/COpenCombineHelpers/llvm/Support/MathExtras.h

@@ -1,957 +0,0 @@
-//===-- llvm/Support/MathExtras.h - Useful math functions -------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains some functions that are useful for math stuff.
-//
-//===----------------------------------------------------------------------===//
-
-// MODIFICATION NOTE:
-// This file has been modified for the OpenCombine open source project.
-// - The llvm namespace is wrapped in the opencombine namespace.
-
-#ifndef OPENCOMBINE_LLVM_SUPPORT_MATHEXTRAS_H
-#define OPENCOMBINE_LLVM_SUPPORT_MATHEXTRAS_H
-
-#include "llvm/Support/Compiler.h"
-#include "llvm/Support/SwapByteOrder.h"
-#include <algorithm>
-#include <cassert>
-#include <climits>
-#include <cstring>
-#include <limits>
-#include <type_traits>
-
-#ifdef __ANDROID_NDK__
-#include <android/api-level.h>
-#endif
-
-#ifdef _MSC_VER
-// Declare these intrinsics manually rather including intrin.h. It's very
-// expensive, and MathExtras.h is popular.
-// #include <intrin.h>
-extern "C" {
-unsigned char _BitScanForward(unsigned long *_Index, unsigned long _Mask);
-unsigned char _BitScanForward64(unsigned long *_Index, unsigned __int64 _Mask);
-unsigned char _BitScanReverse(unsigned long *_Index, unsigned long _Mask);
-unsigned char _BitScanReverse64(unsigned long *_Index, unsigned __int64 _Mask);
-}
-#endif
-
-namespace opencombine {
-namespace llvm {
-
-/// The behavior an operation has on an input of 0.
-enum ZeroBehavior {
-  /// The returned value is undefined.
-  ZB_Undefined,
-  /// The returned value is numeric_limits<T>::max()
-  ZB_Max,
-  /// The returned value is numeric_limits<T>::digits
-  ZB_Width
-};
-
-/// Mathematical constants.
-namespace numbers {
-// TODO: Track C++20 std::numbers.
-// TODO: Favor using the hexadecimal FP constants (requires C++17).
-constexpr double e          = 2.7182818284590452354, // (0x1.5bf0a8b145749P+1) https://oeis.org/A001113
-                 egamma     = .57721566490153286061, // (0x1.2788cfc6fb619P-1) https://oeis.org/A001620
-                 ln2        = .69314718055994530942, // (0x1.62e42fefa39efP-1) https://oeis.org/A002162
-                 ln10       = 2.3025850929940456840, // (0x1.24bb1bbb55516P+1) https://oeis.org/A002392
-                 log2e      = 1.4426950408889634074, // (0x1.71547652b82feP+0)
-                 log10e     = .43429448190325182765, // (0x1.bcb7b1526e50eP-2)
-                 pi         = 3.1415926535897932385, // (0x1.921fb54442d18P+1) https://oeis.org/A000796
-                 inv_pi     = .31830988618379067154, // (0x1.45f306bc9c883P-2) https://oeis.org/A049541
-                 sqrtpi     = 1.7724538509055160273, // (0x1.c5bf891b4ef6bP+0) https://oeis.org/A002161
-                 inv_sqrtpi = .56418958354775628695, // (0x1.20dd750429b6dP-1) https://oeis.org/A087197
-                 sqrt2      = 1.4142135623730950488, // (0x1.6a09e667f3bcdP+0) https://oeis.org/A00219
-                 inv_sqrt2  = .70710678118654752440, // (0x1.6a09e667f3bcdP-1)
-                 sqrt3      = 1.7320508075688772935, // (0x1.bb67ae8584caaP+0) https://oeis.org/A002194
-                 inv_sqrt3  = .57735026918962576451, // (0x1.279a74590331cP-1)
-                 phi        = 1.6180339887498948482; // (0x1.9e3779b97f4a8P+0) https://oeis.org/A001622
-constexpr float ef          = 2.71828183F, // (0x1.5bf0a8P+1) https://oeis.org/A001113
-                egammaf     = .577215665F, // (0x1.2788d0P-1) https://oeis.org/A001620
-                ln2f        = .693147181F, // (0x1.62e430P-1) https://oeis.org/A002162
-                ln10f       = 2.30258509F, // (0x1.26bb1cP+1) https://oeis.org/A002392
-                log2ef      = 1.44269504F, // (0x1.715476P+0)
-                log10ef     = .434294482F, // (0x1.bcb7b2P-2)
-                pif         = 3.14159265F, // (0x1.921fb6P+1) https://oeis.org/A000796
-                inv_pif     = .318309886F, // (0x1.45f306P-2) https://oeis.org/A049541
-                sqrtpif     = 1.77245385F, // (0x1.c5bf8aP+0) https://oeis.org/A002161
-                inv_sqrtpif = .564189584F, // (0x1.20dd76P-1) https://oeis.org/A087197
-                sqrt2f      = 1.41421356F, // (0x1.6a09e6P+0) https://oeis.org/A002193
-                inv_sqrt2f  = .707106781F, // (0x1.6a09e6P-1)
-                sqrt3f      = 1.73205081F, // (0x1.bb67aeP+0) https://oeis.org/A002194
-                inv_sqrt3f  = .577350269F, // (0x1.279a74P-1)
-                phif        = 1.61803399F; // (0x1.9e377aP+0) https://oeis.org/A001622
-} // namespace numbers
-
-namespace detail {
-template <typename T, std::size_t SizeOfT> struct TrailingZerosCounter {
-  static unsigned count(T Val, ZeroBehavior) {
-    if (!Val)
-      return std::numeric_limits<T>::digits;
-    if (Val & 0x1)
-      return 0;
-
-    // Bisection method.
-    unsigned ZeroBits = 0;
-    T Shift = std::numeric_limits<T>::digits >> 1;
-    T Mask = std::numeric_limits<T>::max() >> Shift;
-    while (Shift) {
-      if ((Val & Mask) == 0) {
-        Val >>= Shift;
-        ZeroBits |= Shift;
-      }
-      Shift >>= 1;
-      Mask >>= Shift;
-    }
-    return ZeroBits;
-  }
-};
-
-#if defined(__GNUC__) || defined(_MSC_VER)
-template <typename T> struct TrailingZerosCounter<T, 4> {
-  static unsigned count(T Val, ZeroBehavior ZB) {
-    if (ZB != ZB_Undefined && Val == 0)
-      return 32;
-
-#if __has_builtin(__builtin_ctz) || defined(__GNUC__)
-    return __builtin_ctz(Val);
-#elif defined(_MSC_VER)
-    unsigned long Index;
-    _BitScanForward(&Index, Val);
-    return Index;
-#endif
-  }
-};
-
-#if !defined(_MSC_VER) || defined(_M_X64)
-template <typename T> struct TrailingZerosCounter<T, 8> {
-  static unsigned count(T Val, ZeroBehavior ZB) {
-    if (ZB != ZB_Undefined && Val == 0)
-      return 64;
-
-#if __has_builtin(__builtin_ctzll) || defined(__GNUC__)
-    return __builtin_ctzll(Val);
-#elif defined(_MSC_VER)
-    unsigned long Index;
-    _BitScanForward64(&Index, Val);
-    return Index;
-#endif
-  }
-};
-#endif
-#endif
-} // namespace detail
-
-/// Count number of 0's from the least significant bit to the most
-///   stopping at the first 1.
-///
-/// Only unsigned integral types are allowed.
-///
-/// \param ZB the behavior on an input of 0. Only ZB_Width and ZB_Undefined are
-///   valid arguments.
-template <typename T>
-unsigned countTrailingZeros(T Val, ZeroBehavior ZB = ZB_Width) {
-  static_assert(std::numeric_limits<T>::is_integer &&
-                    !std::numeric_limits<T>::is_signed,
-                "Only unsigned integral types are allowed.");
-  return llvm::detail::TrailingZerosCounter<T, sizeof(T)>::count(Val, ZB);
-}
-
-namespace detail {
-template <typename T, std::size_t SizeOfT> struct LeadingZerosCounter {
-  static unsigned count(T Val, ZeroBehavior) {
-    if (!Val)
-      return std::numeric_limits<T>::digits;
-
-    // Bisection method.
-    unsigned ZeroBits = 0;
-    for (T Shift = std::numeric_limits<T>::digits >> 1; Shift; Shift >>= 1) {
-      T Tmp = Val >> Shift;
-      if (Tmp)
-        Val = Tmp;
-      else
-        ZeroBits |= Shift;
-    }
-    return ZeroBits;
-  }
-};
-
-#if defined(__GNUC__) || defined(_MSC_VER)
-template <typename T> struct LeadingZerosCounter<T, 4> {
-  static unsigned count(T Val, ZeroBehavior ZB) {
-    if (ZB != ZB_Undefined && Val == 0)
-      return 32;
-
-#if __has_builtin(__builtin_clz) || defined(__GNUC__)
-    return __builtin_clz(Val);
-#elif defined(_MSC_VER)
-    unsigned long Index;
-    _BitScanReverse(&Index, Val);
-    return Index ^ 31;
-#endif
-  }
-};
-
-#if !defined(_MSC_VER) || defined(_M_X64)
-template <typename T> struct LeadingZerosCounter<T, 8> {
-  static unsigned count(T Val, ZeroBehavior ZB) {
-    if (ZB != ZB_Undefined && Val == 0)
-      return 64;
-
-#if __has_builtin(__builtin_clzll) || defined(__GNUC__)
-    return __builtin_clzll(Val);
-#elif defined(_MSC_VER)
-    unsigned long Index;
-    _BitScanReverse64(&Index, Val);
-    return Index ^ 63;
-#endif
-  }
-};
-#endif
-#endif
-} // namespace detail
-
-/// Count number of 0's from the most significant bit to the least
-///   stopping at the first 1.
-///
-/// Only unsigned integral types are allowed.
-///
-/// \param ZB the behavior on an input of 0. Only ZB_Width and ZB_Undefined are
-///   valid arguments.
-template <typename T>
-unsigned countLeadingZeros(T Val, ZeroBehavior ZB = ZB_Width) {
-  static_assert(std::numeric_limits<T>::is_integer &&
-                    !std::numeric_limits<T>::is_signed,
-                "Only unsigned integral types are allowed.");
-  return llvm::detail::LeadingZerosCounter<T, sizeof(T)>::count(Val, ZB);
-}
-
-/// Get the index of the first set bit starting from the least
-///   significant bit.
-///
-/// Only unsigned integral types are allowed.
-///
-/// \param ZB the behavior on an input of 0. Only ZB_Max and ZB_Undefined are
-///   valid arguments.
-template <typename T> T findFirstSet(T Val, ZeroBehavior ZB = ZB_Max) {
-  if (ZB == ZB_Max && Val == 0)
-    return std::numeric_limits<T>::max();
-
-  return countTrailingZeros(Val, ZB_Undefined);
-}
-
-/// Create a bitmask with the N right-most bits set to 1, and all other
-/// bits set to 0.  Only unsigned types are allowed.
-template <typename T> T maskTrailingOnes(unsigned N) {
-  static_assert(std::is_unsigned<T>::value, "Invalid type!");
-  const unsigned Bits = CHAR_BIT * sizeof(T);
-  assert(N <= Bits && "Invalid bit index");
-  return N == 0 ? 0 : (T(-1) >> (Bits - N));
-}
-
-/// Create a bitmask with the N left-most bits set to 1, and all other
-/// bits set to 0.  Only unsigned types are allowed.
-template <typename T> T maskLeadingOnes(unsigned N) {
-  return ~maskTrailingOnes<T>(CHAR_BIT * sizeof(T) - N);
-}
-
-/// Create a bitmask with the N right-most bits set to 0, and all other
-/// bits set to 1.  Only unsigned types are allowed.
-template <typename T> T maskTrailingZeros(unsigned N) {
-  return maskLeadingOnes<T>(CHAR_BIT * sizeof(T) - N);
-}
-
-/// Create a bitmask with the N left-most bits set to 0, and all other
-/// bits set to 1.  Only unsigned types are allowed.
-template <typename T> T maskLeadingZeros(unsigned N) {
-  return maskTrailingOnes<T>(CHAR_BIT * sizeof(T) - N);
-}
-
-/// Get the index of the last set bit starting from the least
-///   significant bit.
-///
-/// Only unsigned integral types are allowed.
-///
-/// \param ZB the behavior on an input of 0. Only ZB_Max and ZB_Undefined are
-///   valid arguments.
-template <typename T> T findLastSet(T Val, ZeroBehavior ZB = ZB_Max) {
-  if (ZB == ZB_Max && Val == 0)
-    return std::numeric_limits<T>::max();
-
-  // Use ^ instead of - because both gcc and llvm can remove the associated ^
-  // in the __builtin_clz intrinsic on x86.
-  return countLeadingZeros(Val, ZB_Undefined) ^
-         (std::numeric_limits<T>::digits - 1);
-}
-
-/// Macro compressed bit reversal table for 256 bits.
-///
-/// http://graphics.stanford.edu/~seander/bithacks.html#BitReverseTable
-static const unsigned char BitReverseTable256[256] = {
-#define R2(n) n, n + 2 * 64, n + 1 * 64, n + 3 * 64
-#define R4(n) R2(n), R2(n + 2 * 16), R2(n + 1 * 16), R2(n + 3 * 16)
-#define R6(n) R4(n), R4(n + 2 * 4), R4(n + 1 * 4), R4(n + 3 * 4)
-  R6(0), R6(2), R6(1), R6(3)
-#undef R2
-#undef R4
-#undef R6
-};
-
-/// Reverse the bits in \p Val.
-template <typename T>
-T reverseBits(T Val) {
-  unsigned char in[sizeof(Val)];
-  unsigned char out[sizeof(Val)];
-  std::memcpy(in, &Val, sizeof(Val));
-  for (unsigned i = 0; i < sizeof(Val); ++i)
-    out[(sizeof(Val) - i) - 1] = BitReverseTable256[in[i]];
-  std::memcpy(&Val, out, sizeof(Val));
-  return Val;
-}
-
-// NOTE: The following support functions use the _32/_64 extensions instead of
-// type overloading so that signed and unsigned integers can be used without
-// ambiguity.
-
-/// Return the high 32 bits of a 64 bit value.
-constexpr inline uint32_t Hi_32(uint64_t Value) {
-  return static_cast<uint32_t>(Value >> 32);
-}
-
-/// Return the low 32 bits of a 64 bit value.
-constexpr inline uint32_t Lo_32(uint64_t Value) {
-  return static_cast<uint32_t>(Value);
-}
-
-/// Make a 64-bit integer from a high / low pair of 32-bit integers.
-constexpr inline uint64_t Make_64(uint32_t High, uint32_t Low) {
-  return ((uint64_t)High << 32) | (uint64_t)Low;
-}
-
-/// Checks if an integer fits into the given bit width.
-template <unsigned N> constexpr inline bool isInt(int64_t x) {
-  return N >= 64 || (-(INT64_C(1)<<(N-1)) <= x && x < (INT64_C(1)<<(N-1)));
-}
-// Template specializations to get better code for common cases.
-template <> constexpr inline bool isInt<8>(int64_t x) {
-  return static_cast<int8_t>(x) == x;
-}
-template <> constexpr inline bool isInt<16>(int64_t x) {
-  return static_cast<int16_t>(x) == x;
-}
-template <> constexpr inline bool isInt<32>(int64_t x) {
-  return static_cast<int32_t>(x) == x;
-}
-
-/// Checks if a signed integer is an N bit number shifted left by S.
-template <unsigned N, unsigned S>
-constexpr inline bool isShiftedInt(int64_t x) {
-  static_assert(
-      N > 0, "isShiftedInt<0> doesn't make sense (refers to a 0-bit number.");
-  static_assert(N + S <= 64, "isShiftedInt<N, S> with N + S > 64 is too wide.");
-  return isInt<N + S>(x) && (x % (UINT64_C(1) << S) == 0);
-}
-
-/// Checks if an unsigned integer fits into the given bit width.
-///
-/// This is written as two functions rather than as simply
-///
-///   return N >= 64 || X < (UINT64_C(1) << N);
-///
-/// to keep MSVC from (incorrectly) warning on isUInt<64> that we're shifting
-/// left too many places.
-template <unsigned N>
-constexpr inline typename std::enable_if<(N < 64), bool>::type
-isUInt(uint64_t X) {
-  static_assert(N > 0, "isUInt<0> doesn't make sense");
-  return X < (UINT64_C(1) << (N));
-}
-template <unsigned N>
-constexpr inline typename std::enable_if<N >= 64, bool>::type
-isUInt(uint64_t X) {
-  return true;
-}
-
-// Template specializations to get better code for common cases.
-template <> constexpr inline bool isUInt<8>(uint64_t x) {
-  return static_cast<uint8_t>(x) == x;
-}
-template <> constexpr inline bool isUInt<16>(uint64_t x) {
-  return static_cast<uint16_t>(x) == x;
-}
-template <> constexpr inline bool isUInt<32>(uint64_t x) {
-  return static_cast<uint32_t>(x) == x;
-}
-
-/// Checks if a unsigned integer is an N bit number shifted left by S.
-template <unsigned N, unsigned S>
-constexpr inline bool isShiftedUInt(uint64_t x) {
-  static_assert(
-      N > 0, "isShiftedUInt<0> doesn't make sense (refers to a 0-bit number)");
-  static_assert(N + S <= 64,
-                "isShiftedUInt<N, S> with N + S > 64 is too wide.");
-  // Per the two static_asserts above, S must be strictly less than 64.  So
-  // 1 << S is not undefined behavior.
-  return isUInt<N + S>(x) && (x % (UINT64_C(1) << S) == 0);
-}
-
-/// Gets the maximum value for a N-bit unsigned integer.
-inline uint64_t maxUIntN(uint64_t N) {
-  assert(N > 0 && N <= 64 && "integer width out of range");
-
-  // uint64_t(1) << 64 is undefined behavior, so we can't do
-  //   (uint64_t(1) << N) - 1
-  // without checking first that N != 64.  But this works and doesn't have a
-  // branch.
-  return UINT64_MAX >> (64 - N);
-}
-
-/// Gets the minimum value for a N-bit signed integer.
-inline int64_t minIntN(int64_t N) {
-  assert(N > 0 && N <= 64 && "integer width out of range");
-
-  return -(UINT64_C(1)<<(N-1));
-}
-
-/// Gets the maximum value for a N-bit signed integer.
-inline int64_t maxIntN(int64_t N) {
-  assert(N > 0 && N <= 64 && "integer width out of range");
-
-  // This relies on two's complement wraparound when N == 64, so we convert to
-  // int64_t only at the very end to avoid UB.
-  return (UINT64_C(1) << (N - 1)) - 1;
-}
-
-/// Checks if an unsigned integer fits into the given (dynamic) bit width.
-inline bool isUIntN(unsigned N, uint64_t x) {
-  return N >= 64 || x <= maxUIntN(N);
-}
-
-/// Checks if an signed integer fits into the given (dynamic) bit width.
-inline bool isIntN(unsigned N, int64_t x) {
-  return N >= 64 || (minIntN(N) <= x && x <= maxIntN(N));
-}
-
-/// Return true if the argument is a non-empty sequence of ones starting at the
-/// least significant bit with the remainder zero (32 bit version).
-/// Ex. isMask_32(0x0000FFFFU) == true.
-constexpr inline bool isMask_32(uint32_t Value) {
-  return Value && ((Value + 1) & Value) == 0;
-}
-
-/// Return true if the argument is a non-empty sequence of ones starting at the
-/// least significant bit with the remainder zero (64 bit version).
-constexpr inline bool isMask_64(uint64_t Value) {
-  return Value && ((Value + 1) & Value) == 0;
-}
-
-/// Return true if the argument contains a non-empty sequence of ones with the
-/// remainder zero (32 bit version.) Ex. isShiftedMask_32(0x0000FF00U) == true.
-constexpr inline bool isShiftedMask_32(uint32_t Value) {
-  return Value && isMask_32((Value - 1) | Value);
-}
-
-/// Return true if the argument contains a non-empty sequence of ones with the
-/// remainder zero (64 bit version.)
-constexpr inline bool isShiftedMask_64(uint64_t Value) {
-  return Value && isMask_64((Value - 1) | Value);
-}
-
-/// Return true if the argument is a power of two > 0.
-/// Ex. isPowerOf2_32(0x00100000U) == true (32 bit edition.)
-constexpr inline bool isPowerOf2_32(uint32_t Value) {
-  return Value && !(Value & (Value - 1));
-}
-
-/// Return true if the argument is a power of two > 0 (64 bit edition.)
-constexpr inline bool isPowerOf2_64(uint64_t Value) {
-  return Value && !(Value & (Value - 1));
-}
-
-/// Return a byte-swapped representation of the 16-bit argument.
-inline uint16_t ByteSwap_16(uint16_t Value) {
-  return sys::SwapByteOrder_16(Value);
-}
-
-/// Return a byte-swapped representation of the 32-bit argument.
-inline uint32_t ByteSwap_32(uint32_t Value) {
-  return sys::SwapByteOrder_32(Value);
-}
-
-/// Return a byte-swapped representation of the 64-bit argument.
-inline uint64_t ByteSwap_64(uint64_t Value) {
-  return sys::SwapByteOrder_64(Value);
-}
-
-/// Count the number of ones from the most significant bit to the first
-/// zero bit.
-///
-/// Ex. countLeadingOnes(0xFF0FFF00) == 8.
-/// Only unsigned integral types are allowed.
-///
-/// \param ZB the behavior on an input of all ones. Only ZB_Width and
-/// ZB_Undefined are valid arguments.
-template <typename T>
-unsigned countLeadingOnes(T Value, ZeroBehavior ZB = ZB_Width) {
-  static_assert(std::numeric_limits<T>::is_integer &&
-                    !std::numeric_limits<T>::is_signed,
-                "Only unsigned integral types are allowed.");
-  return countLeadingZeros<T>(~Value, ZB);
-}
-
-/// Count the number of ones from the least significant bit to the first
-/// zero bit.
-///
-/// Ex. countTrailingOnes(0x00FF00FF) == 8.
-/// Only unsigned integral types are allowed.
-///
-/// \param ZB the behavior on an input of all ones. Only ZB_Width and
-/// ZB_Undefined are valid arguments.
-template <typename T>
-unsigned countTrailingOnes(T Value, ZeroBehavior ZB = ZB_Width) {
-  static_assert(std::numeric_limits<T>::is_integer &&
-                    !std::numeric_limits<T>::is_signed,
-                "Only unsigned integral types are allowed.");
-  return countTrailingZeros<T>(~Value, ZB);
-}
-
-namespace detail {
-template <typename T, std::size_t SizeOfT> struct PopulationCounter {
-  static unsigned count(T Value) {
-    // Generic version, forward to 32 bits.
-    static_assert(SizeOfT <= 4, "Not implemented!");
-#if defined(__GNUC__)
-    return __builtin_popcount(Value);
-#else
-    uint32_t v = Value;
-    v = v - ((v >> 1) & 0x55555555);
-    v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
-    return ((v + (v >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
-#endif
-  }
-};
-
-template <typename T> struct PopulationCounter<T, 8> {
-  static unsigned count(T Value) {
-#if defined(__GNUC__)
-    return __builtin_popcountll(Value);
-#else
-    uint64_t v = Value;
-    v = v - ((v >> 1) & 0x5555555555555555ULL);
-    v = (v & 0x3333333333333333ULL) + ((v >> 2) & 0x3333333333333333ULL);
-    v = (v + (v >> 4)) & 0x0F0F0F0F0F0F0F0FULL;
-    return unsigned((uint64_t)(v * 0x0101010101010101ULL) >> 56);
-#endif
-  }
-};
-} // namespace detail
-
-/// Count the number of set bits in a value.
-/// Ex. countPopulation(0xF000F000) = 8
-/// Returns 0 if the word is zero.
-template <typename T>
-inline unsigned countPopulation(T Value) {
-  static_assert(std::numeric_limits<T>::is_integer &&
-                    !std::numeric_limits<T>::is_signed,
-                "Only unsigned integral types are allowed.");
-  return detail::PopulationCounter<T, sizeof(T)>::count(Value);
-}
-
-/// Compile time Log2.
-/// Valid only for positive powers of two.
-template <size_t kValue> constexpr inline size_t CTLog2() {
-  static_assert(kValue > 0 && llvm::isPowerOf2_64(kValue),
-                "Value is not a valid power of 2");
-  return 1 + CTLog2<kValue / 2>();
-}
-
-template <> constexpr inline size_t CTLog2<1>() { return 0; }
-
-/// Return the log base 2 of the specified value.
-inline double Log2(double Value) {
-#if defined(__ANDROID_API__) && __ANDROID_API__ < 18
-  return __builtin_log(Value) / __builtin_log(2.0);
-#else
-  return log2(Value);
-#endif
-}
-
-/// Return the floor log base 2 of the specified value, -1 if the value is zero.
-/// (32 bit edition.)
-/// Ex. Log2_32(32) == 5, Log2_32(1) == 0, Log2_32(0) == -1, Log2_32(6) == 2
-inline unsigned Log2_32(uint32_t Value) {
-  return 31 - countLeadingZeros(Value);
-}
-
-/// Return the floor log base 2 of the specified value, -1 if the value is zero.
-/// (64 bit edition.)
-inline unsigned Log2_64(uint64_t Value) {
-  return 63 - countLeadingZeros(Value);
-}
-
-/// Return the ceil log base 2 of the specified value, 32 if the value is zero.
-/// (32 bit edition).
-/// Ex. Log2_32_Ceil(32) == 5, Log2_32_Ceil(1) == 0, Log2_32_Ceil(6) == 3
-inline unsigned Log2_32_Ceil(uint32_t Value) {
-  return 32 - countLeadingZeros(Value - 1);
-}
-
-/// Return the ceil log base 2 of the specified value, 64 if the value is zero.
-/// (64 bit edition.)
-inline unsigned Log2_64_Ceil(uint64_t Value) {
-  return 64 - countLeadingZeros(Value - 1);
-}
-
-/// Return the greatest common divisor of the values using Euclid's algorithm.
-template <typename T>
-inline T greatestCommonDivisor(T A, T B) {
-  while (B) {
-    T Tmp = B;
-    B = A % B;
-    A = Tmp;
-  }
-  return A;
-}
-
-inline uint64_t GreatestCommonDivisor64(uint64_t A, uint64_t B) {
-  return greatestCommonDivisor<uint64_t>(A, B);
-}
-
-/// This function takes a 64-bit integer and returns the bit equivalent double.
-inline double BitsToDouble(uint64_t Bits) {
-  double D;
-  static_assert(sizeof(uint64_t) == sizeof(double), "Unexpected type sizes");
-  memcpy(&D, &Bits, sizeof(Bits));
-  return D;
-}
-
-/// This function takes a 32-bit integer and returns the bit equivalent float.
-inline float BitsToFloat(uint32_t Bits) {
-  float F;
-  static_assert(sizeof(uint32_t) == sizeof(float), "Unexpected type sizes");
-  memcpy(&F, &Bits, sizeof(Bits));
-  return F;
-}
-
-/// This function takes a double and returns the bit equivalent 64-bit integer.
-/// Note that copying doubles around changes the bits of NaNs on some hosts,
-/// notably x86, so this routine cannot be used if these bits are needed.
-inline uint64_t DoubleToBits(double Double) {
-  uint64_t Bits;
-  static_assert(sizeof(uint64_t) == sizeof(double), "Unexpected type sizes");
-  memcpy(&Bits, &Double, sizeof(Double));
-  return Bits;
-}
-
-/// This function takes a float and returns the bit equivalent 32-bit integer.
-/// Note that copying floats around changes the bits of NaNs on some hosts,
-/// notably x86, so this routine cannot be used if these bits are needed.
-inline uint32_t FloatToBits(float Float) {
-  uint32_t Bits;
-  static_assert(sizeof(uint32_t) == sizeof(float), "Unexpected type sizes");
-  memcpy(&Bits, &Float, sizeof(Float));
-  return Bits;
-}
-
-/// A and B are either alignments or offsets. Return the minimum alignment that
-/// may be assumed after adding the two together.
-constexpr inline uint64_t MinAlign(uint64_t A, uint64_t B) {
-  // The largest power of 2 that divides both A and B.
-  //
-  // Replace "-Value" by "1+~Value" in the following commented code to avoid
-  // MSVC warning C4146
-  //    return (A | B) & -(A | B);
-  return (A | B) & (1 + ~(A | B));
-}
-
-/// Returns the next power of two (in 64-bits) that is strictly greater than A.
-/// Returns zero on overflow.
-inline uint64_t NextPowerOf2(uint64_t A) {
-  A |= (A >> 1);
-  A |= (A >> 2);
-  A |= (A >> 4);
-  A |= (A >> 8);
-  A |= (A >> 16);
-  A |= (A >> 32);
-  return A + 1;
-}
-
-/// Returns the power of two which is less than or equal to the given value.
-/// Essentially, it is a floor operation across the domain of powers of two.
-inline uint64_t PowerOf2Floor(uint64_t A) {
-  if (!A) return 0;
-  return 1ull << (63 - countLeadingZeros(A, ZB_Undefined));
-}
-
-/// Returns the power of two which is greater than or equal to the given value.
-/// Essentially, it is a ceil operation across the domain of powers of two.
-inline uint64_t PowerOf2Ceil(uint64_t A) {
-  if (!A)
-    return 0;
-  return NextPowerOf2(A - 1);
-}
-
-/// Returns the next integer (mod 2**64) that is greater than or equal to
-/// \p Value and is a multiple of \p Align. \p Align must be non-zero.
-///
-/// If non-zero \p Skew is specified, the return value will be a minimal
-/// integer that is greater than or equal to \p Value and equal to
-/// \p Align * N + \p Skew for some integer N. If \p Skew is larger than
-/// \p Align, its value is adjusted to '\p Skew mod \p Align'.
-///
-/// Examples:
-/// \code
-///   alignTo(5, 8) = 8
-///   alignTo(17, 8) = 24
-///   alignTo(~0LL, 8) = 0
-///   alignTo(321, 255) = 510
-///
-///   alignTo(5, 8, 7) = 7
-///   alignTo(17, 8, 1) = 17
-///   alignTo(~0LL, 8, 3) = 3
-///   alignTo(321, 255, 42) = 552
-/// \endcode
-inline uint64_t alignTo(uint64_t Value, uint64_t Align, uint64_t Skew = 0) {
-  assert(Align != 0u && "Align can't be 0.");
-  Skew %= Align;
-  return (Value + Align - 1 - Skew) / Align * Align + Skew;
-}
-
-/// Returns the next integer (mod 2**64) that is greater than or equal to
-/// \p Value and is a multiple of \c Align. \c Align must be non-zero.
-template <uint64_t Align> constexpr inline uint64_t alignTo(uint64_t Value) {
-  static_assert(Align != 0u, "Align must be non-zero");
-  return (Value + Align - 1) / Align * Align;
-}
-
-/// Returns the integer ceil(Numerator / Denominator).
-inline uint64_t divideCeil(uint64_t Numerator, uint64_t Denominator) {
-  return alignTo(Numerator, Denominator) / Denominator;
-}
-
-/// Returns the largest uint64_t less than or equal to \p Value and is
-/// \p Skew mod \p Align. \p Align must be non-zero
-inline uint64_t alignDown(uint64_t Value, uint64_t Align, uint64_t Skew = 0) {
-  assert(Align != 0u && "Align can't be 0.");
-  Skew %= Align;
-  return (Value - Skew) / Align * Align + Skew;
-}
-
-/// Sign-extend the number in the bottom B bits of X to a 32-bit integer.
-/// Requires 0 < B <= 32.
-template <unsigned B> constexpr inline int32_t SignExtend32(uint32_t X) {
-  static_assert(B > 0, "Bit width can't be 0.");
-  static_assert(B <= 32, "Bit width out of range.");
-  return int32_t(X << (32 - B)) >> (32 - B);
-}
-
-/// Sign-extend the number in the bottom B bits of X to a 32-bit integer.
-/// Requires 0 < B < 32.
-inline int32_t SignExtend32(uint32_t X, unsigned B) {
-  assert(B > 0 && "Bit width can't be 0.");
-  assert(B <= 32 && "Bit width out of range.");
-  return int32_t(X << (32 - B)) >> (32 - B);
-}
-
-/// Sign-extend the number in the bottom B bits of X to a 64-bit integer.
-/// Requires 0 < B < 64.
-template <unsigned B> constexpr inline int64_t SignExtend64(uint64_t x) {
-  static_assert(B > 0, "Bit width can't be 0.");
-  static_assert(B <= 64, "Bit width out of range.");
-  return int64_t(x << (64 - B)) >> (64 - B);
-}
-
-/// Sign-extend the number in the bottom B bits of X to a 64-bit integer.
-/// Requires 0 < B < 64.
-inline int64_t SignExtend64(uint64_t X, unsigned B) {
-  assert(B > 0 && "Bit width can't be 0.");
-  assert(B <= 64 && "Bit width out of range.");
-  return int64_t(X << (64 - B)) >> (64 - B);
-}
-
-/// Subtract two unsigned integers, X and Y, of type T and return the absolute
-/// value of the result.
-template <typename T>
-typename std::enable_if<std::is_unsigned<T>::value, T>::type
-AbsoluteDifference(T X, T Y) {
-  return std::max(X, Y) - std::min(X, Y);
-}
-
-/// Add two unsigned integers, X and Y, of type T.  Clamp the result to the
-/// maximum representable value of T on overflow.  ResultOverflowed indicates if
-/// the result is larger than the maximum representable value of type T.
-template <typename T>
-typename std::enable_if<std::is_unsigned<T>::value, T>::type
-SaturatingAdd(T X, T Y, bool *ResultOverflowed = nullptr) {
-  bool Dummy;
-  bool &Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy;
-  // Hacker's Delight, p. 29
-  T Z = X + Y;
-  Overflowed = (Z < X || Z < Y);
-  if (Overflowed)
-    return std::numeric_limits<T>::max();
-  else
-    return Z;
-}
-
-/// Multiply two unsigned integers, X and Y, of type T.  Clamp the result to the
-/// maximum representable value of T on overflow.  ResultOverflowed indicates if
-/// the result is larger than the maximum representable value of type T.
-template <typename T>
-typename std::enable_if<std::is_unsigned<T>::value, T>::type
-SaturatingMultiply(T X, T Y, bool *ResultOverflowed = nullptr) {
-  bool Dummy;
-  bool &Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy;
-
-  // Hacker's Delight, p. 30 has a different algorithm, but we don't use that
-  // because it fails for uint16_t (where multiplication can have undefined
-  // behavior due to promotion to int), and requires a division in addition
-  // to the multiplication.
-
-  Overflowed = false;
-
-  // Log2(Z) would be either Log2Z or Log2Z + 1.
-  // Special case: if X or Y is 0, Log2_64 gives -1, and Log2Z
-  // will necessarily be less than Log2Max as desired.
-  int Log2Z = Log2_64(X) + Log2_64(Y);
-  const T Max = std::numeric_limits<T>::max();
-  int Log2Max = Log2_64(Max);
-  if (Log2Z < Log2Max) {
-    return X * Y;
-  }
-  if (Log2Z > Log2Max) {
-    Overflowed = true;
-    return Max;
-  }
-
-  // We're going to use the top bit, and maybe overflow one
-  // bit past it. Multiply all but the bottom bit then add
-  // that on at the end.
-  T Z = (X >> 1) * Y;
-  if (Z & ~(Max >> 1)) {
-    Overflowed = true;
-    return Max;
-  }
-  Z <<= 1;
-  if (X & 1)
-    return SaturatingAdd(Z, Y, ResultOverflowed);
-
-  return Z;
-}
-
-/// Multiply two unsigned integers, X and Y, and add the unsigned integer, A to
-/// the product. Clamp the result to the maximum representable value of T on
-/// overflow. ResultOverflowed indicates if the result is larger than the
-/// maximum representable value of type T.
-template <typename T>
-typename std::enable_if<std::is_unsigned<T>::value, T>::type
-SaturatingMultiplyAdd(T X, T Y, T A, bool *ResultOverflowed = nullptr) {
-  bool Dummy;
-  bool &Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy;
-
-  T Product = SaturatingMultiply(X, Y, &Overflowed);
-  if (Overflowed)
-    return Product;
-
-  return SaturatingAdd(A, Product, &Overflowed);
-}
-
-/// Use this rather than HUGE_VALF; the latter causes warnings on MSVC.
-extern const float huge_valf;
-
-
-/// Add two signed integers, computing the two's complement truncated result,
-/// returning true if overflow occured.
-template <typename T>
-typename std::enable_if<std::is_signed<T>::value, T>::type
-AddOverflow(T X, T Y, T &Result) {
-#if __has_builtin(__builtin_add_overflow)
-  return __builtin_add_overflow(X, Y, &Result);
-#else
-  // Perform the unsigned addition.
-  using U = typename std::make_unsigned<T>::type;
-  const U UX = static_cast<U>(X);
-  const U UY = static_cast<U>(Y);
-  const U UResult = UX + UY;
-
-  // Convert to signed.
-  Result = static_cast<T>(UResult);
-
-  // Adding two positive numbers should result in a positive number.
-  if (X > 0 && Y > 0)
-    return Result <= 0;
-  // Adding two negatives should result in a negative number.
-  if (X < 0 && Y < 0)
-    return Result >= 0;
-  return false;
-#endif
-}
-
-/// Subtract two signed integers, computing the two's complement truncated
-/// result, returning true if an overflow ocurred.
-template <typename T>
-typename std::enable_if<std::is_signed<T>::value, T>::type
-SubOverflow(T X, T Y, T &Result) {
-#if __has_builtin(__builtin_sub_overflow)
-  return __builtin_sub_overflow(X, Y, &Result);
-#else
-  // Perform the unsigned addition.
-  using U = typename std::make_unsigned<T>::type;
-  const U UX = static_cast<U>(X);
-  const U UY = static_cast<U>(Y);
-  const U UResult = UX - UY;
-
-  // Convert to signed.
-  Result = static_cast<T>(UResult);
-
-  // Subtracting a positive number from a negative results in a negative number.
-  if (X <= 0 && Y > 0)
-    return Result >= 0;
-  // Subtracting a negative number from a positive results in a positive number.
-  if (X >= 0 && Y < 0)
-    return Result <= 0;
-  return false;
-#endif
-}
-
-
-/// Multiply two signed integers, computing the two's complement truncated
-/// result, returning true if an overflow ocurred.
-template <typename T>
-typename std::enable_if<std::is_signed<T>::value, T>::type
-MulOverflow(T X, T Y, T &Result) {
-  // Perform the unsigned multiplication on absolute values.
-  using U = typename std::make_unsigned<T>::type;
-  const U UX = X < 0 ? (0 - static_cast<U>(X)) : static_cast<U>(X);
-  const U UY = Y < 0 ? (0 - static_cast<U>(Y)) : static_cast<U>(Y);
-  const U UResult = UX * UY;
-
-  // Convert to signed.
-  const bool IsNegative = (X < 0) ^ (Y < 0);
-  Result = IsNegative ? (0 - UResult) : UResult;
-
-  // If any of the args was 0, result is 0 and no overflow occurs.
-  if (UX == 0 || UY == 0)
-    return false;
-
-  // UX and UY are in [1, 2^n], where n is the number of digits.
-  // Check how the max allowed absolute value (2^n for negative, 2^(n-1) for
-  // positive) divided by an argument compares to the other.
-  if (IsNegative)
-    return UX > (static_cast<U>(std::numeric_limits<T>::max()) + U(1)) / UY;
-  else
-    return UX > (static_cast<U>(std::numeric_limits<T>::max())) / UY;
-}
-
-} // End llvm namespace
-} // End opencombine namespace
-
-#endif

Sources/COpenCombineHelpers/llvm/Support/SwapByteOrder.h

@@ -1,166 +0,0 @@
-//===- SwapByteOrder.h - Generic and optimized byte swaps -------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file declares generic and optimized functions to swap the byte order of
-// an integral type.
-//
-//===----------------------------------------------------------------------===//
-
-// MODIFICATION NOTE:
-// This file has been modified for the OpenCombine open source project.
-// - The llvm namespace is wrapped in the opencombine namespace.
-
-#ifndef OPENCOMBINE_LLVM_SUPPORT_SWAPBYTEORDER_H
-#define OPENCOMBINE_LLVM_SUPPORT_SWAPBYTEORDER_H
-
-#include "llvm/Support/Compiler.h"
-#include "llvm/Support/DataTypes.h"
-#include <cstddef>
-#include <type_traits>
-#if defined(_MSC_VER) && !defined(_DEBUG)
-#include <stdlib.h>
-#endif
-
-#if defined(__linux__) || defined(__GNU__) || defined(__HAIKU__)
-#include <endian.h>
-#elif defined(_AIX)
-#include <sys/machine.h>
-#elif defined(__sun)
-/* Solaris provides _BIG_ENDIAN/_LITTLE_ENDIAN selector in sys/types.h */
-#include <sys/types.h>
-#define BIG_ENDIAN 4321
-#define LITTLE_ENDIAN 1234
-#if defined(_BIG_ENDIAN)
-#define BYTE_ORDER BIG_ENDIAN
-#else
-#define BYTE_ORDER LITTLE_ENDIAN
-#endif
-#else
-#if !defined(BYTE_ORDER) && !defined(_WIN32)
-#include <machine/endian.h>
-#endif
-#endif
-
-namespace opencombine {
-namespace llvm {
-namespace sys {
-
-#if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN
-constexpr bool IsBigEndianHost = true;
-#else
-constexpr bool IsBigEndianHost = false;
-#endif
-
-static const bool IsLittleEndianHost = !IsBigEndianHost;
-
-/// SwapByteOrder_16 - This function returns a byte-swapped representation of
-/// the 16-bit argument.
-inline uint16_t SwapByteOrder_16(uint16_t value) {
-#if defined(_MSC_VER) && !defined(_DEBUG)
-  // The DLL version of the runtime lacks these functions (bug!?), but in a
-  // release build they're replaced with BSWAP instructions anyway.
-  return _byteswap_ushort(value);
-#else
-  uint16_t Hi = value << 8;
-  uint16_t Lo = value >> 8;
-  return Hi | Lo;
-#endif
-}
-
-/// This function returns a byte-swapped representation of the 32-bit argument.
-inline uint32_t SwapByteOrder_32(uint32_t value) {
-#if defined(__llvm__) || (defined(__GNUC__) && !defined(__ICC))
-  return __builtin_bswap32(value);
-#elif defined(_MSC_VER) && !defined(_DEBUG)
-  return _byteswap_ulong(value);
-#else
-  uint32_t Byte0 = value & 0x000000FF;
-  uint32_t Byte1 = value & 0x0000FF00;
-  uint32_t Byte2 = value & 0x00FF0000;
-  uint32_t Byte3 = value & 0xFF000000;
-  return (Byte0 << 24) | (Byte1 << 8) | (Byte2 >> 8) | (Byte3 >> 24);
-#endif
-}
-
-/// This function returns a byte-swapped representation of the 64-bit argument.
-inline uint64_t SwapByteOrder_64(uint64_t value) {
-#if defined(__llvm__) || (defined(__GNUC__) && !defined(__ICC))
-  return __builtin_bswap64(value);
-#elif defined(_MSC_VER) && !defined(_DEBUG)
-  return _byteswap_uint64(value);
-#else
-  uint64_t Hi = SwapByteOrder_32(uint32_t(value));
-  uint32_t Lo = SwapByteOrder_32(uint32_t(value >> 32));
-  return (Hi << 32) | Lo;
-#endif
-}
-
-inline unsigned char  getSwappedBytes(unsigned char C) { return C; }
-inline   signed char  getSwappedBytes(signed char C) { return C; }
-inline          char  getSwappedBytes(char C) { return C; }
-
-inline unsigned short getSwappedBytes(unsigned short C) { return SwapByteOrder_16(C); }
-inline   signed short getSwappedBytes(  signed short C) { return SwapByteOrder_16(C); }
-
-inline unsigned int   getSwappedBytes(unsigned int   C) { return SwapByteOrder_32(C); }
-inline   signed int   getSwappedBytes(  signed int   C) { return SwapByteOrder_32(C); }
-
-#if __LONG_MAX__ == __INT_MAX__
-inline unsigned long  getSwappedBytes(unsigned long  C) { return SwapByteOrder_32(C); }
-inline   signed long  getSwappedBytes(  signed long  C) { return SwapByteOrder_32(C); }
-#elif __LONG_MAX__ == __LONG_LONG_MAX__
-inline unsigned long  getSwappedBytes(unsigned long  C) { return SwapByteOrder_64(C); }
-inline   signed long  getSwappedBytes(  signed long  C) { return SwapByteOrder_64(C); }
-#else
-#error "Unknown long size!"
-#endif
-
-inline unsigned long long getSwappedBytes(unsigned long long C) {
-  return SwapByteOrder_64(C);
-}
-inline signed long long getSwappedBytes(signed long long C) {
-  return SwapByteOrder_64(C);
-}
-
-inline float getSwappedBytes(float C) {
-  union {
-    uint32_t i;
-    float f;
-  } in, out;
-  in.f = C;
-  out.i = SwapByteOrder_32(in.i);
-  return out.f;
-}
-
-inline double getSwappedBytes(double C) {
-  union {
-    uint64_t i;
-    double d;
-  } in, out;
-  in.d = C;
-  out.i = SwapByteOrder_64(in.i);
-  return out.d;
-}
-
-template <typename T>
-inline typename std::enable_if<std::is_enum<T>::value, T>::type
-getSwappedBytes(T C) {
-  return static_cast<T>(
-      getSwappedBytes(static_cast<typename std::underlying_type<T>::type>(C)));
-}
-
-template<typename T>
-inline void swapByteOrder(T &Value) {
-  Value = getSwappedBytes(Value);
-}
-
-} // end namespace sys
-} // end namespace llvm
-} // end namespace opencombine
-
-#endif

Sources/COpenCombineHelpers/llvm/Support/type_traits.h

@@ -1,198 +0,0 @@
-//===- llvm/Support/type_traits.h - Simplfied type traits -------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file provides useful additions to the standard type_traits library.
-//
-//===----------------------------------------------------------------------===//
-
-// MODIFICATION NOTE:
-// This file has been modified for the OpenCombine open source project.
-// - The llvm namespace is wrapped in the opencombine namespace.
-
-#ifndef OPENCOMBINE_LLVM_SUPPORT_TYPE_TRAITS_H
-#define OPENCOMBINE_LLVM_SUPPORT_TYPE_TRAITS_H
-
-#include "llvm/Support/Compiler.h"
-#include <type_traits>
-#include <utility>
-
-namespace opencombine {
-namespace llvm {
-
-
-/// Metafunction that determines whether the given type is either an
-/// integral type or an enumeration type, including enum classes.
-///
-/// Note that this accepts potentially more integral types than is_integral
-/// because it is based on being implicitly convertible to an integral type.
-/// Also note that enum classes aren't implicitly convertible to integral types,
-/// the value may therefore need to be explicitly converted before being used.
-template <typename T> class is_integral_or_enum {
-  using UnderlyingT = typename std::remove_reference<T>::type;
-
-public:
-  static const bool value =
-      !std::is_class<UnderlyingT>::value && // Filter conversion operators.
-      !std::is_pointer<UnderlyingT>::value &&
-      !std::is_floating_point<UnderlyingT>::value &&
-      (std::is_enum<UnderlyingT>::value ||
-       std::is_convertible<UnderlyingT, unsigned long long>::value);
-};
-
-/// If T is a pointer, just return it. If it is not, return T&.
-template<typename T, typename Enable = void>
-struct add_lvalue_reference_if_not_pointer { using type = T &; };
-
-template <typename T>
-struct add_lvalue_reference_if_not_pointer<
-    T, typename std::enable_if<std::is_pointer<T>::value>::type> {
-  using type = T;
-};
-
-/// If T is a pointer to X, return a pointer to const X. If it is not,
-/// return const T.
-template<typename T, typename Enable = void>
-struct add_const_past_pointer { using type = const T; };
-
-template <typename T>
-struct add_const_past_pointer<
-    T, typename std::enable_if<std::is_pointer<T>::value>::type> {
-  using type = const typename std::remove_pointer<T>::type *;
-};
-
-template <typename T, typename Enable = void>
-struct const_pointer_or_const_ref {
-  using type = const T &;
-};
-template <typename T>
-struct const_pointer_or_const_ref<
-    T, typename std::enable_if<std::is_pointer<T>::value>::type> {
-  using type = typename add_const_past_pointer<T>::type;
-};
-
-namespace detail {
-/// Internal utility to detect trivial copy construction.
-template<typename T> union copy_construction_triviality_helper {
-    T t;
-    copy_construction_triviality_helper() = default;
-    copy_construction_triviality_helper(const copy_construction_triviality_helper&) = default;
-    ~copy_construction_triviality_helper() = default;
-};
-/// Internal utility to detect trivial move construction.
-template<typename T> union move_construction_triviality_helper {
-    T t;
-    move_construction_triviality_helper() = default;
-    move_construction_triviality_helper(move_construction_triviality_helper&&) = default;
-    ~move_construction_triviality_helper() = default;
-};
-
-template<class T>
-union trivial_helper {
-    T t;
-};
-
-} // end namespace detail
-
-/// An implementation of `std::is_trivially_copy_constructible` since we have
-/// users with STLs that don't yet include it.
-template <typename T>
-struct is_trivially_copy_constructible
-    : std::is_copy_constructible<
-          ::opencombine::llvm::detail::copy_construction_triviality_helper<T>> {};
-template <typename T>
-struct is_trivially_copy_constructible<T &> : std::true_type {};
-template <typename T>
-struct is_trivially_copy_constructible<T &&> : std::false_type {};
-
-/// An implementation of `std::is_trivially_move_constructible` since we have
-/// users with STLs that don't yet include it.
-template <typename T>
-struct is_trivially_move_constructible
-    : std::is_move_constructible<
-          ::opencombine::llvm::detail::move_construction_triviality_helper<T>> {};
-template <typename T>
-struct is_trivially_move_constructible<T &> : std::true_type {};
-template <typename T>
-struct is_trivially_move_constructible<T &&> : std::true_type {};
-
-
-template <typename T>
-struct is_copy_assignable {
-  template<class F>
-    static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
-    static std::false_type get(...);
-    static constexpr bool value = decltype(get((T*)nullptr))::value;
-};
-
-template <typename T>
-struct is_move_assignable {
-  template<class F>
-    static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
-    static std::false_type get(...);
-    static constexpr bool value = decltype(get((T*)nullptr))::value;
-};
-
-
-// An implementation of `std::is_trivially_copyable` since STL version
-// is not equally supported by all compilers, especially GCC 4.9.
-// Uniform implementation of this trait is important for ABI compatibility
-// as it has an impact on SmallVector's ABI (among others).
-template <typename T>
-class is_trivially_copyable {
-
-  // copy constructors
-  static constexpr bool has_trivial_copy_constructor =
-      std::is_copy_constructible<detail::trivial_helper<T>>::value;
-  static constexpr bool has_deleted_copy_constructor =
-      !std::is_copy_constructible<T>::value;
-
-  // move constructors
-  static constexpr bool has_trivial_move_constructor =
-      std::is_move_constructible<detail::trivial_helper<T>>::value;
-  static constexpr bool has_deleted_move_constructor =
-      !std::is_move_constructible<T>::value;
-
-  // copy assign
-  static constexpr bool has_trivial_copy_assign =
-      is_copy_assignable<detail::trivial_helper<T>>::value;
-  static constexpr bool has_deleted_copy_assign =
-      !is_copy_assignable<T>::value;
-
-  // move assign
-  static constexpr bool has_trivial_move_assign =
-      is_move_assignable<detail::trivial_helper<T>>::value;
-  static constexpr bool has_deleted_move_assign =
-      !is_move_assignable<T>::value;
-
-  // destructor
-  static constexpr bool has_trivial_destructor =
-      std::is_destructible<detail::trivial_helper<T>>::value;
-
-  public:
-
-  static constexpr bool value =
-      has_trivial_destructor &&
-      (has_deleted_move_assign || has_trivial_move_assign) &&
-      (has_deleted_move_constructor || has_trivial_move_constructor) &&
-      (has_deleted_copy_assign || has_trivial_copy_assign) &&
-      (has_deleted_copy_constructor || has_trivial_copy_constructor);
-
-#ifdef HAVE_STD_IS_TRIVIALLY_COPYABLE
-  static_assert(value == std::is_trivially_copyable<T>::value,
-                "inconsistent behavior between llvm:: and std:: implementation of is_trivially_copyable");
-#endif
-};
-template <typename T>
-class is_trivially_copyable<T*> : public std::true_type {
-};
-
-
-} // end namespace llvm
-} // end namespace opencombine
-
-#endif // OPENCOMBINE_LLVM_SUPPORT_TYPE_TRAITS_H

Sources/COpenCombineHelpers/stl_polyfill/span.h

@@ -1,78 +0,0 @@
-//
-//  span.h
-//  
-//
-//  Created by Sergej Jaskiewicz on 30.10.2019.
-//
-
-#ifndef OPENCOMBINE_SPAN_H
-#define OPENCOMBINE_SPAN_H
-
-#include <cstddef>
-#include <type_traits>
-#include <iterator>
-
-namespace opencombine {
-
-// This is a very simplified implementation of std::span from C++20.
-// Not all compilers support it yet.
-template <typename T>
-class span {
-public:
-    using element_type = T;
-    using value_type = std::remove_cv<T>;
-    using index_type = size_t;
-    using differenc_type = ptrdiff_t;
-    using pointer = T*;
-    using const_pointer = const T*;
-    using reference = T&;
-    using const_reference = const T&;
-    using iterator = T*;
-    using const_iterator = const T*;
-    using reverse_iterator = std::reverse_iterator<iterator>;
-    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-
-    constexpr span() noexcept: data_(nullptr), size_(0) {}
-    constexpr span(pointer ptr, index_type count): data_(ptr), size_(count) {}
-    constexpr span(pointer first, pointer last): span(first, last - first) {}
-    constexpr span(const span& other) noexcept = default;
-
-    constexpr span& operator=(const span& other) noexcept = default;
-
-    constexpr const_reference operator[](index_type index) const noexcept {
-        assert(index < size_);
-        return data_[index];
-    }
-
-    constexpr reference operator[](index_type index) noexcept {
-        assert(index < size_);
-        return data_[index];
-    }
-
-    const_pointer data() const noexcept { return data_; }
-
-    pointer data() noexcept { return data_; }
-
-    index_type size() const noexcept { return size_; }
-
-    const_iterator begin() const noexcept { return data_; }
-    iterator begin() noexcept { return data_; }
-
-    const_iterator end() const noexcept { return data_ + size_; }
-    iterator end() noexcept { return data_ + size_; }
-
-    bool operator==(const span& other) const {
-        return size_ == other.size_ && std::equal(begin(), end(), other.begin());
-    }
-
-    bool operator!=(const span& other) const {
-        return !operator==(other);
-    }
-private:
-    pointer data_;
-    index_type size_;
-};
-
-} // end namespace opencombine
-
-#endif /* OPENCOMBINE_SPAN_H */

Sources/COpenCombineHelpers/stl_polyfill/string_view.h

@@ -1,56 +0,0 @@
-//
-//  string_view.h
-//  
-//
-//  Created by Sergej Jaskiewicz on 31.10.2019.
-//
-
-#ifndef OPENCOMBINE_STRING_VIEW_H
-#define OPENCOMBINE_STRING_VIEW_H
-
-#include <iterator>
-#include <cstddef>
-#include <cstring>
-
-namespace opencombine {
-
-// This is a very simplified implementation of std::string_view from C++17.
-// Not all compilers support it yet.
-struct string_view {
-    using traits_type = void;
-    using value_type = char;
-    using pointer = char*;
-    using const_pointer = const char*;
-    using reference = char&;
-    using const_reference = const char&;
-    using const_iterator = const char*;
-    using iterator = const_iterator;
-    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-    using reverse_iterator = const_reverse_iterator;
-    using size_type = size_t;
-    using difference_type = ptrdiff_t;
-
-    string_view() noexcept : string_view(nullptr, 0) {}
-    string_view(const string_view& other) noexcept = default;
-    string_view(const char* data, size_type size) : data_(data), size_(size) {}
-    string_view(const char* data) : string_view(data, strlen(data)) {}
-
-    string_view& operator=(const string_view& view) noexcept = default;
-
-    const_pointer data() const noexcept { return data_; }
-
-    constexpr size_type size() const noexcept { return size_; }
-
-    const_iterator begin() const noexcept { return data_; }
-    iterator begin() noexcept { return data_; }
-
-    const_iterator end() const noexcept { return data_ + size_; }
-    iterator end() noexcept { return data_ + size_; }
-private:
-    const_pointer data_;
-    size_type size_;
-};
-
-} // end namespace opencombine
-
-#endif /* OPENCOMBINE_STRING_VIEW_H */

Sources/COpenCombineHelpers/swift/ABI/MetadataKind.def

@@ -1,93 +0,0 @@
-//===--- MetadataKind.def ---------------------------------------*- C++ -*-===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
-//
-//===----------------------------------------------------------------------===//
-//
-// This is a file that enables metaprogramming with metadata kinds.
-//
-//===----------------------------------------------------------------------===//
-
-/// METADATAKIND(Name, Value)
-///   Represents a swift native runtime metadata kind. Name is the Name of the
-///   metadata kind and Value is the integral value used to identify the value.
-#ifndef METADATAKIND
-#define METADATAKIND(Name, Value)
-#endif
-
-/// ABSTRACTMETADATAKIND(Name, Start, End)
-///   Represents an abstraction categorization of a range of metadata kind
-///   values. Name is the identifier of the range and Start, End are the
-///   beginning and end of the range.
-#ifndef ABSTRACTMETADATAKIND
-#define ABSTRACTMETADATAKIND(Name, Start, End)
-#endif
-
-/// NOMINALTYPEMETADATAKIND(Name, Value)
-///   Represents the native metadata kind for a swift nominal type. Name is the
-///   name of the kind and Value is the integral value used to identify the
-///   value. Delegates to METADATAKIND if not defined.
-#ifndef NOMINALTYPEMETADATAKIND
-#define NOMINALTYPEMETADATAKIND(Name, Value) METADATAKIND(Name, Value)
-#endif
-
-/// A class type.
-NOMINALTYPEMETADATAKIND(Class, 0)
-
-/// A struct type.
-NOMINALTYPEMETADATAKIND(Struct, 0 | MetadataKindIsNonHeap)
-
-/// An enum type.
-/// If we add reference enums, that needs to go here.
-NOMINALTYPEMETADATAKIND(Enum, 1 | MetadataKindIsNonHeap)
-
-/// An optional type.
-NOMINALTYPEMETADATAKIND(Optional, 2 | MetadataKindIsNonHeap)
-
-/// A foreign class, such as a Core Foundation class.
-METADATAKIND(ForeignClass, 3 | MetadataKindIsNonHeap)
-
-/// A type whose value is not exposed in the metadata system.
-METADATAKIND(Opaque, 0 | MetadataKindIsRuntimePrivate | MetadataKindIsNonHeap)
-
-/// A tuple.
-METADATAKIND(Tuple, 1 | MetadataKindIsRuntimePrivate | MetadataKindIsNonHeap)
-
-/// A monomorphic function.
-METADATAKIND(Function, 2 | MetadataKindIsRuntimePrivate | MetadataKindIsNonHeap)
-
-/// An existential type.
-METADATAKIND(Existential, 3 | MetadataKindIsRuntimePrivate | MetadataKindIsNonHeap)
-
-/// A metatype.
-METADATAKIND(Metatype, 4 | MetadataKindIsRuntimePrivate | MetadataKindIsNonHeap)
-
-/// An ObjC class wrapper.
-METADATAKIND(ObjCClassWrapper, 5 | MetadataKindIsRuntimePrivate | MetadataKindIsNonHeap)
-
-/// An existential metatype.
-METADATAKIND(ExistentialMetatype, 6 | MetadataKindIsRuntimePrivate | MetadataKindIsNonHeap)
-
-/// A heap-allocated local variable using statically-generated metadata.
-METADATAKIND(HeapLocalVariable, 0 | MetadataKindIsNonType)
-
-/// A heap-allocated local variable using runtime-instantiated metadata.
-METADATAKIND(HeapGenericLocalVariable,
-             0 | MetadataKindIsNonType | MetadataKindIsRuntimePrivate)
-
-/// A native error object.
-METADATAKIND(ErrorObject,
-             1 | MetadataKindIsNonType | MetadataKindIsRuntimePrivate)
-
-// getEnumeratedMetadataKind assumes that all the enumerated values here
-// will be <= LastEnumeratedMetadataKind.
-
-#undef ABSTRACTMETADATAKIND
-#undef NOMINALTYPEMETADATAKIND
-#undef METADATAKIND

Sources/COpenCombineHelpers/swift/ABI/TrailingObjects.h

@@ -1,395 +0,0 @@
-//===--- TrailingObjects.h - Variable-length, Swift-ABI classes -*- C++ -*-===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// This header is a fork of the LLVM TrailingObjects template. It has the
-/// additional constraint over llvm::TrailingObjects of having to maintain ABI
-/// stability across versions. The following documentation is copied from
-/// the original TrailingObjects implementation:
-///
-/// This header defines support for implementing classes that have
-/// some trailing object (or arrays of objects) appended to them. The
-/// main purpose is to make it obvious where this idiom is being used,
-/// and to make the usage more idiomatic and more difficult to get
-/// wrong.
-///
-/// The TrailingObject template abstracts away the reinterpret_cast,
-/// pointer arithmetic, and size calculations used for the allocation
-/// and access of appended arrays of objects, and takes care that they
-/// are all allocated at their required alignment. Additionally, it
-/// ensures that the base type is final -- deriving from a class that
-/// expects data appended immediately after it is typically not safe.
-///
-/// Users are expected to derive from this template, and provide
-/// numTrailingObjects implementations for each trailing type except
-/// the last, e.g. like this sample:
-///
-/// \code
-/// class VarLengthObj : private TrailingObjects<VarLengthObj, int, double> {
-///   friend TrailingObjects;
-///
-///   unsigned NumInts, NumDoubles;
-///   size_t numTrailingObjects(OverloadToken<int>) const { return NumInts; }
-///  };
-/// \endcode
-///
-/// You can access the appended arrays via 'getTrailingObjects', and
-/// determine the size needed for allocation via
-/// 'additionalSizeToAlloc' and 'totalSizeToAlloc'.
-///
-/// All the methods implemented by this class are are intended for use
-/// by the implementation of the class, not as part of its interface
-/// (thus, private inheritance is suggested).
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef OPENCOMBINE_TRAILINGOBJECTS_H
-#define OPENCOMBINE_TRAILINGOBJECTS_H
-
-#include "llvm/Support/AlignOf.h"
-#include "llvm/Support/Alignment.h"
-#include "llvm/Support/Compiler.h"
-#include "llvm/Support/MathExtras.h"
-#include "llvm/Support/type_traits.h"
-#include <new>
-#include <type_traits>
-
-namespace opencombine {
-namespace swift {
-namespace ABI {
-
-namespace trailing_objects_internal {
-/// Helper template to calculate the max alignment requirement for a set of
-/// objects.
-template <typename First, typename... Rest> class AlignmentCalcHelper {
-private:
-  enum {
-    FirstAlignment = alignof(First),
-    RestAlignment = AlignmentCalcHelper<Rest...>::Alignment,
-  };
-
-public:
-  enum {
-    Alignment = FirstAlignment > RestAlignment ? FirstAlignment : RestAlignment
-  };
-};
-
-template <typename First> class AlignmentCalcHelper<First> {
-public:
-  enum { Alignment = alignof(First) };
-};
-
-/// The base class for TrailingObjects* classes.
-class TrailingObjectsBase {
-protected:
-  /// OverloadToken's purpose is to allow specifying function overloads
-  /// for different types, without actually taking the types as
-  /// parameters. (Necessary because member function templates cannot
-  /// be specialized, so overloads must be used instead of
-  /// specialization.)
-  template <typename T> struct OverloadToken {};
-};
-
-template <int Align>
-class TrailingObjectsAligner : public TrailingObjectsBase {};
-template <>
-class alignas(1) TrailingObjectsAligner<1> : public TrailingObjectsBase {};
-template <>
-class alignas(2) TrailingObjectsAligner<2> : public TrailingObjectsBase {};
-template <>
-class alignas(4) TrailingObjectsAligner<4> : public TrailingObjectsBase {};
-template <>
-class alignas(8) TrailingObjectsAligner<8> : public TrailingObjectsBase {};
-template <>
-class alignas(16) TrailingObjectsAligner<16> : public TrailingObjectsBase {};
-template <>
-class alignas(32) TrailingObjectsAligner<32> : public TrailingObjectsBase {};
-
-// Just a little helper for transforming a type pack into the same
-// number of a different type. e.g.:
-//   ExtractSecondType<Foo..., int>::type
-template <typename Ty1, typename Ty2> struct ExtractSecondType {
-  typedef Ty2 type;
-};
-
-// TrailingObjectsImpl is somewhat complicated, because it is a
-// recursively inheriting template, in order to handle the template
-// varargs. Each level of inheritance picks off a single trailing type
-// then recurses on the rest. The "Align", "BaseTy", and
-// "TopTrailingObj" arguments are passed through unchanged through the
-// recursion. "PrevTy" is, at each level, the type handled by the
-// level right above it.
-
-template <int Align, typename BaseTy, typename TopTrailingObj, typename PrevTy,
-          typename... MoreTys>
-class TrailingObjectsImpl {
-  // The main template definition is never used -- the two
-  // specializations cover all possibilities.
-};
-
-template <int Align, typename BaseTy, typename TopTrailingObj, typename PrevTy,
-          typename NextTy, typename... MoreTys>
-class TrailingObjectsImpl<Align, BaseTy, TopTrailingObj, PrevTy, NextTy,
-                          MoreTys...>
-    : public TrailingObjectsImpl<Align, BaseTy, TopTrailingObj, NextTy,
-                                 MoreTys...> {
-
-  typedef TrailingObjectsImpl<Align, BaseTy, TopTrailingObj, NextTy, MoreTys...>
-      ParentType;
-
-  struct RequiresRealignment {
-    static const bool value = alignof(PrevTy) < alignof(NextTy);
-  };
-
-  static constexpr bool requiresRealignment() {
-    return RequiresRealignment::value;
-  }
-
-protected:
-  // Ensure the inherited getTrailingObjectsImpl is not hidden.
-  using ParentType::getTrailingObjectsImpl;
-
-  // These two functions are helper functions for
-  // TrailingObjects::getTrailingObjects. They recurse to the left --
-  // the result for each type in the list of trailing types depends on
-  // the result of calling the function on the type to the
-  // left. However, the function for the type to the left is
-  // implemented by a *subclass* of this class, so we invoke it via
-  // the TopTrailingObj, which is, via the
-  // curiously-recurring-template-pattern, the most-derived type in
-  // this recursion, and thus, contains all the overloads.
-  static const NextTy *
-  getTrailingObjectsImpl(const BaseTy *Obj,
-                         TrailingObjectsBase::OverloadToken<NextTy>) {
-    auto *Ptr = TopTrailingObj::getTrailingObjectsImpl(
-                    Obj, TrailingObjectsBase::OverloadToken<PrevTy>()) +
-                TopTrailingObj::callNumTrailingObjects(
-                    Obj, TrailingObjectsBase::OverloadToken<PrevTy>());
-
-    if (requiresRealignment())
-      return reinterpret_cast<const NextTy *>(
-          llvm::alignAddr(Ptr, llvm::Align(alignof(NextTy))));
-    else
-      return reinterpret_cast<const NextTy *>(Ptr);
-  }
-
-  static NextTy *
-  getTrailingObjectsImpl(BaseTy *Obj,
-                         TrailingObjectsBase::OverloadToken<NextTy>) {
-    auto *Ptr = TopTrailingObj::getTrailingObjectsImpl(
-                    Obj, TrailingObjectsBase::OverloadToken<PrevTy>()) +
-                TopTrailingObj::callNumTrailingObjects(
-                    Obj, TrailingObjectsBase::OverloadToken<PrevTy>());
-
-    if (requiresRealignment())
-      return reinterpret_cast<NextTy *>(llvm::alignAddr(Ptr, alignof(NextTy)));
-    else
-      return reinterpret_cast<NextTy *>(Ptr);
-  }
-
-  // Helper function for TrailingObjects::additionalSizeToAlloc: this
-  // function recurses to superclasses, each of which requires one
-  // fewer size_t argument, and adds its own size.
-  static constexpr size_t additionalSizeToAllocImpl(
-      size_t SizeSoFar, size_t Count1,
-      typename ExtractSecondType<MoreTys, size_t>::type... MoreCounts) {
-    return ParentType::additionalSizeToAllocImpl(
-        (requiresRealignment() ? llvm::alignTo<alignof(NextTy)>(SizeSoFar)
-                               : SizeSoFar) +
-            sizeof(NextTy) * Count1,
-        MoreCounts...);
-  }
-};
-
-// The base case of the TrailingObjectsImpl inheritance recursion,
-// when there's no more trailing types.
-template <int Align, typename BaseTy, typename TopTrailingObj, typename PrevTy>
-class TrailingObjectsImpl<Align, BaseTy, TopTrailingObj, PrevTy>
-    : public TrailingObjectsAligner<Align> {
-protected:
-  // This is a dummy method, only here so the "using" doesn't fail --
-  // it will never be called, because this function recurses backwards
-  // up the inheritance chain to subclasses.
-  static void getTrailingObjectsImpl();
-
-  static constexpr size_t additionalSizeToAllocImpl(size_t SizeSoFar) {
-    return SizeSoFar;
-  }
-
-  template <bool CheckAlignment> static void verifyTrailingObjectsAlignment() {}
-};
-
-} // end namespace trailing_objects_internal
-
-// Finally, the main type defined in this file, the one intended for users...
-
-/// See the file comment for details on the usage of the
-/// TrailingObjects type.
-template <typename BaseTy, typename... TrailingTys>
-class TrailingObjects : private trailing_objects_internal::TrailingObjectsImpl<
-                            trailing_objects_internal::AlignmentCalcHelper<
-                                TrailingTys...>::Alignment,
-                            BaseTy, TrailingObjects<BaseTy, TrailingTys...>,
-                            BaseTy, TrailingTys...> {
-
-  template <int A, typename B, typename T, typename P, typename... M>
-  friend class trailing_objects_internal::TrailingObjectsImpl;
-
-  template <typename... Tys> class Foo {};
-
-  typedef trailing_objects_internal::TrailingObjectsImpl<
-      trailing_objects_internal::AlignmentCalcHelper<TrailingTys...>::Alignment,
-      BaseTy, TrailingObjects<BaseTy, TrailingTys...>, BaseTy, TrailingTys...>
-      ParentType;
-  using TrailingObjectsBase = trailing_objects_internal::TrailingObjectsBase;
-
-  using ParentType::getTrailingObjectsImpl;
-
-  // These two methods are the base of the recursion for this method.
-  static const BaseTy *
-  getTrailingObjectsImpl(const BaseTy *Obj,
-                         TrailingObjectsBase::OverloadToken<BaseTy>) {
-    return Obj;
-  }
-
-  static BaseTy *
-  getTrailingObjectsImpl(BaseTy *Obj,
-                         TrailingObjectsBase::OverloadToken<BaseTy>) {
-    return Obj;
-  }
-
-  // callNumTrailingObjects simply calls numTrailingObjects on the
-  // provided Obj -- except when the type being queried is BaseTy
-  // itself. There is always only one of the base object, so that case
-  // is handled here. (An additional benefit of indirecting through
-  // this function is that consumers only say "friend
-  // TrailingObjects", and thus, only this class itself can call the
-  // numTrailingObjects function.)
-  static size_t
-  callNumTrailingObjects(const BaseTy *Obj,
-                         TrailingObjectsBase::OverloadToken<BaseTy>) {
-    return 1;
-  }
-
-  template <typename T>
-  static size_t callNumTrailingObjects(const BaseTy *Obj,
-                                       TrailingObjectsBase::OverloadToken<T>) {
-    return Obj->numTrailingObjects(TrailingObjectsBase::OverloadToken<T>());
-  }
-
-public:
-  // Make this (privately inherited) member public.
-#ifndef _MSC_VER
-  using ParentType::OverloadToken;
-#else
-  // MSVC bug prevents the above from working, at least up through CL
-  // 19.10.24629.
-  template <typename T>
-  using OverloadToken = typename ParentType::template OverloadToken<T>;
-#endif
-
-  /// Returns a pointer to the trailing object array of the given type
-  /// (which must be one of those specified in the class template). The
-  /// array may have zero or more elements in it.
-  template <typename T> const T *getTrailingObjects() const {
-    // Forwards to an impl function with overloads, since member
-    // function templates can't be specialized.
-    return this->getTrailingObjectsImpl(
-        static_cast<const BaseTy *>(this),
-        TrailingObjectsBase::OverloadToken<T>());
-  }
-
-  /// Returns a pointer to the trailing object array of the given type
-  /// (which must be one of those specified in the class template). The
-  /// array may have zero or more elements in it.
-  template <typename T> T *getTrailingObjects() {
-    // Forwards to an impl function with overloads, since member
-    // function templates can't be specialized.
-    return this->getTrailingObjectsImpl(
-        static_cast<BaseTy *>(this), TrailingObjectsBase::OverloadToken<T>());
-  }
-
-  /// Returns the size of the trailing data, if an object were
-  /// allocated with the given counts (The counts are in the same order
-  /// as the template arguments). This does not include the size of the
-  /// base object.  The template arguments must be the same as those
-  /// used in the class; they are supplied here redundantly only so
-  /// that it's clear what the counts are counting in callers.
-  template <typename... Tys>
-  static constexpr typename std::enable_if<
-      std::is_same<Foo<TrailingTys...>, Foo<Tys...>>::value, size_t>::type
-  additionalSizeToAlloc(typename trailing_objects_internal::ExtractSecondType<
-                        TrailingTys, size_t>::type... Counts) {
-    return ParentType::additionalSizeToAllocImpl(0, Counts...);
-  }
-
-  /// Returns the total size of an object if it were allocated with the
-  /// given trailing object counts. This is the same as
-  /// additionalSizeToAlloc, except it *does* include the size of the base
-  /// object.
-  template <typename... Tys>
-  static constexpr typename std::enable_if<
-      std::is_same<Foo<TrailingTys...>, Foo<Tys...>>::value, size_t>::type
-  totalSizeToAlloc(typename trailing_objects_internal::ExtractSecondType<
-                   TrailingTys, size_t>::type... Counts) {
-    return sizeof(BaseTy) + ParentType::additionalSizeToAllocImpl(0, Counts...);
-  }
-
-  /// A type where its ::with_counts template member has a ::type member
-  /// suitable for use as uninitialized storage for an object with the given
-  /// trailing object counts. The template arguments are similar to those
-  /// of additionalSizeToAlloc.
-  ///
-  /// Use with FixedSizeStorageOwner, e.g.:
-  ///
-  /// \code{.cpp}
-  ///
-  /// MyObj::FixedSizeStorage<void *>::with_counts<1u>::type myStackObjStorage;
-  /// MyObj::FixedSizeStorageOwner
-  ///     myStackObjOwner(new ((void *)&myStackObjStorage) MyObj);
-  /// MyObj *const myStackObjPtr = myStackObjOwner.get();
-  ///
-  /// \endcode
-  template <typename... Tys> struct FixedSizeStorage {
-    template <size_t... Counts> struct with_counts {
-      enum { Size = totalSizeToAlloc<Tys...>(Counts...) };
-      using type = std::aligned_storage<Size, alignof(BaseTy)>;
-    };
-  };
-
-  /// A type that acts as the owner for an object placed into fixed storage.
-  class FixedSizeStorageOwner {
-  public:
-    FixedSizeStorageOwner(BaseTy *p) : p(p) {}
-    ~FixedSizeStorageOwner() {
-      assert(p && "FixedSizeStorageOwner owns null?");
-      p->~BaseTy();
-    }
-
-    BaseTy *get() { return p; }
-    const BaseTy *get() const { return p; }
-
-  private:
-    FixedSizeStorageOwner(const FixedSizeStorageOwner &) = delete;
-    FixedSizeStorageOwner(FixedSizeStorageOwner &&) = delete;
-    FixedSizeStorageOwner &operator=(const FixedSizeStorageOwner &) = delete;
-    FixedSizeStorageOwner &operator=(FixedSizeStorageOwner &&) = delete;
-
-    BaseTy *const p;
-  };
-};
-
-} // end namespace ABI
-} // end namespace swift
-} // end namespace opencombine
-
-#endif

Sources/COpenCombineHelpers/swift/ABI/ValueWitness.def

@@ -1,314 +0,0 @@
-//===--- ValueWitness.def - Value witness x-macros --------------*- C++ -*-===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
-//
-//===----------------------------------------------------------------------===//
-//
-// X-macro definition file for value witness tables.
-//
-//===----------------------------------------------------------------------===//
-
-// This file is "parameterized" in the sense that exactly one of the
-// following macros *must* be defined:
-
-/// WANT_ALL_VALUE_WITNESSES
-///   Define this to expand all value witnesses, not just the ones from
-///   a specific category.
-#if defined(WANT_ALL_VALUE_WITNESSES)
-#undef WANT_ALL_VALUE_WITNESSES
-#define WANT_REQUIRED_VALUE_WITNESSES         1
-#define WANT_ENUM_VALUE_WITNESSES             1
-
-/// WANT_ONLY_REQUIRED_VALUE_WITNESSES
-///   Define this to expand only the required value witnesses.
-#elif defined(WANT_ONLY_REQUIRED_VALUE_WITNESSES)
-#undef WANT_ONLY_REQUIRED_VALUE_WITNESSES
-#define WANT_REQUIRED_VALUE_WITNESSES         1
-#define WANT_ENUM_VALUE_WITNESSES             0
-
-/// WANT_ONLY_ENUM_VALUE_WITNESSES
-///   Define this to expand only the enum value witnesses.
-#elif  defined(WANT_ONLY_ENUM_VALUE_WITNESSES)
-#undef  WANT_ONLY_ENUM_VALUE_WITNESSES
-#define WANT_REQUIRED_VALUE_WITNESSES         0
-#define WANT_ENUM_VALUE_WITNESSES             1
-
-/// WANT_REQUIRED_VALUE_WITNESSES
-/// WANT_ENUM_VALUE_WITNESSES
-///   Define all of these to control exactly what to expand.
-#else
-#if !defined(WANT_REQUIRED_VALUE_WITNESSES) || !defined(WANT_ENUM_VALUE_WITNESSES)
-#error failed to define a WANT macro; possible typo?
-#endif
-#endif
-
-/// VALUE_WITNESS(lowerId, upperId)
-///   A fallback called for value witnesses if either of DATA_VALUE_WITNESS or
-///   FUNCTION_VALUE_WITNESS is not defined.
-
-/// FUNCTION_VALUE_WITNESS(lowerId, upperId, returnType, paramTypeList)
-///   A function value witness.  Types will be defined in terms of the
-///   following macros:
-///     MUTABLE_VALUE_TYPE - a pointer to a mutable opaque value
-///     IMMUTABLE_VALUE_TYPE - a pointer to an immutable opaque value
-///     MUTABLE_BUFFER_TYPE - a pointer to a fixed-size value buffer
-///     IMMUTABLE_BUFFER_TYPE - a pointer to an immutable fixed-size buffer
-///     TYPE_TYPE - a pointer to type metadata
-///     SIZE_TYPE - StoredSize
-///     INT_TYPE - int
-///     UINT_TYPE - unsigned int
-///     VOID_TYPE - void
-///   Defaults to VALUE_WITNESS.
-///   FIXME: The 'copy' witnesses should be using immutable types but aren't.
-#ifndef FUNCTION_VALUE_WITNESS
-#define FUNCTION_VALUE_WITNESS(lowerId, upperId, returnType, paramTypes) \
-  VALUE_WITNESS(lowerId, upperId)
-#endif
-
-/// DATA_VALUE_WITNESS(lowerId, upperId, type)
-///   A non-function value witness.  Types are specified as for
-///   FUNCTION_VALUE_WITNESS
-///   Defaults to VALUE_WITNESS.
-#ifndef DATA_VALUE_WITNESS
-#define DATA_VALUE_WITNESS(lowerId, upperId, type) \
-  VALUE_WITNESS(lowerId, upperId)
-#endif
-
-/// Begin a range of value witnesses.  This will be expanded immediately
-/// after the first value in the range, whose ID will be upperId.
-/// Range expansions do not interact well with the use of WANT_ONLY_*.
-#ifndef BEGIN_VALUE_WITNESS_RANGE
-#define BEGIN_VALUE_WITNESS_RANGE(rangeId, upperId)
-#endif
-
-/// End a range of value witnesses.  This will be expanded immediately
-/// after the last value in the range, whose ID will be upperId.
-/// Range expansions do not interact well with the use of WANT_ONLY_*.
-#ifndef END_VALUE_WITNESS_RANGE
-#define END_VALUE_WITNESS_RANGE(rangeId, upperId)
-#endif
-
-#if WANT_REQUIRED_VALUE_WITNESSES
-
-///   T *(*initializeBufferWithCopyOfBuffer)(B *dest, B *src, M *self);
-/// Given an invalid buffer, initialize it as a copy of the
-/// object in the source buffer.
-FUNCTION_VALUE_WITNESS(initializeBufferWithCopyOfBuffer,
-                       InitializeBufferWithCopyOfBuffer,
-                       MUTABLE_VALUE_TYPE,
-                       (MUTABLE_BUFFER_TYPE, MUTABLE_BUFFER_TYPE, TYPE_TYPE))
-
-BEGIN_VALUE_WITNESS_RANGE(ValueWitness,
-                          InitializeBufferWithCopyOfBuffer)
-BEGIN_VALUE_WITNESS_RANGE(RequiredValueWitness,
-                          InitializeBufferWithCopyOfBuffer)
-BEGIN_VALUE_WITNESS_RANGE(RequiredValueWitnessFunction,
-                          InitializeBufferWithCopyOfBuffer)
-
-///   void (*destroy)(T *object, witness_t *self);
-///
-/// Given a valid object of this type, destroy it, leaving it as an
-/// invalid object.  This is useful when generically destroying
-/// an object which has been allocated in-line, such as an array,
-/// struct, or tuple element.
-FUNCTION_VALUE_WITNESS(destroy,
-                       Destroy,
-                       VOID_TYPE,
-                       (MUTABLE_VALUE_TYPE, TYPE_TYPE))
-
-///   T *(*initializeWithCopy)(T *dest, T *src, M *self);
-///
-/// Given an invalid object of this type, initialize it as a copy of
-/// the source object.  Returns the dest object.
-FUNCTION_VALUE_WITNESS(initializeWithCopy,
-                       InitializeWithCopy,
-                       MUTABLE_VALUE_TYPE,
-                       (MUTABLE_VALUE_TYPE, MUTABLE_VALUE_TYPE, TYPE_TYPE))
-
-///   T *(*assignWithCopy)(T *dest, T *src, M *self);
-///
-/// Given a valid object of this type, change it to be a copy of the
-/// source object.  Returns the dest object.
-FUNCTION_VALUE_WITNESS(assignWithCopy,
-                       AssignWithCopy,
-                       MUTABLE_VALUE_TYPE,
-                       (MUTABLE_VALUE_TYPE, MUTABLE_VALUE_TYPE, TYPE_TYPE))
-
-///   T *(*initializeWithTake)(T *dest, T *src, M *self);
-///
-/// Given an invalid object of this type, initialize it by taking
-/// the value of the source object.  The source object becomes
-/// invalid.  Returns the dest object.
-FUNCTION_VALUE_WITNESS(initializeWithTake,
-                       InitializeWithTake,
-                       MUTABLE_VALUE_TYPE,
-                       (MUTABLE_VALUE_TYPE, MUTABLE_VALUE_TYPE, TYPE_TYPE))
-
-///   T *(*assignWithTake)(T *dest, T *src, M *self);
-///
-/// Given a valid object of this type, change it to be a copy of the
-/// source object.  The source object becomes invalid.  Returns the
-/// dest object.
-FUNCTION_VALUE_WITNESS(assignWithTake,
-                       AssignWithTake,
-                       MUTABLE_VALUE_TYPE,
-                       (MUTABLE_VALUE_TYPE, MUTABLE_VALUE_TYPE, TYPE_TYPE))
-
-/// unsigned (*getEnumTagSinglePayload)(const T* enum, UINT_TYPE emptyCases,
-///                                     M *self);
-/// Given an instance of valid single payload enum with a payload of this
-/// witness table's type (e.g Optional<ThisType>) , get the tag of the enum.
-FUNCTION_VALUE_WITNESS(getEnumTagSinglePayload,
-                       GetEnumTagSinglePayload,
-                       UINT_TYPE,
-                       (IMMUTABLE_VALUE_TYPE, UINT_TYPE, TYPE_TYPE))
-
-/// void (*storeEnumTagSinglePayload)(T* enum, UINT_TYPE whichCase,
-///                                   UINT_TYPE emptyCases, M *self);
-/// Given uninitialized memory for an instance of a single payload enum with a
-/// payload of this witness table's type (e.g Optional<ThisType>), store the
-/// tag.
-FUNCTION_VALUE_WITNESS(storeEnumTagSinglePayload,
-                       StoreEnumTagSinglePayload,
-                       VOID_TYPE,
-                       (MUTABLE_VALUE_TYPE, UINT_TYPE, UINT_TYPE, TYPE_TYPE))
-
-END_VALUE_WITNESS_RANGE(RequiredValueWitnessFunction,
-                        StoreEnumTagSinglePayload)
-
-///   SIZE_TYPE size;
-///
-/// The required storage size of a single object of this type.
-DATA_VALUE_WITNESS(size,
-                   Size,
-                   SIZE_TYPE)
-
-BEGIN_VALUE_WITNESS_RANGE(TypeLayoutWitness,
-                          Size)
-
-BEGIN_VALUE_WITNESS_RANGE(RequiredTypeLayoutWitness,
-                          Size)
-
-///   SIZE_TYPE stride;
-///
-/// The required size per element of an array of this type. It is at least
-/// one, even for zero-sized types, like the empty tuple.
-DATA_VALUE_WITNESS(stride,
-                   Stride,
-                   SIZE_TYPE)
-
-
-///   UINT_TYPE flags;
-///
-/// The ValueWitnessAlignmentMask bits represent the required
-/// alignment of the first byte of an object of this type, expressed
-/// as a mask of the low bits that must not be set in the pointer.
-/// This representation can be easily converted to the 'alignof'
-/// result by merely adding 1, but it is more directly useful for
-/// performing dynamic structure layouts, and it grants an
-/// additional bit of precision in a compact field without needing
-/// to switch to an exponent representation.
-///
-/// The ValueWitnessIsNonPOD bit is set if the type is not POD.
-///
-/// The ValueWitnessIsNonInline bit is set if the type cannot be
-/// represented in a fixed-size buffer or if it is not bitwise takable.
-///
-/// The ExtraInhabitantsMask bits represent the number of "extra inhabitants"
-/// of the bit representation of the value that do not form valid values of
-/// the type.
-///
-/// The Enum_HasSpareBits bit is set if the type's binary representation
-/// has unused bits.
-///
-/// The HasEnumWitnesses bit is set if the type is an enum type.
-DATA_VALUE_WITNESS(flags,
-                   Flags,
-                   UINT_TYPE)
-
-///   UINT_TYPE extraInhabitantCount;
-///
-/// The number of extra inhabitants in the type.
-DATA_VALUE_WITNESS(extraInhabitantCount,
-                   ExtraInhabitantCount,
-                   UINT_TYPE)
-
-END_VALUE_WITNESS_RANGE(RequiredTypeLayoutWitness,
-                        ExtraInhabitantCount)
-
-END_VALUE_WITNESS_RANGE(RequiredValueWitness,
-                        ExtraInhabitantCount)
-
-END_VALUE_WITNESS_RANGE(TypeLayoutWitness,
-                        ExtraInhabitantCount)
-
-#endif /* WANT_REQUIRED_VALUE_WITNESSES */
-
-#if WANT_ENUM_VALUE_WITNESSES
-
-// The following value witnesses are conditionally present if the witnessed
-// type is an enum.
-
-///   unsigned (*getEnumTag)(T *obj, M *self);
-///
-/// Given a valid object of this enum type, extracts the tag value indicating
-/// which case of the enum is inhabited. Returned values are in the range
-/// [0..NumElements-1].
-FUNCTION_VALUE_WITNESS(getEnumTag,
-                       GetEnumTag,
-                       INT_TYPE,
-                       (IMMUTABLE_VALUE_TYPE, TYPE_TYPE))
-
-BEGIN_VALUE_WITNESS_RANGE(EnumValueWitness,
-                          GetEnumTag)
-
-///   void (*destructiveProjectEnumData)(T *obj, M *self);
-/// Given a valid object of this enum type, destructively extracts the
-/// associated payload.
-FUNCTION_VALUE_WITNESS(destructiveProjectEnumData,
-                       DestructiveProjectEnumData,
-                       VOID_TYPE,
-                       (MUTABLE_VALUE_TYPE, TYPE_TYPE))
-
-///   void (*destructiveInjectEnumTag)(T *obj, unsigned tag, M *self);
-/// Given an enum case tag and a valid object of case's payload type,
-/// destructively inserts the tag into the payload. The given tag value
-/// must be in the range [-ElementsWithPayload..ElementsWithNoPayload-1].
-FUNCTION_VALUE_WITNESS(destructiveInjectEnumTag,
-                       DestructiveInjectEnumTag,
-                       VOID_TYPE,
-                       (MUTABLE_VALUE_TYPE, UINT_TYPE, TYPE_TYPE))
-
-END_VALUE_WITNESS_RANGE(EnumValueWitness,
-                        DestructiveInjectEnumTag)
-
-END_VALUE_WITNESS_RANGE(ValueWitness,
-                        DestructiveInjectEnumTag)
-
-#endif /* WANT_ENUM_VALUE_WITNESSES */
-
-#undef MUTABLE_VALUE_TYPE
-#undef IMMUTABLE_VALUE_TYPE
-#undef MUTABLE_BUFFER_TYPE
-#undef IMMUTABLE_BUFFER_TYPE
-#undef TYPE_TYPE
-#undef SIZE_TYPE
-#undef INT_TYPE
-#undef VOID_TYPE
-
-#undef END_VALUE_WITNESS_RANGE
-#undef BEGIN_VALUE_WITNESS_RANGE
-#undef DATA_VALUE_WITNESS
-#undef FUNCTION_VALUE_WITNESS
-#undef VALUE_WITNESS
-#undef ENUM_VALUE_WITNESS
-#undef NON_REQUIRED_VALUE_WITNESS
-#undef REQUIRED_VALUE_WITNESS
-#undef WANT_ENUM_VALUE_WITNESSES
-#undef WANT_REQUIRED_VALUE_WITNESSES

Sources/COpenCombineHelpers/swift/Basic/FlagSet.h

@@ -1,129 +0,0 @@
-//===--- FlagSet.h - Helper class for opaque flag types ---------*- C++ -*-===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines the FlagSet template, a class which makes it easier to
-// define opaque flag types.
-//
-//===----------------------------------------------------------------------===//
-
-// MODIFICATION NOTE:
-// This file has been modified for the OpenCombine open source project.
-// - The swift namespace is wrapped in the opencombine namespace.
-
-#ifndef OPENCOMBINE_SWIFT_BASIC_FLAGSET_H
-#define OPENCOMBINE_SWIFT_BASIC_FLAGSET_H
-
-#include <type_traits>
-#include <assert.h>
-
-namespace opencombine {
-namespace swift {
-
-/// A template designed to simplify the task of defining a wrapper type
-/// for a flags bitfield.
-///
-/// Unfortunately, this doesn't currently support functional-style
-/// building patterns, which means this can't practically be used for
-/// types that need to be used in constant expressions.
-template <typename IntType>
-class FlagSet {
-  static_assert(std::is_integral<IntType>::value,
-                "storage type for FlagSet must be an integral type");
-  IntType Bits;
-
-protected:
-  template <unsigned BitWidth>
-  static constexpr IntType lowMaskFor() {
-    return IntType((1 << BitWidth) - 1);
-  }
-
-  template <unsigned FirstBit, unsigned BitWidth = 1>
-  static constexpr IntType maskFor() {
-    return lowMaskFor<BitWidth>() << FirstBit;
-  }
-
-  constexpr FlagSet(IntType bits = 0) : Bits(bits) {}
-
-  /// Read a single-bit flag.
-  template <unsigned Bit>
-  bool getFlag() const {
-    return Bits & maskFor<Bit>();
-  }
-
-  /// Set a single-bit flag.
-  template <unsigned Bit>
-  void setFlag(bool value) {
-    if (value) {
-      Bits |= maskFor<Bit>();
-    } else {
-      Bits &= ~maskFor<Bit>();
-    }
-  }
-
-  /// Read a multi-bit field.
-  template <unsigned FirstBit, unsigned BitWidth, typename FieldType = IntType>
-  FieldType getField() const {
-    return FieldType((Bits >> FirstBit) & lowMaskFor<BitWidth>());
-  }
-
-  /// Assign to a multi-bit field.
-  template <unsigned FirstBit, unsigned BitWidth, typename FieldType = IntType>
-  void setField(typename std::enable_if<true, FieldType>::type value) {
-    // Note that we suppress template argument deduction for FieldType.
-    assert(IntType(value) <= lowMaskFor<BitWidth>() && "value out of range");
-    Bits = (Bits & ~maskFor<FirstBit, BitWidth>())
-         | (IntType(value) << FirstBit);
-  }
-
-  // A convenient macro for defining a getter and setter for a flag.
-  // Intended to be used in the body of a subclass of FlagSet.
-#define FLAGSET_DEFINE_FLAG_ACCESSORS(BIT, GETTER, SETTER) \
-  bool GETTER() const {                                    \
-    return this->template getFlag<BIT>();                  \
-  }                                                        \
-  void SETTER(bool value) {                                \
-    this->template setFlag<BIT>(value);                    \
-  }
-
-  // A convenient macro for defining a getter and setter for a field.
-  // Intended to be used in the body of a subclass of FlagSet.
-#define FLAGSET_DEFINE_FIELD_ACCESSORS(BIT, WIDTH, TYPE, GETTER, SETTER) \
-  TYPE GETTER() const {                                                  \
-    return this->template getField<BIT, WIDTH, TYPE>();                  \
-  }                                                                      \
-  void SETTER(TYPE value) {                                              \
-    this->template setField<BIT, WIDTH, TYPE>(value);                    \
-  }
-
-  // A convenient macro to expose equality operators.
-  // These can't be provided directly by FlagSet because that would allow
-  // different flag sets to be compared if they happen to have the same
-  // underlying type.
-#define FLAGSET_DEFINE_EQUALITY(TYPENAME)                                \
-  friend bool operator==(TYPENAME lhs, TYPENAME rhs) {                   \
-    return lhs.getOpaqueValue() == rhs.getOpaqueValue();                 \
-  }                                                                      \
-  friend bool operator!=(TYPENAME lhs, TYPENAME rhs) {                   \
-    return lhs.getOpaqueValue() != rhs.getOpaqueValue();                 \
-  }
-
-public:
-  /// Get the bits as an opaque integer value.
-  IntType getOpaqueValue() const {
-    return Bits;
-  }
-};
-
-} // end namespace swift
-} // end namespace opencombine
-
-#endif

Sources/COpenCombineHelpers/swift/Basic/RelativePointer.h

@@ -1,568 +0,0 @@
-//===--- RelativePointer.h - Relative Pointer Support -----------*- C++ -*-===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-///
-/// Some data structures emitted by the Swift compiler use relative indirect
-/// addresses in order to minimize startup cost for a process. By referring to
-/// the offset of the global offset table entry for a symbol, instead of
-/// directly referring to the symbol, compiler-emitted data structures avoid
-/// requiring unnecessary relocation at dynamic linking time. This header
-/// contains types to help dereference these relative addresses.
-///
-/// Theory of references to objects
-/// -------------------------------
-///
-/// A reference can be absolute or relative:
-///
-///   - An absolute reference is a pointer to the object.
-///
-///   - A relative reference is a (signed) offset from the address of the
-///     reference to the address of its direct referent.
-///
-/// A relative reference can be direct, indirect, or symbolic.
-///
-/// In a direct reference, the direct referent is simply the target object.
-/// Generally, a statically-emitted relative reference can only be direct
-/// if it can be resolved to a constant offset by the linker, because loaders
-/// do not support forming relative references.  This means that either the
-/// reference and object must lie within the same linkage unit or the
-/// difference must be computed at runtime by code.
-///
-/// In a symbolic reference, the direct referent is a string holding the symbol
-/// name of the object.  A relative reference can only be symbolic if the
-/// object actually has a symbol at runtime, which may require exporting
-/// many internal symbols that would otherwise be strippable.
-///
-/// In an indirect reference, the direct referent is a variable holding an
-/// absolute reference to the object.  An indirect relative reference may
-/// refer to an arbitrary symbol, be it anonymous within the linkage unit
-/// or completely external to it, but it requires the introduction of an
-/// intermediate absolute reference that requires load-time initialization.
-/// However, this initialization can be shared among all indirect references
-/// within the linkage unit, and the linker will generally place all such
-/// references adjacent to one another to improve load-time locality.
-///
-/// A reference can be made a dynamic union of more than one of these options.
-/// This allows the compiler/linker to use a direct reference when possible
-/// and a less-efficient option where required.  However, it also requires
-/// the cases to be dynamically distinguished.  This can be done by setting
-/// a low bit of the offset, as long as the difference between the direct
-/// referent's address and the reference is a multiple of 2.  This works well
-/// for "indirectable" references because most objects are known to be
-/// well-aligned, and the cases that aren't (chiefly functions and strings)
-/// rarely need the flexibility of this kind of reference.  It does not
-/// work quite as well for "possibly symbolic" references because C strings
-/// are not naturally aligned, and making them aligned generally requires
-/// moving them out of the linker's ordinary string section; however, it's
-/// still workable.
-///
-/// Finally, a relative reference can be near or far.  A near reference
-/// is potentially smaller, but it requires the direct referent to lie
-/// within a certain distance of the reference, even if dynamically
-/// initialized.
-///
-/// In Swift, we always prefer to use a near direct relative reference
-/// when it is possible to do so: that is, when the relationship is always
-/// between two global objects emitted in the same linkage unit, and there
-/// is no compatibility constraint requiring the use of an absolute reference.
-///
-/// When more flexibility is required, there are several options:
-///
-///   1. Use an absolute reference.  Size penalty on 64-bit.  Requires
-///      load-time work.
-///
-///   2. Use a far direct relative reference.  Size penalty on 64-bit.
-///      Requires load-time work when object is outside linkage unit.
-///      Generally not directly supported by loaders.
-///
-///   3. Use an always-indirect relative reference.  Size penalty of one
-///      pointer (shared).  Requires load-time work even when object is
-///      within linkage unit.
-///
-///   4. Use a near indirectable relative reference.  Size penalty of one
-///      pointer (shared) when reference exceeds range.  Runtime / code-size
-///      penalty on access.  Requires load-time work (shared) only when
-///      object is outside linkage unit.
-///
-///   5. Use a far indirectable relative reference.  Size penalty on 64-bit.
-///      Size penalty of one pointer (shared) when reference exceeds range
-///      and is initialized statically.  Runtime / code-size penalty on access.
-///      Requires load-time work (shared) only when object is outside linkage
-///      unit.
-///
-///   6. Use a near or far symbolic relative reference.  No load-time work.
-///      Severe runtime penalty on access.  Requires custom logic to statically
-///      optimize.  Requires emission of symbol for target even if private
-///      to linkage unit.
-///
-///   7. Use a near or far direct-or-symbolic relative reference.  No
-///      load-time work.  Severe runtime penalty on access if object is
-///      outside of linkage unit.  Requires custom logic to statically optimize.
-///
-/// In general, it's our preference in Swift to use option #4 when there
-/// is no possibility of initializing the reference dynamically and option #5
-/// when there is.  This is because it is infeasible to actually share the
-/// memory for the intermediate absolute reference when it must be allocated
-/// dynamically.
-///
-/// Symbolic references are an interesting idea that we have not yet made
-/// use of.  They may be acceptable in reflective metadata cases where it
-/// is desirable to heavily bias towards never using the metadata.  However,
-/// they're only profitable if there wasn't any other indirect reference
-/// to the target, and it is likely that their optimal use requires a more
-/// intelligent toolchain from top to bottom.
-///
-/// Note that the cost of load-time work also includes a binary-size penalty
-/// to store the loader metadata necessary to perform that work.  Therefore
-/// it is better to avoid it even when there are dynamic optimizations in
-/// place to skip the work itself.
-///
-//===----------------------------------------------------------------------===//
-
-// MODIFICATION NOTE:
-// This file has been modified for the OpenCombine open source project.
-// - The swift namespace is wrapped in the opencombine namespace.
-
-#ifndef OPENCOMBINE_SWIFT_BASIC_RELATIVEPOINTER_H
-#define OPENCOMBINE_SWIFT_BASIC_RELATIVEPOINTER_H
-
-#include <cstdint>
-
-namespace opencombine {
-namespace swift {
-
-namespace detail {
-
-/// Apply a relative offset to a base pointer. The offset is applied to the base
-/// pointer using sign-extended, wrapping arithmetic.
-template<typename BasePtrTy, typename Offset>
-static inline uintptr_t applyRelativeOffset(BasePtrTy *basePtr, Offset offset) {
-  static_assert(std::is_integral<Offset>::value &&
-                std::is_signed<Offset>::value,
-                "offset type should be signed integer");
-
-  auto base = reinterpret_cast<uintptr_t>(basePtr);
-  // We want to do wrapping arithmetic, but with a sign-extended
-  // offset. To do this in C, we need to do signed promotion to get
-  // the sign extension, but we need to perform arithmetic on unsigned values,
-  // since signed overflow is undefined behavior.
-  auto extendOffset = (uintptr_t)(intptr_t)offset;
-  return base + extendOffset;
-}
-
-/// Measure the relative offset between two pointers. This measures
-/// (referent - base) using wrapping arithmetic. The result is truncated if
-/// Offset is smaller than a pointer, with an assertion that the
-/// pre-truncation result is a sign extension of the truncated result.
-template<typename Offset, typename A, typename B>
-static inline Offset measureRelativeOffset(A *referent, B *base) {
-  static_assert(std::is_integral<Offset>::value &&
-                std::is_signed<Offset>::value,
-                "offset type should be signed integer");
-
-  auto distance = (uintptr_t)referent - (uintptr_t)base;
-  // Truncate as unsigned, then wrap around to signed.
-  auto truncatedDistance =
-    (Offset)(typename std::make_unsigned<Offset>::type)distance;
-  // Assert that the truncation didn't discard any non-sign-extended bits.
-  assert((intptr_t)truncatedDistance == (intptr_t)distance
-         && "pointers are too far apart to fit in offset type");
-  return truncatedDistance;
-}
-
-} // namespace detail
-
-/// A relative reference to an object stored in memory. The reference may be
-/// direct or indirect, and uses the low bit of the (assumed at least
-/// 2-byte-aligned) pointer to differentiate.
-template<typename ValueTy, bool Nullable = false, typename Offset = int32_t>
-class RelativeIndirectPointer {
-private:
-  static_assert(std::is_integral<Offset>::value &&
-                std::is_signed<Offset>::value,
-                "offset type should be signed integer");
-
-  /// The relative offset of the pointer's memory from the `this` pointer.
-  /// This is an indirect reference.
-  Offset RelativeOffset;
-
-  /// RelativePointers should appear in statically-generated metadata. They
-  /// shouldn't be constructed or copied.
-  RelativeIndirectPointer() = delete;
-  RelativeIndirectPointer(RelativeIndirectPointer &&) = delete;
-  RelativeIndirectPointer(const RelativeIndirectPointer &) = delete;
-  RelativeIndirectPointer &operator=(RelativeIndirectPointer &&)
-    = delete;
-  RelativeIndirectPointer &operator=(const RelativeIndirectPointer &)
-    = delete;
-
-public:
-  const ValueTy *get() const & {
-    // Check for null.
-    if (Nullable && RelativeOffset == 0)
-      return nullptr;
-
-    uintptr_t address = detail::applyRelativeOffset(this, RelativeOffset);
-    return *reinterpret_cast<const ValueTy * const *>(address);
-  }
-
-  /// A zero relative offset encodes a null reference.
-  bool isNull() const & {
-    return RelativeOffset == 0;
-  }
-
-  operator const ValueTy* () const & {
-    return get();
-  }
-
-  const ValueTy *operator->() const & {
-    return get();
-  }
-};
-
-/// A relative reference to an object stored in memory. The reference may be
-/// direct or indirect, and uses the low bit of the (assumed at least
-/// 2-byte-aligned) pointer to differentiate.
-template<typename ValueTy, bool Nullable = false, typename Offset = int32_t>
-class RelativeIndirectablePointer {
-private:
-  static_assert(std::is_integral<Offset>::value &&
-                std::is_signed<Offset>::value,
-                "offset type should be signed integer");
-
-  /// The relative offset of the pointer's memory from the `this` pointer.
-  /// If the low bit is clear, this is a direct reference; otherwise, it is
-  /// an indirect reference.
-  Offset RelativeOffsetPlusIndirect;
-
-  /// RelativePointers should appear in statically-generated metadata. They
-  /// shouldn't be constructed or copied.
-  RelativeIndirectablePointer() = delete;
-  RelativeIndirectablePointer(RelativeIndirectablePointer &&) = delete;
-  RelativeIndirectablePointer(const RelativeIndirectablePointer &) = delete;
-  RelativeIndirectablePointer &operator=(RelativeIndirectablePointer &&)
-    = delete;
-  RelativeIndirectablePointer &operator=(const RelativeIndirectablePointer &)
-    = delete;
-
-public:
-  /// Allow construction and reassignment from an absolute pointer.
-  /// These always produce a direct relative offset.
-  RelativeIndirectablePointer(ValueTy *absolute)
-  : RelativeOffsetPlusIndirect(
-      Nullable && absolute == nullptr
-        ? 0
-        : detail::measureRelativeOffset<Offset>(absolute, this)) {
-    if (!Nullable)
-      assert(absolute != nullptr &&
-             "constructing non-nullable relative pointer from null");
-  }
-
-  RelativeIndirectablePointer &operator=(ValueTy *absolute) & {
-    if (!Nullable)
-      assert(absolute != nullptr &&
-             "constructing non-nullable relative pointer from null");
-
-    RelativeOffsetPlusIndirect = Nullable && absolute == nullptr
-      ? 0
-      : detail::measureRelativeOffset<Offset>(absolute, this);
-    return *this;
-  }
-
-  const ValueTy *get() const & {
-    static_assert(alignof(ValueTy) >= 2 && alignof(Offset) >= 2,
-                  "alignment of value and offset must be at least 2 to "
-                  "make room for indirectable flag");
-
-    // Check for null.
-    if (Nullable && RelativeOffsetPlusIndirect == 0)
-      return nullptr;
-
-    Offset offsetPlusIndirect = RelativeOffsetPlusIndirect;
-    uintptr_t address = detail::applyRelativeOffset(this,
-                                                    offsetPlusIndirect & ~1);
-
-    // If the low bit is set, then this is an indirect address. Otherwise,
-    // it's direct.
-    if (offsetPlusIndirect & 1) {
-      return *reinterpret_cast<const ValueTy * const *>(address);
-    } else {
-      return reinterpret_cast<const ValueTy *>(address);
-    }
-  }
-
-  /// A zero relative offset encodes a null reference.
-  bool isNull() const & {
-    return RelativeOffsetPlusIndirect == 0;
-  }
-
-  operator const ValueTy* () const & {
-    return get();
-  }
-
-  const ValueTy *operator->() const & {
-    return get();
-  }
-};
-
-/// A relative reference to an aligned object stored in memory. The reference
-/// may be direct or indirect, and uses the low bit of the (assumed at least
-/// 2-byte-aligned) pointer to differentiate. The remaining low bits store
-/// an additional tiny integer value.
-template<typename ValueTy, typename IntTy, bool Nullable = false,
-         typename Offset = int32_t>
-class RelativeIndirectablePointerIntPair {
-private:
-  static_assert(std::is_integral<Offset>::value &&
-                std::is_signed<Offset>::value,
-                "offset type should be signed integer");
-
-  /// The relative offset of the pointer's memory from the `this` pointer.
-  /// If the low bit is clear, this is a direct reference; otherwise, it is
-  /// an indirect reference.
-  Offset RelativeOffsetPlusIndirectAndInt;
-
-  /// RelativePointers should appear in statically-generated metadata. They
-  /// shouldn't be constructed or copied.
-  RelativeIndirectablePointerIntPair() = delete;
-  RelativeIndirectablePointerIntPair(
-                           RelativeIndirectablePointerIntPair &&) = delete;
-  RelativeIndirectablePointerIntPair(
-                      const RelativeIndirectablePointerIntPair &) = delete;
-  RelativeIndirectablePointerIntPair& operator=(
-                           RelativeIndirectablePointerIntPair &&) = delete;
-  RelativeIndirectablePointerIntPair &operator=(
-                      const RelativeIndirectablePointerIntPair &) = delete;
-
-  // Retrieve the mask for the stored integer value.
-  static Offset getIntMask() {
-    return (alignof(Offset) - 1) & ~(Offset)0x01;
-  }
-
-public:
-  const ValueTy *getPointer() const & {
-    static_assert(alignof(ValueTy) >= 2 && alignof(Offset) >= 2,
-                  "alignment of value and offset must be at least 2 to "
-                  "make room for indirectable flag");
-
-    Offset offset = (RelativeOffsetPlusIndirectAndInt & ~getIntMask());
-
-    // Check for null.
-    if (Nullable && offset == 0)
-      return nullptr;
-
-    Offset offsetPlusIndirect = offset;
-    uintptr_t address = detail::applyRelativeOffset(this,
-                                                    offsetPlusIndirect & ~1);
-
-    // If the low bit is set, then this is an indirect address. Otherwise,
-    // it's direct.
-    if (offsetPlusIndirect & 1) {
-      return *reinterpret_cast<const ValueTy * const *>(address);
-    } else {
-      return reinterpret_cast<const ValueTy *>(address);
-    }
-  }
-
-  /// A zero relative offset encodes a null reference.
-  bool isNull() const & {
-    Offset offset = (RelativeOffsetPlusIndirectAndInt & ~getIntMask());
-    return offset == 0;
-  }
-
-  IntTy getInt() const & {
-    return IntTy((RelativeOffsetPlusIndirectAndInt & getIntMask()) >> 1);
-  }
-};
-
-/// A relative reference to a function, intended to reference private metadata
-/// functions for the current executable or dynamic library image from
-/// position-independent constant data.
-template<typename T, bool Nullable, typename Offset>
-class RelativeDirectPointerImpl {
-private:
-  /// The relative offset of the function's entry point from *this.
-  Offset RelativeOffset;
-
-  /// RelativePointers should appear in statically-generated metadata. They
-  /// shouldn't be constructed or copied.
-  RelativeDirectPointerImpl() = delete;
-  /// RelativePointers should appear in statically-generated metadata. They
-  /// shouldn't be constructed or copied.
-  RelativeDirectPointerImpl(RelativeDirectPointerImpl &&) = delete;
-  RelativeDirectPointerImpl(const RelativeDirectPointerImpl &) = delete;
-  RelativeDirectPointerImpl &operator=(RelativeDirectPointerImpl &&)
-    = delete;
-  RelativeDirectPointerImpl &operator=(const RelativeDirectPointerImpl &)
-    = delete;
-
-
-public:
-  using ValueTy = T;
-  using PointerTy = T*;
-
-  // Allow construction and reassignment from an absolute pointer.
-  RelativeDirectPointerImpl(PointerTy absolute)
-    : RelativeOffset(Nullable && absolute == nullptr
-                       ? 0
-                       : detail::measureRelativeOffset<Offset>(absolute, this))
-  {
-    if (!Nullable)
-      assert(absolute != nullptr &&
-             "constructing non-nullable relative pointer from null");
-  }
-  explicit constexpr RelativeDirectPointerImpl(std::nullptr_t)
-  : RelativeOffset (0) {
-    static_assert(Nullable, "can't construct non-nullable pointer from null");
-  }
-
-  RelativeDirectPointerImpl &operator=(PointerTy absolute) & {
-    if (!Nullable)
-      assert(absolute != nullptr &&
-             "constructing non-nullable relative pointer from null");
-    RelativeOffset = Nullable && absolute == nullptr
-      ? 0
-      : detail::measureRelativeOffset<Offset>(absolute, this);
-    return *this;
-  }
-
-  PointerTy get() const & {
-    // Check for null.
-    if (Nullable && RelativeOffset == 0)
-      return nullptr;
-
-    // The value is addressed relative to `this`.
-    uintptr_t absolute = detail::applyRelativeOffset(this, RelativeOffset);
-    return reinterpret_cast<PointerTy>(absolute);
-  }
-
-  /// A zero relative offset encodes a null reference.
-  bool isNull() const & {
-    return RelativeOffset == 0;
-  }
-};
-
-/// A direct relative reference to an object.
-template<typename T, bool Nullable = true, typename Offset = int32_t>
-class RelativeDirectPointer :
-  private RelativeDirectPointerImpl<T, Nullable, Offset>
-{
-  using super = RelativeDirectPointerImpl<T, Nullable, Offset>;
-public:
-  using super::get;
-  using super::super;
-
-  RelativeDirectPointer &operator=(T *absolute) & {
-    super::operator=(absolute);
-    return *this;
-  }
-
-  operator typename super::PointerTy() const & {
-    return this->get();
-  }
-
-  const typename super::ValueTy *operator->() const & {
-    return this->get();
-  }
-
-  using super::isNull;
-};
-
-/// A specialization of RelativeDirectPointer for function pointers,
-/// allowing for calls.
-template<typename RetTy, typename...ArgTy, bool Nullable, typename Offset>
-class RelativeDirectPointer<RetTy (ArgTy...), Nullable, Offset> :
-  private RelativeDirectPointerImpl<RetTy (ArgTy...), Nullable, Offset>
-{
-  using super = RelativeDirectPointerImpl<RetTy (ArgTy...), Nullable, Offset>;
-public:
-  using super::get;
-  using super::super;
-
-  RelativeDirectPointer &operator=(RetTy (*absolute)(ArgTy...)) & {
-    super::operator=(absolute);
-    return *this;
-  }
-
-  operator typename super::PointerTy() const & {
-    return this->get();
-  }
-
-  RetTy operator()(ArgTy...arg) const {
-    return this->get()(std::forward<ArgTy>(arg)...);
-  }
-
-  using super::isNull;
-};
-
-/// A direct relative reference to an aligned object, with an additional
-/// tiny integer value crammed into its low bits.
-template<typename PointeeTy, typename IntTy, bool Nullable = false,
-         typename Offset = int32_t>
-class RelativeDirectPointerIntPair {
-  Offset RelativeOffsetPlusInt;
-
-  /// RelativePointers should appear in statically-generated metadata. They
-  /// shouldn't be constructed or copied.
-  RelativeDirectPointerIntPair() = delete;
-  RelativeDirectPointerIntPair(RelativeDirectPointerIntPair &&) = delete;
-  RelativeDirectPointerIntPair(const RelativeDirectPointerIntPair &) = delete;
-  RelativeDirectPointerIntPair &operator=(RelativeDirectPointerIntPair &&)
-    = delete;
-  RelativeDirectPointerIntPair &operator=(const RelativeDirectPointerIntPair&)
-    = delete;
-
-  static Offset getMask() {
-    return alignof(Offset) - 1;
-  }
-
-public:
-  using ValueTy = PointeeTy;
-  using PointerTy = PointeeTy*;
-
-  PointerTy getPointer() const & {
-    Offset offset = (RelativeOffsetPlusInt & ~getMask());
-
-    // Check for null.
-    if (Nullable && offset == 0)
-      return nullptr;
-
-    // The value is addressed relative to `this`.
-    uintptr_t absolute = detail::applyRelativeOffset(this, offset);
-    return reinterpret_cast<PointerTy>(absolute);
-  }
-
-  IntTy getInt() const & {
-    return IntTy(RelativeOffsetPlusInt & getMask());
-  }
-
-  Offset getOpaqueValue() const & {
-    return RelativeOffsetPlusInt;
-  }
-};
-
-// Type aliases for "far" relative pointers, which need to be able to reach
-// across the full address space instead of only across a single small-code-
-// model image.
-
-template<typename T, bool Nullable = false>
-using FarRelativeIndirectablePointer =
-  RelativeIndirectablePointer<T, Nullable, intptr_t>;
-
-template<typename T, bool Nullable = false>
-using FarRelativeDirectPointer = RelativeDirectPointer<T, Nullable, intptr_t>;
-
-} // end namespace swift
-} // end namespace opencombine
-
-#endif // OPENCOMBINE_SWIFT_BASIC_RELATIVEPOINTER_H

Sources/COpenCombineHelpers/swift/Demangling/Demangle.h

@@ -1,44 +0,0 @@
-//===--- Demangle.h - Interface to Swift symbol demangling ------*- C++ -*-===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
-//
-//===----------------------------------------------------------------------===//
-//
-// This file is the public API of the demangler library.
-// Tools which use the demangler library (like lldb) must include this - and
-// only this - header file.
-//
-//===----------------------------------------------------------------------===//
-
-// MODIFICATION NOTE:
-// This file has been modified for the OpenCombine open source project.
-// - Some declarations have been removed.
-// - The swift namespace is wrapped in the opencombine namespace.
-
-#ifndef OPENCOMBINE_SWIFT_DEMANGLING_DEMANGLE_H
-#define OPENCOMBINE_SWIFT_DEMANGLING_DEMANGLE_H
-
-#include <memory>
-#include <string>
-#include <cassert>
-#include <cstdint>
-#include "stl_polyfill/string_view.h"
-
-namespace opencombine {
-namespace swift {
-namespace Demangle {
-/// Form a StringRef around the mangled name starting at base, if the name may
-/// contain symbolic references.
-string_view makeSymbolicMangledNameStringRef(const char *base);
-
-} // end namespace Demangle
-} // end namespace swift
-} // end namespace opencombine
-
-#endif // OPENCOMBINE_SWIFT_DEMANGLING_DEMANGLE_H

Sources/COpenCombineHelpers/swift/Reflection/Records.h

@@ -1,664 +0,0 @@
-//===--- Records.h - Swift Type Reflection Records --------------*- C++ -*-===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
-//
-//===----------------------------------------------------------------------===//
-//
-// Implements the structures of type reflection records.
-//
-//===----------------------------------------------------------------------===//
-
-// MODIFICATION NOTE:
-// This file has been modified for the OpenCombine open source project.
-// - Some declarations have been removed.
-// - The swift namespace is wrapped in the opencombine namespace.
-
-#ifndef OPENCOMBINE_SWIFT_REFLECTION_RECORDS_H
-#define OPENCOMBINE_SWIFT_REFLECTION_RECORDS_H
-
-#include "swift/Basic/RelativePointer.h"
-#include "swift/Demangling/Demangle.h"
-#include "stl_polyfill/string_view.h"
-#include "stl_polyfill/span.h"
-
-namespace opencombine {
-namespace swift {
-
-const uint16_t SWIFT_REFLECTION_METADATA_VERSION = 3; // superclass field
-
-namespace reflection {
-
-// Field records describe the type of a single stored property or case member
-// of a class, struct or enum.
-class FieldRecordFlags {
-  using int_type = uint32_t;
-  enum : int_type {
-    // Is this an indirect enum case?
-    IsIndirectCase = 0x1,
-    
-    // Is this a mutable `var` property?
-    IsVar = 0x2,
-  };
-  int_type Data = 0;
-
-public:
-  bool isIndirectCase() const {
-    return (Data & IsIndirectCase) == IsIndirectCase;
-  }
-
-  bool isVar() const {
-    return (Data & IsVar) == IsVar;
-  }
-
-  void setIsIndirectCase(bool IndirectCase=true) {
-    if (IndirectCase)
-      Data |= IsIndirectCase;
-    else
-      Data &= ~IsIndirectCase;
-  }
-
-  void setIsVar(bool Var=true) {
-    if (Var)
-      Data |= IsVar;
-    else
-      Data &= ~IsVar;
-  }
-
-  int_type getRawValue() const {
-    return Data;
-  }
-};
-
-class FieldRecord {
-  const FieldRecordFlags Flags;
-  const RelativeDirectPointer<const char> MangledTypeName;
-  const RelativeDirectPointer<const char> FieldName;
-
-public:
-  FieldRecord() = delete;
-
-  bool hasMangledTypeName() const {
-    return MangledTypeName;
-  }
-
-  string_view getMangledTypeName(uintptr_t Offset) const {
-    return Demangle::makeSymbolicMangledNameStringRef(
-      (const char *)((uintptr_t)MangledTypeName.get() + Offset));
-  }
-
-  string_view getFieldName(uintptr_t Offset)  const {
-    if (FieldName)
-      return (const char *)((uintptr_t)FieldName.get() + Offset);
-    return "";
-  }
-
-  bool isIndirectCase() const {
-    return Flags.isIndirectCase();
-  }
-};
-
-struct FieldRecordIterator {
-  const FieldRecord *Cur;
-  const FieldRecord * const End;
-
-  FieldRecordIterator(const FieldRecord *Cur, const FieldRecord * const End)
-    : Cur(Cur), End(End) {}
-
-  const FieldRecord &operator*() const {
-    return *Cur;
-  }
-
-  const FieldRecord *operator->() const {
-    return Cur;
-  }
-
-  FieldRecordIterator &operator++() {
-    ++Cur;
-    return *this;
-  }
-
-  bool operator==(const FieldRecordIterator &other) const {
-    return Cur == other.Cur && End == other.End;
-  }
-
-  bool operator!=(const FieldRecordIterator &other) const {
-    return !(*this == other);
-  }
-};
-
-enum class FieldDescriptorKind : uint16_t {
-  // Swift nominal types.
-  Struct,
-  Class,
-  Enum,
-
-  // Fixed-size multi-payload enums have a special descriptor format that
-  // encodes spare bits.
-  //
-  // FIXME: Actually implement this. For now, a descriptor with this kind
-  // just means we also have a builtin descriptor from which we get the
-  // size and alignment.
-  MultiPayloadEnum,
-
-  // A Swift opaque protocol. There are no fields, just a record for the
-  // type itself.
-  Protocol,
-
-  // A Swift class-bound protocol.
-  ClassProtocol,
-
-  // An Objective-C protocol, which may be imported or defined in Swift.
-  ObjCProtocol,
-
-  // An Objective-C class, which may be imported or defined in Swift.
-  // In the former case, field type metadata is not emitted, and
-  // must be obtained from the Objective-C runtime.
-  ObjCClass
-};
-
-// Field descriptors contain a collection of field records for a single
-// class, struct or enum declaration.
-class FieldDescriptor {
-  const FieldRecord *getFieldRecordBuffer() const {
-    return reinterpret_cast<const FieldRecord *>(this + 1);
-  }
-
-  const RelativeDirectPointer<const char> MangledTypeName;
-  const RelativeDirectPointer<const char> Superclass;
-
-public:
-  FieldDescriptor() = delete;
-
-  const FieldDescriptorKind Kind;
-  const uint16_t FieldRecordSize;
-  const uint32_t NumFields;
-
-  using const_iterator = FieldRecordIterator;
-
-  bool isEnum() const {
-    return (Kind == FieldDescriptorKind::Enum ||
-            Kind == FieldDescriptorKind::MultiPayloadEnum);
-  }
-
-  bool isClass() const {
-    return (Kind == FieldDescriptorKind::Class ||
-            Kind == FieldDescriptorKind::ObjCClass);
-  }
-
-  bool isProtocol() const {
-    return (Kind == FieldDescriptorKind::Protocol ||
-            Kind == FieldDescriptorKind::ClassProtocol ||
-            Kind == FieldDescriptorKind::ObjCProtocol);
-  }
-
-  bool isStruct() const {
-    return Kind == FieldDescriptorKind::Struct;
-  }
-
-  const_iterator begin() const {
-    auto Begin = getFieldRecordBuffer();
-    auto End = Begin + NumFields;
-    return const_iterator { Begin, End };
-  }
-
-  const_iterator end() const {
-    auto Begin = getFieldRecordBuffer();
-    auto End = Begin + NumFields;
-    return const_iterator { End, End };
-  }
-
-  span<const FieldRecord> getFields() const {
-    return {getFieldRecordBuffer(), NumFields};
-  }
-
-  bool hasMangledTypeName() const {
-    return MangledTypeName;
-  }
-
-  string_view getMangledTypeName(uintptr_t Offset) const {
-    return Demangle::makeSymbolicMangledNameStringRef(
-      (const char *)((uintptr_t)MangledTypeName.get() + Offset));
-  }
-
-  bool hasSuperclass() const {
-    return Superclass;
-  }
-
-  string_view getSuperclass(uintptr_t Offset) const {
-    return Demangle::makeSymbolicMangledNameStringRef(
-      (const char*)((uintptr_t)Superclass.get() + Offset));
-  }
-};
-
-class FieldDescriptorIterator
-  : public std::iterator<std::forward_iterator_tag, FieldDescriptor> {
-public:
-  const void *Cur;
-  const void * const End;
-  FieldDescriptorIterator(const void *Cur, const void * const End)
-    : Cur(Cur), End(End) {}
-
-  const FieldDescriptor &operator*() const {
-    return *reinterpret_cast<const FieldDescriptor *>(Cur);
-  }
-
-  const FieldDescriptor *operator->() const {
-    return reinterpret_cast<const FieldDescriptor *>(Cur);
-  }
-
-  FieldDescriptorIterator &operator++() {
-    const auto &FR = this->operator*();
-    const void *Next = reinterpret_cast<const char *>(Cur)
-      + sizeof(FieldDescriptor) + FR.NumFields * FR.FieldRecordSize;
-    Cur = Next;
-    return *this;
-  }
-
-  bool operator==(FieldDescriptorIterator const &other) const {
-    return Cur == other.Cur && End == other.End;
-  }
-
-  bool operator!=(FieldDescriptorIterator const &other) const {
-    return !(*this == other);
-  }
-};
-
-// Associated type records describe the mapping from an associated
-// type to the type witness of a conformance.
-class AssociatedTypeRecord {
-  const RelativeDirectPointer<const char> Name;
-  const RelativeDirectPointer<const char> SubstitutedTypeName;
-
-public:
-  string_view getName(uintptr_t Offset) const {
-    return (const char*)((uintptr_t)Name.get() + Offset);
-  }
-
-  string_view getMangledSubstitutedTypeName(uintptr_t Offset) const {
-    return Demangle::makeSymbolicMangledNameStringRef(
-      (const char*)((uintptr_t)SubstitutedTypeName.get() + Offset));
-  }
-};
-
-struct AssociatedTypeRecordIterator {
-  const AssociatedTypeRecord *Cur;
-  const AssociatedTypeRecord * const End;
-
-  AssociatedTypeRecordIterator()
-    : Cur(nullptr), End(nullptr) {}
-
-  AssociatedTypeRecordIterator(const AssociatedTypeRecord *Cur,
-                               const AssociatedTypeRecord * const End)
-    : Cur(Cur), End(End) {}
-
-  const AssociatedTypeRecord &operator*() const {
-    return *Cur;
-  }
-
-  const AssociatedTypeRecord *operator->() const {
-    return Cur;
-  }
-
-  AssociatedTypeRecordIterator &operator++() {
-    ++Cur;
-    return *this;
-  }
-
-  AssociatedTypeRecordIterator
-  operator=(const AssociatedTypeRecordIterator &Other) {
-    return { Other.Cur, Other.End };
-  }
-
-  bool operator==(const AssociatedTypeRecordIterator &other) const {
-    return Cur == other.Cur && End == other.End;
-  }
-
-  bool operator!=(const AssociatedTypeRecordIterator &other) const {
-    return !(*this == other);
-  }
-
-  operator bool() const {
-    return Cur && End;
-  }
-};
-
-// An associated type descriptor contains a collection of associated
-// type records for a conformance.
-struct AssociatedTypeDescriptor {
-private:
-  const RelativeDirectPointer<const char> ConformingTypeName;
-  const RelativeDirectPointer<const char> ProtocolTypeName;
-public:
-
-  uint32_t NumAssociatedTypes;
-  uint32_t AssociatedTypeRecordSize;
-
-  const AssociatedTypeRecord *getAssociatedTypeRecordBuffer() const {
-    return reinterpret_cast<const AssociatedTypeRecord *>(this + 1);
-  }
-
-  using const_iterator = AssociatedTypeRecordIterator;
-
-  const_iterator begin() const {
-    auto Begin = getAssociatedTypeRecordBuffer();
-    auto End = Begin + NumAssociatedTypes;
-    return const_iterator { Begin, End };
-  }
-
-  const_iterator end() const {
-    auto Begin = getAssociatedTypeRecordBuffer();
-    auto End = Begin + NumAssociatedTypes;
-    return const_iterator { End, End };
-  }
-
-  string_view getMangledProtocolTypeName(uintptr_t Offset) const {
-    return Demangle::makeSymbolicMangledNameStringRef(
-      (const char*)((uintptr_t)ProtocolTypeName.get() + Offset));
-  }
-
-  string_view getMangledConformingTypeName(uintptr_t Offset) const {
-    return Demangle::makeSymbolicMangledNameStringRef(
-      (const char*)((uintptr_t)ConformingTypeName.get() + Offset));
-  }
-};
-
-class AssociatedTypeIterator
-  : public std::iterator<std::forward_iterator_tag, AssociatedTypeDescriptor> {
-public:
-  const void *Cur;
-  const void * const End;
-  AssociatedTypeIterator(const void *Cur, const void * const End)
-    : Cur(Cur), End(End) {}
-
-  const AssociatedTypeDescriptor &operator*() const {
-    return *reinterpret_cast<const AssociatedTypeDescriptor *>(Cur);
-  }
-
-  const AssociatedTypeDescriptor *operator->() const {
-    return reinterpret_cast<const AssociatedTypeDescriptor *>(Cur);
-  }
-
-  AssociatedTypeIterator &operator++() {
-    const auto &ATR = this->operator*();
-    size_t Size = sizeof(AssociatedTypeDescriptor) +
-      ATR.NumAssociatedTypes * ATR.AssociatedTypeRecordSize;
-    const void *Next = reinterpret_cast<const char *>(Cur) + Size;
-    Cur = Next;
-    return *this;
-  }
-
-  bool operator==(AssociatedTypeIterator const &other) const {
-    return Cur == other.Cur && End == other.End;
-  }
-
-  bool operator!=(AssociatedTypeIterator const &other) const {
-    return !(*this == other);
-  }
-};
-
-// Builtin type records describe basic layout information about
-// any builtin types referenced from the other sections.
-class BuiltinTypeDescriptor {
-  const RelativeDirectPointer<const char> TypeName;
-
-public:
-  uint32_t Size;
-
-  // - Least significant 16 bits are the alignment.
-  // - Bit 16 is 'bitwise takable'.
-  // - Remaining bits are reserved.
-  uint32_t AlignmentAndFlags;
-
-  uint32_t Stride;
-  uint32_t NumExtraInhabitants;
-
-  bool isBitwiseTakable() const {
-    return (AlignmentAndFlags >> 16) & 1;
-  }
-
-  uint32_t getAlignment() const {
-    return AlignmentAndFlags & 0xffff;
-  }
-
-  bool hasMangledTypeName() const {
-    return TypeName;
-  }
-
-  string_view getMangledTypeName(uintptr_t Offset) const {
-    return Demangle::makeSymbolicMangledNameStringRef(
-      (const char*)((uintptr_t)TypeName.get() + Offset));
-  }
-};
-
-class BuiltinTypeDescriptorIterator
-  : public std::iterator<std::forward_iterator_tag, BuiltinTypeDescriptor> {
-public:
-  const void *Cur;
-  const void * const End;
-  BuiltinTypeDescriptorIterator(const void *Cur, const void * const End)
-    : Cur(Cur), End(End) {}
-
-  const BuiltinTypeDescriptor &operator*() const {
-    return *reinterpret_cast<const BuiltinTypeDescriptor *>(Cur);
-  }
-
-  const BuiltinTypeDescriptor *operator->() const {
-    return reinterpret_cast<const BuiltinTypeDescriptor *>(Cur);;
-  }
-
-  BuiltinTypeDescriptorIterator &operator++() {
-    const void *Next = reinterpret_cast<const char *>(Cur)
-      + sizeof(BuiltinTypeDescriptor);
-    Cur = Next;
-    return *this;
-  }
-
-  bool operator==(BuiltinTypeDescriptorIterator const &other) const {
-    return Cur == other.Cur && End == other.End;
-  }
-
-  bool operator!=(BuiltinTypeDescriptorIterator const &other) const {
-    return !(*this == other);
-  }
-};
-
-class CaptureTypeRecord {
-  const RelativeDirectPointer<const char> MangledTypeName;
-
-public:
-  CaptureTypeRecord() = delete;
-
-  bool hasMangledTypeName() const {
-    return MangledTypeName;
-  }
-
-  string_view getMangledTypeName(uintptr_t Offset) const {
-    return Demangle::makeSymbolicMangledNameStringRef(
-      (const char*)((uintptr_t)MangledTypeName.get() + Offset));
-  }
-};
-
-struct CaptureTypeRecordIterator {
-  const CaptureTypeRecord *Cur;
-  const CaptureTypeRecord * const End;
-
-  CaptureTypeRecordIterator(const CaptureTypeRecord *Cur,
-                            const CaptureTypeRecord * const End)
-    : Cur(Cur), End(End) {}
-
-  const CaptureTypeRecord &operator*() const {
-    return *Cur;
-  }
-
-  const CaptureTypeRecord *operator->() const {
-    return Cur;
-  }
-
-  CaptureTypeRecordIterator &operator++() {
-    ++Cur;
-    return *this;
-  }
-
-  bool operator==(const CaptureTypeRecordIterator &other) const {
-    return Cur == other.Cur && End == other.End;
-  }
-
-  bool operator!=(const CaptureTypeRecordIterator &other) const {
-    return !(*this == other);
-  }
-};
-
-class MetadataSourceRecord {
-  const RelativeDirectPointer<const char> MangledTypeName;
-  const RelativeDirectPointer<const char> MangledMetadataSource;
-
-public:
-  MetadataSourceRecord() = delete;
-
-  bool hasMangledTypeName() const {
-    return MangledTypeName;
-  }
-
-  string_view getMangledTypeName(uintptr_t Offset) const {
-    return Demangle::makeSymbolicMangledNameStringRef(
-      (const char*)((uintptr_t)MangledTypeName.get() + Offset));
-  }
-
-  bool hasMangledMetadataSource() const {
-    return MangledMetadataSource;
-  }
-
-  string_view getMangledMetadataSource(uintptr_t Offset) const {
-    return Demangle::makeSymbolicMangledNameStringRef(
-      (const char*)((uintptr_t)MangledMetadataSource.get() + Offset));
-  }
-};
-
-struct MetadataSourceRecordIterator {
-  const MetadataSourceRecord *Cur;
-  const MetadataSourceRecord * const End;
-
-  MetadataSourceRecordIterator(const MetadataSourceRecord *Cur,
-                            const MetadataSourceRecord * const End)
-    : Cur(Cur), End(End) {}
-
-  const MetadataSourceRecord &operator*() const {
-    return *Cur;
-  }
-
-  const MetadataSourceRecord *operator->() const {
-    return Cur;
-  }
-
-  MetadataSourceRecordIterator &operator++() {
-    ++Cur;
-    return *this;
-  }
-
-  bool operator==(const MetadataSourceRecordIterator &other) const {
-    return Cur == other.Cur && End == other.End;
-  }
-
-  bool operator!=(const MetadataSourceRecordIterator &other) const {
-    return !(*this == other);
-  }
-};
-
-// Capture descriptors describe the layout of a closure context
-// object. Unlike nominal types, the generic substitutions for a
-// closure context come from the object, and not the metadata.
-class CaptureDescriptor {
-  const CaptureTypeRecord *getCaptureTypeRecordBuffer() const {
-    return reinterpret_cast<const CaptureTypeRecord *>(this + 1);
-  }
-
-  const MetadataSourceRecord *getMetadataSourceRecordBuffer() const {
-    return reinterpret_cast<const MetadataSourceRecord *>(capture_end().End);
-  }
-
-public:
-  /// The number of captures in the closure and the number of typerefs that
-  /// immediately follow this struct.
-  uint32_t NumCaptureTypes;
-
-  /// The number of sources of metadata available in the MetadataSourceMap
-  /// directly following the list of capture's typerefs.
-  uint32_t NumMetadataSources;
-
-  /// The number of items in the NecessaryBindings structure at the head of
-  /// the closure.
-  uint32_t NumBindings;
-
-  using const_iterator = FieldRecordIterator;
-
-  CaptureTypeRecordIterator capture_begin() const {
-    auto Begin = getCaptureTypeRecordBuffer();
-    auto End = Begin + NumCaptureTypes;
-    return { Begin, End };
-  }
-
-  CaptureTypeRecordIterator capture_end() const {
-    auto Begin = getCaptureTypeRecordBuffer();
-    auto End = Begin + NumCaptureTypes;
-    return { End, End };
-  }
-
-  MetadataSourceRecordIterator source_begin() const {
-    auto Begin = getMetadataSourceRecordBuffer();
-    auto End = Begin + NumMetadataSources;
-    return { Begin, End };
-  }
-
-  MetadataSourceRecordIterator source_end() const {
-    auto Begin = getMetadataSourceRecordBuffer();
-    auto End = Begin + NumMetadataSources;
-    return { End, End };
-  }
-};
-
-class CaptureDescriptorIterator
-  : public std::iterator<std::forward_iterator_tag, CaptureDescriptor> {
-public:
-  const void *Cur;
-  const void * const End;
-  CaptureDescriptorIterator(const void *Cur, const void * const End)
-    : Cur(Cur), End(End) {}
-
-  const CaptureDescriptor &operator*() const {
-    return *reinterpret_cast<const CaptureDescriptor *>(Cur);
-  }
-
-  const CaptureDescriptor *operator->() const {
-    return reinterpret_cast<const CaptureDescriptor *>(Cur);
-  }
-
-  CaptureDescriptorIterator &operator++() {
-    const auto &CR = this->operator*();
-    const void *Next = reinterpret_cast<const char *>(Cur)
-      + sizeof(CaptureDescriptor)
-      + CR.NumCaptureTypes * sizeof(CaptureTypeRecord)
-      + CR.NumMetadataSources * sizeof(MetadataSourceRecord);
-    Cur = Next;
-    return *this;
-  }
-
-  bool operator==(CaptureDescriptorIterator const &other) const {
-    return Cur == other.Cur && End == other.End;
-  }
-
-  bool operator!=(CaptureDescriptorIterator const &other) const {
-    return !(*this == other);
-  }
-};
-
-} // end namespace reflection
-} // end namespace swift
-} // end namespace opencombine
-
-#endif // OPENCOMBINE_SWIFT_REFLECTION_RECORDS_H

Sources/COpenCombineHelpers/swift/Runtime/Config.h

@@ -1,73 +0,0 @@
-//===--- Config.h - Swift Language Platform Configuration -------*- C++ -*-===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
-//
-//===----------------------------------------------------------------------===//
-//
-// Definitions of common interest in Swift.
-//
-//===----------------------------------------------------------------------===//
-
-// MODIFICATION NOTE:
-// This file has been modified for the OpenCombine open source project.
-// Some macros have been renamed or removed.
-
-#ifndef OPENCOMBINE_SWIFT_RUNTIME_CONFIG_H
-#define OPENCOMBINE_SWIFT_RUNTIME_CONFIG_H
-
-#ifdef __GNUC__
-#define OPENCOMBINE_SWIFT_RUNTIME_ATTRIBUTE_NORETURN __attribute__((noreturn))
-#elif defined(_MSC_VER)
-#define OPENCOMBINE_SWIFT_RUNTIME_ATTRIBUTE_NORETURN __declspec(noreturn)
-#else
-#define OPENCOMBINE_SWIFT_RUNTIME_ATTRIBUTE_NORETURN
-#endif
-
-/// Does the current Swift platform support "unbridged" interoperation
-/// with Objective-C?  If so, the implementations of various types must
-/// implicitly handle Objective-C pointers.
-///
-/// Apple platforms support this by default.
-#ifndef OPENCOMBINE_SWIFT_OBJC_INTEROP
-#ifdef __APPLE__
-#define OPENCOMBINE_SWIFT_OBJC_INTEROP 1
-#else
-#define OPENCOMBINE_SWIFT_OBJC_INTEROP 0
-#endif
-#endif
-
-/// Which bits in the class metadata are used to distinguish Swift classes
-/// from ObjC classes?
-#ifndef OPENCOMBINE_SWIFT_CLASS_IS_SWIFT_MASK
-
-# if !defined(__APPLE__)
-// Non-Apple platforms always use 1.
-#  define OPENCOMBINE_SWIFT_CLASS_IS_SWIFT_MASK 1ULL
-# else
-// Apple platforms with Swift in the OS (a.k.a. post-ABI-stability) use 2.
-namespace opencombine { extern unsigned long long classIsSwiftMask; }
-# define OPENCOMBINE_SWIFT_CLASS_IS_SWIFT_MASK classIsSwiftMask
-# endif
-#endif
-
-// Define mappings for calling conventions.
-
-#if __has_attribute(swiftcall)
-# define OPENCOMBINE_SWIFT_CALLING_CONVENTION __attribute__((swiftcall))
-# define OPENCOMBINE_SWIFT_CONTEXT __attribute__((swift_context))
-# define OPENCOMBINE_SWIFT_ERROR_RESULT __attribute__((swift_error_result))
-# define OPENCOMBINE_SWIFT_INDIRECT_RESULT __attribute__((swift_indirect_result))
-#else
-# define OPENCOMBINE_SWIFT_CALLING_CONVENTION
-# define OPENCOMBINE_SWIFT_CONTEXT
-# define OPENCOMBINE_SWIFT_ERROR_RESULT
-# define OPENCOMBINE_SWIFT_INDIRECT_RESULT
-#endif
-
-#endif // OPENCOMBINE_SWIFT_RUNTIME_CONFIG_H

Sources/COpenCombineHelpers/swift/Runtime/Metadata.h

@@ -1,46 +0,0 @@
-//===--- Metadata.h - Swift Language ABI Metadata Support -------*- C++ -*-===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
-//
-//===----------------------------------------------------------------------===//
-//
-// Swift runtime support for generating and uniquing metadata.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef OPENCOMBINE_SWIFT_RUNTIME_METADATA_H
-#define OPENCOMBINE_SWIFT_RUNTIME_METADATA_H
-
-#include "swift/ABI/Metadata.h"
-#include "swift/Reflection/Records.h"
-
-// MODIFICATION NOTE:
-// This file has been modified for the OpenCombine open source project.
-// - Some declarations have been removed.
-// - The swift namespace is wrapped in the opencombine namespace.
-// - Replaced ArrayRef and StringRef with span and string_view
-
-namespace opencombine {
-namespace swift {
-
-/// Compute the bounds of class metadata with a resilient superclass.
-ClassMetadataBounds getResilientMetadataBounds(
-                                           const ClassDescriptor *descriptor);
-int32_t getResilientImmediateMembersOffset(const ClassDescriptor *descriptor);
-
-#if OPENCOMBINE_SWIFT_OBJC_INTEROP
-
-extern "C" Class swift_getInitializedObjCClass(Class c);
-
-#endif
-
-} // end namespace swift
-} // end namespace opencombine
-
-#endif // OPENCOMBINE_SWIFT_RUNTIME_METADATA_H

Sources/COpenCombineHelpers/swift/Runtime/Unreachable.h

@@ -1,37 +0,0 @@
-//===--- Unreachable.h - Implements swift_runtime_unreachable ---*- C++ -*-===//
-//
-// This source file is part of the Swift.org open source project
-//
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
-// Licensed under Apache License v2.0 with Runtime Library Exception
-//
-// See https://swift.org/LICENSE.txt for license information
-// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
-//
-//===----------------------------------------------------------------------===//
-//
-//  This file defines swift_runtime_unreachable, an LLVM-independent
-//  implementation of llvm_unreachable.
-//
-//===----------------------------------------------------------------------===//
-
-// MODIFICATION NOTE:
-// This file has been modified for the OpenCombine open source project.
-// - Symbols have been prefix with the 'opencombine' prefix.
-
-#ifndef OPENCOMBINE_SWIFT_RUNTIME_UNREACHABLE_H
-#define OPENCOMBINE_SWIFT_RUNTIME_UNREACHABLE_H
-
-#include <assert.h>
-#include <stdlib.h>
-
-#include "swift/Runtime/Config.h"
-
-OPENCOMBINE_SWIFT_RUNTIME_ATTRIBUTE_NORETURN
-inline static void opencombine_swift_runtime_unreachable(const char *msg) {
-  assert(false && msg);
-  (void)msg;
-  abort();
-}
-
-#endif // OPENCOMBINE_SWIFT_RUNTIME_UNREACHABLE_H

Sources/OpenCombine/CombineIdentifier.swift

@@ -5,14 +5,16 @@
 //  Created by Sergej Jaskiewicz on 10.06.2019.
 //
 
-import func COpenCombineHelpers.nextCombineIdentifier
+#if canImport(COpenCombineHelpers)
+import COpenCombineHelpers
+#endif
 
 public struct CombineIdentifier: Hashable, CustomStringConvertible {
 
     private let value: UInt64
 
     public init() {
-        value = nextCombineIdentifier()
+        value = __nextCombineIdentifier()
     }
 
     public init(_ obj: AnyObject) {

Sources/OpenCombine/CurrentValueSubject.swift

@@ -5,7 +5,9 @@
 //  Created by Sergej Jaskiewicz on 11.06.2019.
 //
 
+#if canImport(COpenCombineHelpers)
 import COpenCombineHelpers
+#endif
 
 /// A subject that wraps a single value and publishes a new element whenever the value
 /// changes.

Sources/OpenCombine/Future.swift

@@ -5,7 +5,9 @@
 //  Created by Max Desiatov on 24/11/2019.
 //
 
+#if canImport(COpenCombineHelpers)
 import COpenCombineHelpers
+#endif
 
 /// A publisher that eventually produces one value and then finishes or fails.
 public final class Future<Output, Failure>: Publisher where Failure: Error {

Sources/OpenCombine/Helpers/EnumerateFields.swift

@@ -1,33 +0,0 @@
-//
-//  EnumerateFields.swift
-//  
-//
-//  Created by Sergej Jaskiewicz on 31.10.2019.
-//
-
-import COpenCombineHelpers
-
-internal typealias FieldEnumerator =
-    (_ fieldName: UnsafePointer<CChar>, _ fieldOffset: Int, _ fieldType: Any.Type) -> Bool
-
-internal func enumerateFields(ofType type: Any.Type,
-                              allowResilientSuperclasses: Bool,
-                              enumerator: FieldEnumerator) {
-    // A neat trick to pass a Swift closure where a C function pointer is expected.
-    // (Unlike closures, function pointers cannot capture context)
-    withoutActuallyEscaping(enumerator) { enumerator in
-        var context = enumerator
-        enumerateFields(
-            typeMetadata: unsafeBitCast(type, to: UnsafeRawPointer.self),
-            allowResilientSuperclasses: allowResilientSuperclasses,
-            enumeratorContext: &context,
-            enumerator: { rawContext, fieldName, fieldOffset, rawMetadataPtr in
-                rawContext
-                    .unsafelyUnwrapped
-                    .assumingMemoryBound(to: FieldEnumerator.self)
-                    .pointee(fieldName,
-                             fieldOffset,
-                             unsafeBitCast(rawMetadataPtr, to: Any.Type.self))
-            })
-    }
-}

Sources/OpenCombine/Helpers/FilterProducer.swift

@@ -5,7 +5,9 @@
 //  Created by Sergej Jaskiewicz on 23.10.2019.
 //
 
+#if canImport(COpenCombineHelpers)
 import COpenCombineHelpers
+#endif
 
 /// A helper class that acts like both subscriber and subscription.
 ///

Sources/OpenCombine/Helpers/Locking.swift

@@ -5,7 +5,12 @@
 //  Created by Sergej Jaskiewicz on 11.06.2019.
 //
 
+#if canImport(COpenCombineHelpers)
 import COpenCombineHelpers
+#endif
+
+internal typealias UnfairLock = __UnfairLock
+internal typealias UnfairRecursiveLock = __UnfairRecursiveLock
 
 extension UnfairRecursiveLock {
 

Sources/OpenCombine/Helpers/ReduceProducer.swift

@@ -5,7 +5,9 @@
 //  Created by Sergej Jaskiewicz on 22.09.2019.
 //
 
+#if canImport(COpenCombineHelpers)
 import COpenCombineHelpers
+#endif
 
 /// A helper class that acts like both subscriber and subscription.
 ///

Sources/OpenCombine/Helpers/SubjectSubscriber.swift

@@ -5,7 +5,9 @@
 //  Created by Sergej Jaskiewicz on 16/09/2019.
 //
 
+#if canImport(COpenCombineHelpers)
 import COpenCombineHelpers
+#endif
 
 // NOTE: This class has been audited for thread safety.
 internal final class SubjectSubscriber<Downstream: Subject>

Sources/OpenCombine/ImmediateScheduler.swift

@@ -7,8 +7,9 @@
 
 /// A scheduler for performing synchronous actions.
 ///
-/// You can use this scheduler for immediate actions. If you attempt to schedule
-/// actions after a specific date, the scheduler produces a fatal error.
+/// You can only use this scheduler for immediate actions. If you attempt to schedule
+/// actions after a specific date, this scheduler ignores the date and performs
+/// them immediately.
 public struct ImmediateScheduler: Scheduler {
 
     /// The time type used by the immediate scheduler.

Sources/OpenCombine/ObservableObject.swift

@@ -5,61 +5,6 @@
 //  Created by Sergej Jaskiewicz on 08/09/2019.
 //
 
-// We use type metadata in the implementation of ObservableObject,
-// but type metadata is stable only on Darwin. There are no such guarantees
-// on non-Apple platforms (yet).
-//
-// This means that on Linux the layout of type metadata can change in a new Swift release,
-// which will cause bugs that are hard to track (basically, undefined behavior).
-//
-// Whenever a new Swift version is available, we well test OpenCombine against it,
-// and if everything works, release an update as soon as possible where the maximum
-// supported Swift version is incremented.
-#if !canImport(Darwin) && swift(>=5.1.50)
-#warning("""
-ObservableObject is not guaranteed to work on non-Apple platforms with this version \
-of Swift because its implementation relies on ABI stability.
-
-In order to fix this warning, please update to the newest version of OpenCombine, \
-or create an issue at https://github.com/broadwaylamb/OpenCombine if there is no \
-newer version yet.
-""")
-#endif
-
-#if swift(>=5.1)
-private protocol _ObservableObjectProperty {
-    var objectWillChange: ObservableObjectPublisher? { get set }
-}
-
-extension _ObservableObjectProperty {
-
-    fileprivate static func installPublisher(
-        _ publisher: ObservableObjectPublisher,
-        on publishedStorage: UnsafeMutableRawPointer
-    ) {
-        // It is safe to call assumingMemoryBound here because we know for sure
-        // that the actual type of the pointee is Self.
-        publishedStorage
-            .assumingMemoryBound(to: Self.self)
-            .pointee
-            .objectWillChange = publisher
-    }
-
-    fileprivate static func getPublisher(
-        from publishedStorage: UnsafeMutableRawPointer
-    ) -> ObservableObjectPublisher? {
-        // It is safe to call assumingMemoryBound here because we know for sure
-        // that the actual type of the pointee is Self.
-        return publishedStorage
-            .assumingMemoryBound(to: Self.self)
-            .pointee
-            .objectWillChange
-    }
-}
-
-extension Published: _ObservableObjectProperty {}
-#endif
-
 /// A type of object with a publisher that emits before the object has changed.
 ///
 /// By default an `ObservableObject` will synthesize an `objectWillChange`
@@ -96,60 +41,23 @@ public protocol ObservableObject: AnyObject {
 }
 
 extension ObservableObject where ObjectWillChangePublisher == ObservableObjectPublisher {
-
-    /// A publisher that emits before the object has changed.
-    public var objectWillChange: ObservableObjectPublisher {
+    // swiftlint:disable let_var_whitespace
 #if swift(>=5.1)
-        var installedPublisher: ObservableObjectPublisher?
-
-        enumerateFields(ofType: Self.self,
-                        allowResilientSuperclasses: false) { _, fieldOffset, fieldType in
-            let storage = Unmanaged
-                .passUnretained(self)
-                .toOpaque()
-                .advanced(by: fieldOffset)
-
-            guard let fieldType = fieldType as? _ObservableObjectProperty.Type else {
-                // Visit other fields until we meet a @Published field
-                return true
-            }
-
-            // Now we know that the field is @Published.
-
-            if let alreadyInstalledPublisher = fieldType.getPublisher(from: storage) {
-                installedPublisher = alreadyInstalledPublisher
-                // Don't visit other fields, as all @Published fields
-                // already have a publisher installed.
-                return false
-            }
-
-            // Okay, this field doesn't have a publisher installed.
-            // This means that other fields don't have it either
-            // (because we install it only once and fields can't be added at runtime).
-
-            var lazilyCreatedPublisher: ObjectWillChangePublisher {
-                if let publisher = installedPublisher {
-                    return publisher
-                }
-                let publisher = ObservableObjectPublisher()
-                installedPublisher = publisher
-                return publisher
-            }
-
-            fieldType.installPublisher(lazilyCreatedPublisher, on: storage)
-
-            // Continue visiting other fields.
-            return true
-        }
-
-        return installedPublisher ?? ObservableObjectPublisher()
-#else
-        // There are no @Published in Swift 5.0, so we act the same as in Swift 5.1
-        // with classes without @Published properties.
-        // We create a new instance every time.
-        return ObservableObjectPublisher()
-#endif // swift(>=5.1)
+    /// A publisher that emits before the object has changed.
+    @available(*, unavailable, message: """
+               The default implementation of objectWillChange is not available yet. \
+               It's being worked on in \
+               https://github.com/broadwaylamb/OpenCombine/pull/97
+               """)
+    public var objectWillChange: ObservableObjectPublisher {
+        fatalError("unimplemented")
     }
+#else
+    public var objectWillChange: ObservableObjectPublisher {
+        return ObservableObjectPublisher()
+    }
+#endif
+    // swiftlint:enable let_var_whitespace
 }
 
 /// The default publisher of an `ObservableObject`.

Sources/OpenCombine/PassthroughSubject.swift

@@ -5,7 +5,9 @@
 //  Created by Sergej Jaskiewicz on 11.06.2019.
 //
 
+#if canImport(COpenCombineHelpers)
 import COpenCombineHelpers
+#endif
 
 /// A subject that passes along values and completion.
 ///

Sources/OpenCombine/Publishers/Just.swift

@@ -249,6 +249,26 @@ extension Just {
     ) -> Result<ElementOfResult, Error>.OCombine.Publisher {
         return .init(Result { try nextPartialResult(initialResult, output) })
     }
+
+    public func prepend(_ elements: Output...) -> Publishers.Sequence<[Output], Never> {
+        return prepend(elements)
+    }
+
+    public func prepend<Elements: Sequence>(
+        _ elements: Elements
+    ) -> Publishers.Sequence<[Output], Never> where Output == Elements.Element {
+        return .init(sequence: elements + [output])
+    }
+
+    public func append(_ elements: Output...) -> Publishers.Sequence<[Output], Never> {
+        return append(elements)
+    }
+
+    public func append<Elements: Sequence>(
+        _ elements: Elements
+    ) -> Publishers.Sequence<[Output], Never> where Output == Elements.Element {
+        return .init(sequence: [output] + elements)
+    }
 }
 
 extension Just {

Sources/OpenCombine/Publishers/Publishers.Autoconnect.swift

@@ -5,7 +5,9 @@
 //  Created by Sergej Jaskiewicz on 18/09/2019.
 //
 
+#if canImport(COpenCombineHelpers)
 import COpenCombineHelpers
+#endif
 
 extension ConnectablePublisher {
 

Sources/OpenCombine/Publishers/Publishers.Breakpoint.swift

@@ -0,0 +1,183 @@
+//
+//  Publishers.Breakpoint.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 03.12.2019.
+//
+
+#if canImport(COpenCombineHelpers)
+import COpenCombineHelpers
+#endif
+
+extension Publisher {
+
+    /// Raises a debugger signal when a provided closure needs to stop the process in
+    /// the debugger.
+    ///
+    /// When any of the provided closures returns `true`, this publisher raises
+    /// the `SIGTRAP` signal to stop the process in the debugger.
+    /// Otherwise, this publisher passes through values and completions as-is.
+    ///
+    /// - Parameters:
+    ///   - receiveSubscription: A closure that executes when when the publisher receives
+    ///     a subscription. Return `true` from this closure to raise `SIGTRAP`, or `false`
+    ///     to continue.
+    ///   - receiveOutput: A closure that executes when when the publisher receives
+    ///     a value. Return `true` from this closure to raise `SIGTRAP`, or `false`
+    ///     to continue.
+    ///   - receiveCompletion: A closure that executes when when the publisher receives
+    ///     a completion. Return `true` from this closure to raise `SIGTRAP`, or `false`
+    ///     to continue.
+    /// - Returns: A publisher that raises a debugger signal when one of the provided
+    ///   closures returns `true`.
+    public func breakpoint(
+        receiveSubscription: ((Subscription) -> Bool)? = nil,
+        receiveOutput: ((Output) -> Bool)? = nil,
+        receiveCompletion: ((Subscribers.Completion<Failure>) -> Bool)? = nil
+    ) -> Publishers.Breakpoint<Self> {
+        return .init(upstream: self,
+                     receiveSubscription: receiveSubscription,
+                     receiveOutput: receiveOutput,
+                     receiveCompletion: receiveCompletion)
+    }
+
+    /// Raises a debugger signal upon receiving a failure.
+    ///
+    /// When the upstream publisher fails with an error, this publisher raises
+    /// the `SIGTRAP` signal, which stops the process in the debugger.
+    /// Otherwise, this publisher passes through values and completions as-is.
+    ///
+    /// - Returns: A publisher that raises a debugger signal upon receiving a failure.
+    public func breakpointOnError() -> Publishers.Breakpoint<Self> {
+        return breakpoint { completion in
+            switch completion {
+            case .finished:
+                return false
+            case .failure:
+                return true
+            }
+        }
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that raises a debugger signal when a provided closure needs to stop
+    /// the process in the debugger.
+    ///
+    /// When any of the provided closures returns `true`, this publisher raises
+    /// the `SIGTRAP` signal to stop the process in the debugger.
+    /// Otherwise, this publisher passes through values and completions as-is.
+    public struct Breakpoint<Upstream: Publisher>: Publisher {
+
+        public typealias Output = Upstream.Output
+
+        public typealias Failure = Upstream.Failure
+
+        /// The publisher from which this publisher receives elements.
+        public let upstream: Upstream
+
+        /// A closure that executes when the publisher receives a subscription, and can
+        /// raise a debugger signal by returning a `true` Boolean value.
+        public let receiveSubscription: ((Subscription) -> Bool)?
+
+        /// A closure that executes when the publisher receives output from the upstream
+        /// publisher, and can raise a debugger signal by returning a `true` Boolean
+        /// value.
+        public let receiveOutput: ((Upstream.Output) -> Bool)?
+
+        /// A closure that executes when the publisher receives completion, and can raise
+        /// a debugger signal by returning a `true` Boolean value.
+        public let receiveCompletion:
+            ((Subscribers.Completion<Upstream.Failure>) -> Bool)?
+
+        /// Creates a breakpoint publisher with the provided upstream publisher and
+        /// breakpoint-raising closures.
+        ///
+        /// - Parameters:
+        ///   - upstream: The publisher from which this publisher receives elements.
+        ///   - receiveSubscription: A closure that executes when the publisher receives
+        ///     a subscription, and can raise a debugger signal by returning a `true`
+        ///     Boolean value.
+        ///   - receiveOutput: A closure that executes when the publisher receives output
+        ///     from the upstream publisher, and can raise a debugger signal by returning
+        ///     a `true` Boolean value.
+        ///   - receiveCompletion: A closure that executes when the publisher receives
+        ///     completion, and can raise a debugger signal by returning a `true` Boolean
+        ///     value.
+        public init(
+            upstream: Upstream,
+            receiveSubscription: ((Subscription) -> Bool)? = nil,
+            receiveOutput: ((Upstream.Output) -> Bool)? = nil,
+            receiveCompletion: ((Subscribers.Completion<Failure>) -> Bool)? = nil
+        ) {
+            self.upstream = upstream
+            self.receiveSubscription = receiveSubscription
+            self.receiveOutput = receiveOutput
+            self.receiveCompletion = receiveCompletion
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Upstream.Failure == Downstream.Failure,
+                  Upstream.Output == Downstream.Input
+        {
+            upstream.subscribe(Inner(self, downstream: subscriber))
+        }
+    }
+}
+
+extension Publishers.Breakpoint {
+    private struct Inner<Downstream: Subscriber>
+        : Subscriber,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == Upstream.Output, Downstream.Failure == Upstream.Failure
+    {
+        typealias Input = Upstream.Output
+        typealias Failure = Upstream.Failure
+
+        private let downstream: Downstream
+        private let breakpoint: Publishers.Breakpoint<Upstream>
+
+        let combineIdentifier = CombineIdentifier()
+
+        init(_ breakpoint: Publishers.Breakpoint<Upstream>,
+             downstream: Downstream) {
+            self.downstream = downstream
+            self.breakpoint = breakpoint
+        }
+
+        func receive(subscription: Subscription) {
+            if breakpoint.receiveSubscription?(subscription) == true {
+                __stopInDebugger()
+            }
+            downstream.receive(subscription: subscription)
+        }
+
+        func receive(_ input: Upstream.Output) -> Subscribers.Demand {
+            if breakpoint.receiveOutput?(input) == true {
+                __stopInDebugger()
+            }
+            return downstream.receive(input)
+        }
+
+        func receive(completion: Subscribers.Completion<Upstream.Failure>) {
+            if breakpoint.receiveCompletion?(completion) == true {
+                __stopInDebugger()
+            }
+            downstream.receive(completion: completion)
+        }
+
+        var description: String { return "Breakpoint" }
+
+        var customMirror: Mirror {
+            let children = CollectionOfOne<Mirror.Child>(
+                ("upstream", breakpoint.upstream)
+            )
+            return Mirror(self, children: children)
+        }
+
+        var playgroundDescription: Any { return description }
+    }
+}

Sources/OpenCombine/Publishers/Publishers.Concatenate.swift

@@ -0,0 +1,250 @@
+//
+//  Publishers.Concatenate.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 24.10.2019.
+//
+
+extension Publisher {
+
+    /// Prefixes a `Publisher`'s output with the specified sequence.
+    ///
+    /// - Parameter elements: The elements to publish before this publisher’s elements.
+    /// - Returns: A publisher that prefixes the specified elements prior to this
+    ///   publisher’s elements.
+    public func prepend(
+        _ elements: Output...
+    ) -> Publishers.Concatenate<Publishers.Sequence<[Output], Failure>, Self> {
+        return prepend(elements)
+    }
+
+    /// Prefixes a `Publisher`'s output with the specified sequence.
+    ///
+    /// - Parameter elements: A sequence of elements to publish before this publisher’s
+    ///   elements.
+    /// - Returns: A publisher that prefixes the sequence of elements prior to this
+    ///   publisher’s elements.
+    public func prepend<Elements: Sequence>(
+        _ elements: Elements
+    ) -> Publishers.Concatenate<Publishers.Sequence<Elements, Failure>, Self>
+        where Output == Elements.Element
+    {
+        return prepend(.init(sequence: elements))
+    }
+
+    /// Prefixes this publisher’s output with the elements emitted by the given publisher.
+    ///
+    /// The resulting publisher doesn’t emit any elements until the prefixing publisher
+    /// finishes.
+    ///
+    /// - Parameter publisher: The prefixing publisher.
+    /// - Returns: A publisher that prefixes the prefixing publisher’s elements prior to
+    ///   this publisher’s elements.
+    public func prepend<Prefix: Publisher>(
+        _ publisher: Prefix
+    ) -> Publishers.Concatenate<Prefix, Self>
+        where Failure == Prefix.Failure, Output == Prefix.Output
+    {
+        return .init(prefix: publisher, suffix: self)
+    }
+
+    /// Append a `Publisher`'s output with the specified sequence.
+    public func append(
+        _ elements: Output...
+    ) -> Publishers.Concatenate<Self, Publishers.Sequence<[Output], Failure>> {
+        return append(elements)
+    }
+
+    /// Appends a `Publisher`'s output with the specified sequence.
+    public func append<Elements: Sequence>(
+        _ elements: Elements
+    ) -> Publishers.Concatenate<Self, Publishers.Sequence<Elements, Failure>>
+        where Output == Elements.Element
+    {
+        return append(.init(sequence: elements))
+    }
+
+    /// Appends this publisher’s output with the elements emitted by the given publisher.
+    ///
+    /// This operator produces no elements until this publisher finishes. It then produces
+    /// this publisher’s elements, followed by the given publisher’s elements.
+    /// If this publisher fails with an error, the prefixing publisher does not publish
+    /// the provided publisher’s elements.
+    ///
+    /// - Parameter publisher: The appending publisher.
+    /// - Returns: A publisher that appends the appending publisher’s elements after this
+    ///   publisher’s elements.
+    public func append<Suffix: Publisher>(
+        _ publisher: Suffix
+    ) -> Publishers.Concatenate<Self, Suffix>
+        where Suffix.Failure == Failure, Suffix.Output == Output
+    {
+        return .init(prefix: self, suffix: publisher)
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that emits all of one publisher’s elements before those from anothe
+    /// publisher.
+    public struct Concatenate<Prefix: Publisher, Suffix: Publisher>: Publisher
+        where Prefix.Failure == Suffix.Failure, Prefix.Output == Suffix.Output
+    {
+        public typealias Output = Suffix.Output
+
+        public typealias Failure = Suffix.Failure
+
+        /// The publisher to republish, in its entirety, before republishing elements from
+        /// `suffix`.
+        public let prefix: Prefix
+
+        /// The publisher to republish only after `prefix` finishes.
+        public let suffix: Suffix
+
+        public init(prefix: Prefix, suffix: Suffix) {
+            self.prefix = prefix
+            self.suffix = suffix
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Suffix.Failure == Downstream.Failure, Suffix.Output == Downstream.Input
+        {
+            let inner = Inner(downstream: subscriber, suffix: suffix)
+            prefix.subscribe(inner)
+            subscriber.receive(subscription: inner)
+        }
+    }
+}
+
+extension Publishers.Concatenate: Equatable where Prefix: Equatable, Suffix: Equatable {}
+
+extension Publishers.Concatenate {
+    private final class Inner<Downstream: Subscriber>
+        : Subscriber,
+          Subscription,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == Suffix.Output, Downstream.Failure == Suffix.Failure
+    {
+        typealias Input = Suffix.Output
+
+        typealias Failure = Suffix.Failure
+
+        private let downstream: Downstream
+
+        private let suffix: Suffix
+
+        private var prefixFinished = false
+
+        private var demand = Subscribers.Demand.none
+
+        private var upstream: Subscription?
+
+        private var expectedSubscriptions = 2
+
+        private let lock = UnfairLock.allocate()
+
+        // ??? This lock is non-recursive in Combine, but it should be!
+        // (FB7404824 if Apple folks are watching)
+        private let downstreamLock = UnfairLock.allocate()
+
+        fileprivate init(downstream: Downstream, suffix: Suffix) {
+            self.downstream = downstream
+            self.suffix = suffix
+        }
+
+        deinit {
+            lock.deallocate()
+            downstreamLock.deallocate()
+        }
+
+        func receive(subscription: Subscription) {
+            lock.lock()
+            guard upstream == nil, expectedSubscriptions > 0 else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            upstream = subscription
+            expectedSubscriptions -= 1
+            let demand = self.demand
+            lock.unlock()
+            if demand > 0 {
+                subscription.request(demand)
+            }
+        }
+
+        func receive(_ input: Input) -> Subscribers.Demand {
+            lock.lock()
+            demand -= 1
+            lock.unlock()
+            downstreamLock.lock()
+            let newDemand = downstream.receive(input)
+            downstreamLock.unlock()
+            lock.lock()
+            demand += newDemand
+            lock.unlock()
+            return newDemand
+        }
+
+        func receive(completion: Subscribers.Completion<Failure>) {
+            // Reading prefixFinished should be locked. Combine doesn't lock here.
+            if prefixFinished {
+                downstreamLock.lock()
+                downstream.receive(completion: completion)
+                downstreamLock.unlock()
+                return
+            }
+
+            guard case .finished = completion else {
+                downstreamLock.lock()
+                downstream.receive(completion: completion)
+                downstreamLock.unlock()
+                return
+            }
+
+            prefixFinished = true // Should be locked as well?
+            lock.lock()
+            upstream = nil
+            lock.unlock()
+            suffix.subscribe(self)
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            lock.lock()
+            self.demand += demand
+            guard let subscription = upstream else {
+                lock.unlock()
+                return
+            }
+            lock.unlock()
+            subscription.request(demand)
+        }
+
+        func cancel() {
+            lock.lock()
+            guard let subscription = upstream else {
+                lock.unlock()
+                return
+            }
+            upstream = nil
+            lock.unlock()
+            subscription.cancel()
+        }
+
+        var description: String { return "Concatenate" }
+
+        var customMirror: Mirror {
+            let children: [Mirror.Child] = [
+                ("downstream", downstream),
+                ("upstreamSubscription", upstream as Any),
+                ("suffix", suffix),
+                ("demand", demand)
+            ]
+            return Mirror(self, children: children)
+        }
+
+        var playgroundDescription: Any { return description }
+    }
+}

Sources/OpenCombine/Publishers/Publishers.Delay.swift

@@ -0,0 +1,229 @@
+//
+//  Publishers.Delay.swift
+//  OpenCombine
+//
+//  Created by Евгений Богомолов on 07/09/2019.
+//
+
+#if canImport(COpenCombineHelpers)
+import COpenCombineHelpers
+#endif
+
+extension Publisher {
+
+    /// Delays delivery of all output to the downstream receiver by a specified amount
+    /// of time on a particular scheduler.
+    ///
+    /// The delay affects the delivery of elements and completion, but not of the original
+    /// subscription.
+    ///
+    /// - Parameters:
+    ///   - interval: The amount of time to delay.
+    ///   - tolerance: The allowed tolerance in firing delayed events.
+    ///   - scheduler: The scheduler to deliver the delayed events.
+    /// - Returns: A publisher that delays delivery of elements and completion to
+    ///   the downstream receiver.
+    public func delay<Context: Scheduler>(
+        for interval: Context.SchedulerTimeType.Stride,
+        tolerance: Context.SchedulerTimeType.Stride? = nil,
+        scheduler: Context,
+        options: Context.SchedulerOptions? = nil
+    ) -> Publishers.Delay<Self, Context> {
+        return .init(upstream: self,
+                     interval: interval,
+                     tolerance: tolerance ?? scheduler.minimumTolerance,
+                     scheduler: scheduler,
+                     options: options)
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that delays delivery of elements and completion
+    /// to the downstream receiver.
+    public struct Delay<Upstream: Publisher, Context: Scheduler>: Publisher {
+
+        public typealias Output = Upstream.Output
+
+        public typealias Failure = Upstream.Failure
+
+        /// The publisher that this publisher receives elements from.
+        public let upstream: Upstream
+
+        /// The amount of time to delay.
+        public let interval: Context.SchedulerTimeType.Stride
+
+        /// The allowed tolerance in firing delayed events.
+        public let tolerance: Context.SchedulerTimeType.Stride
+
+        /// The scheduler to deliver the delayed events.
+        public let scheduler: Context
+
+        public let options: Context.SchedulerOptions?
+
+        public init(upstream: Upstream,
+                    interval: Context.SchedulerTimeType.Stride,
+                    tolerance: Context.SchedulerTimeType.Stride,
+                    scheduler: Context,
+                    options: Context.SchedulerOptions? = nil)
+        {
+            self.upstream = upstream
+            self.interval = interval
+            self.tolerance = tolerance
+            self.scheduler = scheduler
+            self.options = options
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Upstream.Failure == Downstream.Failure,
+                  Upstream.Output == Downstream.Input
+        {
+            upstream.subscribe(Inner(self, downstream: subscriber))
+        }
+    }
+}
+
+extension Publishers.Delay {
+    private final class Inner<Downstream: Subscriber>
+        : Subscriber,
+          Subscription
+        where Downstream.Input == Upstream.Output, Downstream.Failure == Upstream.Failure
+    {
+        // NOTE: This class has been audited for thread safety
+
+        typealias Input = Upstream.Output
+        typealias Failure = Upstream.Failure
+
+        fileprivate typealias Delay = Publishers.Delay<Upstream, Context>
+
+        private enum State {
+            case ready(Delay, Downstream)
+            case subscribed(Delay, Downstream, Subscription)
+            case terminal
+        }
+
+        private let lock = UnfairLock.allocate()
+        private var state: State
+        private let downstreamLock = UnfairLock.allocate()
+
+        fileprivate init(_ publisher: Delay, downstream: Downstream) {
+            state = .ready(publisher, downstream)
+        }
+
+        deinit {
+            lock.deallocate()
+            downstreamLock.deallocate()
+        }
+
+        private func schedule(_ delay: Delay,
+                              immediate: Bool,
+                              work: @escaping () -> Void) {
+            if immediate {
+                delay.scheduler.schedule(options: delay.options, work)
+                return
+            }
+            delay
+                .scheduler
+                .schedule(after: delay.scheduler.now.advanced(by: delay.interval),
+                          tolerance: delay.tolerance,
+                          options: delay.options,
+                          work)
+        }
+
+        func receive(subscription: Subscription) {
+            lock.lock()
+            guard case let .ready(delay, downstream) = state else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            state = .subscribed(delay, downstream, subscription)
+            lock.unlock()
+            schedule(delay, immediate: true) { [weak self] in
+                self?.scheduledReceive(subscription: subscription)
+            }
+        }
+
+        private func scheduledReceive(subscription: Subscription) {
+            lock.lock()
+            guard case let .subscribed(_, downstream, _) = state else {
+                lock.unlock()
+                return
+            }
+            lock.unlock()
+            downstreamLock.lock()
+            downstream.receive(subscription: self)
+            downstreamLock.unlock()
+        }
+
+        func receive(_ input: Upstream.Output) -> Subscribers.Demand {
+            lock.lock()
+            guard case let .subscribed(delay, downstream, _) = state else {
+                lock.unlock()
+                return .none
+            }
+            lock.unlock()
+            schedule(delay, immediate: false) { [weak self] in
+                self?.scheduledReceive(input, downstream: downstream)
+            }
+            return .none
+        }
+
+        private func scheduledReceive(_ input: Upstream.Output, downstream: Downstream) {
+            downstreamLock.lock()
+            let newDemand = downstream.receive(input)
+            downstreamLock.unlock()
+            guard newDemand > 0 else {
+                return
+            }
+            lock.lock()
+            guard case let .subscribed(_, _, subscription) = state else {
+                lock.unlock()
+                return
+            }
+            lock.unlock()
+            subscription.request(newDemand)
+        }
+
+        func receive(completion: Subscribers.Completion<Failure>) {
+            lock.lock()
+            guard case let .subscribed(delay, downstream, _) = state else {
+                lock.unlock()
+                return
+            }
+            state = .terminal
+            lock.unlock()
+            schedule(delay, immediate: false) { [weak self] in
+                self?.scheduledReceive(completion: completion, downstream: downstream)
+            }
+        }
+
+        private func scheduledReceive(completion: Subscribers.Completion<Failure>,
+                                      downstream: Downstream) {
+            downstreamLock.lock()
+            downstream.receive(completion: completion)
+            downstreamLock.unlock()
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            lock.lock()
+            guard case let .subscribed(_, _, subscription) = state else {
+                lock.unlock()
+                return
+            }
+            lock.unlock()
+            subscription.request(demand)
+        }
+
+        func cancel() {
+            lock.lock()
+            guard case let .subscribed(_, _, subscription) = state else {
+                lock.unlock()
+                return
+            }
+            state = .terminal
+            lock.unlock()
+            subscription.cancel()
+        }
+    }
+}

Sources/OpenCombine/Publishers/Publishers.Drop.swift

@@ -5,7 +5,9 @@
 //  Created by Sven Weidauer on 03.10.2019.
 //
 
+#if canImport(COpenCombineHelpers)
 import COpenCombineHelpers
+#endif
 
 extension Publisher {
     /// Omits the specified number of elements before republishing subsequent elements.

Sources/OpenCombine/Publishers/Publishers.DropWhile.swift

@@ -5,7 +5,9 @@
 //  Created by Sergej Jaskiewicz on 16.06.2019.
 //
 
+#if canImport(COpenCombineHelpers)
 import COpenCombineHelpers
+#endif
 
 extension Publisher {
 

Sources/OpenCombine/Publishers/Publishers.FlatMap.swift

@@ -4,7 +4,9 @@
 //  Created by Eric Patey on 16.08.2019.
 //
 
+#if canImport(COpenCombineHelpers)
 import COpenCombineHelpers
+#endif
 
 extension Publisher {
     /// Transforms all elements from an upstream publisher into a new or existing

Sources/OpenCombine/Publishers/Publishers.HandleEvents.swift

@@ -0,0 +1,197 @@
+//
+//  Publishers.HandleEvents.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 03.12.2019.
+//
+
+#if canImport(COpenCombineHelpers)
+import COpenCombineHelpers
+#endif
+
+extension Publisher {
+
+    /// Performs the specified closures when publisher events occur.
+    ///
+    /// - Parameters:
+    ///   - receiveSubscription: A closure that executes when the publisher receives
+    ///     the subscription from the upstream publisher. Defaults to `nil`.
+    ///   - receiveOutput: A closure that executes when the publisher receives a value
+    ///     from the upstream publisher. Defaults to `nil`.
+    ///   - receiveCompletion: A closure that executes when the publisher receives
+    ///     the completion from the upstream publisher. Defaults to `nil`.
+    ///   - receiveCancel: A closure that executes when the downstream receiver cancels
+    ///     publishing. Defaults to `nil`.
+    ///   - receiveRequest: A closure that executes when the publisher receives a request
+    ///     for more elements. Defaults to `nil`.
+    /// - Returns: A publisher that performs the specified closures when publisher events
+    ///   occur.
+    public func handleEvents(
+        receiveSubscription: ((Subscription) -> Void)? = nil,
+        receiveOutput: ((Output) -> Void)? = nil,
+        receiveCompletion: ((Subscribers.Completion<Failure>) -> Void)? = nil,
+        receiveCancel: (() -> Void)? = nil,
+        receiveRequest: ((Subscribers.Demand) -> Void)? = nil
+    ) -> Publishers.HandleEvents<Self> {
+        return .init(upstream: self,
+                     receiveSubscription: receiveSubscription,
+                     receiveOutput: receiveOutput,
+                     receiveCompletion: receiveCompletion,
+                     receiveCancel: receiveCancel,
+                     receiveRequest: receiveRequest)
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that performs the specified closures when publisher events occur.
+    public struct HandleEvents<Upstream: Publisher>: Publisher {
+
+        public typealias Output = Upstream.Output
+
+        public typealias Failure = Upstream.Failure
+
+        /// The publisher from which this publisher receives elements.
+        public let upstream: Upstream
+
+        /// A closure that executes when the publisher receives the subscription from
+        /// the upstream publisher.
+        public var receiveSubscription: ((Subscription) -> Void)?
+
+        ///  A closure that executes when the publisher receives a value from the upstream
+        ///  publisher.
+        public var receiveOutput: ((Upstream.Output) -> Void)?
+
+        /// A closure that executes when the publisher receives the completion from
+        /// the upstream publisher.
+        public var receiveCompletion:
+            ((Subscribers.Completion<Upstream.Failure>) -> Void)?
+
+        ///  A closure that executes when the downstream receiver cancels publishing.
+        public var receiveCancel: (() -> Void)?
+
+        /// A closure that executes when the publisher receives a request for more
+        /// elements.
+        public var receiveRequest: ((Subscribers.Demand) -> Void)?
+
+        public init(
+            upstream: Upstream,
+            receiveSubscription: ((Subscription) -> Void)? = nil,
+            receiveOutput: ((Output) -> Void)? = nil,
+            receiveCompletion: ((Subscribers.Completion<Failure>) -> Void)? = nil,
+            receiveCancel: (() -> Void)? = nil,
+            receiveRequest: ((Subscribers.Demand) -> Void)?
+        ) {
+            self.upstream = upstream
+            self.receiveSubscription = receiveSubscription
+            self.receiveOutput = receiveOutput
+            self.receiveCompletion = receiveCompletion
+            self.receiveCancel = receiveCancel
+            self.receiveRequest = receiveRequest
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Upstream.Failure == Downstream.Failure,
+                  Upstream.Output == Downstream.Input
+        {
+            let inner = Inner(self, downstream: subscriber)
+            subscriber.receive(subscription: inner)
+            upstream.subscribe(inner)
+        }
+    }
+}
+
+extension Publishers.HandleEvents {
+    private final class Inner<Downstream: Subscriber>
+        : Subscriber,
+          Subscription,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == Upstream.Output, Downstream.Failure == Upstream.Failure
+    {
+        typealias Input = Upstream.Output
+        typealias Failure = Upstream.Failure
+
+        private var status = SubscriptionStatus.awaitingSubscription
+        private var pendingDemand = Subscribers.Demand.none
+        private let lock = UnfairLock.allocate()
+        private var events: Publishers.HandleEvents<Upstream>?
+        private let downstream: Downstream
+
+        init(_ events: Publishers.HandleEvents<Upstream>, downstream: Downstream) {
+            self.events = events
+            self.downstream = downstream
+        }
+
+        deinit {
+            lock.deallocate()
+        }
+
+        func receive(subscription: Subscription) {
+            events?.receiveSubscription?(subscription)
+            lock.lock()
+            guard case .awaitingSubscription = status else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            status = .subscribed(subscription)
+            let pendingDemand = self.pendingDemand
+            self.pendingDemand = .none
+            lock.unlock()
+            if pendingDemand > 0 {
+                subscription.request(pendingDemand)
+            }
+        }
+
+        func receive(_ input: Upstream.Output) -> Subscribers.Demand {
+            events?.receiveOutput?(input)
+            let newDemand = downstream.receive(input)
+            if newDemand > 0 {
+                events?.receiveRequest?(newDemand)
+            }
+            return newDemand
+        }
+
+        func receive(completion: Subscribers.Completion<Upstream.Failure>) {
+            events?.receiveCompletion?(completion)
+            lock.lock()
+            events = nil
+            status = .terminal
+            lock.unlock()
+            downstream.receive(completion: completion)
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            events?.receiveRequest?(demand)
+            lock.lock()
+            if case let .subscribed(subscription) = status {
+                lock.unlock()
+                subscription.request(demand)
+                return
+            }
+            pendingDemand += demand
+            lock.unlock()
+        }
+
+        func cancel() {
+            events?.receiveCancel?()
+            lock.lock()
+            guard case let .subscribed(subscription) = status else {
+                lock.unlock()
+                return
+            }
+            events = nil
+            status = .terminal
+            lock.unlock()
+            subscription.cancel()
+        }
+
+        var description: String { return "HandleEvents" }
+
+        var customMirror: Mirror { return Mirror(self, children: EmptyCollection()) }
+
+        var playgroundDescription: Any { return description }
+    }
+}

Sources/OpenCombine/Publishers/Publishers.IgnoreOutput.swift

@@ -4,7 +4,9 @@
 //  Created by Eric Patey on 16.08.2019.
 //
 
+#if canImport(COpenCombineHelpers)
 import COpenCombineHelpers
+#endif
 
 extension Publisher {
 

Sources/OpenCombine/Publishers/Publishers.Map.swift

@@ -5,7 +5,9 @@
 //  Created by Anton Nazarov on 25.06.2019.
 //
 
+#if canImport(COpenCombineHelpers)
 import COpenCombineHelpers
+#endif
 
 extension Publisher {
 

Sources/OpenCombine/Publishers/Publishers.MeasureInterval.swift

@@ -0,0 +1,170 @@
+//
+//  Publishers.MeasureInterval.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 03.12.2019.
+//
+
+#if canImport(COpenCombineHelpers)
+import COpenCombineHelpers
+#endif
+
+extension Publisher {
+
+    /// Measures and emits the time interval between events received from an upstream
+    /// publisher.
+    ///
+    /// The output type of the returned scheduler is the time interval of the provided
+    /// scheduler.
+    ///
+    /// - Parameters:
+    ///   - scheduler: The scheduler on which to deliver elements.
+    ///   - options: Options that customize the delivery of elements.
+    /// - Returns: A publisher that emits elements representing the time interval between
+    ///   the elements it receives.
+    public func measureInterval<Context: Scheduler>(
+        using scheduler: Context,
+        options: Context.SchedulerOptions? = nil
+    ) -> Publishers.MeasureInterval<Self, Context> {
+        return .init(upstream: self, scheduler: scheduler)
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that measures and emits the time interval between events received from
+    /// an upstream publisher.
+    public struct MeasureInterval<Upstream: Publisher, Context: Scheduler>: Publisher {
+
+        public typealias Output = Context.SchedulerTimeType.Stride
+
+        public typealias Failure = Upstream.Failure
+
+        /// The publisher from which this publisher receives elements.
+        public let upstream: Upstream
+
+        /// The scheduler on which to deliver elements.
+        public let scheduler: Context
+
+        public init(upstream: Upstream, scheduler: Context) {
+            self.upstream = upstream
+            self.scheduler = scheduler
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Upstream.Failure == Downstream.Failure,
+                  Downstream.Input == Context.SchedulerTimeType.Stride
+        {
+            upstream.subscribe(Inner(self, downstream: subscriber))
+        }
+    }
+}
+
+extension Publishers.MeasureInterval {
+    private final class Inner<Downstream: Subscriber>
+        : Subscriber,
+          Subscription,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == Context.SchedulerTimeType.Stride,
+              Downstream.Failure == Upstream.Failure
+    {
+        // NOTE: This class has been audited for thread safety
+
+        typealias Input = Upstream.Output
+        typealias Failure = Upstream.Failure
+
+        typealias MeasureInterval = Publishers.MeasureInterval<Upstream, Context>
+
+        private enum State {
+            case ready(MeasureInterval, Downstream)
+            case subscribed(MeasureInterval, Downstream, Subscription)
+            case terminal
+        }
+
+        private let lock = UnfairLock.allocate()
+
+        private var state: State
+
+        private var last: Context.SchedulerTimeType?
+
+        init(_ measureInterval: MeasureInterval, downstream: Downstream) {
+            state = .ready(measureInterval, downstream)
+        }
+
+        deinit {
+            lock.deallocate()
+        }
+
+        func receive(subscription: Subscription) {
+            lock.lock()
+            guard case let .ready(measureInterval, downstream) = state else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            state = .subscribed(measureInterval, downstream, subscription)
+            last = measureInterval.scheduler.now
+            lock.unlock()
+            downstream.receive(subscription: self)
+        }
+
+        func receive(_: Input) -> Subscribers.Demand {
+            lock.lock()
+            guard case let .subscribed(measureInterval, downstream, subscription) = state,
+                  let previousTime = last else {
+                lock.unlock()
+                return .none
+            }
+            let now = measureInterval.scheduler.now
+            last = now
+            lock.unlock()
+            let newDemand = downstream.receive(previousTime.distance(to: now))
+            if newDemand > 0 {
+                subscription.request(newDemand)
+            }
+            return .none
+        }
+
+        func receive(completion: Subscribers.Completion<Failure>) {
+            lock.lock()
+            guard case let .subscribed(_, downstream, _) = state else {
+                lock.unlock()
+                return
+            }
+            state = .terminal
+            last = nil
+            lock.unlock()
+            downstream.receive(completion: completion)
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            lock.lock()
+            guard case let .subscribed(_, _, subscription) = state else {
+                lock.unlock()
+                return
+            }
+            lock.unlock()
+            subscription.request(demand)
+        }
+
+        func cancel() {
+            lock.lock()
+            guard case let .subscribed(_, _, subscription) = state else {
+                lock.unlock()
+                return
+            }
+            state = .terminal
+            last = nil
+            lock.unlock()
+            subscription.cancel()
+        }
+
+        var description: String { return "MeasureInterval" }
+
+        var customMirror: Mirror { return Mirror(self, children: EmptyCollection()) }
+
+        var playgroundDescription: Any { return description }
+    }
+}

Sources/OpenCombine/Publishers/Publishers.Multicast.swift

@@ -5,7 +5,9 @@
 //  Created by Sergej Jaskiewicz on 14.06.2019.
 //
 
+#if canImport(COpenCombineHelpers)
 import COpenCombineHelpers
+#endif
 
 extension Publisher {
 

Sources/OpenCombine/Publishers/Publishers.Output.swift

@@ -5,7 +5,9 @@
 //  Created by Sergej Jaskiewicz on 24.10.2019.
 //
 
+#if canImport(COpenCombineHelpers)
 import COpenCombineHelpers
+#endif
 
 extension Publisher {
 

Sources/OpenCombine/Publishers/Publishers.Print.swift

@@ -5,7 +5,9 @@
 //  Created by Sergej Jaskiewicz on 16.06.2019.
 //
 
+#if canImport(COpenCombineHelpers)
 import COpenCombineHelpers
+#endif
 
 extension Publisher {
 

Sources/OpenCombine/Publishers/Publishers.ReceiveOn.swift

@@ -0,0 +1,217 @@
+//
+//  Publishers.ReceiveOn.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 02.12.2019.
+//
+
+#if canImport(COpenCombineHelpers)
+import COpenCombineHelpers
+#endif
+
+extension Publisher {
+    /// Specifies the scheduler on which to receive elements from the publisher.
+    ///
+    /// You use the `receive(on:options:)` operator to receive results on a specific
+    /// scheduler, such as performing UI work on the main run loop.
+    /// In contrast with `subscribe(on:options:)`, which affects upstream messages,
+    /// `receive(on:options:)` changes the execution context of downstream messages.
+    /// In the following example, requests to `jsonPublisher` are performed on
+    /// `backgroundQueue`, but elements received from it are performed on `RunLoop.main`.
+    ///
+    ///     // Some publisher.
+    ///     let jsonPublisher = MyJSONLoaderPublisher()
+    ///
+    ///     // Some subscriber that updates the UI.
+    ///     let labelUpdater = MyLabelUpdateSubscriber()
+    ///
+    ///     jsonPublisher
+    ///         .subscribe(on: backgroundQueue)
+    ///         .receiveOn(on: RunLoop.main)
+    ///         .subscribe(labelUpdater)
+    ///
+    /// - Parameters:
+    ///   - scheduler: The scheduler the publisher is to use for element delivery.
+    ///   - options: Scheduler options that customize the element delivery.
+    /// - Returns: A publisher that delivers elements using the specified scheduler.
+    public func receive<Context: Scheduler>(
+        on scheduler: Context,
+        options: Context.SchedulerOptions? = nil
+    ) -> Publishers.ReceiveOn<Self, Context> {
+        return .init(upstream: self, scheduler: scheduler, options: options)
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that delivers elements to its downstream subscriber on a specific
+    /// scheduler.
+    public struct ReceiveOn<Upstream: Publisher, Context: Scheduler>: Publisher {
+
+        public typealias Output = Upstream.Output
+
+        public typealias Failure = Upstream.Failure
+
+        /// The publisher from which this publisher receives elements.
+        public let upstream: Upstream
+
+        /// The scheduler the publisher is to use for element delivery.
+        public let scheduler: Context
+
+        /// Scheduler options that customize the delivery of elements.
+        public let options: Context.SchedulerOptions?
+
+        public init(upstream: Upstream,
+                    scheduler: Context,
+                    options: Context.SchedulerOptions?) {
+            self.upstream = upstream
+            self.scheduler = scheduler
+            self.options = options
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Upstream.Failure == Downstream.Failure,
+                  Upstream.Output == Downstream.Input
+        {
+            upstream.subscribe(Inner(self, downstream: subscriber))
+        }
+    }
+}
+
+extension Publishers.ReceiveOn {
+    private final class Inner<Downstream: Subscriber>
+        : Subscriber,
+          Subscription,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == Upstream.Output, Downstream.Failure == Upstream.Failure
+    {
+        typealias Input = Upstream.Output
+
+        typealias Failure = Upstream.Failure
+
+        typealias ReceiveOn = Publishers.ReceiveOn<Upstream, Context>
+
+        private enum State {
+            case ready(ReceiveOn, Downstream)
+            case subscribed(ReceiveOn, Downstream, Subscription)
+            case terminal
+        }
+
+        private let lock = UnfairLock.allocate()
+        private var state: State
+        private let downstreamLock = UnfairLock.allocate()
+
+        init(_ receiveOn: ReceiveOn, downstream: Downstream) {
+            state = .ready(receiveOn, downstream)
+        }
+
+        deinit {
+            lock.deallocate()
+            downstreamLock.deallocate()
+        }
+
+        func receive(subscription: Subscription) {
+            lock.lock()
+            guard case let .ready(receiveOn, downstream) = state else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            state = .subscribed(receiveOn, downstream, subscription)
+            lock.unlock()
+            receiveOn.scheduler.schedule(options: receiveOn.options) { [weak self] in
+                self?.scheduledReceive(subscription: subscription)
+            }
+        }
+
+        private func scheduledReceive(subscription: Subscription) {
+            lock.lock()
+            guard case let .subscribed(_, downstream, _) = state else {
+                lock.unlock()
+                return
+            }
+            lock.unlock()
+            downstreamLock.lock()
+            downstream.receive(subscription: self)
+            downstreamLock.unlock()
+        }
+
+        func receive(_ input: Upstream.Output) -> Subscribers.Demand {
+            lock.lock()
+            guard case let .subscribed(receiveOn, downstream, _) = state else {
+                lock.unlock()
+                return .none
+            }
+            lock.unlock()
+            receiveOn.scheduler.schedule(options: receiveOn.options) { [weak self] in
+                self?.scheduledReceive(input, downstream: downstream)
+            }
+            return .none
+        }
+
+        private func scheduledReceive(_ input: Upstream.Output, downstream: Downstream) {
+            downstreamLock.lock()
+            let newDemand = downstream.receive(input)
+            downstreamLock.unlock()
+            guard newDemand > 0 else {
+                return
+            }
+            lock.lock()
+            guard case let .subscribed(_, _, subscription) = state else {
+                lock.unlock()
+                return
+            }
+            lock.unlock()
+            subscription.request(newDemand)
+        }
+
+        func receive(completion: Subscribers.Completion<Upstream.Failure>) {
+            lock.lock()
+            guard case let .subscribed(receiveOn, downstream, _) = state else {
+                lock.unlock()
+                return
+            }
+            state = .terminal
+            lock.unlock()
+            receiveOn.scheduler.schedule(options: receiveOn.options) { [weak self] in
+                self?.scheduledReceive(completion: completion, downstream: downstream)
+            }
+        }
+
+        private func scheduledReceive(completion: Subscribers.Completion<Failure>,
+                                      downstream: Downstream) {
+            downstreamLock.lock()
+            downstream.receive(completion: completion)
+            downstreamLock.unlock()
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            lock.lock()
+            guard case let .subscribed(_, _, subscription) = state else {
+                lock.unlock()
+                return
+            }
+            lock.unlock()
+            subscription.request(demand)
+        }
+
+        func cancel() {
+            lock.lock()
+            guard case let .subscribed(_, _, subscription) = state else {
+                lock.unlock()
+                return
+            }
+            state = .terminal
+            lock.unlock()
+            subscription.cancel()
+        }
+
+        var description: String { return "ReceiveOn" }
+
+        var customMirror: Mirror { return Mirror(self, children: EmptyCollection()) }
+
+        var playgroundDescription: Any { return description }
+    }
+}

Sources/OpenCombine/Publishers/Publishers.ReplaceError.swift

@@ -5,7 +5,9 @@
 //  Created by Bogdan Vlad on 8/29/19.
 //
 
+#if canImport(COpenCombineHelpers)
 import COpenCombineHelpers
+#endif
 
 extension Publisher {
     /// Replaces any errors in the stream with the provided element.

Sources/OpenCombine/Publishers/Publishers.Scan.swift

@@ -4,7 +4,9 @@
 //  Created by Eric Patey on 26.08.2019.
 //
 
+#if canImport(COpenCombineHelpers)
 import COpenCombineHelpers
+#endif
 
 extension Publisher {
 

Sources/OpenCombine/Publishers/Publishers.Sequence.swift

@@ -5,7 +5,9 @@
 //  Created by Sergej Jaskiewicz on 19.06.2019.
 //
 
+#if canImport(COpenCombineHelpers)
 import COpenCombineHelpers
+#endif
 
 extension Publishers {
 

Sources/OpenCombine/Publishers/Publishers.SubscribeOn.swift

@@ -0,0 +1,192 @@
+//
+//  Publishers.SubscribeOn.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 02.12.2019.
+//
+
+#if canImport(COpenCombineHelpers)
+import COpenCombineHelpers
+#endif
+
+extension Publisher {
+
+    /// Specifies the scheduler on which to perform subscribe, cancel, and request
+    /// operations.
+    ///
+    /// In contrast with `receive(on:options:)`, which affects downstream messages,
+    /// `subscribe(on:)` changes the execution context of upstream messages.
+    /// In the following example, requests to `jsonPublisher` are performed on
+    /// `backgroundQueue`, but elements received from it are performed on `RunLoop.main`.
+    ///
+    ///     let ioPerformingPublisher == // Some publisher.
+    ///     let uiUpdatingSubscriber == // Some subscriber that updates the UI.
+    ///
+    ///     ioPerformingPublisher
+    ///         .subscribe(on: backgroundQueue)
+    ///         .receiveOn(on: RunLoop.main)
+    ///         .subscribe(uiUpdatingSubscriber)
+    ///
+    /// - Parameters:
+    ///   - scheduler: The scheduler on which to receive upstream messages.
+    ///   - options: Options that customize the delivery of elements.
+    /// - Returns: A publisher which performs upstream operations on the specified
+    ///   scheduler.
+    public func subscribe<Context: Scheduler>(
+        on scheduler: Context,
+        options: Context.SchedulerOptions? = nil
+    ) -> Publishers.SubscribeOn<Self, Context> {
+        return .init(upstream: self, scheduler: scheduler, options: options)
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that receives elements from an upstream publisher on a specific
+    /// scheduler.
+    public struct SubscribeOn<Upstream: Publisher, Context: Scheduler>: Publisher {
+
+        public typealias Output = Upstream.Output
+
+        public typealias Failure = Upstream.Failure
+
+        /// The publisher from which this publisher receives elements.
+        public let upstream: Upstream
+
+        /// The scheduler the publisher should use to receive elements.
+        public let scheduler: Context
+
+        /// Scheduler options that customize the delivery of elements.
+        public let options: Context.SchedulerOptions?
+
+        public init(upstream: Upstream,
+                    scheduler: Context,
+                    options: Context.SchedulerOptions?) {
+            self.upstream = upstream
+            self.scheduler = scheduler
+            self.options = options
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Upstream.Failure == Downstream.Failure,
+                  Upstream.Output == Downstream.Input
+        {
+            scheduler.schedule(options: options) {
+                self.upstream.subscribe(Inner(self, downstream: subscriber))
+            }
+        }
+    }
+}
+
+extension Publishers.SubscribeOn {
+    private final class Inner<Downstream: Subscriber>
+        : Subscriber,
+          Subscription,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == Upstream.Output, Downstream.Failure == Upstream.Failure
+    {
+        typealias Input = Upstream.Output
+
+        typealias Failure = Upstream.Failure
+
+        typealias SubscribeOn = Publishers.SubscribeOn<Upstream, Context>
+
+       private enum State {
+            case ready(SubscribeOn, Downstream)
+            case subscribed(SubscribeOn, Downstream, Subscription)
+            case terminal
+        }
+
+        private let lock = UnfairLock.allocate()
+        private var state: State
+        private let upstreamLock = UnfairLock.allocate()
+
+        init(_ subscribeOn: SubscribeOn, downstream: Downstream) {
+            state = .ready(subscribeOn, downstream)
+        }
+
+        deinit {
+            lock.deallocate()
+            upstreamLock.deallocate()
+        }
+
+        func receive(subscription: Subscription) {
+            lock.lock()
+            guard case let .ready(subscribeOn, downstream) = state else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            state = .subscribed(subscribeOn, downstream, subscription)
+            lock.unlock()
+            downstream.receive(subscription: self)
+        }
+
+        func receive(_ input: Upstream.Output) -> Subscribers.Demand {
+            lock.lock()
+            guard case let .subscribed(_, downstream, _) = state else {
+                lock.unlock()
+                return .none
+            }
+            lock.unlock()
+            return downstream.receive(input)
+        }
+
+        func receive(completion: Subscribers.Completion<Upstream.Failure>) {
+            lock.lock()
+            guard case let .subscribed(_, downstream, _) = state else {
+                lock.unlock()
+                return
+            }
+            state = .terminal
+            lock.unlock()
+            downstream.receive(completion: completion)
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            lock.lock()
+            guard case let .subscribed(subscribeOn, _, subscription) = state else {
+                lock.unlock()
+                return
+            }
+            lock.unlock()
+            subscribeOn.scheduler.schedule(options: subscribeOn.options) { [weak self] in
+                self?.scheduledRequest(demand, subscription: subscription)
+            }
+        }
+
+        private func scheduledRequest(_ demand: Subscribers.Demand,
+                                      subscription: Subscription) {
+            upstreamLock.lock()
+            subscription.request(demand)
+            upstreamLock.unlock()
+        }
+
+        func cancel() {
+            lock.lock()
+            guard case let .subscribed(subscribeOn, _, subscription) = state else {
+                lock.unlock()
+                return
+            }
+            state = .terminal
+            lock.unlock()
+            subscribeOn.scheduler.schedule(options: subscribeOn.options) { [weak self] in
+                self?.scheduledCancel(subscription)
+            }
+        }
+
+        private func scheduledCancel(_ subscription: Subscription) {
+            upstreamLock.lock()
+            subscription.cancel()
+            upstreamLock.unlock()
+        }
+
+        var description: String { return "SubscribeOn" }
+
+        var customMirror: Mirror { return Mirror(self, children: EmptyCollection()) }
+
+        var playgroundDescription: Any { return description }
+    }
+}

Sources/OpenCombine/Publishers/Record.swift

@@ -5,7 +5,9 @@
 //  Created by Sergej Jaskiewicz on 12.11.2019.
 //
 
+#if canImport(COpenCombineHelpers)
 import COpenCombineHelpers
+#endif
 
 /// A publisher that allows for recording a series of inputs and a completion for later
 /// playback to each subscriber.

Tests/OpenCombineTests/EnumerateFieldsTests.swift

@@ -1,482 +0,0 @@
-//
-//  EnumerateFieldsTests.swift
-//  
-//
-//  Created by Sergej Jaskiewicz on 29.11.2019.
-//
-
-import CoreFoundation
-import Foundation
-import XCTest
-
-// This file contains tests for internal OpenCombine APIs.
-
-#if !OPENCOMBINE_COMPATIBILITY_TEST
-
-final class EnumerateFieldsTests: TestCase {
-
-    func testClassNoFields() {
-        enumerateFields(ofType: NoFields.self, allowResilientSuperclasses: true) { _ in
-            XCTFail("should not be called")
-            return false
-        }
-    }
-
-    func testClassVarsAndLets() {
-        var fields = [FieldInfo]()
-        enumerateFields(ofType: VarsAndLets.self,
-                        allowResilientSuperclasses: true) { field in
-            fields.append(field)
-            if field.name == "stopEnumerating" {
-                return false
-            }
-            return true
-        }
-        XCTAssertEqual(fields, [.init("constant1", 16, Int.self),
-                                .init("constant2", 0, Void.self),
-                                .init("variable1", 24, String.self),
-                                .init("variable2", 40, Double.self),
-                                .init("stopEnumerating", 48, Int.self)])
-        if hasFailed { return }
-        let instance = VarsAndLets()
-        XCTAssertEqual(loadField(fields[0], from: instance, as: Int.self), 42)
-        loadField(fields[1], from: instance, as: Void.self)
-        XCTAssertEqual(loadField(fields[2], from: instance, as: String.self), "hello")
-        XCTAssertEqual(loadField(fields[3], from: instance, as: Double.self), 12.3)
-        XCTAssertEqual(loadField(fields[4], from: instance, as: Int.self), -1)
-    }
-
-    func testRegularDerivedClass() {
-        var fields = [FieldInfo]()
-        enumerateFields(ofType: RegularDerived.self,
-                        allowResilientSuperclasses: true) { field in
-            fields.append(field)
-            return true
-        }
-        XCTAssertEqual(fields, [.init("field1", 16, Int.self),
-                                .init("field2", 24, Bool.self),
-                                .init("field3", 25, Bool.self),
-                                .init("field4", 32, String.self),
-                                .init("field5", 48, Int.self)])
-        if hasFailed { return }
-        let instance = RegularDerived()
-        XCTAssertEqual(loadField(fields[0], from: instance, as: Int.self), 1)
-        XCTAssertEqual(loadField(fields[1], from: instance, as: Bool.self), false)
-        XCTAssertEqual(loadField(fields[2], from: instance, as: Bool.self), true)
-        XCTAssertEqual(loadField(fields[3], from: instance, as: String.self), "3")
-        XCTAssertEqual(loadField(fields[4], from: instance, as: Int.self), 4)
-    }
-
-    func testRegularDerivedClassEarlyExit() {
-        var fields = [FieldInfo]()
-        enumerateFields(ofType: RegularDerived.self,
-                        allowResilientSuperclasses: true) { field in
-            fields.append(field)
-            if field.name == "field2" {
-                return false
-            }
-            return true
-        }
-        XCTAssertEqual(fields, [.init("field1", 16, Int.self),
-                                .init("field2", 24, Bool.self)])
-    }
-
-    func testObjCClass() {
-        // All Foundation classes are native Swift classes on non-Darwin platforms
-#if canImport(Darwin)
-        enumerateFields(ofType: NSNumber.self,
-                        allowResilientSuperclasses: true) { _ in
-            XCTFail("should not be called")
-            return false
-        }
-#endif
-    }
-
-    func testSwiftSubclassOfObjCClass() {
-        // All Foundation classes are native Swift classes on non-Darwin platforms
-#if canImport(Darwin)
-        var fields = [FieldInfo]()
-        enumerateFields(ofType: ObjCDerived.self,
-                        allowResilientSuperclasses: true) { field in
-            fields.append(field)
-            if field.name == "field2" {
-                return false
-            }
-            return true
-        }
-        XCTAssertEqual(fields, [.init("field1", 8, Int.self),
-                                .init("field2", 16, Bool.self)])
-        if hasFailed { return }
-        let instance = ObjCDerived()
-        XCTAssertEqual(loadField(fields[0], from: instance, as: Int.self), 1)
-        XCTAssertEqual(loadField(fields[1], from: instance, as: Bool.self), true)
-#endif
-    }
-
-    func testNSObjectSubclass() {
-        var fields = [FieldInfo]()
-        enumerateFields(ofType: DerivedFromNSObject.self,
-                        allowResilientSuperclasses: true) { field in
-            fields.append(field)
-            return true
-        }
-#if canImport(Darwin)
-        XCTAssertEqual(fields, [.init("field1", 8, Int.self),
-                                .init("field2", 16, Bool.self),
-                                .init("field3", 17, Bool.self)])
-#else
-        XCTAssertEqual(fields, [.init("field1", 16, Int.self),
-                                .init("field2", 24, Bool.self),
-                                .init("field3", 25, Bool.self)])
-#endif
-        if hasFailed { return }
-        let instance = DerivedFromNSObject()
-        XCTAssertEqual(loadField(fields[0], from: instance, as: Int.self), 1)
-        XCTAssertEqual(loadField(fields[1], from: instance, as: Bool.self), true)
-        XCTAssertEqual(loadField(fields[2], from: instance, as: Bool.self), false)
-    }
-
-    func testResilientClass() {
-        var fields = [FieldInfo]()
-        enumerateFields(ofType: JSONDecoder.self,
-                        allowResilientSuperclasses: true) { field in
-            fields.append(field)
-            return true
-        }
-        XCTAssertFalse(fields.isEmpty)
-    }
-
-    func testSubclassOfResilientClass() {
-#if canImport(Darwin) // There are no resilient classes on non-Darwin platforms
-        enumerateFields(ofType: DerivedFromResilientClass.self,
-                        allowResilientSuperclasses: false) { _ in
-            XCTFail("should not be called")
-            return true
-        }
-
-        var fields = [FieldInfo]()
-        enumerateFields(ofType: DerivedFromResilientClass.self,
-                        allowResilientSuperclasses: true) { field in
-            fields.append(field)
-            return true
-        }
-        XCTAssertFalse(fields.isEmpty)
-#endif
-    }
-
-    func testGenericClass() {
-        var fields = [FieldInfo]()
-        enumerateFields(ofType: GenericBase<String, Decimal>.self,
-                        allowResilientSuperclasses: true) { field in
-            fields.append(field)
-            return true
-        }
-        XCTAssertEqual(fields, [.init("field1", 16, String.self),
-                                .init("field2", 32, Decimal.self)])
-        if hasFailed { return }
-        let instance = GenericBase<String, Decimal>("foo", 13.5)
-        XCTAssertEqual(loadField(fields[0], from: instance, as: String.self), "foo")
-        XCTAssertEqual(loadField(fields[1], from: instance, as: Decimal.self), 13.5)
-    }
-
-    func testGenericSubclassOfGenericClass() {
-        var fields = [FieldInfo]()
-        enumerateFields(ofType: GenericDerived<String, Int, Bool, [Int]>.self,
-                        allowResilientSuperclasses: true) { field in
-            fields.append(field)
-            return true
-        }
-        XCTAssertEqual(fields, [.init("field1", 16, String.self),
-                                .init("field2", 32, Int.self),
-                                .init("field3", 40, Bool.self),
-                                .init("field4", 48, [Int].self)])
-        if hasFailed { return }
-        let instance = GenericDerived("foo", 42, true, [1, 2, 3])
-        XCTAssertEqual(loadField(fields[0], from: instance, as: String.self), "foo")
-        XCTAssertEqual(loadField(fields[1], from: instance, as: Int.self), 42)
-        XCTAssertEqual(loadField(fields[2], from: instance, as: Bool.self), true)
-        XCTAssertEqual(loadField(fields[3], from: instance, as: [Int].self), [1, 2, 3])
-    }
-
-    func testGenericSubclassOfNonGenericResilientClass() {
-#if canImport(Darwin) // There are no resilient classes on non-Darwin platforms
-        enumerateFields(ofType: GenericDerivedFromResilientBase<Int, Int>.self,
-                        allowResilientSuperclasses: false) { _ in
-            XCTFail("should not be called")
-            return true
-        }
-
-        var superclassFields = [FieldInfo]()
-        enumerateFields(ofType: JSONDecoder.self,
-                        allowResilientSuperclasses: false) { field in
-            superclassFields.append(field)
-            return true
-        }
-
-        var fields = [FieldInfo]()
-        enumerateFields(ofType: GenericDerivedFromResilientBase<Int, Int>.self,
-                        allowResilientSuperclasses: true) { field in
-            fields.append(field)
-            return true
-        }
-        XCTAssertEqual(fields, superclassFields + [.init("field1", 128, Int.self),
-                                                   .init("field2", 136, Int.self)])
-#endif
-    }
-
-    func testForeignClass() {
-        enumerateFields(ofType: CFMutableArray.self,
-                        allowResilientSuperclasses: true) { _ in
-            XCTFail("should not be called")
-            return true
-        }
-    }
-
-    func testClassWithFieldsOfResilientTypes() {
-#if canImport(Darwin)
-        guard #available(macOS 10.12, iOS 10.0, *) else { return }
-#endif
-        var fields = [FieldInfo]()
-        enumerateFields(ofType: HasResilientFields.self,
-                        allowResilientSuperclasses: true) { field in
-            fields.append(field)
-            return true
-        }
-        XCTAssertEqual(fields, [.init("field1", 16, IndexPath.self),
-                                .init("field2", 40, Measurement<UnitSpeed>.self),
-                                .init("field3", 56, Bool.self)])
-        if hasFailed { return }
-        let instance = HasResilientFields()
-        XCTAssertEqual(loadField(fields[0], from: instance, as: IndexPath.self), [42, 12])
-        XCTAssertEqual(loadField(fields[1],
-                                 from: instance,
-                                 as: Measurement<UnitSpeed>.self),
-                       Measurement<UnitSpeed>(value: 12, unit: .metersPerSecond))
-        XCTAssertEqual(loadField(fields[2], from: instance, as: Bool.self), true)
-    }
-
-    func testStructLetsAndVars() {
-        var fields = [FieldInfo]()
-        enumerateFields(ofType: CommonValue.self,
-                        allowResilientSuperclasses: false) { field in
-            fields.append(field)
-            return true
-        }
-
-        XCTAssertEqual(fields, [.init("field1", 0, Int.self),
-                                .init("field2", 8, Bool.self),
-                                .init("field3", 9, Bool.self),
-                                .init("field4", 16, [String].self),
-                                .init("field5", 0, Void.self)])
-        if hasFailed { return }
-        let value = CommonValue(field1: 42,
-                                field2: true,
-                                field3: false,
-                                field4: ["it", "works"],
-                                field5: ())
-        XCTAssertEqual(loadField(fields[0], from: value, as: Int.self), 42)
-        XCTAssertEqual(loadField(fields[1], from: value, as: Bool.self), true)
-        XCTAssertEqual(loadField(fields[2], from: value, as: Bool.self), false)
-        XCTAssertEqual(loadField(fields[3], from: value, as: [String].self),
-                       ["it", "works"])
-        loadField(fields[4], from: value, as: Void.self)
-    }
-
-    func testGenericStruct() {
-        var fields = [FieldInfo]()
-        enumerateFields(ofType: GenericValue<Int, String>.self,
-                        allowResilientSuperclasses: false) { field in
-            fields.append(field)
-            return true
-        }
-        XCTAssertEqual(fields, [.init("field1", 0, Int.self),
-                                .init("field2", 8, String.self),
-                                .init("field3", 24, Bool.self)])
-        if hasFailed { return }
-        let value = GenericValue(field1: 12345678, field2: "🦊", field3: true)
-        XCTAssertEqual(loadField(fields[0], from: value, as: Int.self), 12345678)
-        XCTAssertEqual(loadField(fields[1], from: value, as: String.self), "🦊")
-        XCTAssertEqual(loadField(fields[2], from: value, as: Bool.self), true)
-    }
-
-    func testResilientStruct() {
-#if canImport(Darwin) // There are no resilient classes on non-Darwin platforms
-        var fields = [FieldInfo]()
-        enumerateFields(ofType: Notification.self,
-                        allowResilientSuperclasses: false) { field in
-            fields.append(field)
-            return true
-        }
-        XCTAssertEqual(fields, [.init("name", 0, Notification.Name.self),
-                                .init("object", 8, Any?.self),
-                                .init("userInfo", 40, [AnyHashable : Any]?.self)])
-        if hasFailed { return }
-        let value = Notification(name: .init("some note"),
-                                 object: ["a", "b"] as Set<String>,
-                                 userInfo: ["a" : 1, "b": 2])
-        XCTAssertEqual(loadField(fields[0], from: value, as: Notification.Name.self),
-                       .init("some note"))
-
-        XCTAssertEqual(loadField(fields[1], from: value, as: Any?.self) as? Set<String>,
-                       ["a", "b"])
-#endif
-    }
-
-    func testTuple() {
-        enumerateFields(ofType: Void.self, allowResilientSuperclasses: false) { _ in
-            XCTFail("should not be called")
-            return true
-        }
-
-        typealias Tuple =
-            (Int, String, label1: Double, Bool, s̈pin̈al_tap̈: IndexPath, label3: Float)
-        var fields = [FieldInfo]()
-        enumerateFields(ofType: Tuple.self,
-                        allowResilientSuperclasses: true) { field in
-            fields.append(field)
-            return true
-        }
-        XCTAssertEqual(fields, [.init("", 0, Int.self),
-                                .init("", 8, String.self),
-                                .init("label1", 24, Double.self),
-                                .init("", 32, Bool.self),
-                                .init("s̈pin̈al_tap̈", 40, IndexPath.self),
-                                .init("label3", 60, Float.self)])
-        if hasFailed { return }
-        let value: Tuple = (1234, "🌚", 59.1, false, [9, 3, 1], 10.1)
-        XCTAssertEqual(loadField(fields[0], from: value, as: Int.self), 1234)
-        XCTAssertEqual(loadField(fields[1], from: value, as: String.self), "🌚")
-        XCTAssertEqual(loadField(fields[2], from: value, as: Double.self), 59.1)
-        XCTAssertEqual(loadField(fields[3], from: value, as: Bool.self), false)
-        XCTAssertEqual(loadField(fields[4], from: value, as: IndexPath.self), [9, 3, 1])
-        XCTAssertEqual(loadField(fields[5], from: value, as: Float.self), 10.1)
-    }
-}
-
-private func loadField<FieldType>(_ field: FieldInfo,
-                                  from instance: AnyObject,
-                                  as type: FieldType.Type,
-                                  file: StaticString = #file,
-                                  line: UInt = #line) -> FieldType? {
-    if field.type != type {
-        XCTFail("Type mismatch", file: file, line: line)
-        return nil
-    }
-    return Unmanaged
-        .passUnretained(instance)
-        .toOpaque()
-        .load(fromByteOffset: field.offset, as: type)
-}
-
-private func loadField<Value, FieldType>(_ field: FieldInfo,
-                                         from value: Value,
-                                         as type: FieldType.Type,
-                                         file: StaticString = #file,
-                                         line: UInt = #line) -> FieldType? {
-    if field.type != type {
-        XCTFail("Type mismatch", file: file, line: line)
-        return nil
-    }
-    return withUnsafePointer(to: value) {
-        UnsafeRawPointer($0).load(fromByteOffset: field.offset, as: type)
-    }
-}
-
-// swiftlint:disable generic_type_name
-
-private final class NoFields {}
-
-private final class VarsAndLets {
-    let constant1 = 42
-    let constant2: Void = ()
-    var variable1 = "hello"
-    var variable2 = 12.3
-    let stopEnumerating = -1
-    var neverVisited = 10
-}
-
-private class RegularBase {
-    var field1 = 1
-    var field2 = false
-    var field3 = true
-}
-
-private final class RegularDerived: RegularBase {
-    var field4 = "3"
-    var field5 = 4
-}
-
-private final class ObjCDerived: NSOrderedSet {
-    var field1 = 1
-    var field2 = true
-    let field3 = false
-}
-
-private final class DerivedFromNSObject: NSObject {
-    var field1 = 1
-    var field2 = true
-    let field3 = false
-}
-
-private final class DerivedFromResilientClass: JSONDecoder {
-    var field1 = 1
-    var field2 = "hello"
-}
-
-private class GenericBase<A, B> {
-    var field1: A
-    var field2: B
-
-    init(_ field1: A, _ field2: B) {
-        self.field1 = field1
-        self.field2 = field2
-    }
-}
-
-private final class GenericDerived<A, B, C, D>: GenericBase<A, B> {
-    var field3: C
-    var field4: D
-
-    init(_ field1: A, _ field2: B, _ field3: C, _ field4: D) {
-        self.field3 = field3
-        self.field4 = field4
-        super.init(field1, field2)
-    }
-}
-
-private class GenericDerivedFromResilientBase<A, B>: JSONDecoder {
-    var field1: A
-    var field2: B
-
-    init(_ field1: A, _ field2: B) {
-        self.field1 = field1
-        self.field2 = field2
-    }
-}
-
-@available(macOS 10.12, iOS 10.0, *)
-private final class HasResilientFields {
-    // Foundation.IndexPath is resilient struct
-    var field1 = IndexPath(indexes: [42, 12])
-
-    // Foundation.Measurement is resilient generic struct
-    let field2 = Measurement<UnitSpeed>(value: 12, unit: .metersPerSecond)
-
-    var field3 = true
-}
-
-private struct CommonValue {
-    var field1: Int
-    let field2: Bool
-    let field3: Bool
-    var field4: [String]
-    let field5: ()
-}
-
-private struct GenericValue<A, B> {
-    let field1: A
-    let field2: B
-    let field3: Bool
-}
-
-#endif

Tests/OpenCombineTests/Helpers/AssertCrashes.swift

@@ -82,15 +82,6 @@ extension XCTest {
                 printDiagostics()
             }
         }
-#endif
-    }
-
-    @available(macOS 10.13, iOS 8.0, *)
-    func assertCrashesOnDarwin(within body: () -> Void) {
-#if canImport(Darwin)
-        assertCrashes(within: body)
-#else
-        body()
 #endif
     }
 }

Tests/OpenCombineTests/Helpers/CommonTests.swift

@@ -164,13 +164,6 @@ extension XCTest {
         try XCTUnwrap(helper.downstreamSubscription).cancel()
 
         XCTAssertEqual(helper.subscription.history, [.cancelled, .cancelled])
-
-        let thirdSubscription = CustomSubscription()
-
-        try XCTUnwrap(helper.publisher.subscriber)
-            .receive(subscription: thirdSubscription)
-
-        XCTAssertEqual(thirdSubscription.history, [.cancelled])
     }
 }
 

Tests/OpenCombineTests/Helpers/CustomPublisher.swift

@@ -34,13 +34,15 @@ import OpenCombine
 typealias CustomPublisher = CustomPublisherBase<Int, TestingError>
 
 @available(macOS 10.15, iOS 13.0, *)
-class CustomPublisherBase<Output, Failure: Error>: Publisher {
+class CustomPublisherBase<Output, Failure: Error>: Publisher, Cancellable {
 
     private(set) var subscriber: AnySubscriber<Output, Failure>?
     private(set) var erasedSubscriber: Any?
     private let subscription: Subscription?
 
-    var onSubscribe: ((AnySubscriber<Output, Failure>) -> Void)?
+    var willSubscribe: ((AnySubscriber<Output, Failure>) -> Void)?
+
+    var didSubscribe: ((AnySubscriber<Output, Failure>) -> Void)?
 
     required init(subscription: Subscription?) {
         self.subscription = subscription
@@ -51,9 +53,10 @@ class CustomPublisherBase<Output, Failure: Error>: Publisher {
     {
         let anySubscriber = AnySubscriber(subscriber)
         self.subscriber = anySubscriber
-        onSubscribe?(anySubscriber)
+        willSubscribe?(anySubscriber)
         erasedSubscriber = subscriber
         subscription.map(subscriber.receive(subscription:))
+        didSubscribe?(anySubscriber)
     }
 
     func send(subscription: CustomSubscription) {
@@ -67,6 +70,11 @@ class CustomPublisherBase<Output, Failure: Error>: Publisher {
     func send(completion: Subscribers.Completion<Failure>) {
         subscriber?.receive(completion: completion)
     }
+
+    func cancel() {
+        subscriber = nil
+        erasedSubscriber = nil
+    }
 }
 
 @available(macOS 10.15, iOS 13.0, *)

Tests/OpenCombineTests/Helpers/FairPriorityQueue.swift

@@ -0,0 +1,104 @@
+//
+//  FairPriorityQueue.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 02.12.2019.
+//
+
+/// A priproty queue based on binary min-heap.
+/// If two elements with the same priority are added, the element that was added
+/// earlier has will have "better" priority (i. e. it will be also extracted earlier).
+struct FairPriorityQueue<Priority: Comparable, Element> {
+
+    private var storage: [((Priority, UInt), Element)] = []
+    private var next: UInt = 0
+
+    init() {}
+
+    mutating func insert(_ element: Element, priority: Priority) {
+        storage.append(((priority, next), element))
+        next += 1
+        var newElementIndex = storage.endIndex - 1
+        while let parent = self.parent(of: newElementIndex),
+              storage[parent].0 > storage[newElementIndex].0 {
+            storage.swapAt(newElementIndex, parent)
+            newElementIndex = parent
+        }
+    }
+
+    func min() -> Element? {
+        return storage.first?.1
+    }
+
+    @discardableResult
+    mutating func extractMin() -> (Priority, Element)? {
+        guard let max = storage.first else { return nil }
+        storage[0] = storage[storage.endIndex - 1]
+        storage.removeLast()
+        minHeapify(0)
+        return (max.0.0, max.1)
+    }
+
+    var count: Int {
+        return storage.count
+    }
+
+    var isEmpty: Bool {
+        return storage.isEmpty
+    }
+
+    private func leftChild(of index: Int) -> Int? {
+        assert(index >= 0)
+        let childIndex = 2 * index + 1
+        return childIndex < storage.endIndex ? childIndex : nil
+    }
+
+    private func rightChild(of index: Int) -> Int? {
+        assert(index >= 0)
+        let childIndex = 2 * index + 2
+        return childIndex < storage.endIndex ? childIndex : nil
+    }
+
+    private func parent(of index: Int) -> Int? {
+        assert(index >= 0)
+        if index == 0 { return nil }
+        return (index - 1) / 2
+    }
+
+    private mutating func minHeapify(_ root: Int) {
+        var root = root
+        var largest = root
+        while true {
+            assert(largest == root)
+            if let left = leftChild(of: root), storage[root].0 > storage[left].0 {
+                largest = left
+            }
+            if let right = rightChild(of: root), storage[largest].0 > storage[right].0 {
+                largest = right
+            }
+            if largest == root {
+                break
+            }
+            storage.swapAt(root, largest)
+            root = largest
+        }
+    }
+}
+
+extension FairPriorityQueue: Sequence {
+    struct Iterator: IteratorProtocol {
+        private var queue: FairPriorityQueue
+
+        fileprivate init(_ queue: FairPriorityQueue) {
+            self.queue = queue
+        }
+
+        mutating func next() -> (Priority, Element)? {
+            return queue.extractMin()
+        }
+    }
+
+    func makeIterator() -> Iterator {
+        return Iterator(self)
+    }
+}

Tests/OpenCombineTests/Helpers/TestCase.swift

@@ -1,29 +0,0 @@
-//
-//  TestCase.swift
-//  
-//
-//  Created by Sergej Jaskiewicz on 29.11.2019.
-//
-
-import XCTest
-
-class TestCase: XCTestCase {
-
-    var hasFailed = false
-
-    override func recordFailure(withDescription description: String,
-                                inFile filePath: String,
-                                atLine lineNumber: Int,
-                                expected: Bool) {
-        hasFailed = true
-        super.recordFailure(withDescription: description,
-                            inFile: filePath,
-                            atLine: lineNumber,
-                            expected: expected)
-    }
-
-    override func setUp() {
-        super.setUp()
-        hasFailed = false
-    }
-}

Tests/OpenCombineTests/Helpers/TestEnumerateFields.swift

@@ -1,55 +0,0 @@
-//
-//  TestEnumerateFields.swift
-//  
-//
-//  Created by Sergej Jaskiewicz on 31.10.2019.
-//
-
-import COpenCombineHelpers
-
-internal struct FieldInfo: Equatable, CustomDebugStringConvertible {
-    let name: String
-    let offset: Int
-    let type: Any.Type
-
-    init(_ name: String, _ offset: Int, _ type: Any.Type) {
-        self.name = name
-        self.offset = offset
-        self.type = type
-    }
-
-    static func == (lhs: FieldInfo, rhs: FieldInfo) -> Bool {
-        return lhs.name   == rhs.name   &&
-               lhs.offset == rhs.offset &&
-               lhs.type   == rhs.type
-    }
-
-    var debugDescription: String {
-        return "(name: \(name.debugDescription), offset: \(offset), type: \(type).self)"
-    }
-}
-
-internal typealias FieldEnumerator = (FieldInfo) -> Bool
-
-internal func enumerateFields(ofType type: Any.Type,
-                              allowResilientSuperclasses: Bool,
-                              enumerator: FieldEnumerator) {
-    withoutActuallyEscaping(enumerator) { enumerator in
-        var context = enumerator
-        enumerateFields(
-            typeMetadata: unsafeBitCast(type, to: UnsafeRawPointer.self),
-            allowResilientSuperclasses: allowResilientSuperclasses,
-            enumeratorContext: &context,
-            enumerator: { rawContext, fieldName, fieldOffset, rawMetadataPtr in
-                let fieldInfo = FieldInfo(
-                    String(cString: fieldName),
-                    fieldOffset,
-                    unsafeBitCast(rawMetadataPtr, to: Any.Type.self)
-                )
-                return rawContext
-                    .unsafelyUnwrapped
-                    .assumingMemoryBound(to: FieldEnumerator.self)
-                    .pointee(fieldInfo)
-            })
-    }
-}

Tests/OpenCombineTests/Helpers/TestLifecycle.swift

@@ -19,6 +19,7 @@ func testLifecycle<UpstreamOutput, Operator: Publisher>(
     line: UInt = #line,
     sendValue valueToBeSent: UpstreamOutput,
     cancellingSubscriptionReleasesSubscriber: Bool,
+    finishingIsPassedThrough: Bool = true,
     _ makeOperator: (PassthroughSubject<UpstreamOutput, TestingError>) -> Operator
 ) throws {
     var deinitCounter = 0
@@ -101,7 +102,11 @@ func testLifecycle<UpstreamOutput, Operator: Publisher>(
                    file: file,
                    line: line)
 
-    try XCTUnwrap(subscription, file: file, line: line).cancel()
+    try XCTUnwrap(subscription,
+                  "Lifecycle test #3: subscription should be saved",
+                  file: file,
+                  line: line)
+        .cancel()
 
     if cancellingSubscriptionReleasesSubscriber {
         XCTAssertEqual(deinitCounter,
@@ -134,8 +139,15 @@ func testLifecycle<UpstreamOutput, Operator: Publisher>(
         passthrough.send(completion: .finished)
     }
 
-    XCTAssertTrue(subscriberDestroyed,
-                  "Lifecycle test #4: deinit should be called",
-                  file: file,
-                  line: line)
+    if finishingIsPassedThrough {
+        XCTAssertTrue(subscriberDestroyed,
+                      "Lifecycle test #4: deinit should be called",
+                      file: file,
+                      line: line)
+    } else {
+        XCTAssertFalse(subscriberDestroyed,
+                       "Lifecycle test #4: deinit should not be called",
+                       file: file,
+                       line: line)
+    }
 }

Tests/OpenCombineTests/Helpers/TestReflection.swift

@@ -79,9 +79,9 @@ internal func testReflection<Output, Failure: Error, Operator: Publisher>(
     line: UInt = #line,
     parentInput: Output.Type,
     parentFailure: Failure.Type,
-    description expectedDescription: String,
+    description expectedDescription: String?,
     customMirror customMirrorPredicate: ((Mirror) -> Bool)?,
-    playgroundDescription: String,
+    playgroundDescription: String?,
     _ makeOperator: (CustomConnectablePublisherBase<Output, Failure>) -> Operator
 ) throws {
     let publisher = CustomConnectablePublisherBase<Output, Failure>(subscription: nil)
@@ -97,16 +97,18 @@ internal func testReflection<Output, Failure: Error, Operator: Publisher>(
                    file: file,
                    line: line)
 
-    let customMirror =
-        try XCTUnwrap((erasedSubscriber as? CustomReflectable)?.customMirror,
-                      file: file,
-                      line: line)
-
     if let customMirrorPredicate = customMirrorPredicate {
+        let customMirror =
+            try XCTUnwrap((erasedSubscriber as? CustomReflectable)?.customMirror,
+                          file: file,
+                          line: line)
         XCTAssert(customMirrorPredicate(customMirror),
                   "customMirror doesn't satisfy the predicate",
                   file: file,
                   line: line)
+    } else {
+        XCTAssertFalse(erasedSubscriber is CustomReflectable,
+                       "subscriber shouldn't conform to CustomReflectable")
     }
 
     XCTAssertFalse(erasedSubscriber is CustomDebugStringConvertible,

Tests/OpenCombineTests/Helpers/VirtualTimeScheduler.swift

@@ -0,0 +1,316 @@
+//
+//  VirtualTimeScheduler.swift
+//  OpenCombineTests
+//
+//  Created by Евгений Богомолов on 14/09/2019.
+//
+
+#if OPENCOMBINE_COMPATIBILITY_TEST
+import Combine
+#else
+import OpenCombine
+#endif
+
+@available(macOS 10.15, iOS 13.0, *)
+final class VirtualTimeScheduler: Scheduler {
+
+    struct SchedulerTimeType: Strideable,
+                              Comparable,
+                              Hashable,
+                              SchedulerTimeIntervalConvertible
+    {
+
+        struct Stride: ExpressibleByFloatLiteral,
+                       Comparable,
+                       SignedNumeric,
+                       SchedulerTimeIntervalConvertible
+        {
+            var magnitude: Int64
+
+            fileprivate init(magnitude: Int64) {
+                self.magnitude = magnitude
+            }
+
+            init(integerLiteral value: Int) {
+                self = .seconds(value)
+            }
+
+            init(floatLiteral value: Double) {
+                self = .seconds(value)
+            }
+
+            init?<Source: BinaryInteger>(exactly source: Source) {
+                guard let magnitude = Int64(exactly: source) else {
+                    return nil
+                }
+                self.init(magnitude: magnitude)
+            }
+
+            static func < (lhs: Stride, rhs: Stride) -> Bool {
+                return lhs.magnitude < rhs.magnitude
+            }
+
+            static func * (lhs: Stride, rhs: Stride) -> Stride {
+                return Stride(magnitude: lhs.magnitude * rhs.magnitude)
+            }
+
+            static func + (lhs: Stride, rhs: Stride) -> Stride {
+                return Stride(magnitude: lhs.magnitude + rhs.magnitude)
+            }
+
+            static func - (lhs: Stride, rhs: Stride) -> Stride {
+                return Stride(magnitude: lhs.magnitude - rhs.magnitude)
+            }
+
+            static func -= (lhs: inout Stride, rhs: Stride) {
+                lhs.magnitude -= rhs.magnitude
+            }
+
+            static func *= (lhs: inout Stride, rhs: Stride) {
+                lhs.magnitude *= rhs.magnitude
+            }
+
+            static func += (lhs: inout Stride, rhs: Stride) {
+                lhs.magnitude += rhs.magnitude
+            }
+
+            static func seconds(_ value: Int) -> Stride {
+                return Stride(magnitude: Int64(value) * 1_000_000_000)
+            }
+
+            static func seconds(_ value: Double) -> Stride {
+                return Stride(magnitude: Int64(value * 1_000_000_000))
+            }
+
+            static func milliseconds(_ value: Int) -> Stride {
+                return Stride(magnitude: Int64(value) * 1_000_000)
+            }
+
+            static func microseconds(_ value: Int) -> Stride {
+                return Stride(magnitude: Int64(value) * 1_000)
+            }
+
+            static func nanoseconds(_ value: Int) -> Stride {
+                return Stride(magnitude: Int64(value))
+            }
+        }
+
+        /// Time in virtual nanoseconds
+        let time: UInt64
+
+        private init(nanoseconds time: UInt64) {
+            self.time = time
+        }
+
+        static func == (lhs: SchedulerTimeType, rhs: SchedulerTimeType) -> Bool {
+            return lhs.time == rhs.time
+        }
+
+        static func < (lhs: SchedulerTimeType, rhs: SchedulerTimeType) -> Bool {
+            return lhs.time < rhs.time
+        }
+
+        func hash(into hasher: inout Hasher) {
+            hasher.combine(time)
+        }
+
+        func distance(to other: SchedulerTimeType) -> Stride {
+            if self > other {
+                return Stride(magnitude: -Int64(time - other.time))
+            } else {
+                return Stride(magnitude: Int64(other.time - time))
+            }
+        }
+
+        func advanced(by stride: Stride) -> SchedulerTimeType {
+            return stride.magnitude < 0
+                ? SchedulerTimeType(nanoseconds: time - UInt64(-stride.magnitude))
+                : SchedulerTimeType(nanoseconds: time + UInt64(stride.magnitude))
+        }
+
+        static func + (lhs: SchedulerTimeType, rhs: Stride) -> SchedulerTimeType {
+            return lhs.advanced(by: rhs)
+        }
+
+        static let beginningOfTime = SchedulerTimeType(nanoseconds: 0)
+
+        static func seconds(_ value: Int) -> SchedulerTimeType {
+            precondition(value >= 0, "value must not be negative")
+            return .init(nanoseconds: UInt64(value) * 1_000_000_000)
+        }
+
+        static func seconds(_ value: Double) -> SchedulerTimeType {
+            precondition(value >= 0, "value must not be negative")
+            return .init(nanoseconds: UInt64(value * 1_000_000_000))
+        }
+
+        static func milliseconds(_ value: Int) -> SchedulerTimeType {
+            precondition(value >= 0, "value must not be negative")
+            return .init(nanoseconds: UInt64(value) * 1_000_000)
+        }
+
+        static func microseconds(_ value: Int) -> SchedulerTimeType {
+            precondition(value >= 0, "value must not be negative")
+            return .init(nanoseconds: UInt64(value) * 1_000)
+        }
+
+        static func nanoseconds(_ value: Int) -> SchedulerTimeType {
+            precondition(value >= 0, "value must not be negative")
+            return .init(nanoseconds: UInt64(value))
+        }
+    }
+
+    enum SchedulerOptions: Equatable, CustomStringConvertible {
+        case nontrivialOptions
+
+        var description: String {
+            switch self {
+            case .nontrivialOptions:
+                return ".nontrivialOptions"
+            }
+        }
+    }
+
+    private final class CancellableToken: Cancellable {
+
+        private(set) var isCancelled = false
+
+        func cancel() {
+            isCancelled = true
+        }
+    }
+
+    enum Event: Equatable, CustomStringConvertible {
+        case now
+        case minimumTolerance
+        case schedule(options: SchedulerOptions?)
+        case scheduleAfterDate(SchedulerTimeType,
+                               tolerance: SchedulerTimeType.Stride,
+                               options: SchedulerOptions?)
+        case scheduleAfterDateWithInterval(SchedulerTimeType,
+                                           interval: SchedulerTimeType.Stride,
+                                           tolerance: SchedulerTimeType.Stride,
+                                           options: SchedulerOptions?)
+
+        var description: String {
+
+            func describeOptions(_ options: SchedulerOptions?) -> String {
+                return options.map(String.init(describing:)) ?? "nil"
+            }
+
+            func describeDate(_ date: SchedulerTimeType) -> String {
+                return ".nanoseconds(\(date.time)"
+            }
+
+            func describeStride(_ stride: SchedulerTimeType.Stride) -> String {
+                return ".nanoseconds(\(stride.magnitude))"
+            }
+
+            switch self {
+            case .now:
+                return ".now"
+            case .minimumTolerance:
+                return ".minimumTolerance"
+            case let .schedule(options):
+                return ".schedule(options: \(describeOptions(options)))"
+            case let .scheduleAfterDate(date, tolerance, options):
+                return """
+                .scheduleAfterDate(\(describeDate(date)), \
+                tolerance: \(describeStride(tolerance)), \
+                options: \(describeOptions(options)))
+                """
+            case let .scheduleAfterDateWithInterval(date, interval, tolerance, options):
+                return """
+                .scheduleAfterDateWithInterval(\(describeDate(date)), \
+                interval: \(describeStride(interval)), \
+                tolerance: \(describeStride(tolerance)), \
+                options: \(describeOptions(options)))
+                """
+            }
+        }
+    }
+
+    private(set) var history = [Event]()
+
+    /// All private methods should reference this property instead of `now`
+    /// to prevent polluting the scheduler history. Accessing `now` creates an entry
+    /// in the `history` array.
+    private var _now = SchedulerTimeType.beginningOfTime
+
+    private var workQueue = FairPriorityQueue<SchedulerTimeType, () -> Void>()
+
+    var scheduledDates: [SchedulerTimeType] {
+        return workQueue.map { $0.0 }
+    }
+
+    var now: SchedulerTimeType {
+        history.append(.now)
+        return _now
+    }
+
+    var minimumTolerance: SchedulerTimeType.Stride {
+        history.append(.minimumTolerance)
+        return 0
+    }
+
+    func schedule(options: SchedulerOptions?, _ action: @escaping () -> Void) {
+        history.append(.schedule(options: options))
+        workQueue.insert(action, priority: _now)
+    }
+
+    func schedule(after date: SchedulerTimeType,
+                  tolerance: SchedulerTimeType.Stride,
+                  options: SchedulerOptions?,
+                  _ action: @escaping () -> Void) {
+        history.append(.scheduleAfterDate(date, tolerance: tolerance, options: options))
+        workQueue.insert(action, priority: date)
+    }
+
+    func schedule(after date: SchedulerTimeType,
+                  interval: SchedulerTimeType.Stride,
+                  tolerance: SchedulerTimeType.Stride,
+                  options: SchedulerOptions?,
+                  _ action: @escaping () -> Void) -> Cancellable {
+        history.append(.scheduleAfterDateWithInterval(date,
+                                                      interval: interval,
+                                                      tolerance: tolerance,
+                                                      options: options))
+        let cancellableToken = CancellableToken()
+        repeatedlyExecute(after: date,
+                          interval: interval,
+                          cancellableToken: cancellableToken,
+                          action: action)
+        return cancellableToken
+    }
+
+    private func repeatedlyExecute(after date: SchedulerTimeType,
+                                   interval: SchedulerTimeType.Stride,
+                                   cancellableToken: CancellableToken,
+                                   action: @escaping () -> Void) {
+        let enqueuedAction: () -> Void = { [unowned self] in
+            if cancellableToken.isCancelled { return }
+            action()
+            self.repeatedlyExecute(after: date + interval,
+                                   interval: interval,
+                                   cancellableToken: cancellableToken,
+                                   action: action)
+        }
+        workQueue.insert(enqueuedAction, priority: date)
+    }
+
+    /// Sets `now` to the provided value. Useful for testing that an entity that
+    /// uses the scheduler doesn't rely on clock monotonicity.
+    ///
+    /// - Note: The actions that were already executed will not be executed again.
+    ///   This function does **not** provide time machine-like functionality.
+    func rewind(to time: SchedulerTimeType) {
+        _now = time
+    }
+
+    func executeScheduledActions() {
+        while let (time, action) = workQueue.extractMin() {
+            _now = max(time, _now)
+            action()
+        }
+    }
+}

Tests/OpenCombineTests/Helpers/XCTUnwrap.swift

@@ -9,7 +9,19 @@ import XCTest
 
 // FIXME: XCTUnwrap is unavailable in Swift Package Manager yet.
 
-private struct UnwrappingFailure: Error {}
+private struct UnwrappingFailure: Error, LocalizedError {
+
+    let message: String
+
+    var errorDescription: String? {
+        var failureDescription = "XCTUnwrap failed"
+        if !message.isEmpty {
+            failureDescription += ": "
+            failureDescription += message
+        }
+        return failureDescription
+    }
+}
 
 /// Asserts that an expression is not `nil`, and returns its unwrapped value.
 ///
@@ -32,10 +44,11 @@ public func XCTUnwrap<Result>(_ expression: @autoclosure () throws -> Result?,
                               file: StaticString = #file,
                               line: UInt = #line) throws -> Result {
     let result = try expression()
-    XCTAssertNotNil(result, message(), file: file, line: line)
     if let result = result {
         return result
     } else {
-        throw UnwrappingFailure()
+        let error = UnwrappingFailure(message: message())
+        XCTFail(error.errorDescription ?? "", file: file, line: line)
+        throw error
     }
 }

Tests/OpenCombineTests/ObservableObjectTests.swift

@@ -1,419 +0,0 @@
-//
-//  ObservableObjectTests.swift
-//  
-//
-//  Created by Sergej Jaskiewicz on 26.10.2019.
-//
-
-#if swift(>=5.1)
-
-import XCTest
-
-#if OPENCOMBINE_COMPATIBILITY_TEST
-
-import Combine
-
-@available(macOS 10.15, iOS 13.0, *)
-private typealias ObservableObject = Combine.ObservableObject
-
-@available(macOS 10.15, iOS 13.0, *)
-private typealias Published = Combine.Published
-
-#else
-
-import OpenCombine
-
-private typealias ObservableObject = OpenCombine.ObservableObject
-private typealias Published = OpenCombine.Published
-
-#endif
-
-@available(macOS 10.15, iOS 13.0, *)
-final class ObservableObjectTests: XCTestCase {
-
-    var disposeBag = [AnyCancellable]()
-
-    override func tearDown() {
-        disposeBag = []
-        super.tearDown()
-    }
-
-    func testNoFields() {
-        let observableObject = NoFields()
-        let publisher1 = observableObject.objectWillChange
-        let publisher2 = observableObject.objectWillChange
-        XCTAssert(publisher1 !== publisher2,
-                  """
-                  If there are no fields, objectWillChange property should return \
-                  a new instance every time
-                  """)
-    }
-
-    func testNoPublishedFields() {
-        let observableObject = NoPublishedFields()
-        let publisher1 = observableObject.objectWillChange
-        let publisher2 = observableObject.objectWillChange
-        XCTAssert(publisher1 !== publisher2,
-                  """
-                  If there are no @Published fields, objectWillChange property should \
-                  return a new instance every time
-                  """)
-    }
-
-    func testPublishedFieldIsConstant() {
-        let observableObject = PublishedFieldIsConstant()
-
-        let publisher1 = observableObject.objectWillChange
-        let publisher2 = observableObject.objectWillChange
-
-        XCTAssert(publisher1 === publisher2,
-                  """
-                  Even if the Published field is a constant, a publisher \
-                  should be installed there.
-                  """)
-    }
-
-    func testDerivedClassWithPublishedField() {
-        let observableObject = ObservedDerivedWithObservedBase()
-
-        var counter = 0
-
-        observableObject.objectWillChange.sink { counter += 1 }.store(in: &disposeBag)
-
-        XCTAssertEqual(observableObject.publishedValue0, 0)
-        XCTAssertEqual(observableObject.simpleValue, "what")
-        XCTAssertEqual(observableObject.subclassPublished0, 0)
-        XCTAssertEqual(observableObject.subclassPublished1, 1)
-        XCTAssertEqual(observableObject.subclassPublished2, 2)
-
-        observableObject.publishedValue0 += 5
-
-        XCTAssertEqual(counter, 1)
-        XCTAssertEqual(observableObject.publishedValue0, 5)
-
-        Published<String>[_enclosingInstance: observableObject,
-                          wrapped: \.simpleValue,
-                          storage: \.publishedValue1] += "???"
-
-        XCTAssertEqual(counter, 2)
-        XCTAssertEqual(observableObject.simpleValue, "what")
-
-        observableObject.subclassPublished0 += 3
-
-        XCTAssertEqual(counter, 3)
-        XCTAssertEqual(observableObject.subclassPublished0, 3)
-
-        observableObject.subclassPublished1 += 3
-
-        XCTAssertEqual(counter, 4)
-        XCTAssertEqual(observableObject.subclassPublished1, 4)
-
-        observableObject.subclassPublished2 += 3
-
-        XCTAssertEqual(counter, 5)
-        XCTAssertEqual(observableObject.subclassPublished1, 4)
-    }
-
-    func testObjCClassRetroactiveConformance() {
-        let observableObject = NSNumber(value: 42.0)
-        let publisher1 = observableObject.objectWillChange
-        let publisher2 = observableObject.objectWillChange
-        XCTAssert(publisher1 !== publisher2,
-                  """
-                  For instances of Objective-C classes objectWillChange property should \
-                  return a new instance every time
-                  """)
-    }
-
-    func testObjCClassSubclass() {
-        let observableObject = ObjCClassSubclass()
-        let publisher1 = observableObject.objectWillChange
-        let publisher2 = observableObject.objectWillChange
-        XCTAssert(publisher1 === publisher2)
-    }
-
-    func testResilientClassSubclass() {
-        let observableObject = ResilientClassSubclass()
-        let publisher1 = observableObject.objectWillChange
-        let publisher2 = observableObject.objectWillChange
-#if canImport(Darwin)
-        XCTAssert(publisher1 !== publisher2,
-                  """
-                  For subclasses of resilient classes objectWillChange property should \
-                  return a new instance every time
-                  """)
-#else
-        // There are no resilient classes on non-Darwin platforms.
-        XCTAssert(publisher1 === publisher2)
-#endif
-    }
-
-    func testResilientClassSubclass2() {
-        let observableObject = ResilientClassSubclass2()
-        let publisher1 = observableObject.objectWillChange
-        let publisher2 = observableObject.objectWillChange
-#if canImport(Darwin)
-        XCTAssert(publisher1 !== publisher2,
-                  """
-                  For subclasses of resilient classes objectWillChange property should \
-                  return a new instance every time
-                  """)
-#else
-        // There are no resilient classes on non-Darwin platforms.
-        XCTAssert(publisher1 === publisher2)
-#endif
-        }
-
-    func testResilientClassRetroactiveConformance() {
-        let observableObject = JSONEncoder()
-        let publisher1 = observableObject.objectWillChange
-        let publisher2 = observableObject.objectWillChange
-        XCTAssert(publisher1 !== publisher2,
-                  """
-                  For instances of resilient classes objectWillChange property should \
-                  return a new instance every time
-                  """)
-    }
-
-    func testGenericClass() {
-        let observableObject = GenericClass(123, true)
-
-        var counter = 0
-
-        observableObject.objectWillChange.sink { counter += 1 }.store(in: &disposeBag)
-        XCTAssertEqual(counter, 0)
-        XCTAssertEqual(observableObject.value1, 123)
-        XCTAssertEqual(observableObject.value2, true)
-
-        observableObject.value1 += 1
-
-        XCTAssertEqual(counter, 1)
-        XCTAssertEqual(observableObject.value1, 124)
-
-        observableObject.value2.toggle()
-
-        XCTAssertEqual(counter, 2)
-        XCTAssertEqual(observableObject.value2, false)
-    }
-
-    func testGenericSubclassOfResilientClass() {
-        let observableObject = ResilientClassGenericSubclass("hello", true)
-
-        var counter = 0
-
-        // A bug in Combine (FB7471594). It should not crash. Why would it crash?
-        assertCrashesOnDarwin {
-            observableObject.objectWillChange.sink { counter += 1 }.store(in: &disposeBag)
-            XCTAssertEqual(counter, 0)
-            XCTAssertEqual(observableObject.value1, "hello")
-            XCTAssertEqual(observableObject.value2, true)
-
-            observableObject.value1 += "!"
-
-            XCTAssertEqual(counter, 1)
-            XCTAssertEqual(observableObject.value1, "hello!")
-
-            observableObject.value2.toggle()
-
-            XCTAssertEqual(counter, 2)
-            XCTAssertEqual(observableObject.value2, false)
-        }
-    }
-
-    func testGenericSubclassOfResilientClass2() {
-        let observableObject = ResilientClassGenericSubclass2("hello", true)
-
-        var counter = 0
-
-        // A bug in Combine (FB7471594). It should not crash. Why would it crash?
-        assertCrashesOnDarwin {
-            observableObject.objectWillChange.sink { counter += 1 }.store(in: &disposeBag)
-            XCTAssertEqual(counter, 0)
-            XCTAssertEqual(observableObject.value1, "hello")
-            XCTAssertEqual(observableObject.value2, true)
-
-            observableObject.value1 += "!"
-
-            XCTAssertEqual(counter, 1)
-            XCTAssertEqual(observableObject.value1, "hello!")
-
-            observableObject.value2.toggle()
-
-            XCTAssertEqual(counter, 2)
-            XCTAssertEqual(observableObject.value2, false)
-
-            observableObject.value3.toggle()
-
-            XCTAssertEqual(counter, 3)
-            XCTAssertEqual(observableObject.value3, true)
-        }
-    }
-
-    func testObservableDerivedWithNonObservableBase() {
-        let observableObject = ObservedDerivedWithNonObservedBase()
-        var counter = 0
-        observableObject.objectWillChange.sink { counter += 1 }.store(in: &disposeBag)
-
-        XCTAssertEqual(counter, 0)
-        XCTAssertEqual(observableObject.nonObservedBaseValue0, 10)
-        XCTAssertEqual(observableObject.nonObservedBaseValue1, .pi)
-        XCTAssertEqual(observableObject.observedDerivedValue2,
-                       "Asuka is obviously the best girl.")
-        XCTAssertEqual(observableObject.observedDerivedValue3, 255)
-
-        observableObject.nonObservedBaseValue0 -= 1
-        XCTAssertEqual(counter, 1)
-        XCTAssertEqual(observableObject.nonObservedBaseValue0, 9)
-
-        observableObject.nonObservedBaseValue1 *= 2
-        XCTAssertEqual(counter, 2)
-        XCTAssertEqual(observableObject.nonObservedBaseValue1, 2 * .pi)
-
-        observableObject.observedDerivedValue2 = "Nevermind."
-        XCTAssertEqual(counter, 3)
-        XCTAssertEqual(observableObject.observedDerivedValue2, "Nevermind.")
-
-        observableObject.observedDerivedValue3 &+= 1
-        XCTAssertEqual(counter, 4)
-        XCTAssertEqual(observableObject.observedDerivedValue3, 0)
-    }
-
-    func testNSObjectSubclass() {
-        let observableObject = NSObjectSubclass()
-        var counter = 0
-        observableObject.objectWillChange.sink { counter += 1 }.store(in: &disposeBag)
-
-        XCTAssertEqual(counter, 0)
-        XCTAssertEqual(observableObject.value0, 0)
-        XCTAssertEqual(observableObject.value1, 42)
-
-        observableObject.value0 += 1
-        XCTAssertEqual(counter, 1)
-        XCTAssertEqual(observableObject.value0, 1)
-
-        observableObject.value1 += 1
-        XCTAssertEqual(counter, 2)
-        XCTAssertEqual(observableObject.value1, 43)
-    }
-
-    func testClassWithResilientField() {
-        let observableObject = ClassWithResilientField()
-        var counter = 0
-        observableObject.objectWillChange.sink { counter += 1 }.store(in: &disposeBag)
-
-        XCTAssertEqual(counter, 0)
-
-        observableObject.note2 = Notification(name: .init("note 2 modified"))
-        XCTAssertEqual(counter, 1)
-    }
-}
-
-@available(macOS 10.15, iOS 13.0, *)
-private final class NoFields: ObservableObject {}
-
-@available(macOS 10.15, iOS 13.0, *)
-private final class NoPublishedFields: ObservableObject {
-    var field = NoFields()
-    var int = 0
-}
-
-@available(macOS 10.15, iOS 13.0, *)
-private final class PublishedFieldIsConstant: ObservableObject {
-    let publishedValue = Published(initialValue: 42)
-}
-
-@available(macOS 10.15, iOS 13.0, *)
-private class ObservedBase: ObservableObject {
-    @Published var publishedValue0 = 0
-    var publishedValue1 = Published(initialValue: "Hello!")
-    let publishedValue2 = Published(initialValue: 42)
-    var simpleValue = "what"
-}
-
-@available(macOS 10.15, iOS 13.0, *)
-private final class ObservedDerivedWithObservedBase: ObservedBase {
-    @Published var subclassPublished0 = 0
-    @Published var subclassPublished1 = 1
-    @Published var subclassPublished2 = 2
-}
-
-@available(macOS 10.15, iOS 13.0, *)
-extension NSNumber: ObservableObject {}
-
-@available(macOS 10.15, iOS 13.0, *)
-private final class ObjCClassSubclass: NSOrderedSet, ObservableObject {
-    @Published var published = 10
-}
-
-@available(macOS 10.15, iOS 13.0, *)
-private class ResilientClassSubclass: JSONDecoder, ObservableObject {
-    @Published var published0 = 10
-    @Published var published1 = "hello!"
-}
-
-@available(macOS 10.15, iOS 13.0, *)
-private final class ResilientClassSubclass2: ResilientClassSubclass {
-    @Published var published3 = true
-}
-
-@available(macOS 10.15, iOS 13.0, *)
-extension JSONEncoder: ObservableObject {}
-
-@available(macOS 10.15, iOS 13.0, *)
-private final class GenericClass<Value1, Value2>: ObservableObject {
-    @Published var value1: Value1
-    @Published var value2: Value2
-
-    init(_ value1: Value1, _ value2: Value2) {
-        self.value1 = value1
-        self.value2 = value2
-    }
-}
-
-@available(macOS 10.15, iOS 13.0, *)
-private class NonObservedBase {
-    @Published var nonObservedBaseValue0 = 10
-    @Published var nonObservedBaseValue1 = Double.pi
-}
-
-@available(macOS 10.15, iOS 13.0, *)
-private class ObservedDerivedWithNonObservedBase: NonObservedBase, ObservableObject {
-    @Published var observedDerivedValue2 = "Asuka is obviously the best girl."
-    @Published var observedDerivedValue3: UInt8 = 255
-}
-
-@available(macOS 10.15, iOS 13.0, *)
-private class NSObjectSubclass: NSObject, ObservableObject {
-    @Published var value0 = 0
-    @Published var value1: UInt8 = 42
-}
-
-@available(macOS 10.15, iOS 13.0, *)
-private class ResilientClassGenericSubclass<Value1, Value2>
-    : JSONDecoder,
-      ObservableObject
-{
-    @Published var value1: Value1
-    @Published var value2: Value2
-
-    init(_ value1: Value1, _ value2: Value2) {
-        self.value1 = value1
-        self.value2 = value2
-    }
-}
-
-@available(macOS 10.15, iOS 13.0, *)
-private final class ResilientClassGenericSubclass2<Value1, Value2>
-    : ResilientClassGenericSubclass<Value1, Value2>
-{
-    @Published var value3 = false
-}
-
-@available(macOS 10.15, iOS 13.0, *)
-private final class ClassWithResilientField: ObservableObject {
-    // Foundation.Notification is resilient struct
-    private var note1 = Notification(name: .init("note 1"))
-    @Published var note2 = Notification(name: .init("note 2"))
-}
-
-#endif // swift(>=5.1)

Tests/OpenCombineTests/PublisherTests/BreakpointTests.swift

@@ -0,0 +1,173 @@
+//
+//  BreakpointTests.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 03.12.2019.
+//
+
+import XCTest
+
+#if OPENCOMBINE_COMPATIBILITY_TEST
+import Combine
+#else
+import OpenCombine
+#endif
+
+@available(macOS 10.15, iOS 13.0, *)
+final class BreakpointTests: XCTestCase {
+
+    func testReceiveSubscription() {
+        var shouldStop = false
+        var counter = 0
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: nil,
+                                        receiveValueDemand: .max(1)) {
+            $0.breakpoint(receiveSubscription: { _ in counter += 1; return shouldStop })
+        }
+
+        XCTAssertNotNil(helper.sut.receiveSubscription)
+        XCTAssertNil(helper.sut.receiveOutput)
+        XCTAssertNil(helper.sut.receiveCompletion)
+
+        XCTAssertEqual(helper.publisher.send(12), .max(1))
+        helper.publisher.send(completion: .finished)
+        helper.publisher.send(completion: .failure(.oops))
+        XCTAssertEqual(helper.publisher.send(21), .max(1))
+        helper.publisher.send(subscription: CustomSubscription())
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("CustomSubscription"),
+                                                 .value(12),
+                                                 .completion(.finished),
+                                                 .completion(.failure(.oops)),
+                                                 .value(21),
+                                                 .subscription("CustomSubscription")])
+        XCTAssertEqual(helper.subscription.history, [])
+        shouldStop = true
+        XCTAssertEqual(counter, 2)
+        assertCrashes {
+            helper.publisher.send(subscription: CustomSubscription())
+        }
+    }
+
+    func testReceiveValue() {
+        var counter = 0
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: nil,
+                                        receiveValueDemand: .max(1)) {
+            $0.breakpoint(receiveOutput: { counter += 1; return $0 < 0 })
+        }
+
+        XCTAssertNil(helper.sut.receiveSubscription)
+        XCTAssertNotNil(helper.sut.receiveOutput)
+        XCTAssertNil(helper.sut.receiveCompletion)
+
+        XCTAssertEqual(helper.publisher.send(12), .max(1))
+        helper.publisher.send(completion: .finished)
+        helper.publisher.send(completion: .failure(.oops))
+        XCTAssertEqual(helper.publisher.send(21), .max(1))
+        helper.publisher.send(subscription: CustomSubscription())
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("CustomSubscription"),
+                                                 .value(12),
+                                                 .completion(.finished),
+                                                 .completion(.failure(.oops)),
+                                                 .value(21),
+                                                 .subscription("CustomSubscription")])
+        XCTAssertEqual(helper.subscription.history, [])
+        XCTAssertEqual(counter, 2)
+        assertCrashes {
+            _ = helper.publisher.send(-1)
+        }
+    }
+
+    func testReceiveCompletion() {
+        var counter = 0
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: nil,
+                                        receiveValueDemand: .max(1)) {
+            $0.breakpoint(receiveCompletion: { counter += 1; return $0 == .finished })
+        }
+
+        XCTAssertNil(helper.sut.receiveSubscription)
+        XCTAssertNil(helper.sut.receiveOutput)
+        XCTAssertNotNil(helper.sut.receiveCompletion)
+
+        XCTAssertEqual(helper.publisher.send(12), .max(1))
+        helper.publisher.send(completion: .failure(.oops))
+        helper.publisher.send(completion: .failure(.oops))
+        XCTAssertEqual(helper.publisher.send(21), .max(1))
+        helper.publisher.send(subscription: CustomSubscription())
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("CustomSubscription"),
+                                                 .value(12),
+                                                 .completion(.failure(.oops)),
+                                                 .completion(.failure(.oops)),
+                                                 .value(21),
+                                                 .subscription("CustomSubscription")])
+        XCTAssertEqual(counter, 2)
+        assertCrashes {
+            helper.publisher.send(completion: .finished)
+        }
+    }
+
+    func testBreakpointOnError() throws {
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: nil,
+                                        receiveValueDemand: .max(1)) {
+            $0.breakpointOnError()
+        }
+
+        XCTAssertNil(helper.sut.receiveSubscription)
+        XCTAssertNil(helper.sut.receiveOutput)
+        XCTAssertNotNil(helper.sut.receiveCompletion)
+
+        XCTAssertEqual(helper.publisher.send(12), .max(1))
+        helper.publisher.send(completion: .finished)
+        helper.publisher.send(completion: .finished)
+        XCTAssertEqual(helper.publisher.send(21), .max(1))
+        helper.publisher.send(subscription: CustomSubscription())
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("CustomSubscription"),
+                                                 .value(12),
+                                                 .completion(.finished),
+                                                 .completion(.finished),
+                                                 .value(21),
+                                                 .subscription("CustomSubscription")])
+
+        XCTAssertEqual(helper.sut.receiveCompletion?(.finished), false)
+        XCTAssertEqual(helper.sut.receiveCompletion?(.failure(.oops)), true)
+
+        assertCrashes {
+            helper.publisher.send(completion: .failure(.oops))
+        }
+    }
+
+    func testCancelAlreadyCancelled() throws {
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: .unlimited,
+                                        receiveValueDemand: .none) {
+            $0.breakpointOnError()
+        }
+        try XCTUnwrap(helper.downstreamSubscription).request(.max(14))
+        try XCTUnwrap(helper.downstreamSubscription).cancel()
+        try XCTUnwrap(helper.downstreamSubscription).request(.max(100))
+        try XCTUnwrap(helper.downstreamSubscription).cancel()
+
+        XCTAssertEqual(helper.subscription.history, [.requested(.unlimited),
+                                                     .requested(.max(14)),
+                                                     .cancelled,
+                                                     .requested(.max(100)),
+                                                     .cancelled])
+    }
+
+    func testBreakpointReflection() throws {
+        try testReflection(parentInput: Int.self,
+                           parentFailure: Error.self,
+                           description: "Breakpoint",
+                           customMirror: expectedChildren(
+                               ("upstream", .contains("CustomConnectablePublisherBase"))
+                           ),
+                           playgroundDescription: "Breakpoint",
+                           { $0.breakpointOnError() })
+    }
+}

Tests/OpenCombineTests/PublisherTests/ConcatenateTests.swift

@@ -0,0 +1,440 @@
+//
+//  ConcatenateTests.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 09.12.2019.
+//
+
+import XCTest
+
+#if OPENCOMBINE_COMPATIBILITY_TEST
+import Combine
+#else
+import OpenCombine
+#endif
+
+@available(macOS 10.15, iOS 13.0, *)
+final class ConcatenateTests: XCTestCase {
+
+    func testAppendBasicBehavior() {
+        let subscription1 = CustomSubscription()
+        let subscription2 = CustomSubscription()
+        let publisher1 = CustomPublisher(subscription: subscription1)
+        let publisher2 = CustomPublisher(subscription: subscription2)
+
+        let append = publisher1.append(publisher2)
+
+        let tracking = TrackingSubscriber(
+            receiveSubscription: { $0.request(.max(10)) },
+            receiveValue: { .max($0) },
+            receiveCompletion: { _ in }
+        )
+
+        append.subscribe(tracking)
+
+        XCTAssertEqual(tracking.history, [.subscription("Concatenate")])
+        XCTAssertEqual(subscription1.history, [.requested(.max(10))])
+        XCTAssertEqual(subscription2.history, [])
+
+        XCTAssertEqual(publisher1.send(1), .max(1))
+        XCTAssertEqual(publisher2.send(-1), .none)
+        XCTAssertEqual(publisher1.send(2), .max(2))
+        XCTAssertEqual(publisher2.send(-2), .none)
+        XCTAssertEqual(publisher1.send(3), .max(3))
+        XCTAssertEqual(publisher2.send(-3), .none)
+        publisher2.send(completion: .failure(.oops))
+
+        XCTAssertEqual(tracking.history, [.subscription("Concatenate"),
+                                          .value(1),
+                                          .value(2),
+                                          .value(3)])
+        XCTAssertEqual(subscription1.history, [.requested(.max(10))])
+        XCTAssertEqual(subscription2.history, [])
+
+        publisher1.send(completion: .finished)
+
+        XCTAssertEqual(tracking.history, [.subscription("Concatenate"),
+                                          .value(1),
+                                          .value(2),
+                                          .value(3)])
+        XCTAssertEqual(subscription1.history, [.requested(.max(10))])
+        XCTAssertEqual(subscription2.history, [.requested(.max(13))])
+
+        XCTAssertEqual(publisher1.send(4000), .max(4000))
+        XCTAssertEqual(publisher2.send(5), .max(5))
+
+        XCTAssertEqual(tracking.history, [.subscription("Concatenate"),
+                                          .value(1),
+                                          .value(2),
+                                          .value(3),
+                                          .value(4000),
+                                          .value(5)])
+        XCTAssertEqual(subscription1.history, [.requested(.max(10))])
+        XCTAssertEqual(subscription2.history, [.requested(.max(13))])
+
+        publisher2.send(completion: .finished)
+        publisher2.send(completion: .finished)
+        publisher1.send(completion: .finished)
+        publisher1.send(completion: .failure(.oops))
+        publisher2.send(completion: .failure(.oops))
+
+        XCTAssertEqual(publisher1.send(6000), .max(6000))
+        XCTAssertEqual(publisher2.send(7), .max(7))
+
+        XCTAssertEqual(tracking.history, [.subscription("Concatenate"),
+                                          .value(1),
+                                          .value(2),
+                                          .value(3),
+                                          .value(4000),
+                                          .value(5),
+                                          .completion(.finished),
+                                          .completion(.finished),
+                                          .completion(.finished),
+                                          .completion(.failure(.oops)),
+                                          .completion(.failure(.oops)),
+                                          .value(6000),
+                                          .value(7)])
+        XCTAssertEqual(subscription1.history, [.requested(.max(10))])
+        XCTAssertEqual(subscription2.history, [.requested(.max(13))])
+
+        let subscription3 = CustomSubscription()
+        publisher2.send(subscription: subscription3)
+
+        XCTAssertEqual(tracking.history, [.subscription("Concatenate"),
+                                          .value(1),
+                                          .value(2),
+                                          .value(3),
+                                          .value(4000),
+                                          .value(5),
+                                          .completion(.finished),
+                                          .completion(.finished),
+                                          .completion(.finished),
+                                          .completion(.failure(.oops)),
+                                          .completion(.failure(.oops)),
+                                          .value(6000),
+                                          .value(7)])
+        XCTAssertEqual(subscription3.history, [.cancelled])
+    }
+
+    func testConcatenateTwoSequences() {
+        let sequence1: Publishers.Sequence =
+            sequence(first: 1, next: { $0 > 20 ? nil : $0 * 2 })
+                .publisher
+
+        let sequence2: Publishers.Sequence = (33 ..< 40).publisher
+
+        let expected = [1, 2, 4, 8, 16, 32, 33, 34, 35, 36, 37, 38, 39]
+
+        var historyAppend = [Int]()
+        var appendCompleted = false
+        let append: Publishers.Concatenate = sequence1.append(sequence2)
+        let cancellableAppend = append
+            .sink(receiveCompletion: { _ in appendCompleted = true },
+                  receiveValue: { historyAppend.append($0) })
+        XCTAssertEqual(historyAppend, expected)
+        XCTAssertTrue(appendCompleted)
+        cancellableAppend.cancel()
+
+        var historyPrepend = [Int]()
+        var prependCompleted = false
+        let prepend: Publishers.Concatenate = sequence2.prepend(sequence1)
+        let cancellablePrepend = prepend
+            .sink(receiveCompletion: { _ in prependCompleted = true },
+                  receiveValue: { historyPrepend.append($0) })
+        XCTAssertEqual(historyPrepend, [1, 2, 4, 8, 16, 32, 33, 34, 35, 36, 37, 38, 39])
+        XCTAssertTrue(prependCompleted)
+        cancellablePrepend.cancel()
+    }
+
+    func testPrefixFailureFailsDownstream() {
+        let subscription1 = CustomSubscription()
+        let subscription2 = CustomSubscription()
+        let publisher1 = CustomPublisher(subscription: subscription1)
+        let publisher2 = CustomPublisher(subscription: subscription2)
+
+        let append = publisher1.append(publisher2)
+
+        let tracking = TrackingSubscriber(
+            receiveSubscription: { $0.request(.max(10)) },
+            receiveValue: { .max($0) },
+            receiveCompletion: { _ in }
+        )
+
+        append.subscribe(tracking)
+
+        XCTAssertEqual(tracking.history, [.subscription("Concatenate")])
+        XCTAssertEqual(subscription1.history, [.requested(.max(10))])
+        XCTAssertEqual(subscription2.history, [])
+
+        publisher1.send(completion: .failure(.oops))
+
+        XCTAssertEqual(tracking.history, [.subscription("Concatenate"),
+                                          .completion(.failure(.oops))])
+        XCTAssertEqual(subscription1.history, [.requested(.max(10))])
+        XCTAssertEqual(subscription2.history, [])
+
+        XCTAssertEqual(publisher1.send(2), .max(2))
+        publisher1.send(completion: .finished)
+        XCTAssertEqual(publisher2.send(3), .max(3))
+        publisher2.send(completion: .finished)
+
+        XCTAssertEqual(tracking.history, [.subscription("Concatenate"),
+                                          .completion(.failure(.oops)),
+                                          .value(2),
+                                          .value(3),
+                                          .completion(.finished)])
+        XCTAssertEqual(subscription1.history, [.requested(.max(10))])
+        XCTAssertEqual(subscription2.history, [.requested(.max(11))])
+    }
+
+    func testSubscribesToUpstreamThenSendsSubscriptionDownstream() {
+        let subscription = CustomSubscription()
+        let publisher = CustomPublisher(subscription: subscription)
+        let append = publisher.append(1, 2, 3)
+        let tracking = TrackingSubscriber()
+
+        var didSubscribe = false
+
+        publisher.didSubscribe = { _ in
+            XCTAssertEqual(tracking.history, [])
+            didSubscribe = true
+        }
+
+        XCTAssertEqual(tracking.history, [])
+
+        append.subscribe(tracking)
+
+        XCTAssertTrue(didSubscribe)
+        XCTAssertEqual(tracking.history, [.subscription("Concatenate")])
+    }
+
+    func testBackpressure() throws {
+        let subscription1 = CustomSubscription()
+        let subscription2 = CustomSubscription()
+        let publisher1 = CustomPublisher(subscription: subscription1)
+        let publisher2 = CustomPublisher(subscription: subscription2)
+
+        let append = publisher1.append(publisher2)
+        var downstreamSubscription: Subscription?
+        let tracking = TrackingSubscriber(
+            receiveSubscription: { downstreamSubscription = $0; $0.request(.max(10)) },
+            receiveValue: { .max($0) },
+            receiveCompletion: { _ in }
+        )
+
+        publisher2.willSubscribe = { _ in
+            downstreamSubscription?.request(.max(7))
+            XCTAssertEqual(subscription1.history, [.requested(.max(10)),
+                                                   .requested(.none)])
+            XCTAssertEqual(subscription2.history, [])
+        }
+
+        append.subscribe(tracking)
+        try XCTUnwrap(downstreamSubscription).request(.none)
+        XCTAssertEqual(publisher1.send(3), .max(3))
+
+        XCTAssertEqual(tracking.history, [.subscription("Concatenate"),
+                                          .value(3)])
+        XCTAssertEqual(subscription1.history, [.requested(.max(10)),
+                                               .requested(.none)])
+        XCTAssertEqual(subscription2.history, [])
+
+        publisher1.send(completion: .finished)
+
+        XCTAssertEqual(subscription1.history, [.requested(.max(10)),
+                                               .requested(.none)])
+        XCTAssertEqual(subscription2.history, [.requested(.max(19))])
+
+        try XCTUnwrap(downstreamSubscription).request(.unlimited)
+
+        XCTAssertEqual(subscription1.history, [.requested(.max(10)),
+                                               .requested(.none)])
+        XCTAssertEqual(subscription2.history, [.requested(.max(19)),
+                                               .requested(.unlimited)])
+
+        publisher2.send(completion: .finished)
+
+        try XCTUnwrap(downstreamSubscription).request(.max(42))
+
+        XCTAssertEqual(subscription1.history, [.requested(.max(10)),
+                                               .requested(.none)])
+        XCTAssertEqual(subscription2.history, [.requested(.max(19)),
+                                               .requested(.unlimited),
+                                               .requested(.max(42))])
+    }
+
+    func testCancelAlreadyCancelled() throws {
+        let subscription1 = CustomSubscription()
+        let subscription2 = CustomSubscription()
+        let publisher1 = CustomPublisher(subscription: subscription1)
+        let publisher2 = CustomPublisher(subscription: subscription2)
+
+        let append = publisher1.append(publisher2)
+        var downstreamSubscription: Subscription?
+        let tracking = TrackingSubscriber(
+            receiveSubscription: { downstreamSubscription = $0 },
+            receiveValue: { .max($0) },
+            receiveCompletion: { _ in }
+        )
+        append.subscribe(tracking)
+        try XCTUnwrap(downstreamSubscription).cancel()
+        try XCTUnwrap(downstreamSubscription).cancel()
+        try XCTUnwrap(downstreamSubscription).request(.max(2)) // total demand is 2
+        try XCTUnwrap(downstreamSubscription).cancel()
+        try XCTUnwrap(downstreamSubscription).request(.max(3)) // total demand is 5
+
+        XCTAssertEqual(tracking.history, [.subscription("Concatenate")])
+        XCTAssertEqual(subscription1.history, [.cancelled])
+        XCTAssertEqual(subscription2.history, [])
+
+        XCTAssertEqual(publisher1.send(0), .none) // total demand is 4
+        publisher1.send(completion: .finished)
+
+        XCTAssertEqual(tracking.history, [.subscription("Concatenate"),
+                                          .value(0)])
+        XCTAssertEqual(subscription1.history, [.cancelled])
+        XCTAssertEqual(subscription2.history, [.requested(.max(4))])
+
+        XCTAssertEqual(publisher1.send(0), .none) // total demand is 3
+        publisher1.send(completion: .failure(.oops))
+
+        XCTAssertEqual(tracking.history, [.subscription("Concatenate"),
+                                          .value(0),
+                                          .value(0),
+                                          .completion(.failure(.oops))])
+        XCTAssertEqual(subscription1.history, [.cancelled])
+        XCTAssertEqual(subscription2.history, [.requested(.max(4))])
+
+        try XCTUnwrap(downstreamSubscription).cancel()
+
+        XCTAssertEqual(tracking.history, [.subscription("Concatenate"),
+                                          .value(0),
+                                          .value(0),
+                                          .completion(.failure(.oops))])
+        XCTAssertEqual(subscription1.history, [.cancelled])
+        XCTAssertEqual(subscription2.history, [.requested(.max(4)),
+                                               .cancelled])
+
+        let subscription3 = CustomSubscription()
+        publisher2.send(subscription: subscription3)
+
+        XCTAssertEqual(tracking.history, [.subscription("Concatenate"),
+                                          .value(0),
+                                          .value(0),
+                                          .completion(.failure(.oops))])
+        XCTAssertEqual(subscription1.history, [.cancelled])
+        XCTAssertEqual(subscription2.history, [.requested(.max(4)),
+                                               .cancelled])
+        XCTAssertEqual(subscription3.history, [.cancelled])
+    }
+
+    func testRecursivelyReceiveValue() {
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: nil,
+                                        receiveValueDemand: .none,
+                                        createSut: { $0.append() })
+
+        var recursion = 10
+        helper.tracking.onValue = {
+            if recursion == 0 { return }
+            recursion -= 1
+            XCTAssertEqual(helper.publisher.send($0 + 1), .none)
+        }
+
+        assertCrashes {
+            XCTAssertEqual(helper.publisher.send(1), .none)
+        }
+    }
+
+    func testRecursivelyReceiveFailure() {
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: nil,
+                                        receiveValueDemand: .none,
+                                        createSut: { $0.append() })
+
+        var recursion = 10
+        helper.tracking.onFailure = { _ in
+            if recursion == 0 { return }
+            recursion -= 1
+            helper.publisher.send(completion: .failure(.oops))
+        }
+
+        assertCrashes {
+            helper.publisher.send(completion: .failure(.oops))
+        }
+    }
+
+    func testHelperMethods() {
+        let publisher = CustomPublisher(subscription: nil)
+        XCTAssertEqual(publisher.append(2, 3, 5, 7).suffix.sequence, [2, 3, 5, 7])
+        XCTAssertEqual(publisher.append(CollectionOfOne(42)).suffix.sequence.first, 42)
+        XCTAssertEqual(publisher.prepend(7, 5, 3, 2).prefix.sequence, [7, 5, 3, 2])
+        XCTAssertEqual(publisher.prepend(CollectionOfOne(42)).prefix.sequence.first, 42)
+    }
+
+    func testConcatenateReceiveValueBeforeSubscription() {
+        testReceiveValueBeforeSubscription(value: 12,
+                                           expected: .crash,
+                                           { $0.append(1, 2, 3) })
+
+        testReceiveValueBeforeSubscription(value: 12,
+                                           expected: .crash,
+                                           { $0.prepend(1, 2, 3) })
+    }
+
+    func testConcatenateReceiveCompletionBeforeSubscription() {
+        testReceiveCompletionBeforeSubscription(
+            inputType: Int.self,
+            expected: .history([.subscription("Concatenate")]),
+            { $0.append(1, 2, 3) }
+        )
+
+        testReceiveCompletionBeforeSubscription(
+            inputType: Int.self,
+            expected: .history([.subscription("Concatenate")]),
+            { $0.prepend(1, 2, 3) }
+        )
+    }
+
+    func testConcatenateRequestBeforeSubscription() {
+        testRequestBeforeSubscription(inputType: Int.self,
+                                      shouldCrash: false,
+                                      { $0.append(1, 2, 3) })
+    }
+
+    func testConcatenateCancelBeforeSubscription() {
+        testCancelBeforeSubscription(inputType: Int.self,
+                                     shouldCrash: false,
+                                     { $0.append(1, 2, 3) })
+    }
+
+    func testConcatenateReceiveSubscriptionTwice() throws {
+        try testReceiveSubscriptionTwice { $0.append(1, 2, 3) }
+    }
+
+    func testConcatenateReflection() throws {
+        try testReflection(parentInput: Float.self,
+                           parentFailure: TestingError.self,
+                           description: "Concatenate",
+                           customMirror: expectedChildren(
+                               ("downstream", .contains("TrackingSubscriberBase")),
+                               ("upstreamSubscription", "nil"),
+                               ("suffix", .contains("(sequence: [2.0, 3.0, 5.0, 7.0])")),
+                               ("demand", "max(0)")
+                           ),
+                           playgroundDescription: "Concatenate",
+                           { $0.append(2, 3, 5, 7) })
+    }
+
+    func testConcatenateLifecycle() throws {
+        try testLifecycle(sendValue: 31,
+                          cancellingSubscriptionReleasesSubscriber: false,
+                          finishingIsPassedThrough: true,
+                          { $0.append() })
+
+        try testLifecycle(sendValue: 31,
+                          cancellingSubscriptionReleasesSubscriber: false,
+                          finishingIsPassedThrough: false,
+                          { $0.prepend(1, 2, 3) })
+    }
+}

Tests/OpenCombineTests/PublisherTests/DeferredTests.swift

@@ -7,7 +7,6 @@
 
 import XCTest
 
-//import Combine
 #if OPENCOMBINE_COMPATIBILITY_TEST
 import Combine
 #else

Tests/OpenCombineTests/PublisherTests/DelayTests.swift

@@ -0,0 +1,466 @@
+//
+//  DelayTests.swift
+//  OpenCombineTests
+//
+//  Created by Евгений Богомолов on 08/09/2019.
+//
+
+import XCTest
+
+#if OPENCOMBINE_COMPATIBILITY_TEST
+import Combine
+#else
+import OpenCombine
+#endif
+
+@available(macOS 10.15, iOS 13.0, *)
+final class DelayTests: XCTestCase {
+
+    // Delay's Inner doesn't conform to CustomStringConvertible, so we can't compare
+    // subscriptions using their descriptions
+    let delaySubscription: StringSubscription = {
+        let tracking = TrackingSubscriber()
+        let scheduler = VirtualTimeScheduler()
+        CustomPublisher(subscription: CustomSubscription())
+            .delay(for: 0, scheduler: scheduler)
+            .subscribe(tracking)
+        scheduler.executeScheduledActions()
+        return tracking.subscriptions.first.map(StringSubscription.subscription)
+            ?? "Delay"
+    }()
+
+    func testBasicBehavior() {
+        let scheduler = VirtualTimeScheduler()
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: .max(100),
+                                        receiveValueDemand: .max(12)) {
+            $0.delay(for: .nanoseconds(200),
+                     tolerance: .nanoseconds(5),
+                     scheduler: scheduler,
+                     options: .nontrivialOptions)
+        }
+        XCTAssertNotNil(helper.publisher.subscriber)
+
+        XCTAssertEqual(helper.tracking.history, [])
+        XCTAssertEqual(helper.subscription.history, [])
+        XCTAssertEqual(scheduler.history, [.schedule(options: .nontrivialOptions)])
+
+        scheduler.executeScheduledActions()
+
+        XCTAssertEqual(helper.tracking.history, [.subscription(delaySubscription)])
+        XCTAssertEqual(helper.subscription.history, [.requested(.max(100))])
+        XCTAssertEqual(scheduler.history, [.schedule(options: .nontrivialOptions)])
+
+        XCTAssertEqual(helper.publisher.send(1), .none)
+        XCTAssertEqual(helper.publisher.send(2), .none)
+        XCTAssertEqual(helper.publisher.send(3), .none)
+
+        XCTAssertEqual(helper.tracking.history, [.subscription(delaySubscription)])
+        XCTAssertEqual(helper.subscription.history, [.requested(.max(100))])
+        XCTAssertEqual(scheduler.scheduledDates, [.nanoseconds(200),
+                                                  .nanoseconds(200),
+                                                  .nanoseconds(200)])
+
+        XCTAssertEqual(scheduler.history,
+                       [.schedule(options: .nontrivialOptions),
+                        .now,
+                        .scheduleAfterDate(.nanoseconds(200),
+                                           tolerance: .nanoseconds(5),
+                                           options: .nontrivialOptions),
+                        .now,
+                        .scheduleAfterDate(.nanoseconds(200),
+                                           tolerance: .nanoseconds(5),
+                                           options: .nontrivialOptions),
+                        .now,
+                        .scheduleAfterDate(.nanoseconds(200),
+                                           tolerance: .nanoseconds(5),
+                                           options: .nontrivialOptions)])
+
+        scheduler.executeScheduledActions()
+
+        XCTAssertEqual(helper.tracking.history, [.subscription(delaySubscription),
+                                                 .value(1),
+                                                 .value(2),
+                                                 .value(3)])
+
+        XCTAssertEqual(helper.subscription.history, [.requested(.max(100)),
+                                                     .requested(.max(12)),
+                                                     .requested(.max(12)),
+                                                     .requested(.max(12))])
+
+        XCTAssertEqual(scheduler.history,
+                       [.schedule(options: .nontrivialOptions),
+                        .now,
+                        .scheduleAfterDate(.nanoseconds(200),
+                                           tolerance: .nanoseconds(5),
+                                           options: .nontrivialOptions),
+                        .now,
+                        .scheduleAfterDate(.nanoseconds(200),
+                                           tolerance: .nanoseconds(5),
+                                           options: .nontrivialOptions),
+                        .now,
+                        .scheduleAfterDate(.nanoseconds(200),
+                                           tolerance: .nanoseconds(5),
+                                           options: .nontrivialOptions)])
+
+        helper.publisher.send(completion: .failure(.oops))
+        helper.publisher.send(completion: .finished)
+        XCTAssertEqual(helper.publisher.send(4), .none)
+
+        XCTAssertEqual(helper.tracking.history, [.subscription(delaySubscription),
+                                                 .value(1),
+                                                 .value(2),
+                                                 .value(3)])
+        XCTAssertEqual(helper.subscription.history, [.requested(.max(100)),
+                                                     .requested(.max(12)),
+                                                     .requested(.max(12)),
+                                                     .requested(.max(12))])
+        XCTAssertEqual(scheduler.scheduledDates, [.nanoseconds(400)])
+        XCTAssertEqual(scheduler.history,
+                       [.schedule(options: .nontrivialOptions),
+                        .now,
+                        .scheduleAfterDate(.nanoseconds(200),
+                                           tolerance: .nanoseconds(5),
+                                           options: .nontrivialOptions),
+                        .now,
+                        .scheduleAfterDate(.nanoseconds(200),
+                                           tolerance: .nanoseconds(5),
+                                           options: .nontrivialOptions),
+                        .now,
+                        .scheduleAfterDate(.nanoseconds(200),
+                                           tolerance: .nanoseconds(5),
+                                           options: .nontrivialOptions),
+                        .now,
+                        .scheduleAfterDate(.nanoseconds(400),
+                                           tolerance: .nanoseconds(5),
+                                           options: .nontrivialOptions)])
+
+        scheduler.executeScheduledActions()
+        XCTAssertEqual(helper.tracking.history, [.subscription(delaySubscription),
+                                                 .value(1),
+                                                 .value(2),
+                                                 .value(3),
+                                                 .completion(.failure(.oops))])
+        XCTAssertEqual(helper.subscription.history, [.requested(.max(100)),
+                                                     .requested(.max(12)),
+                                                     .requested(.max(12)),
+                                                     .requested(.max(12))])
+        XCTAssertEqual(scheduler.history,
+                       [.schedule(options: .nontrivialOptions),
+                        .now,
+                        .scheduleAfterDate(.nanoseconds(200),
+                                           tolerance: .nanoseconds(5),
+                                           options: .nontrivialOptions),
+                        .now,
+                        .scheduleAfterDate(.nanoseconds(200),
+                                           tolerance: .nanoseconds(5),
+                                           options: .nontrivialOptions),
+                        .now,
+                        .scheduleAfterDate(.nanoseconds(200),
+                                           tolerance: .nanoseconds(5),
+                                           options: .nontrivialOptions),
+                        .now,
+                        .scheduleAfterDate(.nanoseconds(400),
+                                           tolerance: .nanoseconds(5),
+                                           options: .nontrivialOptions)])
+        XCTAssertEqual(scheduler.now, .nanoseconds(400))
+    }
+
+    func testRequest() throws {
+        let scheduler = VirtualTimeScheduler()
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: nil,
+                                        receiveValueDemand: .none) {
+            $0.delay(for: .nanoseconds(200),
+                     tolerance: .nanoseconds(5),
+                     scheduler: scheduler,
+                     options: .nontrivialOptions)
+        }
+        scheduler.executeScheduledActions()
+
+        XCTAssertEqual(helper.subscription.history, [])
+        XCTAssertEqual(helper.tracking.history, [.subscription(delaySubscription)])
+
+        try XCTUnwrap(helper.downstreamSubscription).request(.max(10))
+        try XCTUnwrap(helper.downstreamSubscription).request(.max(4))
+        try XCTUnwrap(helper.downstreamSubscription).request(.max(5))
+        try XCTUnwrap(helper.downstreamSubscription).request(.none)
+        XCTAssertEqual(helper.publisher.send(2000), .none)
+
+        XCTAssertEqual(helper.tracking.history, [.subscription(delaySubscription)])
+        XCTAssertEqual(helper.subscription.history, [.requested(.max(10)),
+                                                     .requested(.max(4)),
+                                                     .requested(.max(5)),
+                                                     .requested(.none)])
+
+        scheduler.executeScheduledActions()
+        XCTAssertEqual(helper.tracking.history, [.subscription(delaySubscription),
+                                                 .value(2000)])
+        XCTAssertEqual(helper.subscription.history, [.requested(.max(10)),
+                                                     .requested(.max(4)),
+                                                     .requested(.max(5)),
+                                                     .requested(.none)])
+    }
+
+    func testCancelAlreadyCancelled() throws {
+        let scheduler = VirtualTimeScheduler()
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: .unlimited,
+                                        receiveValueDemand: .none) {
+            $0.delay(for: .nanoseconds(200),
+                     tolerance: .nanoseconds(5),
+                     scheduler: scheduler,
+                     options: .nontrivialOptions)
+        }
+
+        scheduler.executeScheduledActions()
+        XCTAssertEqual(helper.subscription.history, [.requested(.unlimited)])
+        XCTAssertEqual(helper.tracking.history, [.subscription(delaySubscription)])
+
+        try XCTUnwrap(helper.downstreamSubscription).cancel()
+        try XCTUnwrap(helper.downstreamSubscription).request(.max(42))
+        try XCTUnwrap(helper.downstreamSubscription).cancel()
+
+        XCTAssertEqual(helper.subscription.history, [.requested(.unlimited), .cancelled])
+        XCTAssertEqual(helper.tracking.history, [.subscription(delaySubscription)])
+        XCTAssertEqual(scheduler.history, [.schedule(options: .nontrivialOptions)])
+
+        XCTAssertEqual(helper.publisher.send(0), .none)
+        helper.publisher.send(completion: .finished)
+
+        XCTAssertEqual(helper.subscription.history, [.requested(.unlimited), .cancelled])
+        XCTAssertEqual(helper.tracking.history, [.subscription(delaySubscription)])
+        XCTAssertEqual(scheduler.history, [.schedule(options: .nontrivialOptions)])
+    }
+
+    func testReceiveCompletionImmediatelyAfterSubscription() {
+        let scheduler = VirtualTimeScheduler()
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: .unlimited,
+                                        receiveValueDemand: .none) {
+            $0.delay(for: .nanoseconds(123),
+                     tolerance: .nanoseconds(5),
+                     scheduler: scheduler,
+                     options: .nontrivialOptions)
+        }
+
+        helper.publisher.send(completion: .failure(.oops))
+
+        XCTAssertEqual(helper.tracking.history, [])
+        XCTAssertEqual(helper.subscription.history, [])
+        XCTAssertEqual(scheduler.history,
+                       [.schedule(options: .nontrivialOptions),
+                        .now,
+                        .scheduleAfterDate(.nanoseconds(123),
+                                           tolerance: .nanoseconds(5),
+                                           options: .nontrivialOptions)])
+
+        scheduler.executeScheduledActions()
+
+        XCTAssertEqual(helper.tracking.history, [.completion(.failure(.oops))])
+        XCTAssertEqual(helper.subscription.history, [])
+    }
+
+    func testReceiveCompletionImmediatelyAfterValue() {
+        let scheduler = VirtualTimeScheduler()
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: .unlimited,
+                                        receiveValueDemand: .max(418)) {
+            $0.delay(for: .nanoseconds(123),
+                     tolerance: .nanoseconds(5),
+                     scheduler: scheduler,
+                     options: .nontrivialOptions)
+        }
+        XCTAssertEqual(helper.publisher.send(-1), .none)
+        scheduler.executeScheduledActions()
+
+        XCTAssertEqual(helper.publisher.send(1000), .none)
+        helper.publisher.send(completion: .finished)
+
+        XCTAssertEqual(helper.tracking.history, [.subscription(delaySubscription),
+                                                 .value(-1)])
+        XCTAssertEqual(helper.subscription.history, [.requested(.unlimited),
+                                                     .requested(.max(418))])
+        XCTAssertEqual(scheduler.history,
+                       [.schedule(options: .nontrivialOptions),
+                        .now,
+                        .scheduleAfterDate(.nanoseconds(123),
+                                           tolerance: .nanoseconds(5),
+                                           options: .nontrivialOptions),
+                        .now,
+                        .scheduleAfterDate(.nanoseconds(246),
+                                           tolerance: .nanoseconds(5),
+                                           options: .nontrivialOptions),
+                        .now,
+                        .scheduleAfterDate(.nanoseconds(246),
+                                           tolerance: .nanoseconds(5),
+                                           options: .nontrivialOptions)])
+
+        scheduler.executeScheduledActions()
+
+        XCTAssertEqual(helper.tracking.history, [.subscription(delaySubscription),
+                                                 .value(-1),
+                                                 .value(1000),
+                                                 .completion(.finished)])
+        XCTAssertEqual(helper.subscription.history, [.requested(.unlimited),
+                                                     .requested(.max(418))])
+    }
+
+    func testCrashesWhenReceivingInputRecursively() {
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: .unlimited,
+                                        receiveValueDemand: .max(418)) {
+            $0.delay(for: .nanoseconds(123), scheduler: ImmediateScheduler.shared)
+        }
+
+        helper.tracking.onValue = { _ in
+            _ = helper.publisher.send(-1)
+        }
+
+        assertCrashes {
+            _ = helper.publisher.send(0)
+        }
+    }
+
+    func testReceiveCompletionRecursively() {
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: .unlimited,
+                                        receiveValueDemand: .max(418)) {
+            $0.delay(for: .nanoseconds(123), scheduler: ImmediateScheduler.shared)
+        }
+        helper.tracking.onFinish = {
+            helper.publisher.send(completion: .finished)
+        }
+        helper.publisher.send(completion: .finished)
+    }
+
+    func testWeakCaptureWhenSchedulingSubscription() {
+        let scheduler = VirtualTimeScheduler()
+        var subscription: Subscription?
+        var subscriberReleased = false
+        do {
+            let publisher = CustomPublisher(subscription: CustomSubscription())
+            let delay = publisher.delay(for: 0.35, scheduler: scheduler)
+            let tracking = TrackingSubscriber(receiveSubscription: { subscription = $0 },
+                                              onDeinit: { subscriberReleased = true })
+            delay.subscribe(tracking)
+            XCTAssertEqual(tracking.history, [])
+            XCTAssertEqual(scheduler.history, [.minimumTolerance,
+                                               .schedule(options: nil)])
+            publisher.cancel()
+        }
+        XCTAssertTrue(subscriberReleased)
+        scheduler.executeScheduledActions()
+        XCTAssertNil(subscription)
+    }
+
+    func testWeakCaptureWhenSchedulingValue() {
+        let scheduler = VirtualTimeScheduler()
+        var value: Int?
+        var subscriberReleased = false
+        do {
+            let publisher = CustomPublisher(subscription: CustomSubscription())
+            let delay = publisher.delay(for: 0.35, scheduler: scheduler)
+            let tracking = TrackingSubscriber(receiveValue: { value = $0; return .none },
+                                              onDeinit: { subscriberReleased = true })
+            delay.subscribe(tracking)
+            scheduler.executeScheduledActions()
+            XCTAssertEqual(tracking.history, [.subscription(delaySubscription)])
+            XCTAssertEqual(publisher.send(42), .none)
+            XCTAssertEqual(tracking.history, [.subscription(delaySubscription)])
+            XCTAssertEqual(scheduler.history,
+                           [.minimumTolerance,
+                            .schedule(options: nil),
+                            .now,
+                            .scheduleAfterDate(.seconds(0.35),
+                                               tolerance: 0,
+                                               options: nil)])
+            tracking.cancel()
+            publisher.cancel()
+        }
+        XCTAssertFalse(subscriberReleased)
+        scheduler.executeScheduledActions()
+        XCTAssertNil(value)
+        XCTAssertTrue(subscriberReleased)
+    }
+
+    func testWeakCaptureWhenSchedulingCompletion() {
+        let scheduler = VirtualTimeScheduler()
+        var completion: Subscribers.Completion<TestingError>?
+        var subscriberReleased = false
+        do {
+            let publisher = CustomPublisher(subscription: CustomSubscription())
+            let delay = publisher.delay(for: 0.35, scheduler: scheduler)
+            let tracking = TrackingSubscriber(receiveCompletion: { completion = $0 },
+                                              onDeinit: { subscriberReleased = true })
+            delay.subscribe(tracking)
+            scheduler.executeScheduledActions()
+            XCTAssertEqual(tracking.history, [.subscription(delaySubscription)])
+            publisher.send(completion: .finished)
+            XCTAssertEqual(tracking.history, [.subscription(delaySubscription)])
+            XCTAssertEqual(scheduler.history,
+                           [.minimumTolerance,
+                            .schedule(options: nil),
+                            .now,
+                            .scheduleAfterDate(.seconds(0.35),
+                                               tolerance: 0,
+                                               options: nil)])
+            tracking.cancel()
+            publisher.cancel()
+        }
+        XCTAssertFalse(subscriberReleased)
+        scheduler.executeScheduledActions()
+        XCTAssertNil(completion)
+        XCTAssertTrue(subscriberReleased)
+    }
+
+    func testDelayReceiveSubscriptionTwice() throws {
+        try testReceiveSubscriptionTwice {
+            $0.delay(for: 0.35, scheduler: ImmediateScheduler.shared)
+        }
+    }
+
+    func testDelayReceiveValueBeforeSubscription() {
+        testReceiveValueBeforeSubscription(value: 213,
+                                           expected: .history([], demand: .none)) {
+            $0.delay(for: 0.35, scheduler: ImmediateScheduler.shared)
+        }
+    }
+
+    func testDelayReceiveCompletionBeforeSubscription()  {
+        testReceiveCompletionBeforeSubscription(inputType: Int.self,
+                                                expected: .history([])) {
+            $0.delay(for: 0.35, scheduler: ImmediateScheduler.shared)
+        }
+    }
+
+    func testDelayRequestBeforeSubscription() {
+        testRequestBeforeSubscription(inputType: Int.self, shouldCrash: false) {
+            $0.delay(for: 0.35, scheduler: ImmediateScheduler.shared)
+        }
+    }
+
+    func testDelayCancelBeforeSubscription() {
+        testCancelBeforeSubscription(inputType: Int.self, shouldCrash: false) {
+            $0.delay(for: 0.35, scheduler: ImmediateScheduler.shared)
+        }
+    }
+
+    func testDelayReflection() throws {
+        /// Delay's Inner doesn't customize its reflection
+        try testReflection(parentInput: Int.self,
+                           parentFailure: Error.self,
+                           description: nil,
+                           customMirror: nil,
+                           playgroundDescription: nil) {
+            $0.delay(for: 42, scheduler: ImmediateScheduler.shared)
+        }
+    }
+
+    func testDelayLifecycle() throws {
+        try testLifecycle(sendValue: 31,
+                          cancellingSubscriptionReleasesSubscriber: true) {
+            $0.delay(for: 42, scheduler: ImmediateScheduler.shared)
+        }
+    }
+}

Tests/OpenCombineTests/PublisherTests/FlatMapTests.swift

@@ -75,7 +75,7 @@ final class FlatMapTests: XCTestCase {
                 XCTAssertNil(upstream.erasedSubscriber)
             }
         )
-        upstream.onSubscribe = { _ in
+        upstream.willSubscribe = { _ in
             upstreamReceivedSubscriber = true
             XCTAssertEqual(tracking.history, [.subscription("FlatMap")])
         }
@@ -564,7 +564,7 @@ final class FlatMapTests: XCTestCase {
             createSut: { $0.flatMap(maxPublishers: .max(1)) { $0 } }
         )
 
-        child.onSubscribe = { subscriber in
+        child.willSubscribe = { subscriber in
             helper.publisher.send(completion: .finished)
         }
 

Tests/OpenCombineTests/PublisherTests/HandleEventsTests.swift

@@ -0,0 +1,261 @@
+//
+//  HandleEventsTests.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 03.12.2019.
+//
+
+import XCTest
+
+#if OPENCOMBINE_COMPATIBILITY_TEST
+import Combine
+#else
+import OpenCombine
+#endif
+
+@available(macOS 10.15, iOS 13.0, *)
+final class HandleEventsTests: XCTestCase {
+
+    func testBasicBehavior() throws {
+        var history = [Event<TestingError>]()
+        let subscription = CustomSubscription()
+        let publisher = CustomPublisher(subscription: subscription)
+        let handleEvents = publisher.handleAllEvents { history.append($0) }
+        var downstreamSubscription: Subscription?
+        let tracking = TrackingSubscriber(
+            receiveSubscription: {
+                XCTAssertNil(publisher.subscriber)
+                downstreamSubscription = $0
+            },
+            receiveValue: { .max($0) }
+        )
+        handleEvents.subscribe(tracking)
+
+        XCTAssertNotNil(publisher.subscriber)
+        XCTAssertEqual(tracking.history, [.subscription("HandleEvents")])
+        XCTAssertEqual(subscription.history, [])
+        XCTAssertEqual(history, [.receiveSubscription("CustomSubscription")])
+
+        XCTAssertEqual(publisher.send(0), .none)
+        XCTAssertEqual(publisher.send(1), .max(1))
+        XCTAssertEqual(publisher.send(2), .max(2))
+        XCTAssertEqual(publisher.send(3), .max(3))
+
+        XCTAssertEqual(tracking.history, [.subscription("HandleEvents"),
+                                          .value(0),
+                                          .value(1),
+                                          .value(2),
+                                          .value(3)])
+        XCTAssertEqual(subscription.history, [])
+        XCTAssertEqual(history, [.receiveSubscription("CustomSubscription"),
+                                 .receiveOutput(0),
+                                 .receiveOutput(1),
+                                 .receiveRequest(.max(1)),
+                                 .receiveOutput(2),
+                                 .receiveRequest(.max(2)),
+                                 .receiveOutput(3),
+                                 .receiveRequest(.max(3))])
+
+        try XCTUnwrap(downstreamSubscription).request(.max(14))
+        try XCTUnwrap(downstreamSubscription).request(.max(10))
+        try XCTUnwrap(downstreamSubscription).request(.none)
+
+        XCTAssertEqual(tracking.history, [.subscription("HandleEvents"),
+                                          .value(0),
+                                          .value(1),
+                                          .value(2),
+                                          .value(3)])
+        XCTAssertEqual(subscription.history, [.requested(.max(14)),
+                                              .requested(.max(10)),
+                                              .requested(.none)])
+        XCTAssertEqual(history, [.receiveSubscription("CustomSubscription"),
+                                 .receiveOutput(0),
+                                 .receiveOutput(1),
+                                 .receiveRequest(.max(1)),
+                                 .receiveOutput(2),
+                                 .receiveRequest(.max(2)),
+                                 .receiveOutput(3),
+                                 .receiveRequest(.max(3)),
+                                 .receiveRequest(.max(14)),
+                                 .receiveRequest(.max(10)),
+                                 .receiveRequest(.none)])
+
+        publisher.send(completion: .finished)
+        publisher.send(completion: .failure(.oops))
+        publisher.send(completion: .finished)
+        XCTAssertEqual(publisher.send(144), .max(144))
+
+        XCTAssertEqual(tracking.history, [.subscription("HandleEvents"),
+                                          .value(0),
+                                          .value(1),
+                                          .value(2),
+                                          .value(3),
+                                          .completion(.finished),
+                                          .completion(.failure(.oops)),
+                                          .completion(.finished),
+                                          .value(144)])
+        XCTAssertEqual(subscription.history, [.requested(.max(14)),
+                                              .requested(.max(10)),
+                                              .requested(.none)])
+        XCTAssertEqual(history, [.receiveSubscription("CustomSubscription"),
+                                 .receiveOutput(0),
+                                 .receiveOutput(1),
+                                 .receiveRequest(.max(1)),
+                                 .receiveOutput(2),
+                                 .receiveRequest(.max(2)),
+                                 .receiveOutput(3),
+                                 .receiveRequest(.max(3)),
+                                 .receiveRequest(.max(14)),
+                                 .receiveRequest(.max(10)),
+                                 .receiveRequest(.none),
+                                 .receiveCompletion(.finished)])
+    }
+
+    func testAccumulatesDemandUntilSubscriptionArrives() {
+        var history = [Event<TestingError>]()
+        let subscription = CustomSubscription()
+        let publisher = CustomPublisher(subscription: subscription)
+        let handleEvents = publisher.handleAllEvents { history.append($0) }
+        var downstreamSubscription: Subscription?
+        let tracking = TrackingSubscriber(
+            receiveSubscription: {
+                XCTAssertNil(publisher.subscriber)
+                XCTAssertEqual(history, [])
+                XCTAssertEqual(subscription.history, [])
+                $0.request(.max(45))
+                $0.request(.none)
+                $0.request(.max(13))
+                XCTAssertEqual(subscription.history, [])
+                downstreamSubscription = $0
+            },
+            receiveValue: { .max($0) }
+        )
+        handleEvents.subscribe(tracking)
+        XCTAssertEqual(tracking.history, [.subscription("HandleEvents")])
+        XCTAssertEqual(subscription.history, [.requested(.max(58))])
+        XCTAssertEqual(history, [.receiveRequest(.max(45)),
+                                 .receiveRequest(.none),
+                                 .receiveRequest(.max(13)),
+                                 .receiveSubscription("CustomSubscription")])
+        XCTAssertNotNil(downstreamSubscription)
+    }
+
+    func testCancelAlreadyCancelled() throws {
+        var history = [Event<TestingError>]()
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: .max(2),
+                                        receiveValueDemand: .max(5)) {
+            $0.handleAllEvents { history.append($0) }
+        }
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("HandleEvents")])
+        XCTAssertEqual(helper.subscription.history, [.requested(.max(2))])
+        XCTAssertEqual(history, [.receiveRequest(.max(2)),
+                                 .receiveSubscription("CustomSubscription")])
+
+        try XCTUnwrap(helper.downstreamSubscription).cancel()
+        try XCTUnwrap(helper.downstreamSubscription).request(.max(1))
+        try XCTUnwrap(helper.downstreamSubscription).cancel()
+
+        XCTAssertEqual(helper.publisher.send(1), .max(5))
+        helper.publisher.send(completion: .finished)
+        helper.publisher.send(completion: .failure(.oops))
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("HandleEvents"),
+                                                 .value(1),
+                                                 .completion(.finished),
+                                                 .completion(.failure(.oops))])
+        XCTAssertEqual(helper.subscription.history, [.requested(.max(2)),
+                                                     .cancelled])
+        XCTAssertEqual(history, [.receiveRequest(.max(2)),
+                                 .receiveSubscription("CustomSubscription"),
+                                 .receiveCancel])
+    }
+
+    func testHandleEventsReceiveSubscriptionTwice() throws {
+        var history = [Event<TestingError>]()
+        try testReceiveSubscriptionTwice { $0.handleAllEvents { history.append($0) } }
+        XCTAssertEqual(history, [.receiveSubscription("CustomSubscription"),
+                                 .receiveSubscription("CustomSubscription"),
+                                 .receiveSubscription("CustomSubscription"),
+                                 .receiveCancel])
+    }
+
+    func testHandleEventsReceiveValueBeforeSubscription() {
+        var history = [Event<Never>]()
+        testReceiveValueBeforeSubscription(
+            value: 144,
+            expected: .history([.subscription("HandleEvents"),
+                                .value(144)],
+                               demand: .max(42)),
+            { $0.handleAllEvents { history.append($0) } }
+        )
+        XCTAssertEqual(history, [.receiveOutput(144),
+                                 .receiveRequest(.max(42))])
+    }
+
+    func testHandleEventsReceiveCompletionBeforeSubscription() {
+        var history = [Event<Never>]()
+        testReceiveCompletionBeforeSubscription(
+            inputType: Int.self,
+            expected: .history([.subscription("HandleEvents"), .completion(.finished)]),
+            { $0.handleAllEvents { history.append($0) } }
+        )
+        XCTAssertEqual(history, [.receiveCompletion(.finished)])
+    }
+
+    func testHandleEventsRequestBeforeSubscription() {
+        var history = [Event<Never>]()
+        testRequestBeforeSubscription(inputType: Int.self,
+                                      shouldCrash: false,
+                                      { $0.handleAllEvents { history.append($0) } })
+        XCTAssertEqual(history, [.receiveRequest(.max(1))])
+    }
+
+    func testHandleEventsCancelBeforeSubscription() {
+        var history = [Event<Never>]()
+        testCancelBeforeSubscription(inputType: Int.self,
+                                     shouldCrash: false,
+                                     { $0.handleAllEvents { history.append($0) } })
+        XCTAssertEqual(history, [.receiveCancel])
+    }
+
+    func testHandleEventsReflection() throws {
+        try testReflection(parentInput: Int.self,
+                           parentFailure: Error.self,
+                           description: "HandleEvents",
+                           customMirror: childrenIsEmpty,
+                           playgroundDescription: "HandleEvents",
+                           { $0.handleEvents() })
+    }
+
+    func testHandleEventsLifecycle() throws {
+        try testLifecycle(sendValue: 31,
+                          cancellingSubscriptionReleasesSubscriber: false,
+                          { $0.handleEvents() })
+    }
+}
+
+@available(macOS 10.15, iOS 13.0, *)
+private enum Event<Failure: Error & Equatable>: Equatable {
+    case receiveSubscription(StringSubscription)
+    case receiveOutput(Int)
+    case receiveCompletion(Subscribers.Completion<Failure>)
+    case receiveCancel
+    case receiveRequest(Subscribers.Demand)
+}
+
+@available(macOS 10.15, iOS 13.0, *)
+extension Publisher where Output == Int, Failure: Equatable {
+    fileprivate func handleAllEvents(
+        _ handle: @escaping (Event<Failure>) -> Void
+    ) -> Publishers.HandleEvents<Self> {
+        return handleEvents(
+            receiveSubscription: { handle(.receiveSubscription(.subscription($0))) },
+            receiveOutput: { handle(.receiveOutput($0)) },
+            receiveCompletion: { handle(.receiveCompletion($0)) },
+            receiveCancel: { handle(.receiveCancel) },
+            receiveRequest: { handle(.receiveRequest($0)) }
+        )
+    }
+}

Tests/OpenCombineTests/PublisherTests/JustTests.swift

@@ -339,4 +339,29 @@ final class JustTests: XCTestCase {
     func testSetFailureTypeOperatorSpecialization() {
         XCTAssertEqual(try Sut(73).setFailureType(to: TestingError.self).result.get(), 73)
     }
+
+    func testPrependOperatorSpecialization() {
+        XCTAssertEqual(Sut<Int>(5).prepend(1, 2, 3, 4), .init(sequence: [1, 2, 3, 4, 5]))
+
+        let trackingCollection = TrackingCollection<Int>([1, 2, 3, 4])
+        XCTAssertEqual(Sut<Int>(5).prepend(trackingCollection),
+                       .init(sequence: [1, 2, 3, 4, 5]))
+
+        XCTAssertEqual(trackingCollection.history, [.initFromSequence,
+                                                    .underestimatedCount,
+                                                    .underestimatedCount,
+                                                    .makeIterator])
+    }
+
+    func testAppendOperatorSpecialization() {
+        XCTAssertEqual(Sut<Int>(1).append(2, 3, 4, 5), .init(sequence: [1, 2, 3, 4, 5]))
+
+        let trackingCollection = TrackingCollection<Int>([2, 3, 4, 5])
+        XCTAssertEqual(Sut<Int>(1).append(trackingCollection),
+                       .init(sequence: [1, 2, 3, 4, 5]))
+
+        XCTAssertEqual(trackingCollection.history, [.initFromSequence,
+                                                    .underestimatedCount,
+                                                    .makeIterator])
+    }
 }

Tests/OpenCombineTests/PublisherTests/MeasureIntervalTests.swift

@@ -0,0 +1,164 @@
+//
+//  MeasureIntervalTests.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 03.12.2019.
+//
+
+import XCTest
+
+#if OPENCOMBINE_COMPATIBILITY_TEST
+import Combine
+#else
+import OpenCombine
+#endif
+
+@available(macOS 10.15, iOS 13.0, *)
+final class MeasureIntervalTests: XCTestCase {
+
+    func testBasicBehavior() {
+        let scheduler = VirtualTimeScheduler()
+        scheduler.rewind(to: .nanoseconds(3))
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: .max(13),
+                                        receiveValueDemand: .none) {
+            $0.measureInterval(using: scheduler, options: .nontrivialOptions)
+        }
+        XCTAssertEqual(helper.tracking.history, [.subscription("MeasureInterval")])
+        XCTAssertEqual(helper.subscription.history, [.requested(.max(13))])
+        XCTAssertEqual(scheduler.history, [.now])
+
+        scheduler.rewind(to: .nanoseconds(14))
+        XCTAssertEqual(helper.publisher.send(1), .none)
+        scheduler.rewind(to: .nanoseconds(17))
+        XCTAssertEqual(helper.publisher.send(2), .none)
+        scheduler.rewind(to: .nanoseconds(10))
+        XCTAssertEqual(helper.publisher.send(3), .none)
+        scheduler.rewind(to: .nanoseconds(21))
+        XCTAssertEqual(helper.publisher.send(4), .none)
+        helper.publisher.send(completion: .finished)
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("MeasureInterval"),
+                                                 .value(.nanoseconds(11)),
+                                                 .value(.nanoseconds(3)),
+                                                 .value(.nanoseconds(-7)),
+                                                 .value(.nanoseconds(11)),
+                                                 .completion(.finished)])
+        XCTAssertEqual(helper.subscription.history, [.requested(.max(13))])
+        XCTAssertEqual(scheduler.history, [.now, .now, .now, .now, .now])
+    }
+
+    func testRequest() throws {
+        let scheduler = VirtualTimeScheduler()
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: nil,
+                                        receiveValueDemand: .max(1)) {
+            $0.measureInterval(using: scheduler, options: .nontrivialOptions)
+        }
+
+        var recursionCounter = 5
+        helper.subscription.onRequest = { _ in
+            if recursionCounter == 0 { return }
+            recursionCounter -= 1
+            XCTAssertEqual(helper.publisher.send(0), .none)
+        }
+
+        XCTAssertEqual(helper.publisher.send(0), .none)
+
+        helper.subscription.onRequest = nil
+
+        try XCTUnwrap(helper.downstreamSubscription).request(.max(2))
+        try XCTUnwrap(helper.downstreamSubscription).request(.unlimited)
+        try XCTUnwrap(helper.downstreamSubscription).request(.none)
+
+        helper.publisher.send(completion: .failure(.oops))
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("MeasureInterval"),
+                                                 .value(.zero),
+                                                 .value(.zero),
+                                                 .value(.zero),
+                                                 .value(.zero),
+                                                 .value(.zero),
+                                                 .value(.zero),
+                                                 .completion(.failure(.oops))])
+        XCTAssertEqual(helper.subscription.history, [.requested(.max(1)),
+                                                     .requested(.max(1)),
+                                                     .requested(.max(1)),
+                                                     .requested(.max(1)),
+                                                     .requested(.max(1)),
+                                                     .requested(.max(1)),
+                                                     .requested(.max(2)),
+                                                     .requested(.unlimited),
+                                                     .requested(.none)])
+    }
+
+    func testCancelAlreadyCancelled() throws {
+        let scheduler = VirtualTimeScheduler()
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: nil,
+                                        receiveValueDemand: .max(1)) {
+            $0.measureInterval(using: scheduler, options: .nontrivialOptions)
+        }
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("MeasureInterval")])
+        XCTAssertEqual(helper.subscription.history, [])
+        XCTAssertEqual(scheduler.history, [.now])
+
+        try XCTUnwrap(helper.downstreamSubscription).cancel()
+        try XCTUnwrap(helper.downstreamSubscription).request(.max(1000))
+        try XCTUnwrap(helper.downstreamSubscription).cancel()
+        XCTAssertEqual(helper.publisher.send(1000), .none)
+        helper.publisher.send(completion: .failure(.oops))
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("MeasureInterval")])
+        XCTAssertEqual(helper.subscription.history, [.cancelled])
+        XCTAssertEqual(scheduler.history, [.now])
+    }
+
+    func testMeasureIntervalReceiveSubscriptionTwice() throws {
+        try testReceiveSubscriptionTwice {
+            $0.measureInterval(using: ImmediateScheduler.shared)
+        }
+    }
+
+    func testMeasureIntervalReceiveValueBeforeSubscription() {
+        testReceiveValueBeforeSubscription(value: 213,
+                                           expected: .history([], demand: .none)) {
+            $0.measureInterval(using: ImmediateScheduler.shared)
+        }
+    }
+
+    func testMeasureIntervalReceiveCompletionBeforeSubscription()  {
+        testReceiveCompletionBeforeSubscription(inputType: Int.self,
+                                                expected: .history([])) {
+            $0.measureInterval(using: ImmediateScheduler.shared)
+        }
+    }
+
+    func testMeasureIntervalRequestBeforeSubscription() {
+        testRequestBeforeSubscription(inputType: Int.self, shouldCrash: false) {
+            $0.measureInterval(using: ImmediateScheduler.shared)
+        }
+    }
+
+    func testMeasureIntervalCancelBeforeSubscription() {
+        testCancelBeforeSubscription(inputType: Int.self, shouldCrash: false) {
+            $0.measureInterval(using: ImmediateScheduler.shared)
+        }
+    }
+
+    func testMeasureIntervalReflection() throws {
+        try testReflection(parentInput: Int.self,
+                           parentFailure: TestingError.self,
+                           description: "MeasureInterval",
+                           customMirror: childrenIsEmpty,
+                           playgroundDescription: "MeasureInterval",
+                           { $0.measureInterval(using: ImmediateScheduler.shared) })
+    }
+
+    func testMeasureIntervalLifecycle() throws {
+        try testLifecycle(sendValue: 31,
+                          cancellingSubscriptionReleasesSubscriber: true,
+                          { $0.measureInterval(using: ImmediateScheduler.shared) })
+    }
+}

Tests/OpenCombineTests/PublisherTests/ReceiveOnTests.swift

@@ -0,0 +1,364 @@
+//
+//  ReceiveOnTests.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 02.12.2019.
+//
+
+import XCTest
+
+#if OPENCOMBINE_COMPATIBILITY_TEST
+import Combine
+#else
+import OpenCombine
+#endif
+
+@available(macOS 10.15, iOS 13.0, *)
+final class ReceiveOnTests: XCTestCase {
+
+    func testBasicBehavior() {
+        let scheduler = VirtualTimeScheduler()
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: .max(100),
+                                        receiveValueDemand: .max(12)) {
+            $0.receive(on: scheduler, options: .nontrivialOptions)
+        }
+        XCTAssertNotNil(helper.publisher.subscriber,
+                        "Subscription must be performed synchronously")
+
+        XCTAssertEqual(helper.tracking.history, [])
+        XCTAssertEqual(helper.subscription.history, [])
+        XCTAssertEqual(scheduler.history, [.schedule(options: .nontrivialOptions)])
+
+        scheduler.executeScheduledActions()
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("ReceiveOn")])
+        XCTAssertEqual(helper.subscription.history, [.requested(.max(100))])
+        XCTAssertEqual(scheduler.history, [.schedule(options: .nontrivialOptions)])
+
+        XCTAssertEqual(helper.publisher.send(1), .none)
+        XCTAssertEqual(helper.publisher.send(2), .none)
+        XCTAssertEqual(helper.publisher.send(3), .none)
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("ReceiveOn")])
+        XCTAssertEqual(helper.subscription.history, [.requested(.max(100))])
+        XCTAssertEqual(scheduler.scheduledDates, [.nanoseconds(0),
+                                                  .nanoseconds(0),
+                                                  .nanoseconds(0)])
+
+        XCTAssertEqual(scheduler.history, [.schedule(options: .nontrivialOptions),
+                                           .schedule(options: .nontrivialOptions),
+                                           .schedule(options: .nontrivialOptions),
+                                           .schedule(options: .nontrivialOptions)])
+
+        scheduler.executeScheduledActions()
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("ReceiveOn"),
+                                                 .value(1),
+                                                 .value(2),
+                                                 .value(3)])
+
+        XCTAssertEqual(helper.subscription.history, [.requested(.max(100)),
+                                                     .requested(.max(12)),
+                                                     .requested(.max(12)),
+                                                     .requested(.max(12))])
+
+        XCTAssertEqual(scheduler.history, [.schedule(options: .nontrivialOptions),
+                                           .schedule(options: .nontrivialOptions),
+                                           .schedule(options: .nontrivialOptions),
+                                           .schedule(options: .nontrivialOptions)])
+
+        helper.publisher.send(completion: .failure(.oops))
+        helper.publisher.send(completion: .finished)
+        XCTAssertEqual(helper.publisher.send(4), .none)
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("ReceiveOn"),
+                                                 .value(1),
+                                                 .value(2),
+                                                 .value(3)])
+        XCTAssertEqual(helper.subscription.history, [.requested(.max(100)),
+                                                     .requested(.max(12)),
+                                                     .requested(.max(12)),
+                                                     .requested(.max(12))])
+        XCTAssertEqual(scheduler.scheduledDates, [.nanoseconds(0)])
+        XCTAssertEqual(scheduler.history, [.schedule(options: .nontrivialOptions),
+                                           .schedule(options: .nontrivialOptions),
+                                           .schedule(options: .nontrivialOptions),
+                                           .schedule(options: .nontrivialOptions),
+                                           .schedule(options: .nontrivialOptions)])
+        scheduler.executeScheduledActions()
+        XCTAssertEqual(helper.tracking.history, [.subscription("ReceiveOn"),
+                                                 .value(1),
+                                                 .value(2),
+                                                 .value(3),
+                                                 .completion(.failure(.oops))])
+        XCTAssertEqual(helper.subscription.history, [.requested(.max(100)),
+                                                     .requested(.max(12)),
+                                                     .requested(.max(12)),
+                                                     .requested(.max(12))])
+        XCTAssertEqual(scheduler.history, [.schedule(options: .nontrivialOptions),
+                                           .schedule(options: .nontrivialOptions),
+                                           .schedule(options: .nontrivialOptions),
+                                           .schedule(options: .nontrivialOptions),
+                                           .schedule(options: .nontrivialOptions)])
+        XCTAssertEqual(scheduler.now, .nanoseconds(0))
+    }
+
+    func testRequest() throws {
+        let scheduler = VirtualTimeScheduler()
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: nil,
+                                        receiveValueDemand: .none) {
+            $0.receive(on: scheduler)
+        }
+        scheduler.executeScheduledActions()
+
+        XCTAssertEqual(helper.subscription.history, [])
+        XCTAssertEqual(helper.tracking.history, [.subscription("ReceiveOn")])
+
+        try XCTUnwrap(helper.downstreamSubscription).request(.max(10))
+        try XCTUnwrap(helper.downstreamSubscription).request(.max(4))
+        try XCTUnwrap(helper.downstreamSubscription).request(.max(5))
+        try XCTUnwrap(helper.downstreamSubscription).request(.none)
+        XCTAssertEqual(helper.publisher.send(2000), .none)
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("ReceiveOn")])
+        XCTAssertEqual(helper.subscription.history, [.requested(.max(10)),
+                                                     .requested(.max(4)),
+                                                     .requested(.max(5)),
+                                                     .requested(.none)])
+
+        scheduler.executeScheduledActions()
+        XCTAssertEqual(helper.tracking.history, [.subscription("ReceiveOn"),
+                                                 .value(2000)])
+        XCTAssertEqual(helper.subscription.history, [.requested(.max(10)),
+                                                     .requested(.max(4)),
+                                                     .requested(.max(5)),
+                                                     .requested(.none)])
+    }
+
+    func testCancelAlreadyCancelled() throws {
+        let scheduler = VirtualTimeScheduler()
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: .unlimited,
+                                        receiveValueDemand: .none) {
+            $0.receive(on: scheduler)
+        }
+
+        scheduler.executeScheduledActions()
+        XCTAssertEqual(helper.subscription.history, [.requested(.unlimited)])
+        XCTAssertEqual(helper.tracking.history, [.subscription("ReceiveOn")])
+
+        try XCTUnwrap(helper.downstreamSubscription).cancel()
+        try XCTUnwrap(helper.downstreamSubscription).request(.max(42))
+        try XCTUnwrap(helper.downstreamSubscription).cancel()
+
+        XCTAssertEqual(helper.subscription.history, [.requested(.unlimited), .cancelled])
+        XCTAssertEqual(helper.tracking.history, [.subscription("ReceiveOn")])
+        XCTAssertEqual(scheduler.history, [.schedule(options: nil)])
+
+        XCTAssertEqual(helper.publisher.send(0), .none)
+        helper.publisher.send(completion: .finished)
+
+        XCTAssertEqual(helper.subscription.history, [.requested(.unlimited), .cancelled])
+        XCTAssertEqual(helper.tracking.history, [.subscription("ReceiveOn")])
+        XCTAssertEqual(scheduler.history, [.schedule(options: nil)])
+    }
+
+    func testReceiveCompletionImmediatelyAfterSubscription() {
+        let scheduler = VirtualTimeScheduler()
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: .unlimited,
+                                        receiveValueDemand: .none) {
+            $0.receive(on: scheduler)
+        }
+
+        helper.publisher.send(completion: .failure(.oops))
+
+        XCTAssertEqual(helper.tracking.history, [])
+        XCTAssertEqual(helper.subscription.history, [])
+        XCTAssertEqual(scheduler.history, [.schedule(options: nil),
+                                           .schedule(options: nil)])
+
+        scheduler.executeScheduledActions()
+
+        XCTAssertEqual(helper.tracking.history, [.completion(.failure(.oops))])
+        XCTAssertEqual(helper.subscription.history, [])
+    }
+
+    func testReceiveCompletionImmediatelyAfterValue() {
+        let scheduler = VirtualTimeScheduler()
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: .unlimited,
+                                        receiveValueDemand: .max(418)) {
+            $0.receive(on: scheduler)
+        }
+        XCTAssertEqual(helper.publisher.send(-1), .none)
+        scheduler.executeScheduledActions()
+
+        XCTAssertEqual(helper.publisher.send(1000), .none)
+        helper.publisher.send(completion: .finished)
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("ReceiveOn"),
+                                                 .value(-1)])
+        XCTAssertEqual(helper.subscription.history, [.requested(.unlimited),
+                                                     .requested(.max(418))])
+        XCTAssertEqual(scheduler.history, [.schedule(options: nil),
+                                           .schedule(options: nil),
+                                           .schedule(options: nil),
+                                           .schedule(options: nil)])
+
+        scheduler.executeScheduledActions()
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("ReceiveOn"),
+                                                 .value(-1),
+                                                 .value(1000),
+                                                 .completion(.finished)])
+        XCTAssertEqual(helper.subscription.history, [.requested(.unlimited),
+                                                     .requested(.max(418))])
+    }
+
+    func testCrashesWhenReceivingInputRecursively() {
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: .unlimited,
+                                        receiveValueDemand: .max(418)) {
+            $0.receive(on: ImmediateScheduler.shared)
+        }
+
+        helper.tracking.onValue = { _ in
+            _ = helper.publisher.send(-1)
+        }
+
+        assertCrashes {
+            _ = helper.publisher.send(0)
+        }
+    }
+
+    func testReceiveCompletionRecursively() {
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: .unlimited,
+                                        receiveValueDemand: .max(418)) {
+            $0.receive(on: ImmediateScheduler.shared)
+        }
+        helper.tracking.onFinish = {
+            helper.publisher.send(completion: .finished)
+        }
+        helper.publisher.send(completion: .finished)
+    }
+
+    func testWeakCaptureWhenSchedulingSubscription() {
+        let scheduler = VirtualTimeScheduler()
+        var subscription: Subscription?
+        var subscriberReleased = false
+        do {
+            let publisher = CustomPublisher(subscription: CustomSubscription())
+            let receiveOn = publisher.receive(on: scheduler)
+            let tracking = TrackingSubscriber(receiveSubscription: { subscription = $0 },
+                                              onDeinit: { subscriberReleased = true })
+            receiveOn.subscribe(tracking)
+            XCTAssertEqual(tracking.history, [])
+            XCTAssertEqual(scheduler.history, [.schedule(options: nil)])
+            publisher.cancel()
+        }
+        XCTAssertTrue(subscriberReleased)
+        scheduler.executeScheduledActions()
+        XCTAssertNil(subscription)
+    }
+
+    func testWeakCaptureWhenSchedulingValue() {
+        let scheduler = VirtualTimeScheduler()
+        var value: Int?
+        var subscriberReleased = false
+        do {
+            let publisher = CustomPublisher(subscription: CustomSubscription())
+            let receiveOn = publisher.receive(on: scheduler)
+            let tracking = TrackingSubscriber(receiveValue: { value = $0; return .none },
+                                              onDeinit: { subscriberReleased = true })
+            receiveOn.subscribe(tracking)
+            scheduler.executeScheduledActions()
+            XCTAssertEqual(tracking.history, [.subscription("ReceiveOn")])
+            XCTAssertEqual(publisher.send(42), .none)
+            XCTAssertEqual(tracking.history, [.subscription("ReceiveOn")])
+            XCTAssertEqual(scheduler.history, [.schedule(options: nil),
+                                               .schedule(options: nil)])
+            tracking.cancel()
+            publisher.cancel()
+        }
+        XCTAssertFalse(subscriberReleased)
+        scheduler.executeScheduledActions()
+        XCTAssertNil(value)
+        XCTAssertTrue(subscriberReleased)
+    }
+
+    func testWeakCaptureWhenSchedulingCompletion() {
+        let scheduler = VirtualTimeScheduler()
+        var completion: Subscribers.Completion<TestingError>?
+        var subscriberReleased = false
+        do {
+            let publisher = CustomPublisher(subscription: CustomSubscription())
+            let receiveOn = publisher.receive(on: scheduler)
+            let tracking = TrackingSubscriber(receiveCompletion: { completion = $0 },
+                                              onDeinit: { subscriberReleased = true })
+            receiveOn.subscribe(tracking)
+            scheduler.executeScheduledActions()
+            XCTAssertEqual(tracking.history, [.subscription("ReceiveOn")])
+            publisher.send(completion: .finished)
+            XCTAssertEqual(tracking.history, [.subscription("ReceiveOn")])
+            XCTAssertEqual(scheduler.history, [.schedule(options: nil),
+                                               .schedule(options: nil)])
+            tracking.cancel()
+            publisher.cancel()
+        }
+        XCTAssertFalse(subscriberReleased)
+        scheduler.executeScheduledActions()
+        XCTAssertNil(completion)
+        XCTAssertTrue(subscriberReleased)
+    }
+
+    func testReceiveOnReceiveSubscriptionTwice() throws {
+        try testReceiveSubscriptionTwice {
+            $0.receive(on: ImmediateScheduler.shared)
+        }
+    }
+
+    func testReceiveOnReceiveValueBeforeSubscription() {
+        testReceiveValueBeforeSubscription(value: 213,
+                                           expected: .history([], demand: .none)) {
+            $0.receive(on: ImmediateScheduler.shared)
+        }
+    }
+
+    func testReceiveOnReceiveCompletionBeforeSubscription()  {
+        testReceiveCompletionBeforeSubscription(inputType: Int.self,
+                                                expected: .history([])) {
+            $0.receive(on: ImmediateScheduler.shared)
+        }
+    }
+
+    func testReceiveOnRequestBeforeSubscription() {
+        testRequestBeforeSubscription(inputType: Int.self, shouldCrash: false) {
+            $0.receive(on: ImmediateScheduler.shared)
+        }
+    }
+
+    func testReceiveOnCancelBeforeSubscription() {
+        testCancelBeforeSubscription(inputType: Int.self, shouldCrash: false) {
+            $0.receive(on: ImmediateScheduler.shared)
+        }
+    }
+
+    func testReceiveOnReflection() throws {
+        try testReflection(parentInput: String.self,
+                           parentFailure: Error.self,
+                           description: "ReceiveOn",
+                           customMirror: childrenIsEmpty,
+                           playgroundDescription: "ReceiveOn",
+                           { $0.receive(on: ImmediateScheduler.shared) })
+    }
+
+    func testReceiveOnLifecycle() throws {
+        try testLifecycle(sendValue: 31, cancellingSubscriptionReleasesSubscriber: true) {
+            $0.receive(on: ImmediateScheduler.shared)
+        }
+    }
+}

Tests/OpenCombineTests/PublisherTests/SubscribeOnTests.swift

@@ -0,0 +1,330 @@
+//
+//  SubscribeOnTests.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 03.12.2019.
+//
+
+import XCTest
+
+#if OPENCOMBINE_COMPATIBILITY_TEST
+import Combine
+#else
+import OpenCombine
+#endif
+
+@available(macOS 10.15, iOS 13.0, *)
+final class SubscribeOnTests: XCTestCase {
+
+    func testSynchronouslySendsEventsDownstream() throws {
+        let scheduler = VirtualTimeScheduler()
+        let subscription = CustomSubscription()
+        let publisher = CustomPublisher(subscription: subscription)
+        let subscribeOn = publisher.subscribe(on: scheduler, options: .nontrivialOptions)
+        let tracking = TrackingSubscriber(
+            receiveSubscription: { $0.request(.max(100)) },
+            receiveValue: { _ in .max(12) }
+        )
+
+        publisher.didSubscribe = { _ in
+            XCTAssertEqual(tracking.history,
+                           [.subscription("SubscribeOn")],
+                           "Subscription object should be sent synchronously")
+            XCTAssertEqual(subscription.history,
+                           [],
+                           "Demand should be requested asynchronously")
+        }
+
+        subscribeOn.subscribe(tracking)
+
+        XCTAssertNil(publisher.subscriber,
+                     "Subscription must be performed asynchronously")
+
+        XCTAssertEqual(tracking.history, [])
+        XCTAssertEqual(subscription.history, [])
+        XCTAssertEqual(scheduler.history, [.schedule(options: .nontrivialOptions)])
+
+        scheduler.executeScheduledActions()
+
+        XCTAssertEqual(tracking.history, [.subscription("SubscribeOn")])
+        XCTAssertEqual(subscription.history, [.requested(.max(100))])
+
+        XCTAssertEqual(publisher.send(1), .max(12))
+        XCTAssertEqual(publisher.send(2), .max(12))
+        XCTAssertEqual(publisher.send(3), .max(12))
+
+        XCTAssertEqual(tracking.history, [.subscription("SubscribeOn"),
+                                          .value(1),
+                                          .value(2),
+                                          .value(3)])
+        XCTAssertEqual(subscription.history, [.requested(.max(100))])
+        XCTAssertEqual(scheduler.history, [.schedule(options: .nontrivialOptions),
+                                           .schedule(options: .nontrivialOptions)])
+
+        publisher.send(completion: .finished)
+        publisher.send(completion: .failure(.oops))
+        XCTAssertEqual(publisher.send(-1), .none)
+
+        XCTAssertEqual(tracking.history, [.subscription("SubscribeOn"),
+                                          .value(1),
+                                          .value(2),
+                                          .value(3),
+                                          .completion(.finished)])
+        XCTAssertEqual(subscription.history, [.requested(.max(100))])
+        XCTAssertEqual(scheduler.history, [.schedule(options: .nontrivialOptions),
+                                           .schedule(options: .nontrivialOptions)])
+    }
+
+    func testAsynchronouslySendsEventsUpstream() throws {
+        let scheduler = VirtualTimeScheduler()
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: nil,
+                                        receiveValueDemand: .unlimited) {
+            $0.subscribe(on: scheduler, options: .nontrivialOptions)
+        }
+        scheduler.executeScheduledActions()
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("SubscribeOn")])
+        XCTAssertEqual(helper.subscription.history, [])
+        XCTAssertEqual(scheduler.history, [.schedule(options: .nontrivialOptions)])
+
+        try XCTUnwrap(helper.downstreamSubscription).request(.max(17))
+        try XCTUnwrap(helper.downstreamSubscription).request(.unlimited)
+        try XCTUnwrap(helper.downstreamSubscription).request(.none)
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("SubscribeOn")])
+        XCTAssertEqual(helper.subscription.history, [])
+        XCTAssertEqual(scheduler.history, [.schedule(options: .nontrivialOptions),
+                                           .schedule(options: .nontrivialOptions),
+                                           .schedule(options: .nontrivialOptions),
+                                           .schedule(options: .nontrivialOptions)])
+
+        scheduler.executeScheduledActions()
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("SubscribeOn")])
+        XCTAssertEqual(helper.subscription.history, [.requested(.max(17)),
+                                                     .requested(.unlimited),
+                                                     .requested(.none)])
+
+        try XCTUnwrap(helper.downstreamSubscription).cancel()
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("SubscribeOn")])
+        XCTAssertEqual(helper.subscription.history, [.requested(.max(17)),
+                                                     .requested(.unlimited),
+                                                     .requested(.none)])
+        XCTAssertEqual(scheduler.history, [.schedule(options: .nontrivialOptions),
+                                           .schedule(options: .nontrivialOptions),
+                                           .schedule(options: .nontrivialOptions),
+                                           .schedule(options: .nontrivialOptions),
+                                           .schedule(options: .nontrivialOptions)])
+
+        scheduler.executeScheduledActions()
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("SubscribeOn")])
+        XCTAssertEqual(helper.subscription.history, [.requested(.max(17)),
+                                                     .requested(.unlimited),
+                                                     .requested(.none),
+                                                     .cancelled])
+    }
+
+    func testCancelAlreadyCancelled() throws {
+        let scheduler = VirtualTimeScheduler()
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: nil,
+                                        receiveValueDemand: .max(42)) {
+            $0.subscribe(on: scheduler)
+        }
+        scheduler.executeScheduledActions()
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("SubscribeOn")])
+        XCTAssertEqual(helper.subscription.history, [])
+        XCTAssertEqual(scheduler.history, [.schedule(options: nil)])
+
+        try XCTUnwrap(helper.downstreamSubscription).cancel()
+        XCTAssertEqual(helper.publisher.send(1000), .none)
+        helper.publisher.send(completion: .failure(.oops))
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("SubscribeOn")])
+        XCTAssertEqual(helper.subscription.history, [])
+        XCTAssertEqual(scheduler.history, [.schedule(options: nil),
+                                           .schedule(options: nil)])
+
+        scheduler.executeScheduledActions()
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("SubscribeOn")])
+        XCTAssertEqual(helper.subscription.history, [.cancelled])
+        XCTAssertEqual(scheduler.history, [.schedule(options: nil),
+                                           .schedule(options: nil)])
+
+        try XCTUnwrap(helper.downstreamSubscription).request(.max(20000))
+        try XCTUnwrap(helper.downstreamSubscription).cancel()
+
+        XCTAssertEqual(scheduler.history, [.schedule(options: nil),
+                                           .schedule(options: nil)])
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("SubscribeOn")])
+        XCTAssertEqual(helper.subscription.history, [.cancelled])
+        XCTAssertEqual(scheduler.history, [.schedule(options: nil),
+                                           .schedule(options: nil)])
+    }
+
+    func testCancelImmediatelyAfterRequest() throws {
+        let scheduler = VirtualTimeScheduler()
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: nil,
+                                        receiveValueDemand: .max(42)) {
+            $0.subscribe(on: scheduler)
+        }
+        scheduler.executeScheduledActions()
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("SubscribeOn")])
+        XCTAssertEqual(helper.subscription.history, [])
+        XCTAssertEqual(scheduler.history, [.schedule(options: nil)])
+
+        try XCTUnwrap(helper.downstreamSubscription).request(.unlimited)
+        try XCTUnwrap(helper.downstreamSubscription).cancel()
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("SubscribeOn")])
+        XCTAssertEqual(helper.subscription.history, [])
+        XCTAssertEqual(scheduler.history, [.schedule(options: nil),
+                                           .schedule(options: nil),
+                                           .schedule(options: nil)])
+
+        scheduler.executeScheduledActions()
+
+        XCTAssertEqual(helper.tracking.history, [.subscription("SubscribeOn")])
+        XCTAssertEqual(helper.subscription.history, [.requested(.unlimited), .cancelled])
+        XCTAssertEqual(scheduler.history, [.schedule(options: nil),
+                                           .schedule(options: nil),
+                                           .schedule(options: nil)])
+    }
+
+    func testCrashWhenRequestingRecursively() throws {
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: nil,
+                                        receiveValueDemand: .none) {
+            $0.subscribe(on: ImmediateScheduler.shared)
+        }
+
+        helper.subscription.onRequest = { _ in
+            helper.downstreamSubscription?.request(.unlimited)
+        }
+
+        try assertCrashes {
+            try XCTUnwrap(helper.downstreamSubscription).request(.max(1))
+        }
+    }
+
+    func testCancelRecursively() throws {
+        let helper = OperatorTestHelper(publisherType: CustomPublisher.self,
+                                        initialDemand: nil,
+                                        receiveValueDemand: .none) {
+            $0.subscribe(on: ImmediateScheduler.shared)
+        }
+
+        helper.subscription.onCancel = {
+            helper.downstreamSubscription?.cancel()
+        }
+
+        try XCTUnwrap(helper.downstreamSubscription).cancel()
+    }
+
+    func testWeakCaptureWhenSchedulingRequest() throws {
+        let scheduler = VirtualTimeScheduler()
+        var subscriberReleased = false
+        let subscription = CustomSubscription()
+        do {
+            let publisher = CustomPublisher(subscription: subscription)
+            let subscribeOn = publisher.subscribe(on: scheduler)
+            var downstreamSubscription: Subscription?
+            let tracking = TrackingSubscriber(
+                receiveSubscription: { downstreamSubscription = $0 },
+                onDeinit: { subscriberReleased = true }
+            )
+            subscribeOn.subscribe(tracking)
+            scheduler.executeScheduledActions()
+            try XCTUnwrap(downstreamSubscription).request(.max(1))
+            XCTAssertEqual(subscription.history, [])
+            XCTAssertEqual(scheduler.history, [.schedule(options: nil),
+                                               .schedule(options: nil)])
+            publisher.cancel()
+            tracking.cancel()
+        }
+        XCTAssertTrue(subscriberReleased)
+        scheduler.executeScheduledActions()
+        XCTAssertEqual(subscription.history, [])
+    }
+
+    func testWeakCaptureWhenSchedulingCancel() throws {
+        let scheduler = VirtualTimeScheduler()
+        var subscriberReleased = false
+        let subscription = CustomSubscription()
+        do {
+            let publisher = CustomPublisher(subscription: subscription)
+            let subscribeOn = publisher.subscribe(on: scheduler)
+            var downstreamSubscription: Subscription?
+            let tracking = TrackingSubscriber(
+                receiveSubscription: { downstreamSubscription = $0 },
+                onDeinit: { subscriberReleased = true }
+            )
+            subscribeOn.subscribe(tracking)
+            scheduler.executeScheduledActions()
+            try XCTUnwrap(downstreamSubscription).cancel()
+            XCTAssertEqual(subscription.history, [])
+            XCTAssertEqual(scheduler.history, [.schedule(options: nil),
+                                               .schedule(options: nil)])
+            publisher.cancel()
+            tracking.cancel()
+        }
+        XCTAssertTrue(subscriberReleased)
+        scheduler.executeScheduledActions()
+        XCTAssertEqual(subscription.history, [])
+    }
+
+    func testSubscribeOnReceiveSubscriptionTwice() throws {
+        try testReceiveSubscriptionTwice {
+            $0.subscribe(on: ImmediateScheduler.shared)
+        }
+    }
+
+    func testSubscribeOnReceiveValueBeforeSubscription() {
+        testReceiveValueBeforeSubscription(value: 213,
+                                           expected: .history([], demand: .none)) {
+            $0.subscribe(on: ImmediateScheduler.shared)
+        }
+    }
+
+    func testSubscribeOnReceiveCompletionBeforeSubscription()  {
+        testReceiveCompletionBeforeSubscription(inputType: Int.self,
+                                                expected: .history([])) {
+            $0.subscribe(on: ImmediateScheduler.shared)
+        }
+    }
+
+    func testSubscribeOnRequestBeforeSubscription() {
+        testRequestBeforeSubscription(inputType: Int.self, shouldCrash: false) {
+            $0.subscribe(on: ImmediateScheduler.shared)
+        }
+    }
+
+    func testSubscribeOnCancelBeforeSubscription() {
+        testCancelBeforeSubscription(inputType: Int.self, shouldCrash: false) {
+            $0.subscribe(on: ImmediateScheduler.shared)
+        }
+    }
+
+    func testSubscribeOnReflection() throws {
+        try testReflection(parentInput: Double.self,
+                           parentFailure: Error.self,
+                           description: "SubscribeOn",
+                           customMirror: childrenIsEmpty,
+                           playgroundDescription: "SubscribeOn",
+                           { $0.subscribe(on: ImmediateScheduler.shared) })
+    }
+
+    func testSubscribeOnLifecycle() throws {
+        try testLifecycle(sendValue: 31, cancellingSubscriptionReleasesSubscriber: true) {
+            $0.subscribe(on: ImmediateScheduler.shared)
+        }
+    }
+}

Tests/OpenCombineTests/VirtualTimeSchedulerTests.swift

@@ -0,0 +1,108 @@
+//
+//  VirtualTimeSchedulerTests.swift
+//  OpenCombineTests
+//
+//  Created by Евгений Богомолов on 14/09/2019.
+//
+
+import XCTest
+
+@available(macOS 10.15, iOS 13.0, *)
+final class VirtualTimeSchedulerTests: XCTestCase {
+
+    func testOrder() {
+        var history = [Int]()
+        let scheduler = VirtualTimeScheduler()
+        scheduler.schedule(after: scheduler.now + .nanoseconds(10)) {
+            history.append(5)
+        }
+        scheduler.schedule {
+            history.append(1)
+        }
+        scheduler.schedule(after: scheduler.now + .nanoseconds(5)) {
+            history.append(3)
+            scheduler.schedule(after: scheduler.now + .nanoseconds(2)) {
+                history.append(4)
+            }
+        }
+        scheduler.schedule {
+            history.append(2)
+        }
+
+        XCTAssertEqual(scheduler.now, .nanoseconds(0))
+        XCTAssertEqual(scheduler.scheduledDates, [.nanoseconds(0),
+                                                  .nanoseconds(0),
+                                                  .nanoseconds(5),
+                                                  .nanoseconds(10)])
+
+        scheduler.executeScheduledActions()
+        XCTAssertEqual(history, [1, 2, 3, 4, 5])
+        XCTAssertEqual(scheduler.now, .nanoseconds(10))
+        XCTAssertEqual(scheduler.scheduledDates, [])
+
+        XCTAssertEqual(scheduler.history, [.now,
+                                           .minimumTolerance,
+                                           .scheduleAfterDate(.nanoseconds(10),
+                                                              tolerance: 0,
+                                                              options: nil),
+                                           .schedule(options: nil),
+                                           .now,
+                                           .minimumTolerance,
+                                           .scheduleAfterDate(.nanoseconds(5),
+                                                              tolerance: 0,
+                                                              options: nil),
+                                           .schedule(options: nil),
+                                           .now,
+                                           .now,
+                                           .minimumTolerance,
+                                           .scheduleAfterDate(.nanoseconds(7),
+                                                              tolerance: 0,
+                                                              options: nil),
+                                           .now])
+    }
+
+    func testRepeadedAction() {
+        let scheduler = VirtualTimeScheduler()
+        var history = [Int]()
+        let cancellable = scheduler.schedule(after: scheduler.now + .microseconds(2),
+                                             interval: .milliseconds(40)) {
+            history.append(Int(scheduler.now.time))
+        }
+        scheduler.schedule(after: scheduler.now + .milliseconds(300)) {
+            cancellable.cancel()
+        }
+        XCTAssertEqual(scheduler.scheduledDates, [.microseconds(2), .milliseconds(300)])
+        scheduler.executeScheduledActions()
+
+        XCTAssertEqual(history, [2000,
+                                 40002000,
+                                 80002000,
+                                 120002000,
+                                 160002000,
+                                 200002000,
+                                 240002000,
+                                 280002000])
+        XCTAssertEqual(scheduler.now, .microseconds(320002))
+        XCTAssertEqual(scheduler.history,
+                       [.now,
+                        .minimumTolerance,
+                        .scheduleAfterDateWithInterval(.microseconds(2),
+                                                       interval: .milliseconds(40),
+                                                       tolerance: 0,
+                                                       options: nil),
+                        .now,
+                        .minimumTolerance,
+                        .scheduleAfterDate(.milliseconds(300),
+                                           tolerance: .nanoseconds(0),
+                                           options: nil),
+                        .now,
+                        .now,
+                        .now,
+                        .now,
+                        .now,
+                        .now,
+                        .now,
+                        .now,
+                        .now])
+    }
+}