Prepare for 0.10.1 (#185)

PropertyListEncoder and PropertyListDecoder are both unavailable prior to Swift 5.1, causing a build error for Swift 5.0.

.circleci/config.yml

@@ -1,16 +1,17 @@
 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.3.0, Swift 5.1.3)":
     macos:
-      xcode: "11.2.1"
+      xcode: "11.3.0"
     environment:
-      SWIFT_VERSION: "5.1.2"
+      SWIFT_VERSION: "5.1.3"
     steps:
       - checkout
       - run:
           name: Building and running tests in debug mode with coverage
           command: |
             make test-debug \
+              SWIFT_BUILD_FLAGS="-Xswiftc -warnings-as-errors" \
               SWIFT_TEST_FLAGS="--enable-code-coverage --build-path .build-test-debug"
             xcrun llvm-cov show \
               -instr-profile=.build-test-debug/debug/codecov/default.profdata \
@@ -20,15 +21,17 @@ jobs:
           name: Building and running tests in debug mode with TSan
           command: |
             make test-debug-sanitize-thread \
+              SWIFT_BUILD_FLAGS="-Xswiftc -warnings-as-errors" \
               SWIFT_TEST_FLAGS="--build-path .build-test-debug-sanitize-thread"
       - run:
           name: Building and running tests in release mode
           command: |
             make test-release \
+              SWIFT_BUILD_FLAGS="-Xswiftc -warnings-as-errors" \
               SWIFT_TEST_FLAGS="--build-path .build-test-release"
       - run:
           name: Generating Xcode project
-          command: make generate-xcodeproj
+          command: make generate-xcodeproj SWIFT_BUILD_FLAGS="-Xswiftc -warnings-as-errors"
       - run:
           name: Building for testing on macOS 10.15.0 with xcodebuild
           command: |
@@ -60,35 +63,35 @@ 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.6 (Xcode 11.6.0, Swift 5.2.4)":
     macos:
-      xcode: "11.2.1"
+      xcode: "11.6.0"
     environment:
-      SWIFT_VERSION: "5.1.2"
+      SWIFT_VERSION: "5.2.4"
     steps:
       - checkout
       - run:
           name: Generating Xcode project
           command: make generate-compatibility-xcodeproj
       - run:
-          name: Building for testing on iOS 13.2.2 with xcodebuild
+          name: Building for testing on iOS 13.6 with xcodebuild
           command: |
             set -o pipefail \
               && xcodebuild build-for-testing \
                    -scheme OpenCombine-Package \
-                   -destination "platform=iOS Simulator,name=iPhone 11,OS=13.2.2" \
+                   -destination "platform=iOS Simulator,name=iPhone 11,OS=13.6" \
                    -derivedDataPath DerivedData \
               | tee xcodebuild_build-for-testing.log \
               | xcpretty
       - store_artifacts:
           path: xcodebuild_build-for-testing.log
       - run:
-          name: Testing against Combine on iOS 13.2.2 with xcodebuild
+          name: Testing against Combine on iOS 13.6 with xcodebuild
           command: |
             set -o pipefail \
               && xcodebuild test-without-building \
                    -scheme OpenCombine-Package \
-                   -destination "platform=iOS Simulator,name=iPhone 11,OS=13.2.2" \
+                   -destination "platform=iOS Simulator,name=iPhone 11,OS=13.6" \
                    -derivedDataPath DerivedData \
               | tee xcodebuild_test-without-building.log \
               | xcpretty --report junit -o build/reports/results.xml
@@ -125,7 +128,7 @@ jobs:
       - run:
           name: Generating Xcode project
           command: |
-            make generate-xcodeproj
+            make generate-xcodeproj SWIFT_BUILD_FLAGS="-Xswiftc -warnings-as-errors"
             xcodebuild -scheme OpenCombine-Package -showdestinations
       - run:
            name: Building for testing on iOS 9.3 with xcodebuild
@@ -158,140 +161,11 @@ 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)":
+  "Execute tests on Ubuntu 18.04 (Swift 5.2)":
     docker:
-      - image: swift:5.1.1-bionic
+      - image: swift:5.2-bionic
     environment:
-      SWIFT_VERSION: "5.1.1"
+      SWIFT_VERSION: "5.2"
     steps:
       - checkout
       - run:
@@ -311,6 +185,7 @@ jobs:
               > /dev/null 2>&1 \
               || true
             make test-debug \
+              SWIFT_BUILD_FLAGS="-Xswiftc -warnings-as-errors" \
               SWIFT_TEST_FLAGS="--enable-test-discovery \
                                 --enable-index-store \
                                 --enable-code-coverage \
@@ -323,6 +198,7 @@ jobs:
           name: Building and running tests in debug mode with TSan
           command: | # We need to run the test command twice because of https://bugs.swift.org/browse/SR-10783
             make test-debug-sanitize-thread \
+              SWIFT_BUILD_FLAGS="-Xswiftc -warnings-as-errors" \
               SWIFT_TEST_FLAGS="--enable-test-discovery \
                                 --enable-index-store \
                                 --build-path .build-test-debug-sanitize-thread" \
@@ -336,6 +212,7 @@ jobs:
           name: Building and running tests in release mode
           command: |
             make test-release \
+              SWIFT_BUILD_FLAGS="-Xswiftc -warnings-as-errors" \
               SWIFT_TEST_FLAGS="--enable-test-discovery \
                                 --enable-index-store \
                                 --build-path .build-test-release"
@@ -346,7 +223,7 @@ jobs:
 
   "Run SwiftLint and Danger":
     macos:
-      xcode: "11.2.0"
+      xcode: "11.3.0"
     environment:
       HOMEBREW_NO_AUTO_UPDATE: "1"
     steps:
@@ -365,7 +242,7 @@ jobs:
 
   "Run Pod spec lint":
     macos:
-      xcode: "11.2.0"
+      xcode: "11.3.0"
     environment:
       HOMEBREW_NO_AUTO_UPDATE: "1"
     steps:
@@ -379,19 +256,16 @@ 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.3.0, Swift 5.1.3)"
   "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.6 (Xcode 11.6.0, Swift 5.2.4)"
   "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)"
+      - "Execute tests on Ubuntu 18.04 (Swift 5.2)"
   "OpenCombine: run SwiftLint and Danger":
     jobs:
       - "Run SwiftLint and Danger"

.swiftlint.yml

@@ -23,6 +23,7 @@ disabled_rules:
   - trailing_comma
   - type_body_length
   - opening_brace
+  - untyped_error_in_catch
 
 opt_in_rules:
   - array_init
@@ -65,6 +66,10 @@ opt_in_rules:
   - vertical_whitespace_closing_braces
   - yoda_condition
 
+implicit_return:
+  included: 
+    - closure
+
 line_length:
   warning: 90
   error: 120

.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"

Gemfile.lock

@@ -18,7 +18,7 @@ GEM
       unf (>= 0.0.5, < 1.0.0)
     dotenv (2.7.5)
     emoji_regex (1.0.1)
-    excon (0.68.0)
+    excon (0.71.0)
     faraday (0.17.0)
       multipart-post (>= 1.2, < 3)
     faraday-cookie_jar (0.0.6)
@@ -93,7 +93,7 @@ GEM
     http-cookie (1.0.3)
       domain_name (~> 0.5)
     httpclient (2.8.3)
-    json (2.2.0)
+    json (2.3.1)
     jwt (2.1.0)
     memoist (0.16.1)
     mime-types (3.3)

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.10.1"
   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"
-end
+  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.10.1"
+  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"
-end
+  spec.dependency     "OpenCombine", '>= 0.9'
+end

OpenCombineFoundation.podspec

@@ -0,0 +1,25 @@
+Pod::Spec.new do |spec|
+    spec.name          = "OpenCombineFoundation"
+    spec.version       = "0.10.1"
+    spec.summary       = "OpenCombine + OpenCombineFoundation interoperability"
+  
+    spec.description   = <<-DESC
+    Adds publishers to Foundation types like NotificationCenter, URLSession etc.
+    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.swift_version = "5.0"
+  
+    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.source_files = "Sources/OpenCombineFoundation/**/*.swift"
+    spec.dependency     "OpenCombine", '>= 0.9'
+  end

Package.swift

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

README.md

@@ -1,8 +1,9 @@
 # OpenCombine
-[![CircleCI](https://circleci.com/gh/broadwaylamb/OpenCombine/tree/master.svg?style=svg)](https://circleci.com/gh/broadwaylamb/OpenCombine/tree/master)
-[![codecov](https://codecov.io/gh/broadwaylamb/OpenCombine/branch/master/graph/badge.svg)](https://codecov.io/gh/broadwaylamb/OpenCombine)
+[![OpenCombine](https://circleci.com/gh/OpenCombine/OpenCombine.svg?style=svg)](https://circleci.com/gh/OpenCombine/OpenCombine)
+[![codecov](https://codecov.io/gh/OpenCombine/OpenCombine/branch/master/graph/badge.svg)](https://codecov.io/gh/OpenCombine/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.
@@ -12,9 +13,9 @@ The main goal of this project is to provide a compatible, reliable and efficient
 The project is in early development.
 
 ### Installation
-`OpenCombine` contains two public targets: `OpenCombine` and `OpenCombineDispatch` (the third one, `COpenCombineHelpers`, is considered private. Don't import it in your projects).
+`OpenCombine` contains three public targets: `OpenCombine`, `OpenCombineFoundation` and `OpenCombineDispatch` (the fourth one, `COpenCombineHelpers`, is considered private. Don't import it in your projects).
 
-OpenCombine itself does not have any dependencies. Not even Foundation or Dispatch. If you want to use OpenCombine with Dispatch (for example for using `DispatchQueue` as `Scheduler` for operators like `debounce`, `receive(on:)` etc.), you will need to import both `OpenCombine` and `OpenCombineDispatch`.
+OpenCombine itself does not have any dependencies. Not even Foundation or Dispatch. If you want to use OpenCombine with Dispatch (for example for using `DispatchQueue` as `Scheduler` for operators like `debounce`, `receive(on:)` etc.), you will need to import both `OpenCombine` and `OpenCombineDispatch`. The same applies to Foundation: if you want to use, for instance, `NotificationCenter` or `URLSession` publishers, you'll need to also import `OpenCombineFoundation`
 
 ##### Swift Package Manager
 ###### Swift Package
@@ -22,17 +23,19 @@ 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/OpenCombine/OpenCombine.git", from: "0.10.1")
 ],
 targets: [
-    .target(name: "MyAwesomePackage", dependencies: ["OpenCombine", "OpenCombineDispatch"])
+    .target(name: "MyAwesomePackage", dependencies: ["OpenCombine",
+                                                     "OpenCombineDispatch",
+                                                     "OpenCombineFoundation"])
 ]
 ```
 
 ###### Xcode
 `OpenCombine` can also be added as a SPM dependency directly in your Xcode project *(requires Xcode 11 upwards)*.
 
-To do so, open Xcode, use **File** → **Swift Packages** → **Add Package Dependency…**, enter the [repository URL](https://github.com/broadwaylamb/OpenCombine.git), choose the latest available version, and activate the checkboxes:
+To do so, open Xcode, use **File** → **Swift Packages** → **Add Package Dependency…**, enter the [repository URL](https://github.com/OpenCombine/OpenCombine.git), choose the latest available version, and activate the checkboxes:
 
 <p align="center">
 <img alt="Select the OpenCombine and OpenCombineDispatch targets" 
@@ -43,17 +46,18 @@ 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.10.1'
+pod 'OpenCombineDispatch', '~> 0.10.1'
+pod 'OpenCombineFoundation', '~> 0.10.1'
 ```
 
 ### Contributing
 
 In order to work on this project you will need Xcode 10.2 and Swift 5.0 or later.
 
-Please refer to the [issue #1](https://github.com/broadwaylamb/OpenCombine/issues/1) for the list of operators that remain unimplemented, as well as the [RemainingCombineInterface.swift](https://github.com/broadwaylamb/OpenCombine/blob/master/RemainingCombineInterface.swift) file. The latter contains the generated interface of Apple's Combine from the latest Xcode 11 version. When the functionality is implemented in OpenCombine, it should be removed from the RemainingCombineInterface.swift file.
+Please refer to the [issue #1](https://github.com/OpenCombine/OpenCombine/issues/1) for the list of operators that remain unimplemented, as well as the [RemainingCombineInterface.swift](https://github.com/OpenCombine/OpenCombine/blob/master/RemainingCombineInterface.swift) file. The latter contains the generated interface of Apple's Combine from the latest Xcode 11 version. When the functionality is implemented in OpenCombine, it should be removed from the RemainingCombineInterface.swift file.
 
-You can refer to [this gist](https://gist.github.com/broadwaylamb/c2c8550d76b3ff851c4c1dbf0a872e26) to observe Apple's Combine API changes between different Xcode (beta) versions, or to [this gist](https://gist.github.com/broadwaylamb/82dc2ce4ffbe06527c2c352b8f10910f) to see the relevant contents of the .swiftinterface file for Combine.
+You can refer to [this repo](https://github.com/OpenCombine/combine-interfaces) to observe Apple's Combine API and documentation changes between different Xcode (beta) versions.
 
 You can run compatibility tests against Apple's Combine. In order to do that you will need either macOS 10.14 with iOS 13 simulator installed (since the only way we can get Apple's Combine on macOS 10.14 is using the simulator), or macOS 10.15 (Apple's Combine is bundled with the OS). Execute the following command from the root of the package:
 
@@ -63,7 +67,29 @@ $ make test-compatibility
 
 Or enable the `-DOPENCOMBINE_COMPATIBILITY_TEST` compiler flag in Xcode's build settings. Note that on iOS only the latter will work.
 
-> NOTE: Before starting to work on some feature, please consult the [GitHub project](https://github.com/broadwaylamb/OpenCombine/projects/2) to make sure that nobody's already making progress on the same feature! If not, then please create a draft PR to indicate that you're beginning your work.
+> NOTE: Before starting to work on some feature, please consult the [GitHub project](https://github.com/OpenCombine/OpenCombine/projects/2) to make sure that nobody's already making progress on the same feature! If not, then please create a draft PR to indicate that you're beginning your work.
+
+#### Releasing a new version
+
+1. Create a new branch from master and call it `release/<major>.<minor>.<patch>`.
+1. Replace the usages of the old version in `README.md` with the new version (make sure to check the [Swift Package Manager](#swift-package-manager) and [CocoaPods](#cocoapods) sections).
+1. Bump the version in `OpenCombine.podspec`, `OpenCombineDispatch.podspec` and `OpenCombineFoundation.podspec`. In the latter two you will also need to set the `spec.dependency "OpenCombine"` property to the **previous** version. Why? Because otherwise the `pod lib lint` command that we run on our regular CI will fail when validating the `OpenCombineDispatch` and `OpenCombineFoundation` podspecs, since the dependencies are not yet in the trunk. If we set the dependencies to the previous version (which is already in the trunk), everything will be fine. This is purely to make the CI work. The clients will not experience any issues, since the version is specified as `>=`.
+1. Create a pull request to master for the release branch and make sure the CI passes.
+1. Merge the pull request.
+1. In the GitHub web interface on the [releases](https://github.com/OpenCombine/OpenCombine/releases) page, click the **Draft a new release** button.
+1. The **Tag version** and **Release title** fields should be filled with the version number.
+1. The description of the release should be consistent with the previous releases. It is a good practice to divide the description into several sections: additions, bugfixes, known issues etc. Also, be sure to mention the nicknames of the contributors of the new release.
+1. Publish the release.
+1. Switch to the master branch and pull the changes.
+1. Push the release to CocoaPods trunk. For that, execute the following commands:
+
+    ```
+    pod trunk push OpenCombine.podspec --verbose --allow-warnings
+    pod trunk push OpenCombineDispatch.podspec --verbose --allow-warnings
+    pod trunk push OpenCombineFoundation.podspec --verbose --allow-warnings
+    ```
+   
+   Note that you need to be one of the owners of the pod for that.
 
 #### GYB
 
@@ -85,3 +111,16 @@ GYB template files have the `.gyb` extension. Run `make gyb` to generate Swift c
 templates. The generated files are prefixed with `GENERATED-`  and are checked into source control. Those
 files should never be edited directly. Instead, the `.gyb` template should be edited, and after that the files
 should be regenerated using `make gyb`.
+
+#### Debugger Support
+
+The file `opencombine_lldb.py`  defines some `lldb` type summaries for easier debugging. These type summaries improve the way `lldb` and Xcode display some OpenCombine values.
+
+To use `opencombine_lldb.py`, figure out its full path. Let's say the full path is `~/projects/OpenCombine/opencombine_lldb.py`. Then the following statement to your `~/.lldbinit` file:
+
+    command script import ~/projects/OpenCombine/opencombine_lldb.py
+
+Currently, `opencombine_lldb.py` defines type summaries for these types:
+
+- `Subscribers.Demand`
+- That's all for now.

RemainingFoundationInterface.swift

@@ -0,0 +1,39 @@
+// From /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/lib/swift/Foundation.swiftmodule/x86_64.swiftinterface
+// swift-interface-format-version: 1.0
+// swift-compiler-version: Apple Swift version 5.1.1 (swiftlang-1100.8.275.1 clang-1100.0.32.1)
+// swift-module-flags: -target x86_64-apple-macosx10.15 -enable-objc-interop -autolink-force-load -enable-library-evolution -module-link-name swiftFoundation -swift-version 5 -O -enforce-exclusivity=unchecked -module-name Foundation
+
+public typealias Published = Combine.Published
+
+public typealias ObservableObject = Combine.ObservableObject
+
+public protocol _KeyValueCodingAndObservingPublishing {
+}
+
+extension NSObject : Foundation._KeyValueCodingAndObservingPublishing {
+}
+
+extension _KeyValueCodingAndObservingPublishing where Self : ObjectiveC.NSObject {
+  public func publisher<Value>(for keyPath: Swift.KeyPath<Self, Value>, options: Foundation.NSKeyValueObservingOptions = [.initial, .new]) -> ObjectiveC.NSObject.KeyValueObservingPublisher<Self, Value>
+}
+
+extension NSObject.KeyValueObservingPublisher {
+  public func didChange() -> Combine.Publishers.Map<ObjectiveC.NSObject.KeyValueObservingPublisher<Subject, Value>, Swift.Void>
+}
+
+extension NSObject {
+  public struct KeyValueObservingPublisher<Subject, Value> : Swift.Equatable where Subject : ObjectiveC.NSObject {
+    public let object: Subject
+    public let keyPath: Swift.KeyPath<Subject, Value>
+    public let options: Foundation.NSKeyValueObservingOptions
+    public init(object: Subject, keyPath: Swift.KeyPath<Subject, Value>, options: Foundation.NSKeyValueObservingOptions)
+    public static func == (lhs: ObjectiveC.NSObject.KeyValueObservingPublisher<Subject, Value>, rhs: ObjectiveC.NSObject.KeyValueObservingPublisher<Subject, Value>) -> Swift.Bool
+  }
+}
+
+extension NSObject.KeyValueObservingPublisher : Combine.Publisher {
+  public typealias Output = Value
+  public typealias Failure = Swift.Never
+  public func receive<S>(subscriber: S) where Value == S.Input, S : Combine.Subscriber, S.Failure == ObjectiveC.NSObject.KeyValueObservingPublisher<Subject, Value>.Failure
+}
+

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.
@@ -11,6 +11,7 @@
 #include <cstdlib>
 #include <system_error>
 #include <pthread.h>
+#include <signal.h>
 
 #ifdef __APPLE__
 #include <os/lock.h>
@@ -235,4 +236,8 @@ void opencombine_unfair_recursive_lock_dealloc(OpenCombineUnfairRecursiveLock lo
     return delete static_cast<PlatformIndependentMutex*>(lock.opaque);
 }
 
+void opencombine_stop_in_debugger(void) {
+    raise(SIGTRAP);
+}
+
 } // extern "C"

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,6 @@
 #define COPENCOMBINEHELPERS_H
 
 #include <stdint.h>
-#include <stddef.h>
-#include <stdbool.h>
 
 #if __has_attribute(swift_name)
 # define OPENCOMBINE_SWIFT_NAME(_name) __attribute__((swift_name(#_name)))
@@ -25,67 +23,54 @@ 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
-);
-
-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) OPENCOMBINE_SWIFT_NAME(__stopInDebugger());
 
 #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/AnyCancellable.swift

@@ -57,7 +57,7 @@ extension AnyCancellable {
 
     /// Stores this AnyCancellable in the specified set.
     /// Parameters:
-    ///    - collection: The set to store this AnyCancellable.
+    ///    - set: The set to store this AnyCancellable.
     public func store(in set: inout Set<AnyCancellable>) {
         set.insert(self)
     }

Sources/OpenCombine/AnyPublisher.swift

@@ -11,6 +11,7 @@ extension Publisher {
     ///
     /// Use `eraseToAnyPublisher()` to expose an instance of `AnyPublisher` to
     /// the downstream subscriber, rather than this publisher’s actual type.
+    @inlinable
     public func eraseToAnyPublisher() -> AnyPublisher<Output, Failure> {
         return .init(self)
     }

Sources/OpenCombine/AnySubscriber.swift

@@ -62,8 +62,8 @@ public struct AnySubscriber<Input, Failure: Error>: Subscriber,
 
         if let playgroundDescription = subscriber as? CustomPlaygroundDisplayConvertible {
             playgroundDescriptionThunk = { playgroundDescription.playgroundDescription }
-        } else if let desccription = subscriber as? CustomStringConvertible {
-            playgroundDescriptionThunk = { desccription.description }
+        } else if let description = subscriber as? CustomStringConvertible {
+            playgroundDescriptionThunk = { description.description }
         } else {
             let fixedDescription = String(describing: type(of: subscriber))
             playgroundDescriptionThunk = { fixedDescription }

Sources/OpenCombine/Cancellable.swift

@@ -28,7 +28,7 @@ extension Cancellable {
 
     /// Stores this Cancellable in the specified set.
     /// Parameters:
-    ///    - collection: The set to store this Cancellable.
+    ///    - set: The set to store this Cancellable.
     public func store(in set: inout Set<AnyCancellable>) {
         AnyCancellable(self).store(in: &set)
     }

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,32 +5,33 @@
 //  Created by Sergej Jaskiewicz on 11.06.2019.
 //
 
-import COpenCombineHelpers
-
 /// A subject that wraps a single value and publishes a new element whenever the value
 /// changes.
 public final class CurrentValueSubject<Output, Failure: Error>: Subject {
 
-    private let _lock = UnfairRecursiveLock.allocate()
+    private let lock = UnfairLock.allocate()
 
-    // TODO: Combine uses bag data structure
-    private var _subscriptions: [Conduit] = []
+    private var active = true
 
-    private var _value: Output
+    private var completion: Subscribers.Completion<Failure>?
 
-    private var _completion: Subscribers.Completion<Failure>?
+    private var downstreams = ConduitList<Output, Failure>.empty
 
-    internal var upstreamSubscriptions: [Subscription] = []
+    private var currentValue: Output
 
-    internal var hasAnyDownstreamDemand = false
+    private var upstreamSubscriptions: [Subscription] = []
 
     /// The value wrapped by this subject, published as a new element whenever it changes.
     public var value: Output {
         get {
-            return _value
+            lock.lock()
+            defer { lock.unlock() }
+            return currentValue
         }
         set {
-            send(newValue)
+            lock.lock()
+            currentValue = newValue
+            sendValueAndConsumeLock(newValue)
         }
     }
 
@@ -38,122 +39,213 @@ public final class CurrentValueSubject<Output, Failure: Error>: Subject {
     ///
     /// - Parameter value: The initial value to publish.
     public init(_ value: Output) {
-        self._value = value
+        self.currentValue = value
     }
 
     deinit {
-        for subscription in _subscriptions {
-            subscription._downstream = nil
+        for subscription in upstreamSubscriptions {
+            subscription.cancel()
         }
-        _lock.deallocate()
+        lock.deallocate()
     }
 
     public func send(subscription: Subscription) {
-        _lock.do {
-            upstreamSubscriptions.append(subscription)
-            subscription.request(.unlimited)
-        }
+        lock.lock()
+        upstreamSubscriptions.append(subscription)
+        lock.unlock()
+        subscription.request(.unlimited)
     }
 
-    public func receive<Subscriber: OpenCombine.Subscriber>(subscriber: Subscriber)
-        where Output == Subscriber.Input, Failure == Subscriber.Failure
+    public func receive<Downstream: Subscriber>(subscriber: Downstream)
+        where Output == Downstream.Input, Failure == Downstream.Failure
     {
-        _lock.do {
-
-            if let completion = _completion {
-                subscriber.receive(subscription: Subscriptions.empty)
-                subscriber.receive(completion: completion)
-                return
-            } else {
-                let subscription = Conduit(parent: self,
-                                           downstream: AnySubscriber(subscriber))
-
-                _subscriptions.append(subscription)
-                subscriber.receive(subscription: subscription)
-            }
+        lock.lock()
+        if active {
+            let conduit = Conduit(parent: self, downstream: subscriber)
+            downstreams.insert(conduit)
+            lock.unlock()
+            subscriber.receive(subscription: conduit)
+        } else {
+            let completion = self.completion!
+            lock.unlock()
+            subscriber.receive(subscription: Subscriptions.empty)
+            subscriber.receive(completion: completion)
         }
     }
 
     public func send(_ input: Output) {
-        _lock.do {
-            _value = input
-            for subscription in _subscriptions where !subscription.isCompleted {
-                if subscription._demand > 0 {
-                    subscription._offer(input)
-                    subscription._demand -= 1
-                } else {
-                    subscription._delivered = false
-                }
-            }
+        lock.lock()
+        sendValueAndConsumeLock(input)
+    }
+
+    private func sendValueAndConsumeLock(_ newValue: Output) {
+#if DEBUG
+        lock.assertOwner()
+#endif
+        guard active else {
+            lock.unlock()
+            return
+        }
+        currentValue = newValue
+        let downstreams = self.downstreams
+        lock.unlock()
+        downstreams.forEach { conduit in
+            conduit.offer(newValue)
         }
     }
 
     public func send(completion: Subscribers.Completion<Failure>) {
-        _completion = completion
-        _lock.do {
-            for subscriber in _subscriptions {
-                subscriber._receive(completion: completion)
-            }
+        lock.lock()
+        guard active else {
+            lock.unlock()
+            return
         }
+        active = false
+        self.completion = completion
+        let downstreams = self.downstreams
+        self.downstreams.removeAll()
+        lock.unlock()
+        downstreams.forEach { conduit in
+            conduit.finish(completion: completion)
+        }
+    }
+
+    private func disassociate(_ conduit: ConduitBase<Output, Failure>) {
+        lock.lock()
+        guard active else {
+            lock.unlock()
+            return
+        }
+        downstreams.remove(conduit)
+        lock.unlock()
     }
 }
 
 extension CurrentValueSubject {
 
-    fileprivate class Conduit: Subscription {
+    private final class Conduit<Downstream: Subscriber>
+        : ConduitBase<Output, Failure>,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == Output, Downstream.Failure == Failure
+    {
 
-        fileprivate var _parent: CurrentValueSubject?
+        fileprivate var parent: CurrentValueSubject?
 
-        fileprivate var _downstream: AnySubscriber<Output, Failure>?
+        fileprivate var downstream: Downstream?
 
-        fileprivate var _demand: Subscribers.Demand = .none
+        fileprivate var demand = Subscribers.Demand.none
 
-        /// Whethere we satisfied the demand
-        fileprivate var _delivered = false
+        private var lock = UnfairLock.allocate()
 
-        var isCompleted: Bool {
-            return _parent == nil
-        }
+        private var downstreamLock = UnfairRecursiveLock.allocate()
 
-        fileprivate func _offer(_ value: Output) {
-            let newDemand = _downstream?.receive(value) ?? .none
-            _demand += newDemand
-            _delivered = true
-        }
+        private var deliveredCurrentValue = false
 
         fileprivate init(parent: CurrentValueSubject,
-                         downstream: AnySubscriber<Output, Failure>) {
-            _parent = parent
-            _downstream = downstream
+                         downstream: Downstream) {
+            self.parent = parent
+            self.downstream = downstream
         }
 
-        fileprivate func _receive(completion: Subscribers.Completion<Failure>) {
-            if !isCompleted {
-                _parent = nil
-                _downstream?.receive(completion: completion)
+        deinit {
+            lock.deallocate()
+            downstreamLock.deallocate()
+        }
+
+        override func offer(_ output: Output) {
+            lock.lock()
+            guard demand > 0, let downstream = self.downstream else {
+                deliveredCurrentValue = false
+                lock.unlock()
+                return
             }
+            demand -= 1
+            deliveredCurrentValue = true
+            lock.unlock()
+            downstreamLock.lock()
+            let newDemand = downstream.receive(output)
+            downstreamLock.unlock()
+            guard newDemand > 0 else { return }
+            lock.lock()
+            demand += newDemand
+            lock.unlock()
         }
 
-        func request(_ demand: Subscribers.Demand) {
-            precondition(demand > 0)
-            _parent?._lock.do {
-                if !_delivered, let value = _parent?.value {
-                    _offer(value)
-                    _demand += demand
-                    _demand -= 1
-                } else {
-                    _demand = demand
-                }
-                _parent?.hasAnyDownstreamDemand = true
+        override func finish(completion: Subscribers.Completion<Failure>) {
+            lock.lock()
+            guard let downstream = self.downstream else {
+                lock.unlock()
+                return
             }
+            self.downstream = nil
+            let parent = self.parent
+            self.parent = nil
+            lock.unlock()
+            parent?.disassociate(self)
+            downstreamLock.lock()
+            downstream.receive(completion: completion)
+            downstreamLock.unlock()
         }
 
-        func cancel() {
-            _parent = nil
+        override func request(_ demand: Subscribers.Demand) {
+            demand.assertNonZero()
+            lock.lock()
+            guard let downstream = self.downstream else {
+                lock.unlock()
+                return
+            }
+            if deliveredCurrentValue {
+                self.demand += demand
+                lock.unlock()
+                return
+            }
+
+            // Hasn't yet delivered the current value
+
+            self.demand += demand
+            deliveredCurrentValue = true
+            if let currentValue = self.parent?.value {
+                self.demand -= 1
+                lock.unlock()
+                downstreamLock.lock()
+                let newDemand = downstream.receive(currentValue)
+                downstreamLock.unlock()
+                guard newDemand > 0 else { return }
+                lock.lock()
+                self.demand += newDemand
+            }
+            lock.unlock()
         }
+
+        override func cancel() {
+            lock.lock()
+            if self.downstream == nil {
+                lock.unlock()
+                return
+            }
+            self.downstream = nil
+            let parent = self.parent
+            self.parent = nil
+            lock.unlock()
+            parent?.disassociate(self)
+        }
+
+        var description: String { return "CurrentValueSubject" }
+
+        var customMirror: Mirror {
+            lock.lock()
+            defer { lock.unlock() }
+            let children: [Mirror.Child] = [
+                ("parent", parent as Any),
+                ("downstream", downstream as Any),
+                ("demand", demand),
+                ("subject", parent as Any)
+            ]
+            return Mirror(self, children: children)
+        }
+
+        var playgroundDescription: Any { return description }
     }
 }
-
-extension CurrentValueSubject.Conduit: CustomStringConvertible {
-    fileprivate var description: String { return "CurrentValueSubject" }
-}

Sources/OpenCombine/Future.swift

@@ -5,116 +5,198 @@
 //  Created by Max Desiatov on 24/11/2019.
 //
 
-import COpenCombineHelpers
-
 /// A publisher that eventually produces one value and then finishes or fails.
-public final class Future<Output, Failure>: Publisher where Failure: Error {
+public final class Future<Output, Failure: Error>: Publisher {
 
     public typealias Promise = (Result<Output, Failure>) -> Void
 
-    private let _lock = UnfairRecursiveLock.allocate()
-    private var _subscriptions: [Conduit] = []
+    private let lock = UnfairLock.allocate()
+
+    private var downstreams = ConduitList<Output, Failure>.empty
 
     private var result: Result<Output, Failure>?
 
     public init(
         _ attemptToFulfill: @escaping (@escaping Promise) -> Void
     ) {
-        attemptToFulfill { result in
-            self._lock.do {
-                guard self.result == nil else { return }
-                self.result = result
-                self._publish(result)
-            }
-        }
+        attemptToFulfill(self.promise)
     }
 
     deinit {
-        _lock.deallocate()
+        lock.deallocate()
     }
 
-    /// 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<Downstream: Subscriber>(
-        subscriber: Downstream
-    ) where Output == Downstream.Input, Failure == Downstream.Failure {
-        let subscription = Conduit(parent: self,
-                                   downstream: AnySubscriber(subscriber))
-
-        _subscriptions.append(subscription)
-       subscriber.receive(subscription: subscription)
-    }
-
-    private func _acknowledgeDownstreamDemand() {
-        _lock.do {
-            guard let result = result else { return }
-            _publish(result)
+    private func promise(_ result: Result<Output, Failure>) {
+        lock.lock()
+        guard self.result == nil else {
+            lock.unlock()
+            return
+        }
+        self.result = result
+        let downstreams = self.downstreams
+        self.downstreams.removeAll()
+        lock.unlock()
+        switch result {
+        case .success(let output):
+            downstreams.forEach { $0.offer(output) }
+        case .failure(let error):
+            downstreams.forEach { $0.finish(completion: .failure(error)) }
         }
     }
 
-    private func _publish(_ result: Result<Output, Failure>) {
-        for subscription in self._subscriptions where !subscription._isCompleted {
-            switch result {
-            case let .success(output) where subscription._demand > 0:
-                subscription._demand -= 1
-                subscription._demand += subscription._downstream?.receive(output) ?? .none
-                subscription._receive(completion: .finished)
-            case let .failure(error):
-                subscription._receive(completion: .failure(error))
-
-            // nothing to do if no demand
-            default: ()
-            }
+    public func receive<Downstream: Subscriber>(subscriber: Downstream)
+        where Output == Downstream.Input, Failure == Downstream.Failure
+    {
+        let conduit = Conduit(parent: self, downstream: subscriber)
+        lock.lock()
+        if let result = self.result {
+            downstreams.insert(conduit)
+            lock.unlock()
+            subscriber.receive(subscription: conduit)
+            conduit.fulfill(result)
+        } else {
+            downstreams.insert(conduit)
+            lock.unlock()
+            subscriber.receive(subscription: conduit)
         }
     }
+
+    private func disassociate(_ conduit: ConduitBase<Output, Failure>) {
+        lock.lock()
+        downstreams.remove(conduit)
+        lock.unlock()
+    }
 }
 
 extension Future {
 
-    fileprivate final class Conduit: Subscription {
+    private final class Conduit<Downstream: Subscriber>
+        : ConduitBase<Output, Failure>,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == Output, Downstream.Failure == Failure
+    {
 
-        fileprivate var _parent: Future<Output, Failure>?
+        fileprivate var parent: Future?
 
-        fileprivate var _downstream: AnySubscriber<Output, Failure>?
+        fileprivate var downstream: Downstream?
 
-        fileprivate var _demand: Subscribers.Demand = .none
+        fileprivate var hasAnyDemand = false
 
-        fileprivate var _isCompleted: Bool {
-            return _parent == nil
+        private var lock = UnfairLock.allocate()
+
+        private var downstreamLock = UnfairRecursiveLock.allocate()
+
+        fileprivate init(parent: Future, downstream: Downstream) {
+            self.parent = parent
+            self.downstream = downstream
         }
 
-        fileprivate init(parent: Future<Output, Failure>,
-                         downstream: AnySubscriber<Output, Failure>) {
-            _parent = parent
-            _downstream = downstream
+        deinit {
+            lock.deallocate()
+            downstreamLock.deallocate()
         }
 
-        fileprivate func _receive(completion: Subscribers.Completion<Failure>) {
-            if !_isCompleted {
-                _parent = nil
-                _downstream?.receive(completion: completion)
+        fileprivate func fulfill(_ result: Result<Output, Failure>) {
+            lock.lock()
+            guard let downstream = self.downstream else {
+                lock.unlock()
+                return
+            }
+            let parent = self.parent
+            if case .success = result, !hasAnyDemand {
+                lock.unlock()
+                return
+            }
+            self.downstream = nil
+            self.parent = nil
+            lock.unlock()
+            downstreamLock.lock()
+            switch result {
+            case .success(let output):
+                _ = downstream.receive(output)
+                downstream.receive(completion: .finished)
+            case .failure(let error):
+                downstream.receive(completion: .failure(error))
+            }
+            downstreamLock.unlock()
+            parent?.disassociate(self)
+        }
+
+        override func offer(_ output: Output) {
+            fulfill(.success(output))
+        }
+
+        override func finish(completion: Subscribers.Completion<Failure>) {
+            switch completion {
+            case .finished:
+                assertionFailure("unreachable")
+            case .failure(let error):
+                fulfill(.failure(error))
             }
         }
 
-        fileprivate func request(_ demand: Subscribers.Demand) {
+        override func request(_ demand: Subscribers.Demand) {
             demand.assertNonZero()
-            _parent?._lock.do {
-                _demand += demand
+            lock.lock()
+            guard let downstream = self.downstream, let parent = self.parent else {
+                lock.unlock()
+                return
             }
-            _parent?._acknowledgeDownstreamDemand()
+            hasAnyDemand = true
+
+            parent.lock.lock()
+            guard let result = parent.result else {
+                parent.lock.unlock()
+                lock.unlock()
+                return
+            }
+            parent.lock.unlock()
+            self.downstream = nil
+            self.parent = nil
+            lock.unlock()
+            downstreamLock.lock()
+            switch result {
+            case .success(let output):
+                _ = downstream.receive(output)
+                downstream.receive(completion: .finished)
+            case .failure(let error):
+                // This branch is not reachable under normal circumstances,
+                // but may be reachable in case of a race condition.
+                downstream.receive(completion: .failure(error))
+            }
+            downstreamLock.unlock()
+            parent.disassociate(self)
         }
 
-        fileprivate func cancel() {
-            _parent = nil
+        override func cancel() {
+            lock.lock()
+            if self.downstream == nil {
+                lock.unlock()
+                return
+            }
+            self.downstream = nil
+            let parent = self.parent
+            self.parent = nil
+            lock.unlock()
+            parent?.disassociate(self)
         }
+
+        var description: String { return "Future" }
+
+        var customMirror: Mirror {
+            lock.lock()
+            defer { lock.unlock() }
+            let children: [Mirror.Child] = [
+                ("parent", parent as Any),
+                ("downstream", downstream as Any),
+                ("hasAnyDemand", hasAnyDemand),
+                ("subject", parent as Any)
+            ]
+            return Mirror(self, children: children)
+        }
+
+        var playgroundDescription: Any { return description }
     }
 }
-
-extension Future.Conduit: CustomStringConvertible {
-    fileprivate var description: String { return "Future" }
-}

Sources/OpenCombine/Helpers/ConduitBase.swift

@@ -0,0 +1,40 @@
+//
+//  ConduitBase.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 25.06.2020.
+//
+
+internal class ConduitBase<Output, Failure: Error>: Subscription {
+
+    internal init() {}
+
+    internal func offer(_ output: Output) {
+        abstractMethod()
+    }
+
+    internal func finish(completion: Subscribers.Completion<Failure>) {
+        abstractMethod()
+    }
+
+    internal func request(_ demand: Subscribers.Demand) {
+        abstractMethod()
+    }
+
+    internal func cancel() {
+        abstractMethod()
+    }
+}
+
+extension ConduitBase: Equatable {
+    internal static func == (lhs: ConduitBase<Output, Failure>,
+                             rhs: ConduitBase<Output, Failure>) -> Bool {
+        return ObjectIdentifier(lhs) == ObjectIdentifier(rhs)
+    }
+}
+
+extension ConduitBase: Hashable {
+    internal func hash(into hasher: inout Hasher) {
+        hasher.combine(ObjectIdentifier(self))
+    }
+}

Sources/OpenCombine/Helpers/ConduitList.swift

@@ -0,0 +1,57 @@
+//
+//  ConduitList.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 25.06.2020.
+//
+
+internal enum ConduitList<Output, Failure: Error> {
+    case empty
+    case single(ConduitBase<Output, Failure>)
+    case many(Set<ConduitBase<Output, Failure>>)
+}
+
+extension ConduitList {
+    internal mutating func insert(_ conduit: ConduitBase<Output, Failure>) {
+        switch self {
+        case .empty:
+            self = .single(conduit)
+        case .single(conduit):
+            break // This element already exists.
+        case .single(let existingConduit):
+            self = .many([existingConduit, conduit])
+        case .many(var set):
+            set.insert(conduit)
+            self = .many(set)
+        }
+    }
+
+    internal func forEach(
+        _ body: (ConduitBase<Output, Failure>) throws -> Void
+    ) rethrows {
+        switch self {
+        case .empty:
+            break
+        case .single(let conduit):
+            try body(conduit)
+        case .many(let set):
+            try set.forEach(body)
+        }
+    }
+
+    internal mutating func remove(_ conduit: ConduitBase<Output, Failure>) {
+        switch self {
+        case .single(conduit):
+            self = .empty
+        case .empty, .single:
+            break
+        case .many(var set):
+            set.remove(conduit)
+            self = .many(set)
+        }
+    }
+
+    internal mutating func removeAll() {
+        self = .empty
+    }
+}

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,13 +5,11 @@
 //  Created by Sergej Jaskiewicz on 23.10.2019.
 //
 
-import COpenCombineHelpers
-
 /// A helper class that acts like both subscriber and subscription.
 ///
 /// Filter-like operators send an instance of their `Inner` class that is subclass
 /// of this class to the upstream publisher (as subscriber) and
-/// to the downstream subcriber (as subscription).
+/// to the downstream subscriber (as subscription).
 ///
 /// Filter-like operators include `Publishers.Filter`,
 /// `Publishers.RemoveDuplicates`, `Publishers.PrefixWhile` and more.

Sources/OpenCombine/Helpers/Locking.swift

@@ -5,14 +5,9 @@
 //  Created by Sergej Jaskiewicz on 11.06.2019.
 //
 
+#if canImport(COpenCombineHelpers)
 import COpenCombineHelpers
+#endif
 
-extension UnfairRecursiveLock {
-
-    @inlinable
-    internal func `do`<Result>(_ body: () throws -> Result) rethrows -> Result {
-        lock()
-        defer { unlock() }
-        return try body()
-    }
-}
+internal typealias UnfairLock = __UnfairLock
+internal typealias UnfairRecursiveLock = __UnfairRecursiveLock

Sources/OpenCombine/Helpers/ReduceProducer.swift

@@ -5,13 +5,11 @@
 //  Created by Sergej Jaskiewicz on 22.09.2019.
 //
 
-import COpenCombineHelpers
-
 /// A helper class that acts like both subscriber and subscription.
 ///
 /// Reduce-like operators send an instance of their `Inner` class that is subclass
 /// of this class to the upstream publisher (as subscriber) and
-/// to the downstream subcriber (as subsription).
+/// to the downstream subscriber (as subscription).
 ///
 /// Reduce-like operators include `Publishers.Reduce`, `Publishers.TryReduce`,
 /// `Publishers.Count`, `Publishers.FirstWhere`, `Publishers.AllSatisfy` and more.

Sources/OpenCombine/Helpers/SubjectSubscriber.swift

@@ -5,8 +5,6 @@
 //  Created by Sergej Jaskiewicz on 16/09/2019.
 //
 
-import COpenCombineHelpers
-
 // NOTE: This class has been audited for thread safety.
 internal final class SubjectSubscriber<Downstream: Subject>
     : Subscriber,
@@ -42,23 +40,21 @@ internal final class SubjectSubscriber<Downstream: Subject>
 
     internal func receive(_ input: Downstream.Output) -> Subscribers.Demand {
         lock.lock()
-        guard let downstreamSubject = downstreamSubject else {
+        guard let subject = downstreamSubject, upstreamSubscription != nil else {
             lock.unlock()
             return .none
         }
-        guard upstreamSubscription != nil else { APIViolationValueBeforeSubscription() }
         lock.unlock()
-        downstreamSubject.send(input)
+        subject.send(input)
         return .none
     }
 
     internal func receive(completion: Subscribers.Completion<Downstream.Failure>) {
         lock.lock()
-        guard let subject = downstreamSubject else {
+        guard let subject = downstreamSubject, upstreamSubscription != nil else {
             lock.unlock()
             return
         }
-        guard upstreamSubscription != nil else { APIViolationUnexpectedCompletion() }
         lock.unlock()
         subject.send(completion: completion)
         downstreamSubject = nil
@@ -89,11 +85,7 @@ internal final class SubjectSubscriber<Downstream: Subject>
 
     internal func cancel() {
         lock.lock()
-        if isCancelled {
-            lock.unlock()
-            return
-        }
-        guard let subscription = upstreamSubscription else {
+        guard !isCancelled, let subscription = upstreamSubscription else {
             lock.unlock()
             return
         }

Sources/OpenCombine/Helpers/SubscriptionStatus.swift

@@ -10,3 +10,14 @@ internal enum SubscriptionStatus {
     case subscribed(Subscription)
     case terminal
 }
+
+extension SubscriptionStatus {
+    internal var isAwaitingSubscription: Bool {
+        switch self {
+        case .awaitingSubscription:
+            return true
+        default:
+            return false
+        }
+    }
+}

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`.
@@ -159,19 +67,126 @@ public final class ObservableObjectPublisher: Publisher {
 
     public typealias Failure = Never
 
-    private let subject: PassthroughSubject<Void, Never>
+    private let lock = UnfairLock.allocate()
 
-    public init() {
-        subject = .init()
+    private var connections = Set<Conduit>()
+
+    // TODO: Combine needs this for some reason
+    private var identifier: ObjectIdentifier?
+
+    public init() {}
+
+    deinit {
+        lock.deallocate()
     }
 
     public func receive<Downstream: Subscriber>(subscriber: Downstream)
         where Downstream.Input == Void, Downstream.Failure == Never
     {
-        subject.subscribe(subscriber)
+        let inner = Inner(downstream: subscriber, parent: self)
+        lock.lock()
+        connections.insert(inner)
+        lock.unlock()
+        subscriber.receive(subscription: inner)
     }
 
     public func send() {
-        subject.send()
+        lock.lock()
+        let connections = self.connections
+        lock.unlock()
+        for connection in connections {
+            connection.send()
+        }
+    }
+
+    private func remove(_ conduit: Conduit) {
+        lock.lock()
+        connections.remove(conduit)
+        lock.unlock()
+    }
+}
+
+extension ObservableObjectPublisher {
+    private class Conduit: Hashable {
+
+        fileprivate func send() {
+            abstractMethod()
+        }
+
+        fileprivate static func == (lhs: Conduit, rhs: Conduit) -> Bool {
+            return lhs === rhs
+        }
+
+        fileprivate func hash(into hasher: inout Hasher) {
+            hasher.combine(ObjectIdentifier(self))
+        }
+    }
+
+    private final class Inner<Downstream: Subscriber>
+        : Conduit,
+          Subscription,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == Void, Downstream.Failure == Never
+    {
+        private enum State {
+            case initialized
+            case active
+            case terminal
+        }
+
+        private weak var parent: ObservableObjectPublisher?
+        private let downstream: Downstream
+        private let downstreamLock = UnfairRecursiveLock.allocate()
+        private let lock = UnfairLock.allocate()
+        private var state = State.initialized
+
+        init(downstream: Downstream, parent: ObservableObjectPublisher) {
+            self.parent = parent
+            self.downstream = downstream
+        }
+
+        deinit {
+            downstreamLock.deallocate()
+            lock.deallocate()
+        }
+
+        override func send() {
+            lock.lock()
+            let state = self.state
+            lock.unlock()
+            if state == .active {
+                downstreamLock.lock()
+                _ = downstream.receive()
+                downstreamLock.unlock()
+            }
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            lock.lock()
+            if state == .initialized {
+                state = .active
+            }
+            lock.unlock()
+        }
+
+        func cancel() {
+            lock.lock()
+            state = .terminal
+            lock.unlock()
+            parent?.remove(self)
+        }
+
+        var description: String { return "ObservableObjectPublisher" }
+
+        var customMirror: Mirror {
+            let children = CollectionOfOne<Mirror.Child>(("downstream", downstream))
+            return Mirror(self, children: children)
+        }
+
+        var playgroundDescription: Any {
+            return description
+        }
     }
 }

Sources/OpenCombine/PassthroughSubject.swift

@@ -5,20 +5,19 @@
 //  Created by Sergej Jaskiewicz on 11.06.2019.
 //
 
-import COpenCombineHelpers
-
 /// A subject that passes along values and completion.
 ///
 /// Use a `PassthroughSubject` in unit tests when you want a publisher than can publish
 /// specific values on-demand during tests.
-public final class PassthroughSubject<Output, Failure: Error>: Subject  {
+public final class PassthroughSubject<Output, Failure: Error>: Subject {
 
-    private let _lock = UnfairRecursiveLock.allocate()
+    private let lock = UnfairLock.allocate()
 
-    private var _completion: Subscribers.Completion<Failure>?
+    private var active = true
 
-    // TODO: Combine uses bag data structure
-    private var _subscriptions: [Conduit] = []
+    private var completion: Subscribers.Completion<Failure>?
+
+    private var downstreams = ConduitList<Output, Failure>.empty
 
     internal var upstreamSubscriptions: [Subscription] = []
 
@@ -27,112 +26,197 @@ public final class PassthroughSubject<Output, Failure: Error>: Subject  {
     public init() {}
 
     deinit {
-        for subscription in _subscriptions {
-            subscription._downstream = nil
+        for subscription in upstreamSubscriptions {
+            subscription.cancel()
         }
-        _lock.deallocate()
+        lock.deallocate()
     }
 
     public func send(subscription: Subscription) {
-        _lock.do {
-            upstreamSubscriptions.append(subscription)
-            if hasAnyDownstreamDemand {
-                subscription.request(.unlimited)
-            }
+        lock.lock()
+        upstreamSubscriptions.append(subscription)
+        let hasAnyDownstreamDemand = self.hasAnyDownstreamDemand
+        lock.unlock()
+        if hasAnyDownstreamDemand {
+            subscription.request(.unlimited)
         }
     }
 
     public func receive<Downstream: Subscriber>(subscriber: Downstream)
         where Output == Downstream.Input, Failure == Downstream.Failure
     {
-        _lock.do {
-            if let completion = _completion {
-                subscriber.receive(subscription: Subscriptions.empty)
-                subscriber.receive(completion: completion)
-                return
-            } else {
-                let subscription = Conduit(parent: self,
-                                           downstream: AnySubscriber(subscriber))
-
-                _subscriptions.append(subscription)
-                subscriber.receive(subscription: subscription)
-            }
+        lock.lock()
+        if active {
+            let conduit = Conduit(parent: self, downstream: subscriber)
+            downstreams.insert(conduit)
+            lock.unlock()
+            subscriber.receive(subscription: conduit)
+        } else {
+            let completion = self.completion!
+            lock.unlock()
+            subscriber.receive(subscription: Subscriptions.empty)
+            subscriber.receive(completion: completion)
         }
     }
 
     public func send(_ input: Output) {
-        _lock.do {
-            for subscription in _subscriptions
-                where !subscription._isCompleted && subscription._demand > 0
-            {
-                let newDemand = subscription._downstream?.receive(input) ?? .none
-                subscription._demand += newDemand
-                subscription._demand -= 1
-            }
+        lock.lock()
+        guard active else {
+            lock.unlock()
+            return
+        }
+        let downstreams = self.downstreams
+        lock.unlock()
+        downstreams.forEach { conduit in
+            conduit.offer(input)
         }
     }
 
     public func send(completion: Subscribers.Completion<Failure>) {
-        _lock.do {
-            _completion = completion
-            for subscriber in _subscriptions {
-                subscriber._receive(completion: completion)
-            }
+        lock.lock()
+        guard active else {
+            lock.unlock()
+            return
+        }
+        active = false
+        self.completion = completion
+        let downstreams = self.downstreams
+        self.downstreams.removeAll()
+        lock.unlock()
+        downstreams.forEach { conduit in
+            conduit.finish(completion: completion)
         }
     }
 
-    private func _acknowledgeDownstreamDemand() {
-        _lock.do {
-            guard !hasAnyDownstreamDemand else { return }
-            hasAnyDownstreamDemand = true
-            for subscription in upstreamSubscriptions {
-                subscription.request(.unlimited)
-            }
+    private func acknowledgeDownstreamDemand() {
+        lock.lock()
+        if hasAnyDownstreamDemand {
+            lock.unlock()
+            return
         }
+        hasAnyDownstreamDemand = true
+        let upstreamSubscriptions = self.upstreamSubscriptions
+        lock.unlock()
+        for subscription in upstreamSubscriptions {
+            subscription.request(.unlimited)
+        }
+    }
+
+    private func disassociate(_ conduit: ConduitBase<Output, Failure>) {
+        lock.lock()
+        guard active else {
+            lock.unlock()
+            return
+        }
+        downstreams.remove(conduit)
+        lock.unlock()
     }
 }
 
 extension PassthroughSubject {
 
-    fileprivate final class Conduit: Subscription {
+    private final class Conduit<Downstream: Subscriber>
+        : ConduitBase<Output, Failure>,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == Output, Downstream.Failure == Failure
+    {
 
-        fileprivate var _parent: PassthroughSubject?
+        fileprivate var parent: PassthroughSubject?
 
-        fileprivate var _downstream: AnySubscriber<Output, Failure>?
+        fileprivate var downstream: Downstream?
 
-        fileprivate var _demand: Subscribers.Demand = .none
+        fileprivate var demand = Subscribers.Demand.none
 
-        fileprivate var _isCompleted: Bool {
-            return _parent == nil
-        }
+        private var lock = UnfairLock.allocate()
+
+        private var downstreamLock = UnfairRecursiveLock.allocate()
 
         fileprivate init(parent: PassthroughSubject,
-                         downstream: AnySubscriber<Output, Failure>) {
-            _parent = parent
-            _downstream = downstream
+                         downstream: Downstream) {
+            self.parent = parent
+            self.downstream = downstream
         }
 
-        fileprivate func _receive(completion: Subscribers.Completion<Failure>) {
-            if !_isCompleted {
-                _parent = nil
-                _downstream?.receive(completion: completion)
+        deinit {
+            lock.deallocate()
+            downstreamLock.deallocate()
+        }
+
+        override func offer(_ output: Output) {
+            lock.lock()
+            guard demand > 0, let downstream = self.downstream else {
+                lock.unlock()
+                return
             }
+            demand -= 1
+            lock.unlock()
+            downstreamLock.lock()
+            let newDemand = downstream.receive(output)
+            downstreamLock.unlock()
+            guard newDemand > 0 else { return }
+            lock.lock()
+            demand += newDemand
+            lock.unlock()
         }
 
-        fileprivate func request(_ demand: Subscribers.Demand) {
+        override func finish(completion: Subscribers.Completion<Failure>) {
+            lock.lock()
+            guard let downstream = self.downstream else {
+                lock.unlock()
+                return
+            }
+            self.downstream = nil
+            let parent = self.parent
+            self.parent = nil
+            lock.unlock()
+            parent?.disassociate(self)
+            downstreamLock.lock()
+            downstream.receive(completion: completion)
+            downstreamLock.unlock()
+        }
+
+        override func request(_ demand: Subscribers.Demand) {
             demand.assertNonZero()
-            _parent?._lock.do {
-                _demand += demand
+            lock.lock()
+            if self.downstream == nil {
+                lock.unlock()
+                return
             }
-            _parent?._acknowledgeDownstreamDemand()
+            self.demand += demand
+            let parent = self.parent
+            lock.unlock()
+            parent?.acknowledgeDownstreamDemand()
         }
 
-        fileprivate func cancel() {
-            _parent = nil
+        override func cancel() {
+            lock.lock()
+            if self.downstream == nil {
+                lock.unlock()
+                return
+            }
+            self.downstream = nil
+            let parent = self.parent
+            self.parent = nil
+            lock.unlock()
+            parent?.disassociate(self)
         }
+
+        var description: String { return "PassthroughSubject" }
+
+        var customMirror: Mirror {
+            lock.lock()
+            defer { lock.unlock() }
+            let children: [Mirror.Child] = [
+                ("parent", parent as Any),
+                ("downstream", downstream as Any),
+                ("demand", demand),
+                ("subject", parent as Any)
+            ]
+            return Mirror(self, children: children)
+        }
+
+        var playgroundDescription: Any { return description }
     }
 }
-
-extension PassthroughSubject.Conduit: CustomStringConvertible {
-    fileprivate var description: String { return "PassthroughSubject" }
-}

Sources/OpenCombine/Published.swift

@@ -18,8 +18,7 @@
 @propertyWrapper
 public struct Published<Value> {
 
-    /// Initialize the storage of the `Published` property as well as the corresponding
-    /// `Publisher`.
+    @inlinable // trivially forwarding
     public init(initialValue: Value) {
         self.init(wrappedValue: initialValue)
     }

Sources/OpenCombine/Publishers/GENERATED-Publishers.Catch.swift

@@ -0,0 +1,620 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃                                                                                     ┃
+// ┃                   Auto-generated from GYB template. DO NOT EDIT!                    ┃
+// ┃                                                                                     ┃
+// ┃                                                                                     ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+//
+//  Publishers.Catch.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 25.12.2019.
+//
+
+extension Publisher {
+
+    /// Handles errors from an upstream publisher by replacing it with another publisher.
+    ///
+    /// The following example replaces any error from the upstream publisher and replaces
+    /// the upstream with a `Just` publisher. This continues the stream by publishing
+    /// a single value and completing normally.
+    /// ```
+    /// enum SimpleError: Error { case error }
+    /// let errorPublisher = (0..<10).publisher.tryMap { v -> Int in
+    ///     if v < 5 {
+    ///         return v
+    ///     } else {
+    ///         throw SimpleError.error
+    ///     }
+    /// }
+    ///
+    /// let noErrorPublisher = errorPublisher.catch { _ in
+    ///     return Just(100)
+    /// }
+    /// ```
+    /// Backpressure note: This publisher passes through `request` and `cancel` to
+    /// the upstream. After receiving an error, the publisher sends sends any unfulfilled
+    /// demand to the new `Publisher`.
+    ///
+    /// - Parameter handler: A closure that accepts the upstream failure as input and
+    ///   returns a publisher to replace the upstream publisher.
+    /// - Returns: A publisher that handles errors from an upstream publisher by replacing
+    ///   the failed publisher with another publisher.
+    public func `catch`<NewPublisher: Publisher>(
+        _ handler: @escaping (Failure) -> NewPublisher
+    ) -> Publishers.Catch<Self, NewPublisher>
+        where NewPublisher.Output == Output
+    {
+        return .init(upstream: self, handler: handler)
+    }
+
+    /// Handles errors from an upstream publisher by either replacing it with another
+    /// publisher or `throw`ing  a new error.
+    ///
+    /// - Parameter handler: A `throw`ing closure that accepts the upstream failure as
+    ///   input and returns a publisher to replace the upstream publisher or if an error
+    ///   is thrown will send the error downstream.
+    /// - Returns: A publisher that handles errors from an upstream publisher by replacing
+    ///   the failed publisher with another publisher.
+    public func tryCatch<NewPublisher: Publisher>(
+        _ handler: @escaping (Failure) throws -> NewPublisher
+    ) -> Publishers.TryCatch<Self, NewPublisher>
+        where NewPublisher.Output == Output
+    {
+        return .init(upstream: self, handler: handler)
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that handles errors from an upstream publisher by replacing the failed
+    /// publisher with another publisher.
+    public struct Catch<Upstream: Publisher, NewPublisher: Publisher>: Publisher
+        where Upstream.Output == NewPublisher.Output
+    {
+        public typealias Output = Upstream.Output
+
+        public typealias Failure = NewPublisher.Failure
+
+        /// The publisher that this publisher receives elements from.
+        public let upstream: Upstream
+
+        /// A closure that accepts the upstream failure as input and returns a publisher
+        /// to replace the upstream publisher.
+        public let handler: (Upstream.Failure) -> NewPublisher
+
+        /// Creates a publisher that handles errors from an upstream publisher by
+        /// replacing the failed publisher with another publisher.
+        ///
+        /// - Parameters:
+        ///   - upstream: The publisher that this publisher receives elements from.
+        ///   - handler: A closure that accepts the upstream failure as input and returns
+        ///     a publisher to replace the upstream publisher.
+        public init(upstream: Upstream,
+                    handler: @escaping (Upstream.Failure) -> NewPublisher) {
+            self.upstream = upstream
+            self.handler = handler
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Downstream.Input == Output, Downstream.Failure == Failure
+        {
+            let inner = Inner(downstream: subscriber, handler: handler)
+            let uncaughtS = Inner.UncaughtS(inner: inner)
+            upstream.subscribe(uncaughtS)
+        }
+    }
+
+    /// A publisher that handles errors from an upstream publisher by replacing the failed
+    /// publisher with another publisher or optionally producing a new error.
+    public struct TryCatch<Upstream: Publisher, NewPublisher: Publisher>: Publisher
+        where Upstream.Output == NewPublisher.Output
+    {
+        public typealias Output = Upstream.Output
+
+        public typealias Failure = Error
+
+        public let upstream: Upstream
+
+        public let handler: (Upstream.Failure) throws -> NewPublisher
+
+        public init(upstream: Upstream,
+                    handler: @escaping (Upstream.Failure) throws -> NewPublisher) {
+            self.upstream = upstream
+            self.handler = handler
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Downstream.Input == Output, Downstream.Failure == Failure
+        {
+            let inner = Inner(downstream: subscriber, handler: handler)
+            let uncaughtS = Inner.UncaughtS(inner: inner)
+            upstream.subscribe(uncaughtS)
+        }
+    }
+}
+
+extension Publishers.Catch {
+    private final class Inner<Downstream: Subscriber>
+        : Subscription,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == Upstream.Output,
+              Downstream.Failure == NewPublisher.Failure
+    {
+        struct UncaughtS: Subscriber,
+                          CustomStringConvertible,
+                          CustomReflectable,
+                          CustomPlaygroundDisplayConvertible
+        {
+            typealias Input = Upstream.Output
+
+            typealias Failure = Upstream.Failure
+
+            let inner: Inner
+
+            var combineIdentifier: CombineIdentifier { return inner.combineIdentifier }
+
+            func receive(subscription: Subscription) {
+                inner.receivePre(subscription: subscription)
+            }
+
+            func receive(_ input: Input) -> Subscribers.Demand {
+                return inner.receivePre(input)
+            }
+
+            func receive(completion: Subscribers.Completion<Failure>) {
+                return inner.receivePre(completion: completion)
+            }
+
+            var description: String { return inner.description }
+
+            var customMirror: Mirror { return inner.customMirror }
+
+            var playgroundDescription: Any { return description }
+        }
+
+        struct CaughtS: Subscriber,
+                        CustomStringConvertible,
+                        CustomReflectable,
+                        CustomPlaygroundDisplayConvertible
+        {
+            typealias Input = NewPublisher.Output
+
+            typealias Failure = NewPublisher.Failure
+
+            let inner: Inner
+
+            var combineIdentifier: CombineIdentifier { return inner.combineIdentifier }
+
+            func receive(subscription: Subscription) {
+                inner.receivePost(subscription: subscription)
+            }
+
+            func receive(_ input: Input) -> Subscribers.Demand {
+                return inner.receivePost(input)
+            }
+
+            func receive(completion: Subscribers.Completion<Failure>) {
+                inner.receivePost(completion: completion)
+            }
+
+            var description: String { return inner.description }
+
+            var customMirror: Mirror { return inner.customMirror }
+
+            var playgroundDescription: Any { return description }
+        }
+
+        private enum State {
+            case pendingPre
+            case pre(Subscription)
+            case pendingPost
+            case post(Subscription)
+            case cancelled
+        }
+
+        private let lock = UnfairLock.allocate()
+
+        private var demand = Subscribers.Demand.none
+
+        private var state = State.pendingPre
+
+        private let downstream: Downstream
+
+        private let handler: (Upstream.Failure) -> NewPublisher
+
+        init(downstream: Downstream,
+             handler: @escaping (Upstream.Failure) -> NewPublisher) {
+            self.downstream = downstream
+            self.handler = handler
+        }
+
+        deinit {
+            lock.deallocate()
+        }
+
+        func receivePre(subscription: Subscription) {
+            lock.lock()
+            guard case .pendingPre = state else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            state = .pre(subscription)
+            lock.unlock()
+            downstream.receive(subscription: self)
+        }
+
+        func receivePre(_ input: Upstream.Output) -> Subscribers.Demand {
+            lock.lock()
+            demand -= 1
+            lock.unlock()
+            let newDemand = downstream.receive(input)
+            lock.lock()
+            demand += newDemand
+            lock.unlock()
+            return newDemand
+        }
+
+        func receivePre(completion: Subscribers.Completion<Upstream.Failure>) {
+            switch completion {
+            case .finished:
+                lock.lock()
+                switch state {
+                case .pre:
+                    state = .cancelled
+                    lock.unlock()
+                    downstream.receive(completion: .finished)
+                case .pendingPre, .pendingPost, .post, .cancelled:
+                    lock.unlock()
+                }
+            case .failure(let error):
+                lock.lock()
+                switch state {
+                case .pre:
+                    state = .pendingPost
+                    lock.unlock()
+                    handler(error).subscribe(CaughtS(inner: self))
+                case .cancelled:
+                    lock.unlock()
+                case .pendingPre, .post, .pendingPost:
+                    completionBeforeSubscription()
+                }
+            }
+        }
+
+        func receivePost(subscription: Subscription) {
+            lock.lock()
+            guard case .pendingPost = state else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            state = .post(subscription)
+            let demand = self.demand
+            lock.unlock()
+            if demand > 0 {
+                subscription.request(demand)
+            }
+        }
+
+        func receivePost(_ input: NewPublisher.Output) -> Subscribers.Demand {
+            return downstream.receive(input)
+        }
+
+        func receivePost(completion: Subscribers.Completion<NewPublisher.Failure>) {
+            lock.lock()
+            guard case .post = state else {
+                lock.unlock()
+                return
+            }
+            state = .cancelled
+            lock.unlock()
+            downstream.receive(completion: completion)
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            demand.assertNonZero()
+            lock.lock()
+            switch state {
+            case .pendingPre:
+                // The client is only able to call the `request` method after we've sent
+                // `self` downstream. We only do it in the `receivePre(subscription:)`
+                // method, after setting `state` to `pre`.
+                // After that `state` never becomes `pendingPre`.
+                requestBeforeSubscription()
+            case let .pre(subscription):
+                self.demand += demand
+                lock.unlock()
+                subscription.request(demand)
+            case .pendingPost:
+                self.demand += demand
+                lock.unlock()
+            case let .post(subscription):
+                lock.unlock()
+                subscription.request(demand)
+            case .cancelled:
+                lock.unlock()
+            }
+        }
+
+        func cancel() {
+            lock.lock()
+            switch state {
+            case let .pre(subscription), let .post(subscription):
+                state = .cancelled
+                lock.unlock()
+                subscription.cancel()
+            case .pendingPre, .pendingPost, .cancelled:
+                lock.unlock()
+            }
+        }
+
+        var description: String { return "Catch" }
+
+        var customMirror: Mirror {
+            let children: [Mirror.Child] = [
+                ("downstream", downstream),
+                ("demand", demand)
+            ]
+            return Mirror(self, children: children)
+        }
+
+        var playgroundDescription: Any { return description }
+    }
+}
+
+extension Publishers.TryCatch {
+    private final class Inner<Downstream: Subscriber>
+        : Subscription,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == Upstream.Output,
+              Downstream.Failure == Error
+    {
+        struct UncaughtS: Subscriber,
+                          CustomStringConvertible,
+                          CustomReflectable,
+                          CustomPlaygroundDisplayConvertible
+        {
+            typealias Input = Upstream.Output
+
+            typealias Failure = Upstream.Failure
+
+            let inner: Inner
+
+            var combineIdentifier: CombineIdentifier { return inner.combineIdentifier }
+
+            func receive(subscription: Subscription) {
+                inner.receivePre(subscription: subscription)
+            }
+
+            func receive(_ input: Input) -> Subscribers.Demand {
+                return inner.receivePre(input)
+            }
+
+            func receive(completion: Subscribers.Completion<Failure>) {
+                return inner.receivePre(completion: completion)
+            }
+
+            var description: String { return inner.description }
+
+            var customMirror: Mirror { return inner.customMirror }
+
+            var playgroundDescription: Any { return description }
+        }
+
+        struct CaughtS: Subscriber,
+                        CustomStringConvertible,
+                        CustomReflectable,
+                        CustomPlaygroundDisplayConvertible
+        {
+            typealias Input = NewPublisher.Output
+
+            typealias Failure = NewPublisher.Failure
+
+            let inner: Inner
+
+            var combineIdentifier: CombineIdentifier { return inner.combineIdentifier }
+
+            func receive(subscription: Subscription) {
+                inner.receivePost(subscription: subscription)
+            }
+
+            func receive(_ input: Input) -> Subscribers.Demand {
+                return inner.receivePost(input)
+            }
+
+            func receive(completion: Subscribers.Completion<Failure>) {
+                inner.receivePost(completion: completion)
+            }
+
+            var description: String { return inner.description }
+
+            var customMirror: Mirror { return inner.customMirror }
+
+            var playgroundDescription: Any { return description }
+        }
+
+        private enum State {
+            case pendingPre
+            case pre(Subscription)
+            case pendingPost
+            case post(Subscription)
+            case cancelled
+        }
+
+        private let lock = UnfairLock.allocate()
+
+        private var demand = Subscribers.Demand.none
+
+        private var state = State.pendingPre
+
+        private let downstream: Downstream
+
+        private let handler: (Upstream.Failure) throws -> NewPublisher
+
+        init(downstream: Downstream,
+             handler: @escaping (Upstream.Failure) throws -> NewPublisher) {
+            self.downstream = downstream
+            self.handler = handler
+        }
+
+        deinit {
+            lock.deallocate()
+        }
+
+        func receivePre(subscription: Subscription) {
+            lock.lock()
+            guard case .pendingPre = state else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            state = .pre(subscription)
+            lock.unlock()
+            downstream.receive(subscription: self)
+        }
+
+        func receivePre(_ input: Upstream.Output) -> Subscribers.Demand {
+            lock.lock()
+            demand -= 1
+            lock.unlock()
+            let newDemand = downstream.receive(input)
+            lock.lock()
+            demand += newDemand
+            lock.unlock()
+            return newDemand
+        }
+
+        func receivePre(completion: Subscribers.Completion<Upstream.Failure>) {
+            switch completion {
+            case .finished:
+                lock.lock()
+                switch state {
+                case .pre:
+                    state = .cancelled
+                    lock.unlock()
+                    downstream.receive(completion: .finished)
+                case .pendingPre, .pendingPost, .post, .cancelled:
+                    lock.unlock()
+                }
+            case .failure(let error):
+                lock.lock()
+                switch state {
+                case .pre:
+                    state = .pendingPost
+                    lock.unlock()
+                    do {
+                        try handler(error).subscribe(CaughtS(inner: self))
+                    } catch let anotherError {
+                        lock.lock()
+                        state = .cancelled
+                        lock.unlock()
+                        downstream.receive(completion: .failure(anotherError))
+                    }
+                case .cancelled:
+                    lock.unlock()
+                case .pendingPre, .post, .pendingPost:
+                    completionBeforeSubscription()
+                }
+            }
+        }
+
+        func receivePost(subscription: Subscription) {
+            lock.lock()
+            guard case .pendingPost = state else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            state = .post(subscription)
+            let demand = self.demand
+            lock.unlock()
+            if demand > 0 {
+                subscription.request(demand)
+            }
+        }
+
+        func receivePost(_ input: NewPublisher.Output) -> Subscribers.Demand {
+            return downstream.receive(input)
+        }
+
+        func receivePost(completion: Subscribers.Completion<NewPublisher.Failure>) {
+            lock.lock()
+            guard case .post = state else {
+                lock.unlock()
+                return
+            }
+            state = .cancelled
+            lock.unlock()
+            downstream.receive(completion: completion.eraseError())
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            demand.assertNonZero()
+            lock.lock()
+            switch state {
+            case .pendingPre:
+                // The client is only able to call the `request` method after we've sent
+                // `self` downstream. We only do it in the `receivePre(subscription:)`
+                // method, after setting `state` to `pre`.
+                // After that `state` never becomes `pendingPre`.
+                requestBeforeSubscription()
+            case let .pre(subscription):
+                self.demand += demand
+                lock.unlock()
+                subscription.request(demand)
+            case .pendingPost:
+                self.demand += demand
+                lock.unlock()
+            case let .post(subscription):
+                lock.unlock()
+                subscription.request(demand)
+            case .cancelled:
+                lock.unlock()
+            }
+        }
+
+        func cancel() {
+            lock.lock()
+            switch state {
+            case let .pre(subscription), let .post(subscription):
+                state = .cancelled
+                lock.unlock()
+                subscription.cancel()
+            case .pendingPre, .pendingPost, .cancelled:
+                lock.unlock()
+            }
+        }
+
+        var description: String { return "TryCatch" }
+
+        var customMirror: Mirror {
+            let children: [Mirror.Child] = [
+                ("downstream", downstream),
+                ("demand", demand)
+            ]
+            return Mirror(self, children: children)
+        }
+
+        var playgroundDescription: Any { return description }
+    }
+}
+
+private func completionBeforeSubscription(file: StaticString = #file,
+                                          line: UInt = #line) -> Never {
+    fatalError("Unexpected state: received completion but do not have subscription",
+               file: file,
+               line: line)
+}
+
+private func requestBeforeSubscription(file: StaticString = #file,
+                                       line: UInt = #line) -> Never {
+    fatalError("Unexpected state: request before subscription sent",
+               file: file,
+               line: line)
+}

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/Optional.Publisher.swift

@@ -235,7 +235,7 @@ extension Optional.OCombine.Publisher {
         in range: RangeExpression
     ) -> Optional<Output>.OCombine.Publisher where RangeExpression.Bound == Int {
         let range = range.relative(to: 0 ..< Int.max)
-        precondition(range.lowerBound >= 0, "lowerBould must not be negative")
+        precondition(range.lowerBound >= 0, "lowerBound must not be negative")
 
         // I don't know why, but Combine has this precondition
         precondition(range.upperBound < .max - 1)

Sources/OpenCombine/Publishers/Publishers.AssertNoFailure.swift

@@ -0,0 +1,132 @@
+//
+//  Publishers.AssertNoFailure.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 25.12.2019.
+//
+
+extension Publisher {
+
+    /// Raises a fatal error when its upstream publisher fails, and otherwise republishes
+    /// all received input.
+    ///
+    /// Use this function for internal sanity checks that are active during testing but
+    /// do not impact performance of shipping code.
+    ///
+    /// - Parameters:
+    ///   - prefix: A string used at the beginning of the fatal error message.
+    ///   - file: A filename used in the error message. This defaults to `#file`.
+    ///   - line: A line number used in the error message. This defaults to `#line`.
+    /// - Returns: A publisher that raises a fatal error when its upstream publisher
+    ///   fails.
+    public func assertNoFailure(_ prefix: String = "",
+                                file: StaticString = #file,
+                                line: UInt = #line) -> Publishers.AssertNoFailure<Self> {
+        return .init(upstream: self, prefix: prefix, file: file, line: line)
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that raises a fatal error upon receiving any failure, and otherwise
+    /// republishes all received input.
+    ///
+    /// Use this function for internal sanity checks that are active during testing but
+    /// do not impact performance of shipping code.
+    public struct AssertNoFailure<Upstream: Publisher>: Publisher {
+
+        public typealias Output = Upstream.Output
+
+        public typealias Failure = Never
+
+        /// The publisher from which this publisher receives elements.
+        public let upstream: Upstream
+
+        /// The string used at the beginning of the fatal error message.
+        public let prefix: String
+
+        /// The filename used in the error message.
+        public let file: StaticString
+
+        /// The line number used in the error message.
+        public let line: UInt
+
+        public init(upstream: Upstream, prefix: String, file: StaticString, line: UInt) {
+            self.upstream = upstream
+            self.prefix = prefix
+            self.file = file
+            self.line = line
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Downstream.Input == Output, Downstream.Failure == Never
+        {
+            upstream.subscribe(Inner(downstream: subscriber,
+                                     prefix: prefix,
+                                     file: file,
+                                     line: line))
+        }
+    }
+}
+
+extension Publishers.AssertNoFailure {
+    private struct Inner<Downstream: Subscriber>
+        : Subscriber,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == Upstream.Output, Downstream.Failure == Never
+    {
+        typealias Input = Upstream.Output
+
+        typealias Failure = Upstream.Failure
+
+        private let downstream: Downstream
+
+        private let prefix: String
+
+        private let file: StaticString
+
+        private let line: UInt
+
+        let combineIdentifier = CombineIdentifier()
+
+        init(downstream: Downstream, prefix: String, file: StaticString, line: UInt) {
+            self.downstream = downstream
+            self.prefix = prefix
+            self.file = file
+            self.line = line
+        }
+
+        func receive(subscription: Subscription) {
+            downstream.receive(subscription: subscription)
+        }
+
+        func receive(_ input: Input) -> Subscribers.Demand {
+            return downstream.receive(input)
+        }
+
+        func receive(completion: Subscribers.Completion<Failure>) {
+            switch completion {
+            case .finished:
+                downstream.receive(completion: .finished)
+            case .failure(let error):
+                let prefix = self.prefix.isEmpty ? "" : self.prefix + ": "
+                fatalError("\(prefix)\(error)", file: file, line: line)
+            }
+        }
+
+        var description: String { return "AssertNoFailure" }
+
+        var customMirror: Mirror {
+            let children: [Mirror.Child] = [
+                ("file", file),
+                ("line", line),
+                ("prefix", prefix)
+            ]
+            return Mirror(self, children: children)
+        }
+
+        var playgroundDescription: Any { return description }
+    }
+}

Sources/OpenCombine/Publishers/Publishers.Autoconnect.swift

@@ -5,8 +5,6 @@
 //  Created by Sergej Jaskiewicz on 18/09/2019.
 //
 
-import COpenCombineHelpers
-
 extension ConnectablePublisher {
 
     /// Automates the process of connecting or disconnecting from this connectable

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.Buffer.swift

@@ -0,0 +1,336 @@
+//
+//  Publishers.Buffer.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 08.01.2020.
+//
+
+extension Publisher {
+
+    /// Buffers elements received from an upstream publisher.
+    /// - Parameter size: The maximum number of elements to store.
+    /// - Parameter prefetch: The strategy for initially populating the buffer.
+    /// - Parameter whenFull: The action to take when the buffer becomes full.
+    public func buffer(
+        size: Int,
+        prefetch: Publishers.PrefetchStrategy,
+        whenFull: Publishers.BufferingStrategy<Failure>
+    ) -> Publishers.Buffer<Self> {
+        return .init(upstream: self,
+                     size: size,
+                     prefetch: prefetch,
+                     whenFull: whenFull)
+    }
+}
+
+extension Publishers {
+
+    /// A strategy for filling a buffer.
+    ///
+    /// * keepFull: A strategy to fill the buffer at subscription time, and keep it full
+    ///   thereafter.
+    /// * byRequest: A strategy that avoids prefetching and instead performs requests
+    ///   on demand.
+    public enum PrefetchStrategy {
+
+        /// A strategy to fill the buffer at subscription time, and keep it full
+        /// thereafter.
+        case keepFull
+
+        /// A strategy that avoids prefetching and instead performs requests
+        /// on demand.
+        case byRequest
+    }
+
+    /// A strategy for handling exhaustion of a buffer’s capacity.
+    ///
+    /// * dropNewest: When full, discard the newly-received element without buffering it.
+    /// * dropOldest: When full, remove the least recently-received element from the
+    ///   buffer.
+    /// * customError: When full, execute the closure to provide a custom error.
+    public enum BufferingStrategy<Failure: Error> {
+
+        /// When full, discard the newly-received element without buffering it.
+        case dropNewest
+
+        /// When full, remove the least recently-received element from the buffer.
+        case dropOldest
+
+        /// When full, execute the closure to provide a custom error.
+        case customError(() -> Failure)
+    }
+
+    /// A publisher that buffers elements received from an upstream publisher.
+    public struct Buffer<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
+
+        /// The maximum number of elements to store.
+        public let size: Int
+
+        /// The strategy for initially populating the buffer.
+        public let prefetch: Publishers.PrefetchStrategy
+
+        /// The action to take when the buffer becomes full.
+        public let whenFull: Publishers.BufferingStrategy<Failure>
+
+        /// Creates a publisher that buffers elements received from an upstream publisher.
+        /// - Parameter upstream: The publisher from which this publisher receives
+        ///   elements.
+        /// - Parameter size: The maximum number of elements to store.
+        /// - Parameter prefetch: The strategy for initially populating the buffer.
+        /// - Parameter whenFull: The action to take when the buffer becomes full.
+        public init(upstream: Upstream,
+                    size: Int,
+                    prefetch: Publishers.PrefetchStrategy,
+                    whenFull: Publishers.BufferingStrategy<Failure>) {
+            self.upstream = upstream
+            self.size = size
+            self.prefetch = prefetch
+            self.whenFull = whenFull
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Downstream.Input == Output, Downstream.Failure == Failure
+        {
+            upstream.subscribe(Inner(downstream: subscriber, buffer: self))
+        }
+    }
+}
+
+extension Publishers.PrefetchStrategy: Equatable {}
+
+extension Publishers.PrefetchStrategy: Hashable {}
+
+extension Publishers.Buffer {
+    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 enum State {
+            case ready(Publishers.Buffer<Upstream>, Downstream)
+            case subscribed(Publishers.Buffer<Upstream>, Downstream, Subscription)
+            case terminal
+        }
+
+        private let lock = UnfairLock.allocate()
+
+        private var recursion = false
+
+        private var state: State
+
+        private var downstreamDemand = Subscribers.Demand.none
+
+        // TODO: Use a deque here?
+        // Need to measure performance with large buffers and `dropOldest` strategy.
+        private var values = [Input]()
+
+        private var upstreamFailed = false
+
+        private var terminal: Subscribers.Completion<Failure>?
+
+        init(downstream: Downstream, buffer: Publishers.Buffer<Upstream>) {
+            state = .ready(buffer, downstream)
+        }
+
+        deinit {
+            lock.deallocate()
+        }
+
+        func receive(subscription: Subscription) {
+            lock.lock()
+            guard case let .ready(buffer, downstream) = state else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            state = .subscribed(buffer, downstream, subscription)
+            lock.unlock()
+
+            let upstreamDemand: Subscribers.Demand
+            switch buffer.prefetch {
+            case .keepFull:
+                upstreamDemand = .max(buffer.size)
+            case .byRequest:
+                upstreamDemand = .unlimited
+            }
+            subscription.request(upstreamDemand)
+            downstream.receive(subscription: self)
+        }
+
+        func receive(_ input: Input) -> Subscribers.Demand {
+            lock.lock()
+            guard case let .subscribed(buffer, _, subscription) = state else {
+                lock.unlock()
+                return .none
+            }
+            switch terminal {
+            case nil, .finished?:
+                if values.count >= buffer.size {
+                    switch buffer.whenFull {
+                    case .dropNewest:
+                        lock.unlock()
+                        return drain()
+                    case .dropOldest:
+                        values.removeFirst()
+                    case let .customError(makeError):
+                        terminal = .failure(makeError())
+                        lock.unlock()
+                        subscription.cancel()
+                        return .none
+                    }
+                }
+
+                values.append(input)
+                lock.unlock()
+                return drain()
+            case .failure?:
+                lock.unlock()
+                return .none
+            }
+        }
+
+        func receive(completion: Subscribers.Completion<Upstream.Failure>) {
+            lock.lock()
+            guard case .subscribed = state, terminal == nil else {
+                lock.unlock()
+                return
+            }
+            terminal = completion
+            lock.unlock()
+            _ = drain()
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            lock.lock()
+            guard case let .subscribed(_, _, subscription) = state else {
+                lock.unlock()
+                return
+            }
+            downstreamDemand += demand
+            let recursion = self.recursion
+            lock.unlock()
+            if recursion {
+                return
+            }
+
+            // Request the number of items just enough to fill the buffer.
+            subscription.request(drain() + demand)
+        }
+
+        func cancel() {
+            lock.lock()
+            guard case let .subscribed(_, _, subscription) = state else {
+                lock.unlock()
+                return
+            }
+            state = .terminal
+            values = []
+            lock.unlock()
+            subscription.cancel()
+        }
+
+        private func drain() -> Subscribers.Demand {
+            var upstreamDemand = Subscribers.Demand.none
+            lock.lock()
+            while true {
+                guard case let .subscribed(buffer, downstream, _) = state else {
+                    lock.unlock()
+                    return upstreamDemand
+                }
+
+                if downstreamDemand > 0 {
+                    if values.isEmpty {
+                        if let completion = terminal {
+                            state = .terminal
+                            lock.unlock()
+                            downstream.receive(completion: completion)
+                        } else {
+                            lock.unlock()
+                        }
+                        return upstreamDemand
+                    }
+                } else {
+                    if let completion = terminal, case .failure = completion {
+                        state = .terminal
+                        lock.unlock()
+                        downstream.receive(completion: completion)
+                    } else {
+                        lock.unlock()
+                    }
+                    return upstreamDemand
+                }
+
+                let poppedValues = lockedPop(downstreamDemand)
+                assert(poppedValues.count > 0,
+                       """
+                       We check that the buffer is not empty and downstreamDemand is \
+                       nonzero, how can this be triggered?
+                       """)
+
+                // This should not crash because `lockedPop(_:)` returns at most
+                // `downstreamDemand` items.
+                downstreamDemand -= poppedValues.count
+
+                recursion = true
+                lock.unlock()
+
+                var newDownstreamDemand = Subscribers.Demand.none
+                var additionalUpstreamDemand = 0
+
+                for value in poppedValues {
+                    newDownstreamDemand += downstream.receive(value)
+                    additionalUpstreamDemand += 1
+                }
+
+                if buffer.prefetch == .keepFull {
+                    upstreamDemand += additionalUpstreamDemand
+                }
+
+                lock.lock()
+                recursion = false
+                downstreamDemand += newDownstreamDemand
+            }
+        }
+
+        private func lockedPop(_ demand: Subscribers.Demand) -> [Input] {
+            assert(demand > 0)
+            guard let max = demand.max else {
+                let poppedValues = self.values
+                self.values = []
+                return poppedValues
+            }
+
+            let poppedValues = Array(values.prefix(max))
+            values.removeFirst(poppedValues.count)
+            return poppedValues
+        }
+
+        var description: String { return "Buffer" }
+
+        var customMirror: Mirror {
+            let children: [Mirror.Child] = [
+                ("values", values),
+                ("state", state),
+                ("downstreamDemand", downstreamDemand),
+                ("terminal", terminal as Any)
+            ]
+            return Mirror(self, children: children)
+        }
+
+        var playgroundDescription: Any { return description }
+    }
+}

Sources/OpenCombine/Publishers/Publishers.Catch.swift.gyb

@@ -0,0 +1,401 @@
+${template_header}
+//
+//  Publishers.Catch.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 25.12.2019.
+//
+
+%{
+instantiations = ['Catch', 'TryCatch']
+}%
+extension Publisher {
+
+    /// Handles errors from an upstream publisher by replacing it with another publisher.
+    ///
+    /// The following example replaces any error from the upstream publisher and replaces
+    /// the upstream with a `Just` publisher. This continues the stream by publishing
+    /// a single value and completing normally.
+    /// ```
+    /// enum SimpleError: Error { case error }
+    /// let errorPublisher = (0..<10).publisher.tryMap { v -> Int in
+    ///     if v < 5 {
+    ///         return v
+    ///     } else {
+    ///         throw SimpleError.error
+    ///     }
+    /// }
+    ///
+    /// let noErrorPublisher = errorPublisher.catch { _ in
+    ///     return Just(100)
+    /// }
+    /// ```
+    /// Backpressure note: This publisher passes through `request` and `cancel` to
+    /// the upstream. After receiving an error, the publisher sends sends any unfulfilled
+    /// demand to the new `Publisher`.
+    ///
+    /// - Parameter handler: A closure that accepts the upstream failure as input and
+    ///   returns a publisher to replace the upstream publisher.
+    /// - Returns: A publisher that handles errors from an upstream publisher by replacing
+    ///   the failed publisher with another publisher.
+    public func `catch`<NewPublisher: Publisher>(
+        _ handler: @escaping (Failure) -> NewPublisher
+    ) -> Publishers.Catch<Self, NewPublisher>
+        where NewPublisher.Output == Output
+    {
+        return .init(upstream: self, handler: handler)
+    }
+
+    /// Handles errors from an upstream publisher by either replacing it with another
+    /// publisher or `throw`ing  a new error.
+    ///
+    /// - Parameter handler: A `throw`ing closure that accepts the upstream failure as
+    ///   input and returns a publisher to replace the upstream publisher or if an error
+    ///   is thrown will send the error downstream.
+    /// - Returns: A publisher that handles errors from an upstream publisher by replacing
+    ///   the failed publisher with another publisher.
+    public func tryCatch<NewPublisher: Publisher>(
+        _ handler: @escaping (Failure) throws -> NewPublisher
+    ) -> Publishers.TryCatch<Self, NewPublisher>
+        where NewPublisher.Output == Output
+    {
+        return .init(upstream: self, handler: handler)
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that handles errors from an upstream publisher by replacing the failed
+    /// publisher with another publisher.
+    public struct Catch<Upstream: Publisher, NewPublisher: Publisher>: Publisher
+        where Upstream.Output == NewPublisher.Output
+    {
+        public typealias Output = Upstream.Output
+
+        public typealias Failure = NewPublisher.Failure
+
+        /// The publisher that this publisher receives elements from.
+        public let upstream: Upstream
+
+        /// A closure that accepts the upstream failure as input and returns a publisher
+        /// to replace the upstream publisher.
+        public let handler: (Upstream.Failure) -> NewPublisher
+
+        /// Creates a publisher that handles errors from an upstream publisher by
+        /// replacing the failed publisher with another publisher.
+        ///
+        /// - Parameters:
+        ///   - upstream: The publisher that this publisher receives elements from.
+        ///   - handler: A closure that accepts the upstream failure as input and returns
+        ///     a publisher to replace the upstream publisher.
+        public init(upstream: Upstream,
+                    handler: @escaping (Upstream.Failure) -> NewPublisher) {
+            self.upstream = upstream
+            self.handler = handler
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Downstream.Input == Output, Downstream.Failure == Failure
+        {
+            let inner = Inner(downstream: subscriber, handler: handler)
+            let uncaughtS = Inner.UncaughtS(inner: inner)
+            upstream.subscribe(uncaughtS)
+        }
+    }
+
+    /// A publisher that handles errors from an upstream publisher by replacing the failed
+    /// publisher with another publisher or optionally producing a new error.
+    public struct TryCatch<Upstream: Publisher, NewPublisher: Publisher>: Publisher
+        where Upstream.Output == NewPublisher.Output
+    {
+        public typealias Output = Upstream.Output
+
+        public typealias Failure = Error
+
+        public let upstream: Upstream
+
+        public let handler: (Upstream.Failure) throws -> NewPublisher
+
+        public init(upstream: Upstream,
+                    handler: @escaping (Upstream.Failure) throws -> NewPublisher) {
+            self.upstream = upstream
+            self.handler = handler
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Downstream.Input == Output, Downstream.Failure == Failure
+        {
+            let inner = Inner(downstream: subscriber, handler: handler)
+            let uncaughtS = Inner.UncaughtS(inner: inner)
+            upstream.subscribe(uncaughtS)
+        }
+    }
+}
+% for instantiation in instantiations:
+%     throws_modifier = ' throws' if instantiation == 'TryCatch' else ''
+
+extension Publishers.${instantiation} {
+    private final class Inner<Downstream: Subscriber>
+        : Subscription,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == Upstream.Output,
+%     if instantiation == 'Catch':
+              Downstream.Failure == NewPublisher.Failure
+%     else:
+              Downstream.Failure == Error
+%     end
+    {
+        struct UncaughtS: Subscriber,
+                          CustomStringConvertible,
+                          CustomReflectable,
+                          CustomPlaygroundDisplayConvertible
+        {
+            typealias Input = Upstream.Output
+
+            typealias Failure = Upstream.Failure
+
+            let inner: Inner
+
+            var combineIdentifier: CombineIdentifier { return inner.combineIdentifier }
+
+            func receive(subscription: Subscription) {
+                inner.receivePre(subscription: subscription)
+            }
+
+            func receive(_ input: Input) -> Subscribers.Demand {
+                return inner.receivePre(input)
+            }
+
+            func receive(completion: Subscribers.Completion<Failure>) {
+                return inner.receivePre(completion: completion)
+            }
+
+            var description: String { return inner.description }
+
+            var customMirror: Mirror { return inner.customMirror }
+
+            var playgroundDescription: Any { return description }
+        }
+
+        struct CaughtS: Subscriber,
+                        CustomStringConvertible,
+                        CustomReflectable,
+                        CustomPlaygroundDisplayConvertible
+        {
+            typealias Input = NewPublisher.Output
+
+            typealias Failure = NewPublisher.Failure
+
+            let inner: Inner
+
+            var combineIdentifier: CombineIdentifier { return inner.combineIdentifier }
+
+            func receive(subscription: Subscription) {
+                inner.receivePost(subscription: subscription)
+            }
+
+            func receive(_ input: Input) -> Subscribers.Demand {
+                return inner.receivePost(input)
+            }
+
+            func receive(completion: Subscribers.Completion<Failure>) {
+                inner.receivePost(completion: completion)
+            }
+
+            var description: String { return inner.description }
+
+            var customMirror: Mirror { return inner.customMirror }
+
+            var playgroundDescription: Any { return description }
+        }
+
+        private enum State {
+            case pendingPre
+            case pre(Subscription)
+            case pendingPost
+            case post(Subscription)
+            case cancelled
+        }
+
+        private let lock = UnfairLock.allocate()
+
+        private var demand = Subscribers.Demand.none
+
+        private var state = State.pendingPre
+
+        private let downstream: Downstream
+
+        private let handler: (Upstream.Failure)${throws_modifier} -> NewPublisher
+
+        init(downstream: Downstream,
+             handler: @escaping (Upstream.Failure)${throws_modifier} -> NewPublisher) {
+            self.downstream = downstream
+            self.handler = handler
+        }
+
+        deinit {
+            lock.deallocate()
+        }
+
+        func receivePre(subscription: Subscription) {
+            lock.lock()
+            guard case .pendingPre = state else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            state = .pre(subscription)
+            lock.unlock()
+            downstream.receive(subscription: self)
+        }
+
+        func receivePre(_ input: Upstream.Output) -> Subscribers.Demand {
+            lock.lock()
+            demand -= 1
+            lock.unlock()
+            let newDemand = downstream.receive(input)
+            lock.lock()
+            demand += newDemand
+            lock.unlock()
+            return newDemand
+        }
+
+        func receivePre(completion: Subscribers.Completion<Upstream.Failure>) {
+            switch completion {
+            case .finished:
+                lock.lock()
+                switch state {
+                case .pre:
+                    state = .cancelled
+                    lock.unlock()
+                    downstream.receive(completion: .finished)
+                case .pendingPre, .pendingPost, .post, .cancelled:
+                    lock.unlock()
+                }
+            case .failure(let error):
+                lock.lock()
+                switch state {
+                case .pre:
+                    state = .pendingPost
+                    lock.unlock()
+%     if instantiation == 'Catch':
+                    handler(error).subscribe(CaughtS(inner: self))
+%     else:
+                    do {
+                        try handler(error).subscribe(CaughtS(inner: self))
+                    } catch let anotherError {
+                        lock.lock()
+                        state = .cancelled
+                        lock.unlock()
+                        downstream.receive(completion: .failure(anotherError))
+                    }
+%     end
+                case .cancelled:
+                    lock.unlock()
+                case .pendingPre, .post, .pendingPost:
+                    completionBeforeSubscription()
+                }
+            }
+        }
+
+        func receivePost(subscription: Subscription) {
+            lock.lock()
+            guard case .pendingPost = state else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            state = .post(subscription)
+            let demand = self.demand
+            lock.unlock()
+            if demand > 0 {
+                subscription.request(demand)
+            }
+        }
+
+        func receivePost(_ input: NewPublisher.Output) -> Subscribers.Demand {
+            return downstream.receive(input)
+        }
+
+        func receivePost(completion: Subscribers.Completion<NewPublisher.Failure>) {
+            lock.lock()
+            guard case .post = state else {
+                lock.unlock()
+                return
+            }
+            state = .cancelled
+            lock.unlock()
+%     if instantiation == 'Catch':
+            downstream.receive(completion: completion)
+%     else:
+            downstream.receive(completion: completion.eraseError())
+%     end
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            demand.assertNonZero()
+            lock.lock()
+            switch state {
+            case .pendingPre:
+                // The client is only able to call the `request` method after we've sent
+                // `self` downstream. We only do it in the `receivePre(subscription:)`
+                // method, after setting `state` to `pre`.
+                // After that `state` never becomes `pendingPre`.
+                requestBeforeSubscription()
+            case let .pre(subscription):
+                self.demand += demand
+                lock.unlock()
+                subscription.request(demand)
+            case .pendingPost:
+                self.demand += demand
+                lock.unlock()
+            case let .post(subscription):
+                lock.unlock()
+                subscription.request(demand)
+            case .cancelled:
+                lock.unlock()
+            }
+        }
+
+        func cancel() {
+            lock.lock()
+            switch state {
+            case let .pre(subscription), let .post(subscription):
+                state = .cancelled
+                lock.unlock()
+                subscription.cancel()
+            case .pendingPre, .pendingPost, .cancelled:
+                lock.unlock()
+            }
+        }
+
+        var description: String { return "${instantiation}" }
+
+        var customMirror: Mirror {
+            let children: [Mirror.Child] = [
+                ("downstream", downstream),
+                ("demand", demand)
+            ]
+            return Mirror(self, children: children)
+        }
+
+        var playgroundDescription: Any { return description }
+    }
+}
+% end
+
+private func completionBeforeSubscription(file: StaticString = #file,
+                                          line: UInt = #line) -> Never {
+    fatalError("Unexpected state: received completion but do not have subscription",
+               file: file,
+               line: line)
+}
+
+private func requestBeforeSubscription(file: StaticString = #file,
+                                       line: UInt = #line) -> Never {
+    fatalError("Unexpected state: request before subscription sent",
+               file: file,
+               line: line)
+}

Sources/OpenCombine/Publishers/Publishers.CollectByCount.swift

@@ -0,0 +1,185 @@
+//
+//  Publishers.CollectByCount.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 24.12.2019.
+//
+
+extension Publisher {
+
+    /// Collects up to the specified number of elements, and then emits a single array of
+    /// the collection.
+    ///
+    /// If the upstream publisher finishes before filling the buffer, this publisher sends
+    /// an array of all the items it has received. This may be fewer than `count`
+    /// elements.
+    /// If the upstream publisher fails with an error, this publisher forwards the error
+    /// to the downstream receiver instead of sending its output.
+    /// Note: When this publisher receives a request for `.max(n)` elements, it requests
+    /// `.max(count * n)` from the upstream publisher.
+    ///
+    /// - Parameter count: The maximum number of received elements to buffer before
+    ///   publishing.
+    /// - Returns: A publisher that collects up to the specified number of elements, and
+    ///   then publishes them as an array.
+    public func collect(_ count: Int) -> Publishers.CollectByCount<Self> {
+        return .init(upstream: self, count: count)
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that buffers a maximum number of items.
+    public struct CollectByCount<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
+
+        ///  The maximum number of received elements to buffer before publishing.
+        public let count: Int
+
+        public init(upstream: Upstream, count: Int) {
+            self.upstream = upstream
+            self.count = count
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Downstream.Failure == Failure, Downstream.Input == Output
+        {
+            upstream.subscribe(Inner(downstream: subscriber, count: count))
+        }
+    }
+}
+
+extension Publishers.CollectByCount: Equatable where Upstream: Equatable {}
+
+extension Publishers.CollectByCount {
+    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 let downstream: Downstream
+
+        private let count: Int
+
+        private var buffer: [Input] = []
+
+        private var subscription: Subscription?
+
+        private var finished = false
+
+        private let lock = UnfairLock.allocate()
+
+        init(downstream: Downstream, count: Int) {
+            self.downstream = downstream
+            self.count = count
+        }
+
+        deinit {
+            lock.deallocate()
+        }
+
+        func receive(subscription: Subscription) {
+            lock.lock()
+            if finished || self.subscription != nil {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            self.subscription = subscription
+            lock.unlock()
+            downstream.receive(subscription: self)
+        }
+
+        func receive(_ input: Upstream.Output) -> Subscribers.Demand {
+            lock.lock()
+            if subscription == nil {
+                lock.unlock()
+                return .none
+            }
+            buffer.append(input)
+            guard buffer.count == count else {
+                lock.unlock()
+                return .none
+            }
+            let output = self.buffer
+            self.buffer = []
+            lock.unlock()
+            return downstream.receive(output) * count
+        }
+
+        func receive(completion: Subscribers.Completion<Upstream.Failure>) {
+            lock.lock()
+            subscription = nil
+            finished = true
+            switch completion {
+            case .finished:
+                if buffer.isEmpty {
+                    lock.unlock()
+                } else {
+                    let buffer = self.buffer
+                    self.buffer = []
+                    lock.unlock()
+                    _ = downstream.receive(buffer)
+                }
+            case .failure:
+                buffer = []
+                lock.unlock()
+            }
+            downstream.receive(completion: completion)
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            demand.assertNonZero()
+            lock.lock()
+            if let subscription = self.subscription {
+                lock.unlock()
+                subscription.request(demand * count)
+            } else {
+                lock.unlock()
+            }
+        }
+
+        func cancel() {
+            lock.lock()
+            if let subscription = self.subscription {
+                buffer = []
+                finished = true
+                self.subscription = nil
+                lock.unlock()
+                subscription.cancel()
+            } else {
+                lock.unlock()
+            }
+        }
+
+        var description: String { return "CollectByCount" }
+
+        var customMirror: Mirror {
+            lock.lock()
+            defer { lock.unlock() }
+            let children: [Mirror.Child] = [
+                ("downstream", downstream),
+                ("upstreamSubscription", subscription as Any),
+                ("buffer", buffer),
+                ("count", count)
+            ]
+            return Mirror(self, children: children)
+        }
+
+        var playgroundDescription: Any { return description }
+    }
+}

Sources/OpenCombine/Publishers/Publishers.Concatenate.swift

@@ -0,0 +1,248 @@
+//
+//  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 another
+    /// 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)
+            subscriber.receive(subscription: inner)
+            prefix.subscribe(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()
+
+        private let downstreamLock = UnfairRecursiveLock.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.Debounce.swift

@@ -0,0 +1,264 @@
+//
+//  Publishers.Debounce.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 17.12.2019.
+//
+
+extension Publisher {
+
+    /// Publishes elements only after a specified time interval elapses between events.
+    ///
+    /// Use this operator when you want to wait for a pause in the delivery of events from
+    /// the upstream publisher. For example, call `debounce` on the publisher from a text
+    /// field to only receive elements when the user pauses or stops typing. When they
+    /// start typing again, the `debounce` holds event delivery until the next pause.
+    ///
+    /// - Parameters:
+    ///   - dueTime: The time the publisher should wait before publishing an element.
+    ///   - scheduler: The scheduler on which this publisher delivers elements
+    ///   - options: Scheduler options that customize this publisher’s delivery
+    ///     of elements.
+    /// - Returns: A publisher that publishes events only after a specified time elapses.
+    public func debounce<Context: Scheduler>(
+        for dueTime: Context.SchedulerTimeType.Stride,
+        scheduler: Context,
+        options: Context.SchedulerOptions? = nil
+    ) -> Publishers.Debounce<Self, Context> {
+        return .init(upstream: self,
+                     dueTime: dueTime,
+                     scheduler: scheduler,
+                     options: options)
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that publishes elements only after a specified time interval elapses
+    /// between events.
+    public struct Debounce<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 amount of time the publisher should wait before publishing an element.
+        public let dueTime: Context.SchedulerTimeType.Stride
+
+        /// The scheduler on which this publisher delivers elements.
+        public let scheduler: Context
+
+        /// Scheduler options that customize this publisher’s delivery of elements.
+        public let options: Context.SchedulerOptions?
+
+        public init(upstream: Upstream,
+                    dueTime: Context.SchedulerTimeType.Stride,
+                    scheduler: Context,
+                    options: Context.SchedulerOptions?) {
+            self.upstream = upstream
+            self.dueTime = dueTime
+            self.scheduler = scheduler
+            self.options = options
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Downstream.Failure == Failure, Downstream.Input == Output
+        {
+            let inner = Inner(downstream: subscriber,
+                              dueTime: dueTime,
+                              scheduler: scheduler,
+                              options: options)
+            upstream.subscribe(inner)
+        }
+    }
+}
+
+extension Publishers.Debounce {
+    private final class Inner<Downstream: Subscriber>
+        : Subscriber,
+          Subscription,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Upstream.Output == Downstream.Input,
+              Upstream.Failure == Downstream.Failure
+    {
+        typealias Input = Upstream.Output
+
+        typealias Failure = Upstream.Failure
+
+        private typealias Generation = UInt64
+
+        private let lock = UnfairLock.allocate()
+
+        private let downstreamLock = UnfairRecursiveLock.allocate()
+
+        private let downstream: Downstream
+
+        private let dueTime: Context.SchedulerTimeType.Stride
+
+        private let scheduler: Context
+
+        private let options: Context.SchedulerOptions?
+
+        private var state = SubscriptionStatus.awaitingSubscription
+
+        private var currentCanceller: Cancellable?
+
+        private var currentValue: Output?
+
+        private var currentGeneration: Generation = 0
+
+        private var downstreamDemand = Subscribers.Demand.none
+
+        init(downstream: Downstream,
+             dueTime: Context.SchedulerTimeType.Stride,
+             scheduler: Context,
+             options: Context.SchedulerOptions?) {
+            self.downstream = downstream
+            self.dueTime = dueTime
+            self.scheduler = scheduler
+            self.options = options
+        }
+
+        deinit {
+            lock.deallocate()
+            downstreamLock.deallocate()
+        }
+
+        func receive(subscription: Subscription) {
+            lock.lock()
+            guard case .awaitingSubscription = state else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            state = .subscribed(subscription)
+            lock.unlock()
+            downstreamLock.lock()
+            downstream.receive(subscription: self)
+            downstreamLock.unlock()
+            subscription.request(.unlimited)
+        }
+
+        func receive(_ input: Input) -> Subscribers.Demand {
+            lock.lock()
+            precondition(!state.isAwaitingSubscription)
+            guard case .subscribed = state else {
+                lock.unlock()
+                return .none
+            }
+            currentGeneration += 1
+            let generation = currentGeneration
+            currentValue = input
+            let due = scheduler.now.advanced(by: dueTime)
+            lock.unlock()
+            let newCanceller = scheduler.schedule(after: due,
+                                                  interval: dueTime,
+                                                  tolerance: scheduler.minimumTolerance,
+                                                  options: options) { [weak self] in
+                self?.due(generation: generation)
+            }
+            lock.lock()
+            let canceller = currentCanceller
+            currentCanceller = newCanceller
+            lock.unlock()
+            canceller?.cancel()
+            return .none
+        }
+
+        func receive(completion: Subscribers.Completion<Upstream.Failure>) {
+            lock.lock()
+            precondition(!state.isAwaitingSubscription)
+            guard case .subscribed = state else {
+                lock.unlock()
+                return
+            }
+            state = .terminal
+            let canceller = currentCanceller
+            lock.unlock()
+            canceller?.cancel()
+            scheduler.schedule {
+                self.downstreamLock.lock()
+                self.downstream.receive(completion: completion)
+                self.downstreamLock.unlock()
+            }
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            lock.lock()
+            precondition(!state.isAwaitingSubscription)
+            guard case .subscribed = state else {
+                lock.unlock()
+                return
+            }
+            downstreamDemand += demand
+            lock.unlock()
+        }
+
+        func cancel() {
+            lock.lock()
+            guard case .subscribed(let subscription) = state else {
+                lock.unlock()
+                return
+            }
+            state = .terminal
+            lock.unlock()
+            subscription.cancel()
+        }
+
+        var description: String { return "Debounce" }
+
+        var customMirror: Mirror {
+            let children: [Mirror.Child] = [
+                ("downstream", downstream),
+                ("downstreamDemand", downstreamDemand),
+                ("currentValue", currentValue as Any)
+            ]
+            return Mirror(self, children: children)
+        }
+
+        var playgroundDescription: Any { return description }
+
+        private func due(generation: Generation) {
+            lock.lock()
+            guard case .subscribed = state else {
+                lock.unlock()
+                return
+            }
+
+            // If this condition holds, it means that no values were received
+            // in this time frame => we should propagate the current value downstream.
+            guard generation == currentGeneration, let value = currentValue else {
+                let canceller = currentCanceller
+                lock.unlock()
+                canceller?.cancel()
+                return
+            }
+
+            let hasAnyDemand = downstreamDemand > 0
+            if hasAnyDemand {
+                downstreamDemand -= 1
+            }
+
+            let canceller = currentCanceller!
+            lock.unlock()
+            canceller.cancel()
+
+            guard hasAnyDemand else { return }
+
+            downstreamLock.lock()
+            let newDemand = downstream.receive(value)
+            downstreamLock.unlock()
+
+            if newDemand == .none { return }
+
+            lock.lock()
+            downstreamDemand += newDemand
+            lock.unlock()
+        }
+    }
+}

Sources/OpenCombine/Publishers/Publishers.Delay.swift

@@ -0,0 +1,207 @@
+//
+//  Publishers.Delay.swift
+//  OpenCombine
+//
+//  Created by Евгений Богомолов on 07/09/2019.
+//
+
+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 = UnfairRecursiveLock.allocate()
+
+        fileprivate init(_ publisher: Delay, downstream: Downstream) {
+            state = .ready(publisher, downstream)
+        }
+
+        deinit {
+            lock.deallocate()
+            downstreamLock.deallocate()
+        }
+
+        private func schedule(_ delay: Delay, work: @escaping () -> Void) {
+            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()
+            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) {
+                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) {
+                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,8 +5,6 @@
 //  Created by Sven Weidauer on 03.10.2019.
 //
 
-import COpenCombineHelpers
-
 extension Publisher {
     /// Omits the specified number of elements before republishing subsequent elements.
     ///

Sources/OpenCombine/Publishers/Publishers.DropUntilOutput.swift

@@ -0,0 +1,267 @@
+//
+//  Publishers.DropUntilOutput.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 24.12.2019.
+//
+
+extension Publisher {
+
+    /// Ignores elements from the upstream publisher until it receives an element from
+    /// a second publisher.
+    ///
+    /// This publisher requests a single value from the upstream publisher, and it ignores
+    /// (drops) all elements from that publisher until the upstream publisher produces
+    /// a value. After the `other` publisher produces an element, this publisher cancels
+    /// its subscription to the `other` publisher, and allows events from the `upstream`
+    /// publisher to pass through.
+    /// After this publisher receives a subscription from the upstream publisher, it
+    /// passes through backpressure requests from downstream to the upstream publisher.
+    /// If the upstream publisher acts on those requests before the other publisher
+    /// produces an item, this publisher drops the elements it receives from the upstream
+    /// publisher.
+    ///
+    /// - Parameter publisher: A publisher to monitor for its first emitted element.
+    /// - Returns: A publisher that drops elements from the upstream publisher until the
+    ///   `other` publisher produces a value.
+    public func drop<Other: Publisher>(
+        untilOutputFrom publisher: Other
+    ) -> Publishers.DropUntilOutput<Self, Other> where Failure == Other.Failure {
+        return .init(upstream: self, other: publisher)
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that ignores elements from the upstream publisher until it receives
+    /// an element from second publisher.
+    public struct DropUntilOutput<Upstream: Publisher, Other: Publisher>: Publisher
+        where Upstream.Failure == Other.Failure
+    {
+        public typealias Output = Upstream.Output
+
+        public typealias Failure = Upstream.Failure
+
+        /// The publisher that this publisher receives elements from.
+        public let upstream: Upstream
+
+        /// A publisher to monitor for its first emitted element.
+        public let other: Other
+
+        /// Creates a publisher that ignores elements from the upstream publisher until
+        /// it receives an element from another publisher.
+        ///
+        /// - Parameters:
+        ///   - upstream: A publisher to drop elements from while waiting for another
+        ///     publisher to emit elements.
+        ///   - other: A publisher to monitor for its first emitted element.
+        public init(upstream: Upstream, other: Other) {
+            self.upstream = upstream
+            self.other = other
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Upstream.Output == Downstream.Input,
+                  Other.Failure == Downstream.Failure
+        {
+            let inner = Inner(downstream: subscriber)
+            subscriber.receive(subscription: inner)
+            other.subscribe(Inner.OtherSubscriber(inner: inner))
+            upstream.subscribe(inner)
+        }
+    }
+}
+
+extension Publishers.DropUntilOutput: Equatable
+    where Upstream: Equatable, Other: Equatable {}
+
+extension Publishers.DropUntilOutput {
+    fileprivate 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 let downstream: Downstream
+
+        private var triggered = false
+
+        private let lock = UnfairLock.allocate()
+
+        private let downstreamLock = UnfairRecursiveLock.allocate()
+
+        private var upstreamSubscription: Subscription?
+
+        private var pendingDemand = Subscribers.Demand.none
+
+        private var otherSubscription: Subscription?
+
+        private var otherFinished = false
+
+        private var cancelled = false
+
+        init(downstream: Downstream) {
+            self.downstream = downstream
+        }
+
+        deinit {
+            lock.deallocate()
+            downstreamLock.deallocate()
+        }
+
+        func receive(subscription: Subscription) {
+            lock.lock()
+            guard upstreamSubscription == nil && !cancelled else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            upstreamSubscription = subscription
+            if pendingDemand > 0 {
+                lock.unlock()
+                subscription.request(pendingDemand)
+            } else {
+                lock.unlock()
+            }
+        }
+
+        func receive(_ input: Input) -> Subscribers.Demand {
+            lock.lock()
+            if !triggered || cancelled {
+                pendingDemand -= 1
+                lock.unlock()
+                return .none
+            }
+            lock.unlock()
+            downstreamLock.lock()
+            let newDemand = downstream.receive(input)
+            downstreamLock.unlock()
+            return newDemand
+        }
+
+        func receive(completion: Subscribers.Completion<Failure>) {
+            lock.lock()
+            if cancelled {
+                lock.unlock()
+                return
+            }
+            cancelled = true
+            lock.unlock()
+            downstreamLock.lock()
+            downstream.receive(completion: completion)
+            downstreamLock.unlock()
+        }
+
+        private func receiveOther(subscription: Subscription) {
+            // Combine doesn't lock here
+            guard otherSubscription == nil else {
+                subscription.cancel()
+                return
+            }
+            otherSubscription = subscription
+            subscription.request(.max(1))
+        }
+
+        private func receiveOther(_ input: Other.Output) -> Subscribers.Demand {
+            lock.lock()
+            triggered = true
+            otherSubscription = nil
+            lock.unlock()
+            return .none
+        }
+
+        private func receiveOther(completion: Subscribers.Completion<Other.Failure>) {
+            lock.lock()
+            if triggered {
+                otherSubscription = nil
+                lock.unlock()
+                return
+            }
+
+            otherFinished = true
+            if let upstreamSubscription = self.upstreamSubscription {
+                self.upstreamSubscription = nil
+                lock.unlock()
+                upstreamSubscription.cancel()
+            } else {
+                lock.unlock()
+            }
+            downstreamLock.lock()
+            downstream.receive(completion: completion)
+            downstreamLock.unlock()
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            lock.lock()
+            pendingDemand += demand
+            if let subscription = upstreamSubscription {
+                lock.unlock()
+                subscription.request(demand)
+            } else {
+                lock.unlock()
+            }
+        }
+
+        func cancel() {
+            lock.lock()
+            let upstreamSubscription = self.upstreamSubscription
+            let otherSubscription = self.otherSubscription
+            self.upstreamSubscription = nil
+            self.otherSubscription = nil
+            cancelled = true
+            lock.unlock()
+
+            upstreamSubscription?.cancel()
+            otherSubscription?.cancel()
+        }
+
+        var description: String { return "DropUntilOutput" }
+
+        var customMirror: Mirror {
+            return Mirror(self, children: EmptyCollection())
+        }
+
+        var playgroundDescription: Any { return description }
+    }
+}
+
+extension Publishers.DropUntilOutput.Inner {
+    fileprivate struct OtherSubscriber
+        : Subscriber,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+    {
+        let inner: Publishers.DropUntilOutput<Upstream, Other>.Inner<Downstream>
+
+        var combineIdentifier: CombineIdentifier {
+            return inner.combineIdentifier
+        }
+
+        func receive(subscription: Subscription) {
+            inner.receiveOther(subscription: subscription)
+        }
+
+        func receive(_ input: Other.Output) -> Subscribers.Demand {
+            return inner.receiveOther(input)
+        }
+
+        func receive(completion: Subscribers.Completion<Other.Failure>) {
+            inner.receiveOther(completion: completion)
+        }
+
+        var description: String { return "DropUntilOutput" }
+
+        var customMirror: Mirror {
+            return Mirror(self, children: EmptyCollection())
+        }
+
+        var playgroundDescription: Any { return description }
+    }
+}

Sources/OpenCombine/Publishers/Publishers.DropWhile.swift

@@ -5,8 +5,6 @@
 //  Created by Sergej Jaskiewicz on 16.06.2019.
 //
 
-import COpenCombineHelpers
-
 extension Publisher {
 
     /// Omits elements from the upstream publisher until a given closure returns false,

Sources/OpenCombine/Publishers/Publishers.First.swift

@@ -24,7 +24,7 @@ extension Publisher {
     /// - Parameter predicate: A closure that takes an element as a parameter and
     ///   returns a Boolean value that indicates whether to publish the element.
     /// - Returns: A publisher that only publishes the first element of a stream
-    ///   that satifies the predicate.
+    ///   that satisfies the predicate.
     public func first(
         where predicate: @escaping (Output) -> Bool
     ) -> Publishers.FirstWhere<Self> {
@@ -40,7 +40,7 @@ extension Publisher {
     /// - Parameter predicate: A closure that takes an element as a parameter and
     ///   returns a Boolean value that indicates whether to publish the element.
     /// - Returns: A publisher that only publishes the first element of a stream
-    ///   that satifies the predicate.
+    ///   that satisfies the predicate.
     public func tryFirst(
         where predicate: @escaping (Output) throws -> Bool
     ) -> Publishers.TryFirstWhere<Self> {

Sources/OpenCombine/Publishers/Publishers.FlatMap.swift

@@ -4,8 +4,6 @@
 //  Created by Eric Patey on 16.08.2019.
 //
 
-import COpenCombineHelpers
-
 extension Publisher {
     /// Transforms all elements from an upstream publisher into a new or existing
     /// publisher.
@@ -80,9 +78,8 @@ extension Publishers.FlatMap {
         /// acquired.
         private var outerSubscription: Subscription?
 
-        // Must be recursive lock. Probably a bug in Combine.
         /// The lock for requesting from `outerSubscription`.
-        private let outerLock = UnfairLock.allocate()
+        private let outerLock = UnfairRecursiveLock.allocate()
 
         /// The lock for modifying the state. All mutable state here should be
         /// read and modified with this lock acquired.
@@ -90,10 +87,9 @@ extension Publishers.FlatMap {
         /// by the `downstreamLock`.
         private let lock = UnfairLock.allocate()
 
-        // Must be recursive lock. Probably a bug in Combine.
         /// All the calls to the downstream subscriber should be made with this lock
         /// acquired.
-        private let downstreamLock = UnfairLock.allocate()
+        private let downstreamLock = UnfairRecursiveLock.allocate()
 
         private let downstream: Downstream
 

Sources/OpenCombine/Publishers/Publishers.HandleEvents.swift

@@ -0,0 +1,193 @@
+//
+//  Publishers.HandleEvents.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 03.12.2019.
+//
+
+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,11 +4,9 @@
 //  Created by Eric Patey on 16.08.2019.
 //
 
-import COpenCombineHelpers
-
 extension Publisher {
 
-    /// Ingores all upstream elements, but passes along a completion
+    /// Ignores all upstream elements, but passes along a completion
     /// state (finished or failed).
     ///
     /// The output type of this publisher is `Never`.

Sources/OpenCombine/Publishers/Publishers.Map.swift

@@ -5,8 +5,6 @@
 //  Created by Anton Nazarov on 25.06.2019.
 //
 
-import COpenCombineHelpers
-
 extension Publisher {
 
     /// Transforms all elements from the upstream publisher with a provided closure.

Sources/OpenCombine/Publishers/Publishers.MeasureInterval.swift

@@ -0,0 +1,166 @@
+//
+//  Publishers.MeasureInterval.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 03.12.2019.
+//
+
+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,8 +5,6 @@
 //  Created by Sergej Jaskiewicz on 14.06.2019.
 //
 
-import COpenCombineHelpers
-
 extension Publisher {
 
     /// Applies a closure to create a subject that delivers elements to subscribers.

Sources/OpenCombine/Publishers/Publishers.Output.swift

@@ -5,8 +5,6 @@
 //  Created by Sergej Jaskiewicz on 24.10.2019.
 //
 
-import COpenCombineHelpers
-
 extension Publisher {
 
     /// Republishes elements up to the specified maximum count.

Sources/OpenCombine/Publishers/Publishers.Print.swift

@@ -5,8 +5,6 @@
 //  Created by Sergej Jaskiewicz on 16.06.2019.
 //
 
-import COpenCombineHelpers
-
 extension Publisher {
 
     /// Prints log messages for all publishing events.

Sources/OpenCombine/Publishers/Publishers.ReceiveOn.swift

@@ -0,0 +1,201 @@
+//
+//  Publishers.ReceiveOn.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 02.12.2019.
+//
+
+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 = UnfairRecursiveLock.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()
+            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) {
+                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) {
+                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.RemoveDuplicates.swift

@@ -59,7 +59,7 @@ extension Publishers {
         /// for purposes of filtering.
         public let predicate: (Output, Output) -> Bool
 
-        /// Creates a publisher that publishes only elements that don’t match the previou
+        /// Creates a publisher that publishes only elements that don’t match the previous
         /// element, as evaluated by a provided closure.
         ///
         /// - Parameter upstream: The publisher from which this publisher receives

Sources/OpenCombine/Publishers/Publishers.ReplaceEmpty.swift

@@ -0,0 +1,180 @@
+//
+//  Publishers.ReplaceEmpty.swift
+//  OpenCombine
+//
+//  Created by Joe Spadafora on 12/10/19.
+//
+
+extension Publisher {
+
+    /// Replaces an empty stream with the provided element.
+    ///
+    /// If the upstream publisher finishes without producing any elements,
+    /// this publisher emits the provided element, then finishes normally.
+    /// - Parameter output: An element to emit when the upstream publisher
+    ///                     finishes without emitting any elements.
+    /// - Returns: A publisher that replaces an empty stream with
+    ///            the provided output element.
+    public func replaceEmpty(with output: Output) -> Publishers.ReplaceEmpty<Self> {
+        return .init(upstream: self, output: output)
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that replaces an empty stream with a provided element.
+    public struct ReplaceEmpty<Upstream: Publisher>: Publisher {
+
+        public typealias Output = Upstream.Output
+
+        public typealias Failure = Upstream.Failure
+
+        /// The element to deliver when the upstream publisher finishes
+        /// without delivering any elements.
+        public let output: Upstream.Output
+
+        /// The publisher from which this publisher receives elements.
+        public let upstream: Upstream
+
+        public init(upstream: Upstream, output: Output) {
+            self.upstream = upstream
+            self.output = output
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Upstream.Failure == Downstream.Failure,
+                  Upstream.Output == Downstream.Input
+        {
+            let inner = Inner(downstream: subscriber, output: output)
+            upstream.subscribe(inner)
+        }
+    }
+}
+
+extension Publishers.ReplaceEmpty: Equatable
+    where Upstream: Equatable, Upstream.Output: Equatable {}
+
+extension Publishers.ReplaceEmpty {
+
+    private final class Inner<Downstream: Subscriber>
+        : Subscriber,
+          Subscription,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Upstream.Failure == Downstream.Failure,
+              Upstream.Output == Downstream.Input
+    {
+
+        typealias Input = Upstream.Output
+        typealias Failure = Upstream.Failure
+
+        private let output: Output
+        private let downstream: Downstream
+
+        private var receivedUpstream = false
+        private var lock = UnfairLock.allocate()
+        private var downstreamRequested = false
+        private var finishedWithoutUpstream = false
+
+        private var status = SubscriptionStatus.awaitingSubscription
+
+        fileprivate init(downstream: Downstream, output: Output) {
+            self.downstream = downstream
+            self.output = output
+        }
+
+        deinit {
+            lock.deallocate()
+        }
+
+        func receive(subscription: Subscription) {
+            lock.lock()
+            guard case .awaitingSubscription = status else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            status = .subscribed(subscription)
+            lock.unlock()
+            downstream.receive(subscription: self)
+            subscription.request(.unlimited)
+        }
+
+        func receive(_ input: Upstream.Output) -> Subscribers.Demand {
+            lock.lock()
+            guard case .subscribed = status else {
+                lock.unlock()
+                return .none
+            }
+            receivedUpstream = true
+            lock.unlock()
+            return downstream.receive(input)
+        }
+
+        func receive(completion: Subscribers.Completion<Upstream.Failure>) {
+            lock.lock()
+            guard case .subscribed = status else {
+                lock.unlock()
+                return
+            }
+            status = .terminal
+            if receivedUpstream {
+                lock.unlock()
+                downstream.receive(completion: completion)
+                return
+            }
+            switch completion {
+            case .finished:
+                if downstreamRequested {
+                    lock.unlock()
+                    _ = downstream.receive(output)
+                    downstream.receive(completion: completion)
+                    return
+                }
+                finishedWithoutUpstream = true
+                lock.unlock()
+            case .failure:
+                lock.unlock()
+                downstream.receive(completion: completion)
+            }
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            demand.assertNonZero()
+            lock.lock()
+            downstreamRequested = true
+            if finishedWithoutUpstream {
+                lock.unlock()
+                _ = downstream.receive(output)
+                downstream.receive(completion: .finished)
+                return
+            }
+            guard case let .subscribed(subscription) = status else {
+                lock.unlock()
+                return
+            }
+            lock.unlock()
+            subscription.request(demand)
+        }
+
+        func cancel() {
+            lock.lock()
+            guard case let .subscribed(subscription) = status else {
+                lock.unlock()
+                return
+            }
+            status = .terminal
+            lock.unlock()
+            subscription.cancel()
+        }
+
+        var description: String { return "ReplaceEmpty" }
+
+        var customMirror: Mirror {
+            return Mirror(self, children: EmptyCollection())
+        }
+
+        var playgroundDescription: Any { return description }
+    }
+}

Sources/OpenCombine/Publishers/Publishers.ReplaceError.swift

@@ -5,8 +5,6 @@
 //  Created by Bogdan Vlad on 8/29/19.
 //
 
-import COpenCombineHelpers
-
 extension Publisher {
     /// Replaces any errors in the stream with the provided element.
     ///

Sources/OpenCombine/Publishers/Publishers.ReplaceNil.swift

@@ -7,7 +7,7 @@
 
 extension Publisher {
 
-    /// Replaces nil elements in the stream with the proviced element.
+    /// Replaces nil elements in the stream with the provided element.
     ///
     /// - Parameter output: The element to use when replacing `nil`.
     /// - Returns: A publisher that replaces `nil` elements from

Sources/OpenCombine/Publishers/Publishers.Scan.swift

@@ -4,8 +4,6 @@
 //  Created by Eric Patey on 26.08.2019.
 //
 
-import COpenCombineHelpers
-
 extension Publisher {
 
     /// Transforms elements from the upstream publisher by providing the current element

Sources/OpenCombine/Publishers/Publishers.Sequence.swift

@@ -5,8 +5,6 @@
 //  Created by Sergej Jaskiewicz on 19.06.2019.
 //
 
-import COpenCombineHelpers
-
 extension Publishers {
 
     /// A publisher that publishes a given sequence of elements.

Sources/OpenCombine/Publishers/Publishers.Share.swift

@@ -9,7 +9,7 @@ extension Publisher {
 
     /// Returns a publisher as a class instance.
     ///
-    /// The downstream subscriber receieves elements and completion states unchanged from
+    /// The downstream subscriber receives elements and completion states unchanged from
     /// the upstream publisher. Use this operator when you want to use
     /// reference semantics, such as storing a publisher instance in a property.
     ///

Sources/OpenCombine/Publishers/Publishers.SubscribeOn.swift

@@ -0,0 +1,188 @@
+//
+//  Publishers.SubscribeOn.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 02.12.2019.
+//
+
+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/Publishers.SwitchToLatest.swift

@@ -0,0 +1,336 @@
+//
+//  Publishers.SwitchToLatest.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 07.01.2020.
+//
+
+extension Publisher where Output: Publisher, Output.Failure == Failure {
+
+    /// Flattens the stream of events from multiple upstream publishers to appear as if
+    /// they were coming from a single stream of events.
+    ///
+    /// This operator switches the inner publisher as new ones arrive but keeps the outer
+    /// one constant for downstream subscribers.
+    /// For example, given the type `Publisher<Publisher<Data, NSError>, Never>`,
+    /// calling `switchToLatest()` will result in the type `Publisher<Data, NSError>`.
+    /// The downstream subscriber sees a continuous stream of values even though they may
+    /// be coming from different upstream publishers.
+    public func switchToLatest() -> Publishers.SwitchToLatest<Output, Self> {
+        return .init(upstream: self)
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that “flattens” nested publishers.
+    ///
+    /// Given a publisher that publishes Publishers, the `SwitchToLatest` publisher
+    /// produces a sequence of events from only the most recent one.
+    ///
+    /// For example, given the type `Publisher<Publisher<Data, NSError>, Never>`,
+    /// calling `switchToLatest()` will result in the type `Publisher<Data, NSError>`.
+    /// The downstream subscriber sees a continuous stream of values even though they may
+    /// be coming from different upstream publishers.
+    public struct SwitchToLatest<NestedPublisher: Publisher, Upstream: Publisher>
+        : Publisher
+        where Upstream.Output == NestedPublisher,
+              Upstream.Failure == NestedPublisher.Failure
+    {
+        public typealias Output = NestedPublisher.Output
+
+        public typealias Failure = NestedPublisher.Failure
+
+        /// The publisher from which this publisher receives elements.
+        public let upstream: Upstream
+
+        /// Creates a publisher that “flattens” nested publishers.
+        ///
+        /// - Parameter upstream: The publisher from which this publisher receives
+        ///   elements.
+        public init(upstream: Upstream) {
+            self.upstream = upstream
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Downstream.Input == Output, Downstream.Failure == Failure
+        {
+            let outer = Outer(downstream: subscriber)
+            subscriber.receive(subscription: outer)
+            upstream.subscribe(outer)
+        }
+    }
+}
+
+extension Publishers.SwitchToLatest {
+    fileprivate final class Outer<Downstream: Subscriber>
+        : Subscriber,
+          Subscription,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == NestedPublisher.Output,
+              Downstream.Failure == Upstream.Failure
+    {
+        typealias Input = Upstream.Output
+
+        typealias Failure = Upstream.Failure
+
+        private let downstream: Downstream
+        private var outerSubscription: Subscription?
+        private var currentInnerSubscription: Subscription?
+        private var currentInnerIndex: UInt64 = 0
+        private var nextInnerIndex: UInt64 = 1
+        private let lock = UnfairLock.allocate()
+        private let downstreamLock = UnfairRecursiveLock.allocate()
+        private var cancelled = false
+        private var finished = false
+        private var sentCompletion = false
+        private var awaitingInnerSubscription = false
+        private var downstreamDemand = Subscribers.Demand.none
+
+        init(downstream: Downstream) {
+            self.downstream = downstream
+        }
+
+        deinit {
+            lock.deallocate()
+            downstreamLock.deallocate()
+        }
+
+        func receive(subscription: Subscription) {
+            lock.lock()
+            guard outerSubscription == nil && !cancelled else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            outerSubscription = subscription
+            lock.unlock()
+            subscription.request(.unlimited)
+        }
+
+        func receive(_ input: Input) -> Subscribers.Demand {
+            lock.lock()
+            if cancelled || finished {
+                lock.unlock()
+                return .none
+            }
+
+            if let currentInnerSubscription = self.currentInnerSubscription  {
+                self.currentInnerSubscription = nil
+                lock.unlock()
+                currentInnerSubscription.cancel()
+                lock.lock()
+            }
+
+            let index = nextInnerIndex
+            currentInnerIndex = index
+            nextInnerIndex += 1
+            awaitingInnerSubscription = true
+            lock.unlock()
+            input.subscribe(Side(inner: self, index: index))
+            return .none
+        }
+
+        func receive(completion: Subscribers.Completion<Failure>) {
+            lock.lock()
+            outerSubscription = nil
+            finished = true
+
+            if cancelled {
+                lock.unlock()
+                return
+            }
+
+            switch completion {
+            case .finished:
+                if awaitingInnerSubscription {
+                    lock.unlock()
+                    return
+                }
+                if currentInnerSubscription == nil {
+                    sentCompletion = true
+                    lock.unlock()
+                    downstreamLock.lock()
+                    downstream.receive(completion: completion)
+                    downstreamLock.unlock()
+                } else {
+                    lock.unlock()
+                }
+            case .failure:
+                let currentInnerSubscription = self.currentInnerSubscription
+                self.currentInnerSubscription = nil
+                sentCompletion = true
+                lock.unlock()
+                currentInnerSubscription?.cancel()
+                downstreamLock.lock()
+                downstream.receive(completion: completion)
+                downstreamLock.unlock()
+            }
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            demand.assertNonZero()
+            lock.lock()
+            downstreamDemand += demand
+            if let currentInnerSubscription = self.currentInnerSubscription {
+                lock.unlock()
+                currentInnerSubscription.request(demand)
+            } else {
+                lock.unlock()
+            }
+        }
+
+        func cancel() {
+            lock.lock()
+            cancelled = true
+            let currentInnerSubscription = self.currentInnerSubscription
+            self.currentInnerSubscription = nil
+            let outerSubscription = self.outerSubscription
+            self.outerSubscription = nil
+            lock.unlock()
+
+            currentInnerSubscription?.cancel()
+            outerSubscription?.cancel()
+        }
+
+        var description: String { return "SwitchToLatest" }
+
+        var customMirror: Mirror {
+            return Mirror(self, children: EmptyCollection())
+        }
+
+        var playgroundDescription: Any { return description }
+
+        private func receiveInner(subscription: Subscription, _ index: UInt64) {
+            lock.lock()
+            guard currentInnerIndex == index &&
+                  !cancelled &&
+                  currentInnerSubscription == nil else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+
+            currentInnerSubscription = subscription
+            awaitingInnerSubscription = false
+            let downstreamDemand = self.downstreamDemand
+            lock.unlock()
+            if downstreamDemand > 0 {
+                subscription.request(downstreamDemand)
+            }
+        }
+
+        private func receiveInner(_ input: NestedPublisher.Output,
+                                  _ index: UInt64) -> Subscribers.Demand {
+            lock.lock()
+            guard currentInnerIndex == index && !cancelled else {
+                lock.unlock()
+                return .none
+            }
+
+            // This will crash if we don't have any demand yet.
+            // Combine crashes here too.
+            downstreamDemand -= 1
+
+            lock.unlock()
+            downstreamLock.lock()
+            let newDemand = downstream.receive(input)
+            downstreamLock.unlock()
+            if newDemand > 0 {
+                lock.lock()
+                downstreamDemand += newDemand
+                lock.unlock()
+            }
+
+            return newDemand
+        }
+
+        private func receiveInner(completion: Subscribers.Completion<Failure>,
+                                  _ index: UInt64) {
+            lock.lock()
+            guard currentInnerIndex == index && !cancelled else {
+                lock.unlock()
+                return
+            }
+            precondition(!awaitingInnerSubscription, "Unexpected completion")
+            currentInnerSubscription = nil
+            switch completion {
+            case .finished:
+                if sentCompletion || !finished {
+                    lock.unlock()
+                    return
+                }
+                sentCompletion = true
+                lock.unlock()
+                downstreamLock.lock()
+                downstream.receive(completion: completion)
+                downstreamLock.unlock()
+            case .failure:
+                if sentCompletion {
+                    lock.unlock()
+                    return
+                }
+                cancelled = true
+                let outerSubscription = self.outerSubscription
+                self.outerSubscription = nil
+                sentCompletion = true
+                lock.unlock()
+                outerSubscription?.cancel()
+                downstreamLock.lock()
+                downstream.receive(completion: completion)
+                downstreamLock.unlock()
+            }
+        }
+    }
+}
+
+extension Publishers.SwitchToLatest.Outer {
+    private struct Side
+        : Subscriber,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+    {
+        typealias Input = NestedPublisher.Output
+
+        typealias Failure = NestedPublisher.Failure
+
+        typealias Outer =
+            Publishers.SwitchToLatest<NestedPublisher, Upstream>.Outer<Downstream>
+
+        private let index: UInt64
+        private let outer: Outer
+
+        let combineIdentifier = CombineIdentifier()
+
+        init(inner: Outer, index: UInt64) {
+            self.index = index
+            self.outer = inner
+        }
+
+        func receive(subscription: Subscription) {
+            outer.receiveInner(subscription: subscription, index)
+        }
+
+        func receive(_ input: Input) -> Subscribers.Demand {
+            return outer.receiveInner(input, index)
+        }
+
+        func receive(completion: Subscribers.Completion<Failure>) {
+            outer.receiveInner(completion: completion, index)
+        }
+
+        var description: String { return "SwitchToLatest" }
+
+        var customMirror: Mirror {
+            let children = CollectionOfOne<Mirror.Child>(
+                ("parentSubscription", outer.combineIdentifier)
+            )
+            return Mirror(self, children: children)
+        }
+
+        var playgroundDescription: Any { return description }
+    }
+}

Sources/OpenCombine/Publishers/Publishers.Timeout.swift

@@ -0,0 +1,229 @@
+//
+//  Publishers.Timeout.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 14.06.2020.
+//
+
+extension Publisher {
+
+    /// Terminates publishing if the upstream publisher exceeds the specified time
+    /// interval without producing an element.
+    ///
+    /// - Parameters:
+    ///   - interval: The maximum time interval the publisher can go without emitting
+    ///     an element, expressed in the time system of the scheduler.
+    ///   - scheduler: The scheduler to deliver events on.
+    ///   - options: Scheduler options that customize the delivery of elements.
+    ///   - customError: A closure that executes if the publisher times out.
+    ///     The publisher sends the failure returned by this closure to the subscriber as
+    ///     the reason for termination.
+    /// - Returns: A publisher that terminates if the specified interval elapses with no
+    ///   events received from the upstream publisher.
+    public func timeout<Context: Scheduler>(
+        _ interval: Context.SchedulerTimeType.Stride,
+        scheduler: Context,
+        options: Context.SchedulerOptions? = nil,
+        customError: (() -> Self.Failure)? = nil
+    ) -> Publishers.Timeout<Self, Context> {
+        return .init(upstream: self,
+                     interval: interval,
+                     scheduler: scheduler,
+                     options: options,
+                     customError: customError)
+    }
+}
+
+extension Publishers {
+
+    public struct Timeout<Upstream: Publisher, Context: Scheduler>: Publisher {
+
+        public typealias Output = Upstream.Output
+
+        public typealias Failure = Upstream.Failure
+
+        public let upstream: Upstream
+
+        public let interval: Context.SchedulerTimeType.Stride
+
+        public let scheduler: Context
+
+        public let options: Context.SchedulerOptions?
+
+        public let customError: (() -> Upstream.Failure)?
+
+        public init(upstream: Upstream,
+                    interval: Context.SchedulerTimeType.Stride,
+                    scheduler: Context,
+                    options: Context.SchedulerOptions?,
+                    customError: (() -> Publishers.Timeout<Upstream, Context>.Failure)?) {
+            self.upstream = upstream
+            self.interval = interval
+            self.scheduler = scheduler
+            self.options = options
+            self.customError = customError
+        }
+
+        public func receive<Downsteam: Subscriber>(subscriber: Downsteam)
+            where Downsteam.Failure == Failure, Downsteam.Input == Output
+        {
+            let inner = Inner(downstream: subscriber,
+                              interval: interval,
+                              scheduler: scheduler,
+                              options: options,
+                              customError: customError)
+            upstream.subscribe(inner)
+        }
+    }
+}
+
+extension Publishers.Timeout {
+    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 let lock = UnfairLock.allocate()
+
+        private let downstreamLock = UnfairRecursiveLock.allocate()
+
+        private let downstream: Downstream
+
+        private let interval: Context.SchedulerTimeType.Stride
+
+        private let scheduler: Context
+
+        private let options: Context.SchedulerOptions?
+
+        private let customError: (() -> Upstream.Failure)?
+
+        private var state = SubscriptionStatus.awaitingSubscription
+
+        private var didTimeout = false
+
+        private var timer: AnyCancellable?
+
+        init(downstream: Downstream,
+             interval: Context.SchedulerTimeType.Stride,
+             scheduler: Context,
+             options: Context.SchedulerOptions?,
+             customError: (() -> Upstream.Failure)?) {
+            self.downstream = downstream
+            self.interval = interval
+            self.scheduler = scheduler
+            self.options = options
+            self.customError = customError
+        }
+
+        deinit {
+            lock.deallocate()
+            downstreamLock.deallocate()
+        }
+
+        func receive(subscription: Subscription) {
+            lock.lock()
+            guard case .awaitingSubscription = state else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            state = .subscribed(subscription)
+            timer = timeoutClock()
+            lock.unlock()
+            downstreamLock.lock()
+            downstream.receive(subscription: self)
+            downstreamLock.unlock()
+            subscription.request(.unlimited)
+        }
+
+        func receive(_ input: Upstream.Output) -> Subscribers.Demand {
+            lock.lock()
+            guard !didTimeout, case .subscribed = state else {
+                lock.unlock()
+                return .none
+            }
+            timer?.cancel()
+            didTimeout = false
+            timer = timeoutClock()
+            lock.unlock()
+            scheduler.schedule(options: options) {
+                self.downstreamLock.lock()
+                _ = self.downstream.receive(input)
+                self.downstreamLock.unlock()
+            }
+            return .unlimited
+        }
+
+        func receive(completion: Subscribers.Completion<Upstream.Failure>) {
+            lock.lock()
+            timer?.cancel()
+            state = .terminal
+            lock.unlock()
+            scheduler.schedule(options: options) {
+                self.downstreamLock.lock()
+                self.downstream.receive(completion: completion)
+                self.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 "Timeout" }
+
+        var customMirror: Mirror { return Mirror(self, children: EmptyCollection()) }
+
+        var playgroundDescription: Any { return description }
+
+        private func timedOut() {
+            lock.lock()
+            guard !didTimeout, case let .subscribed(subscription) = state else {
+                lock.unlock()
+                return
+            }
+            didTimeout = true
+            state = .terminal
+            lock.unlock()
+            subscription.cancel()
+            downstreamLock.lock()
+            downstream
+                .receive(completion: customError.map { .failure($0()) } ?? .finished)
+            downstreamLock.unlock()
+        }
+
+        private func timeoutClock() -> AnyCancellable {
+            let cancellable = scheduler
+                .schedule(after: scheduler.now.advanced(by: interval),
+                          interval: interval,
+                          tolerance: scheduler.minimumTolerance,
+                          options: options,
+                          { [weak self] in self?.timedOut() })
+            return AnyCancellable { cancellable.cancel() }
+        }
+    }
+}

Sources/OpenCombine/Publishers/Record.swift

@@ -5,8 +5,6 @@
 //  Created by Sergej Jaskiewicz on 12.11.2019.
 //
 
-import COpenCombineHelpers
-
 /// A publisher that allows for recording a series of inputs and a completion for later
 /// playback to each subscriber.
 public struct Record<Output, Failure: Error>: Publisher {

Sources/OpenCombine/Scheduler.swift

@@ -23,7 +23,7 @@ public protocol SchedulerTimeIntervalConvertible {
 ///
 /// A scheduler used to execute code as soon as possible, or after a future date.
 /// Individual scheduler implementations use whatever time-keeping system makes sense
-/// for them. Schdedulers express this as their `SchedulerTimeType`. Since this type
+/// for them. Schedulers express this as their `SchedulerTimeType`. Since this type
 /// conforms to `SchedulerTimeIntervalConvertible`, you can always express these times
 /// with the convenience functions like `.milliseconds(500)`. Schedulers can accept
 /// options to control how they execute the actions passed to them. These options may