From a990de90fe41456a23e58bd087d2f107d321f3a1 Mon Sep 17 00:00:00 2001
From: Valentin Popov <valentin@popov.link>
Date: Fri, 19 Jul 2024 16:37:58 +0400
Subject: Deleted vendor folder
---
vendor/bitflags-1.3.2/.cargo-checksum.json | 1 -
vendor/bitflags-1.3.2/CHANGELOG.md | 206 ---
vendor/bitflags-1.3.2/CODE_OF_CONDUCT.md | 73 -
vendor/bitflags-1.3.2/Cargo.toml | 58 -
vendor/bitflags-1.3.2/LICENSE-APACHE | 201 ---
vendor/bitflags-1.3.2/LICENSE-MIT | 25 -
vendor/bitflags-1.3.2/README.md | 32 -
vendor/bitflags-1.3.2/src/example_generated.rs | 14 -
vendor/bitflags-1.3.2/src/lib.rs | 1729 --------------------
vendor/bitflags-1.3.2/tests/basic.rs | 20 -
.../tests/compile-fail/impls/copy.rs | 10 -
.../tests/compile-fail/impls/copy.stderr.beta | 27 -
.../bitflags-1.3.2/tests/compile-fail/impls/eq.rs | 10 -
.../tests/compile-fail/impls/eq.stderr.beta | 55 -
.../compile-fail/non_integer_base/all_defined.rs | 123 --
.../non_integer_base/all_defined.stderr.beta | 27 -
.../compile-fail/non_integer_base/all_missing.rs | 13 -
.../non_integer_base/all_missing.stderr.beta | 13 -
.../tests/compile-fail/visibility/private_field.rs | 13 -
.../visibility/private_field.stderr.beta | 10 -
.../tests/compile-fail/visibility/private_flags.rs | 18 -
.../visibility/private_flags.stderr.beta | 18 -
.../tests/compile-fail/visibility/pub_const.rs | 9 -
.../compile-fail/visibility/pub_const.stderr.beta | 5 -
.../tests/compile-pass/impls/convert.rs | 17 -
.../tests/compile-pass/impls/default.rs | 10 -
.../tests/compile-pass/impls/inherent_methods.rs | 15 -
.../tests/compile-pass/redefinition/core.rs | 14 -
.../tests/compile-pass/redefinition/stringify.rs | 19 -
vendor/bitflags-1.3.2/tests/compile-pass/repr/c.rs | 10 -
.../tests/compile-pass/repr/transparent.rs | 10 -
.../tests/compile-pass/visibility/bits_field.rs | 11 -
.../tests/compile-pass/visibility/pub_in.rs | 19 -
vendor/bitflags-1.3.2/tests/compile.rs | 63 -
34 files changed, 2898 deletions(-)
delete mode 100644 vendor/bitflags-1.3.2/.cargo-checksum.json
delete mode 100644 vendor/bitflags-1.3.2/CHANGELOG.md
delete mode 100644 vendor/bitflags-1.3.2/CODE_OF_CONDUCT.md
delete mode 100644 vendor/bitflags-1.3.2/Cargo.toml
delete mode 100644 vendor/bitflags-1.3.2/LICENSE-APACHE
delete mode 100644 vendor/bitflags-1.3.2/LICENSE-MIT
delete mode 100644 vendor/bitflags-1.3.2/README.md
delete mode 100644 vendor/bitflags-1.3.2/src/example_generated.rs
delete mode 100644 vendor/bitflags-1.3.2/src/lib.rs
delete mode 100644 vendor/bitflags-1.3.2/tests/basic.rs
delete mode 100644 vendor/bitflags-1.3.2/tests/compile-fail/impls/copy.rs
delete mode 100644 vendor/bitflags-1.3.2/tests/compile-fail/impls/copy.stderr.beta
delete mode 100644 vendor/bitflags-1.3.2/tests/compile-fail/impls/eq.rs
delete mode 100644 vendor/bitflags-1.3.2/tests/compile-fail/impls/eq.stderr.beta
delete mode 100644 vendor/bitflags-1.3.2/tests/compile-fail/non_integer_base/all_defined.rs
delete mode 100644 vendor/bitflags-1.3.2/tests/compile-fail/non_integer_base/all_defined.stderr.beta
delete mode 100644 vendor/bitflags-1.3.2/tests/compile-fail/non_integer_base/all_missing.rs
delete mode 100644 vendor/bitflags-1.3.2/tests/compile-fail/non_integer_base/all_missing.stderr.beta
delete mode 100644 vendor/bitflags-1.3.2/tests/compile-fail/visibility/private_field.rs
delete mode 100644 vendor/bitflags-1.3.2/tests/compile-fail/visibility/private_field.stderr.beta
delete mode 100644 vendor/bitflags-1.3.2/tests/compile-fail/visibility/private_flags.rs
delete mode 100644 vendor/bitflags-1.3.2/tests/compile-fail/visibility/private_flags.stderr.beta
delete mode 100644 vendor/bitflags-1.3.2/tests/compile-fail/visibility/pub_const.rs
delete mode 100644 vendor/bitflags-1.3.2/tests/compile-fail/visibility/pub_const.stderr.beta
delete mode 100644 vendor/bitflags-1.3.2/tests/compile-pass/impls/convert.rs
delete mode 100644 vendor/bitflags-1.3.2/tests/compile-pass/impls/default.rs
delete mode 100644 vendor/bitflags-1.3.2/tests/compile-pass/impls/inherent_methods.rs
delete mode 100644 vendor/bitflags-1.3.2/tests/compile-pass/redefinition/core.rs
delete mode 100644 vendor/bitflags-1.3.2/tests/compile-pass/redefinition/stringify.rs
delete mode 100644 vendor/bitflags-1.3.2/tests/compile-pass/repr/c.rs
delete mode 100644 vendor/bitflags-1.3.2/tests/compile-pass/repr/transparent.rs
delete mode 100644 vendor/bitflags-1.3.2/tests/compile-pass/visibility/bits_field.rs
delete mode 100644 vendor/bitflags-1.3.2/tests/compile-pass/visibility/pub_in.rs
delete mode 100644 vendor/bitflags-1.3.2/tests/compile.rs
(limited to 'vendor/bitflags-1.3.2')
diff --git a/vendor/bitflags-1.3.2/.cargo-checksum.json b/vendor/bitflags-1.3.2/.cargo-checksum.json
deleted file mode 100644
index 7e8d470..0000000
--- a/vendor/bitflags-1.3.2/.cargo-checksum.json
+++ /dev/null
@@ -1 +0,0 @@
-{"files":{"CHANGELOG.md":"d362fc1fccaaf4d421bcf0fe8b80ddb4f625dade0c1ee52d08bd0b95509a49d1","CODE_OF_CONDUCT.md":"42634d0f6d922f49857175af991802822f7f920487aefa2ee250a50d12251a66","Cargo.toml":"87aced7532a7974eb37ab5fe6037f0abafc36d6b2d74891ecd2bf2f14f50d11e","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb","README.md":"baa8604f8afb34fd93b9c79729daafb884dedcaf34023e4af8ad037d916061fd","src/example_generated.rs":"e43eb59e90f317f38d436670a6067d2fd9eb35fb319fe716184e4a04e24ed1b2","src/lib.rs":"e6477688535ee326d27238aeedc9cb4320ac35b9d17a4deda09e0587b0ccdbd4","tests/basic.rs":"146f1cbf6279bc609242cd3349f29cb21b41294f5e4921875f5ec95bd83529a2","tests/compile-fail/impls/copy.rs":"b791371237ddc75a7c04d2130e03b462c9c00a80dca08bd45aa97433d9c0d13a","tests/compile-fail/impls/copy.stderr.beta":"77d83484ce221d4b6ff2f7de843929a452d779fcfff428122710dd8218c298e3","tests/compile-fail/impls/eq.rs":"0cee8b9e07d537890e0189710293b53972d0fab63c09366f33c391065afafa99","tests/compile-fail/impls/eq.stderr.beta":"381fc6143d45ce76d7cecc47aa59cb69fe5e79c0b60a4a85d5c6163b400b3cc7","tests/compile-fail/non_integer_base/all_defined.rs":"95e14cad9e94560262f2862c3c01865ac30369b69da1001b0e7285cb55e6cb75","tests/compile-fail/non_integer_base/all_defined.stderr.beta":"1760739a276690903bb03844025587d37939f5dfcbfab309db3c86f32bdbf748","tests/compile-fail/non_integer_base/all_missing.rs":"b3d9da619d23213731ba2581aa7999c796c3c79aaf4f0ee6b11ceec08a11537f","tests/compile-fail/non_integer_base/all_missing.stderr.beta":"37e102290d3867e175b21976be798939f294efb17580d5b51e7b17b590d55132","tests/compile-fail/visibility/private_field.rs":"38e4d3fe6471829360d12c8d09b097f6a21aa93fb51eac3b215d96bdae23316b","tests/compile-fail/visibility/private_field.stderr.beta":"5aa24a3ebb39326f31927721c5017b8beb66c3e501fb865a3fa814c9763bfa0f","tests/compile-fail/visibility/private_flags.rs":"2ce4235802aa4e9c96c4e77d9e31d8401ef58dcda4741325184f0764ab1fe393","tests/compile-fail/visibility/private_flags.stderr.beta":"f3eb9f7baf2689258f3519ff7ee5c6ec3c237264ebcfe63f40c40f2023e5022f","tests/compile-fail/visibility/pub_const.rs":"8f813a97ac518c5ea8ac65b184101912452384afaf7b8d6c5e62f8370eca3c0a","tests/compile-fail/visibility/pub_const.stderr.beta":"823976ae1794d7f5372e2ec9aabba497e7bb88004722904c38da342ed98e8962","tests/compile-pass/impls/convert.rs":"88fe80bfb9cd5779f0e1d92c9ec02a8b6bb67e334c07f2309e9c0ba5ef776eb0","tests/compile-pass/impls/default.rs":"c508f9a461691f44b45142fa5ad599f02326e1de4c0cbca6c0593f4652eba109","tests/compile-pass/impls/inherent_methods.rs":"ecc26388e9a394bfa7a5bb69a5d621ab3d4d1e53f28f657bb8e78fe79f437913","tests/compile-pass/redefinition/core.rs":"ff5b6e72f87acc6ebb12405d3c0f6e3fa62e669933656a454bb63b30ea44179c","tests/compile-pass/redefinition/stringify.rs":"1edbce42b900c14425d7ffa14e83e165ebe452d7dccd8c0a8a821bdec64f5c93","tests/compile-pass/repr/c.rs":"6fda17f7c2edfcd155314579e83d0fc8a16209e400f1f9a5ca77bd9a799041f2","tests/compile-pass/repr/transparent.rs":"6cdc87a2137d8a4e0c8ce9b6cba83c82255f8ea125951bf614418685600489ce","tests/compile-pass/visibility/bits_field.rs":"1f3e5ba5a047440066a9f6bf7b7af33f5b06f6b1da3dd9af6886168199a7ea0a","tests/compile-pass/visibility/pub_in.rs":"e95312ff60966d42ec4bc00225507895a9b8ec24056ce6a9edd9145be35d730f","tests/compile.rs":"f27c67a7dd183ca30efea1b6e0880e3469a6dd63b92b1fd711c082df182c9eec"},"package":"bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"}
\ No newline at end of file
diff --git a/vendor/bitflags-1.3.2/CHANGELOG.md b/vendor/bitflags-1.3.2/CHANGELOG.md
deleted file mode 100644
index 12fea16..0000000
--- a/vendor/bitflags-1.3.2/CHANGELOG.md
+++ /dev/null
@@ -1,206 +0,0 @@
-# 1.3.2
-
-- Allow `non_snake_case` in generated flags types ([#256])
-
-[#252]: https://github.com/bitflags/bitflags/pull/256
-
-# 1.3.1
-
-- Revert unconditional `#[repr(transparent)]` ([#252])
-
-[#252]: https://github.com/bitflags/bitflags/pull/252
-
-# 1.3.0 (yanked)
-
-- Add `#[repr(transparent)]` ([#187])
-
-- End `empty` doc comment with full stop ([#202])
-
-- Fix typo in crate root docs ([#206])
-
-- Document from_bits_unchecked unsafety ([#207])
-
-- Let `is_all` ignore extra bits ([#211])
-
-- Allows empty flag definition ([#225])
-
-- Making crate accessible from std ([#227])
-
-- Make `from_bits` a const fn ([#229])
-
-- Allow multiple bitflags structs in one macro invocation ([#235])
-
-- Add named functions to perform set operations ([#244])
-
-- Fix typos in method docs ([#245])
-
-- Modernization of the `bitflags` macro to take advantage of newer features and 2018 idioms ([#246])
-
-- Fix regression (in an unreleased feature) and simplify tests ([#247])
-
-- Use `Self` and fix bug when overriding `stringify!` ([#249])
-
-[#187]: https://github.com/bitflags/bitflags/pull/187
-[#202]: https://github.com/bitflags/bitflags/pull/202
-[#206]: https://github.com/bitflags/bitflags/pull/206
-[#207]: https://github.com/bitflags/bitflags/pull/207
-[#211]: https://github.com/bitflags/bitflags/pull/211
-[#225]: https://github.com/bitflags/bitflags/pull/225
-[#227]: https://github.com/bitflags/bitflags/pull/227
-[#229]: https://github.com/bitflags/bitflags/pull/229
-[#235]: https://github.com/bitflags/bitflags/pull/235
-[#244]: https://github.com/bitflags/bitflags/pull/244
-[#245]: https://github.com/bitflags/bitflags/pull/245
-[#246]: https://github.com/bitflags/bitflags/pull/246
-[#247]: https://github.com/bitflags/bitflags/pull/247
-[#249]: https://github.com/bitflags/bitflags/pull/249
-
-# 1.2.1
-
-- Remove extraneous `#[inline]` attributes ([#194])
-
-[#194]: https://github.com/bitflags/bitflags/pull/194
-
-# 1.2.0
-
-- Fix typo: {Lower, Upper}Exp - {Lower, Upper}Hex ([#183])
-
-- Add support for "unknown" bits ([#188])
-
-[#183]: https://github.com/rust-lang-nursery/bitflags/pull/183
-[#188]: https://github.com/rust-lang-nursery/bitflags/pull/188
-
-# 1.1.0
-
-This is a re-release of `1.0.5`, which was yanked due to a bug in the RLS.
-
-# 1.0.5
-
-- Use compiletest_rs flags supported by stable toolchain ([#171])
-
-- Put the user provided attributes first ([#173])
-
-- Make bitflags methods `const` on newer compilers ([#175])
-
-[#171]: https://github.com/rust-lang-nursery/bitflags/pull/171
-[#173]: https://github.com/rust-lang-nursery/bitflags/pull/173
-[#175]: https://github.com/rust-lang-nursery/bitflags/pull/175
-
-# 1.0.4
-
-- Support Rust 2018 style macro imports ([#165])
-
- ```rust
- use bitflags::bitflags;
- ```
-
-[#165]: https://github.com/rust-lang-nursery/bitflags/pull/165
-
-# 1.0.3
-
-- Improve zero value flag handling and documentation ([#157])
-
-[#157]: https://github.com/rust-lang-nursery/bitflags/pull/157
-
-# 1.0.2
-
-- 30% improvement in compile time of bitflags crate ([#156])
-
-- Documentation improvements ([#153])
-
-- Implementation cleanup ([#149])
-
-[#156]: https://github.com/rust-lang-nursery/bitflags/pull/156
-[#153]: https://github.com/rust-lang-nursery/bitflags/pull/153
-[#149]: https://github.com/rust-lang-nursery/bitflags/pull/149
-
-# 1.0.1
-- Add support for `pub(restricted)` specifier on the bitflags struct ([#135])
-- Optimize performance of `all()` when called from a separate crate ([#136])
-
-[#135]: https://github.com/rust-lang-nursery/bitflags/pull/135
-[#136]: https://github.com/rust-lang-nursery/bitflags/pull/136
-
-# 1.0.0
-- **[breaking change]** Macro now generates [associated constants](https://doc.rust-lang.org/reference/items.html#associated-constants) ([#24])
-
-- **[breaking change]** Minimum supported version is Rust **1.20**, due to usage of associated constants
-
-- After being broken in 0.9, the `#[deprecated]` attribute is now supported again ([#112])
-
-- Other improvements to unit tests and documentation ([#106] and [#115])
-
-[#24]: https://github.com/rust-lang-nursery/bitflags/pull/24
-[#106]: https://github.com/rust-lang-nursery/bitflags/pull/106
-[#112]: https://github.com/rust-lang-nursery/bitflags/pull/112
-[#115]: https://github.com/rust-lang-nursery/bitflags/pull/115
-
-## How to update your code to use associated constants
-Assuming the following structure definition:
-```rust
-bitflags! {
- struct Something: u8 {
- const FOO = 0b01,
- const BAR = 0b10
- }
-}
-```
-In 0.9 and older you could do:
-```rust
-let x = FOO.bits | BAR.bits;
-```
-Now you must use:
-```rust
-let x = Something::FOO.bits | Something::BAR.bits;
-```
-
-# 0.9.1
-- Fix the implementation of `Formatting` traits when other formatting traits were present in scope ([#105])
-
-[#105]: https://github.com/rust-lang-nursery/bitflags/pull/105
-
-# 0.9.0
-- **[breaking change]** Use struct keyword instead of flags to define bitflag types ([#84])
-
-- **[breaking change]** Terminate const items with semicolons instead of commas ([#87])
-
-- Implement the `Hex`, `Octal`, and `Binary` formatting traits ([#86])
-
-- Printing an empty flag value with the `Debug` trait now prints "(empty)" instead of nothing ([#85])
-
-- The `bitflags!` macro can now be used inside of a fn body, to define a type local to that function ([#74])
-
-[#74]: https://github.com/rust-lang-nursery/bitflags/pull/74
-[#84]: https://github.com/rust-lang-nursery/bitflags/pull/84
-[#85]: https://github.com/rust-lang-nursery/bitflags/pull/85
-[#86]: https://github.com/rust-lang-nursery/bitflags/pull/86
-[#87]: https://github.com/rust-lang-nursery/bitflags/pull/87
-
-# 0.8.2
-- Update feature flag used when building bitflags as a dependency of the Rust toolchain
-
-# 0.8.1
-- Allow bitflags to be used as a dependency of the Rust toolchain
-
-# 0.8.0
-- Add support for the experimental `i128` and `u128` integer types ([#57])
-- Add set method: `flags.set(SOME_FLAG, true)` or `flags.set(SOME_FLAG, false)` ([#55])
- This may break code that defines its own set method
-
-[#55]: https://github.com/rust-lang-nursery/bitflags/pull/55
-[#57]: https://github.com/rust-lang-nursery/bitflags/pull/57
-
-# 0.7.1
-*(yanked)*
-
-# 0.7.0
-- Implement the Extend trait ([#49])
-- Allow definitions inside the `bitflags!` macro to refer to items imported from other modules ([#51])
-
-[#49]: https://github.com/rust-lang-nursery/bitflags/pull/49
-[#51]: https://github.com/rust-lang-nursery/bitflags/pull/51
-
-# 0.6.0
-- The `no_std` feature was removed as it is now the default
-- The `assignment_operators` feature was remove as it is now enabled by default
-- Some clippy suggestions have been applied
diff --git a/vendor/bitflags-1.3.2/CODE_OF_CONDUCT.md b/vendor/bitflags-1.3.2/CODE_OF_CONDUCT.md
deleted file mode 100644
index f7add90..0000000
--- a/vendor/bitflags-1.3.2/CODE_OF_CONDUCT.md
+++ /dev/null
@@ -1,73 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as
-contributors and maintainers pledge to making participation in our project and
-our community a harassment-free experience for everyone, regardless of age, body
-size, disability, ethnicity, gender identity and expression, level of experience,
-education, socio-economic status, nationality, personal appearance, race,
-religion, or sexual identity and orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment
-include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or
- advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic
- address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
- professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable
-behavior and are expected to take appropriate and fair corrective action in
-response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or
-reject comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct, or to ban temporarily or
-permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies both within project spaces and in public spaces
-when an individual is representing the project or its community. Examples of
-representing a project or community include using an official project e-mail
-address, posting via an official social media account, or acting as an appointed
-representative at an online or offline event. Representation of a project may be
-further defined and clarified by project maintainers.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at coc@senaite.org. All
-complaints will be reviewed and investigated and will result in a response that
-is deemed necessary and appropriate to the circumstances. The project team is
-obligated to maintain confidentiality with regard to the reporter of an incident.
-Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good
-faith may face temporary or permanent repercussions as determined by other
-members of the project's leadership.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
-available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
-
-[homepage]: https://www.contributor-covenant.org
\ No newline at end of file
diff --git a/vendor/bitflags-1.3.2/Cargo.toml b/vendor/bitflags-1.3.2/Cargo.toml
deleted file mode 100644
index 9d54c72..0000000
--- a/vendor/bitflags-1.3.2/Cargo.toml
+++ /dev/null
@@ -1,58 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies
-#
-# If you believe there's an error in this file please file an
-# issue against the rust-lang/cargo repository. If you're
-# editing this file be aware that the upstream Cargo.toml
-# will likely look very different (and much more reasonable)
-
-[package]
-edition = "2018"
-name = "bitflags"
-version = "1.3.2"
-authors = ["The Rust Project Developers"]
-exclude = ["bors.toml"]
-description = "A macro to generate structures which behave like bitflags.\n"
-homepage = "https://github.com/bitflags/bitflags"
-documentation = "https://docs.rs/bitflags"
-readme = "README.md"
-keywords = ["bit", "bitmask", "bitflags", "flags"]
-categories = ["no-std"]
-license = "MIT/Apache-2.0"
-repository = "https://github.com/bitflags/bitflags"
-[package.metadata.docs.rs]
-features = ["example_generated"]
-[dependencies.compiler_builtins]
-version = "0.1.2"
-optional = true
-
-[dependencies.core]
-version = "1.0.0"
-optional = true
-package = "rustc-std-workspace-core"
-[dev-dependencies.rustversion]
-version = "1.0"
-
-[dev-dependencies.serde]
-version = "1.0"
-
-[dev-dependencies.serde_derive]
-version = "1.0"
-
-[dev-dependencies.serde_json]
-version = "1.0"
-
-[dev-dependencies.trybuild]
-version = "1.0"
-
-[dev-dependencies.walkdir]
-version = "2.3"
-
-[features]
-default = []
-example_generated = []
-rustc-dep-of-std = ["core", "compiler_builtins"]
diff --git a/vendor/bitflags-1.3.2/LICENSE-APACHE b/vendor/bitflags-1.3.2/LICENSE-APACHE
deleted file mode 100644
index 16fe87b..0000000
--- a/vendor/bitflags-1.3.2/LICENSE-APACHE
+++ /dev/null
@@ -1,201 +0,0 @@
- Apache License
- Version 2.0, January 2004
- http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
- "License" shall mean the terms and conditions for use, reproduction,
- and distribution as defined by Sections 1 through 9 of this document.
-
- "Licensor" shall mean the copyright owner or entity authorized by
- the copyright owner that is granting the License.
-
- "Legal Entity" shall mean the union of the acting entity and all
- other entities that control, are controlled by, or are under common
- control with that entity. For the purposes of this definition,
- "control" means (i) the power, direct or indirect, to cause the
- direction or management of such entity, whether by contract or
- otherwise, or (ii) ownership of fifty percent (50%) or more of the
- outstanding shares, or (iii) beneficial ownership of such entity.
-
- "You" (or "Your") shall mean an individual or Legal Entity
- exercising permissions granted by this License.
-
- "Source" form shall mean the preferred form for making modifications,
- including but not limited to software source code, documentation
- source, and configuration files.
-
- "Object" form shall mean any form resulting from mechanical
- transformation or translation of a Source form, including but
- not limited to compiled object code, generated documentation,
- and conversions to other media types.
-
- "Work" shall mean the work of authorship, whether in Source or
- Object form, made available under the License, as indicated by a
- copyright notice that is included in or attached to the work
- (an example is provided in the Appendix below).
-
- "Derivative Works" shall mean any work, whether in Source or Object
- form, that is based on (or derived from) the Work and for which the
- editorial revisions, annotations, elaborations, or other modifications
- represent, as a whole, an original work of authorship. For the purposes
- of this License, Derivative Works shall not include works that remain
- separable from, or merely link (or bind by name) to the interfaces of,
- the Work and Derivative Works thereof.
-
- "Contribution" shall mean any work of authorship, including
- the original version of the Work and any modifications or additions
- to that Work or Derivative Works thereof, that is intentionally
- submitted to Licensor for inclusion in the Work by the copyright owner
- or by an individual or Legal Entity authorized to submit on behalf of
- the copyright owner. For the purposes of this definition, "submitted"
- means any form of electronic, verbal, or written communication sent
- to the Licensor or its representatives, including but not limited to
- communication on electronic mailing lists, source code control systems,
- and issue tracking systems that are managed by, or on behalf of, the
- Licensor for the purpose of discussing and improving the Work, but
- excluding communication that is conspicuously marked or otherwise
- designated in writing by the copyright owner as "Not a Contribution."
-
- "Contributor" shall mean Licensor and any individual or Legal Entity
- on behalf of whom a Contribution has been received by Licensor and
- subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- copyright license to reproduce, prepare Derivative Works of,
- publicly display, publicly perform, sublicense, and distribute the
- Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- (except as stated in this section) patent license to make, have made,
- use, offer to sell, sell, import, and otherwise transfer the Work,
- where such license applies only to those patent claims licensable
- by such Contributor that are necessarily infringed by their
- Contribution(s) alone or by combination of their Contribution(s)
- with the Work to which such Contribution(s) was submitted. If You
- institute patent litigation against any entity (including a
- cross-claim or counterclaim in a lawsuit) alleging that the Work
- or a Contribution incorporated within the Work constitutes direct
- or contributory patent infringement, then any patent licenses
- granted to You under this License for that Work shall terminate
- as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
- Work or Derivative Works thereof in any medium, with or without
- modifications, and in Source or Object form, provided that You
- meet the following conditions:
-
- (a) You must give any other recipients of the Work or
- Derivative Works a copy of this License; and
-
- (b) You must cause any modified files to carry prominent notices
- stating that You changed the files; and
-
- (c) You must retain, in the Source form of any Derivative Works
- that You distribute, all copyright, patent, trademark, and
- attribution notices from the Source form of the Work,
- excluding those notices that do not pertain to any part of
- the Derivative Works; and
-
- (d) If the Work includes a "NOTICE" text file as part of its
- distribution, then any Derivative Works that You distribute must
- include a readable copy of the attribution notices contained
- within such NOTICE file, excluding those notices that do not
- pertain to any part of the Derivative Works, in at least one
- of the following places: within a NOTICE text file distributed
- as part of the Derivative Works; within the Source form or
- documentation, if provided along with the Derivative Works; or,
- within a display generated by the Derivative Works, if and
- wherever such third-party notices normally appear. The contents
- of the NOTICE file are for informational purposes only and
- do not modify the License. You may add Your own attribution
- notices within Derivative Works that You distribute, alongside
- or as an addendum to the NOTICE text from the Work, provided
- that such additional attribution notices cannot be construed
- as modifying the License.
-
- You may add Your own copyright statement to Your modifications and
- may provide additional or different license terms and conditions
- for use, reproduction, or distribution of Your modifications, or
- for any such Derivative Works as a whole, provided Your use,
- reproduction, and distribution of the Work otherwise complies with
- the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
- any Contribution intentionally submitted for inclusion in the Work
- by You to the Licensor shall be under the terms and conditions of
- this License, without any additional terms or conditions.
- Notwithstanding the above, nothing herein shall supersede or modify
- the terms of any separate license agreement you may have executed
- with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
- names, trademarks, service marks, or product names of the Licensor,
- except as required for reasonable and customary use in describing the
- origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
- agreed to in writing, Licensor provides the Work (and each
- Contributor provides its Contributions) on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
- implied, including, without limitation, any warranties or conditions
- of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
- PARTICULAR PURPOSE. You are solely responsible for determining the
- appropriateness of using or redistributing the Work and assume any
- risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
- whether in tort (including negligence), contract, or otherwise,
- unless required by applicable law (such as deliberate and grossly
- negligent acts) or agreed to in writing, shall any Contributor be
- liable to You for damages, including any direct, indirect, special,
- incidental, or consequential damages of any character arising as a
- result of this License or out of the use or inability to use the
- Work (including but not limited to damages for loss of goodwill,
- work stoppage, computer failure or malfunction, or any and all
- other commercial damages or losses), even if such Contributor
- has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
- the Work or Derivative Works thereof, You may choose to offer,
- and charge a fee for, acceptance of support, warranty, indemnity,
- or other liability obligations and/or rights consistent with this
- License. However, in accepting such obligations, You may act only
- on Your own behalf and on Your sole responsibility, not on behalf
- of any other Contributor, and only if You agree to indemnify,
- defend, and hold each Contributor harmless for any liability
- incurred by, or claims asserted against, such Contributor by reason
- of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
- To apply the Apache License to your work, attach the following
- boilerplate notice, with the fields enclosed by brackets "[]"
- replaced with your own identifying information. (Don't include
- the brackets!) The text should be enclosed in the appropriate
- comment syntax for the file format. We also recommend that a
- file or class name and description of purpose be included on the
- same "printed page" as the copyright notice for easier
- identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
diff --git a/vendor/bitflags-1.3.2/LICENSE-MIT b/vendor/bitflags-1.3.2/LICENSE-MIT
deleted file mode 100644
index 39d4bdb..0000000
--- a/vendor/bitflags-1.3.2/LICENSE-MIT
+++ /dev/null
@@ -1,25 +0,0 @@
-Copyright (c) 2014 The Rust Project Developers
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
diff --git a/vendor/bitflags-1.3.2/README.md b/vendor/bitflags-1.3.2/README.md
deleted file mode 100644
index 0da0f85..0000000
--- a/vendor/bitflags-1.3.2/README.md
+++ /dev/null
@@ -1,32 +0,0 @@
-bitflags
-========
-
-[](https://github.com/bitflags/bitflags/actions)
-[](https://gitter.im/bitflags/Lobby?utm_source=badge&utm_medium=badge&utm_content=badge)
-[](https://crates.io/crates/bitflags)
-[](https://docs.rs/bitflags)
-
-
-A Rust macro to generate structures which behave like a set of bitflags
-
-- [Documentation](https://docs.rs/bitflags)
-- [Release notes](https://github.com/bitflags/bitflags/releases)
-
-## Usage
-
-Add this to your `Cargo.toml`:
-
-```toml
-[dependencies]
-bitflags = "1.3"
-```
-
-and this to your source code:
-
-```rust
-use bitflags::bitflags;
-```
-
-## Rust Version Support
-
-The minimum supported Rust version is 1.46 due to use of associated constants and const functions.
diff --git a/vendor/bitflags-1.3.2/src/example_generated.rs b/vendor/bitflags-1.3.2/src/example_generated.rs
deleted file mode 100644
index cf188d9..0000000
--- a/vendor/bitflags-1.3.2/src/example_generated.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//! This module shows an example of code generated by the macro. **IT MUST NOT BE USED OUTSIDE THIS
-//! CRATE**.
-
-bitflags! {
- /// This is the same `Flags` struct defined in the [crate level example](../index.html#example).
- /// Note that this struct is just for documentation purposes only, it must not be used outside
- /// this crate.
- pub struct Flags: u32 {
- const A = 0b00000001;
- const B = 0b00000010;
- const C = 0b00000100;
- const ABC = Self::A.bits | Self::B.bits | Self::C.bits;
- }
-}
diff --git a/vendor/bitflags-1.3.2/src/lib.rs b/vendor/bitflags-1.3.2/src/lib.rs
deleted file mode 100644
index 935e432..0000000
--- a/vendor/bitflags-1.3.2/src/lib.rs
+++ /dev/null
@@ -1,1729 +0,0 @@
-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! A typesafe bitmask flag generator useful for sets of C-style bitmask flags.
-//! It can be used for creating typesafe wrappers around C APIs.
-//!
-//! The `bitflags!` macro generates `struct`s that manage a set of flags. The
-//! flags should only be defined for integer types, otherwise unexpected type
-//! errors may occur at compile time.
-//!
-//! # Example
-//!
-//! ```
-//! use bitflags::bitflags;
-//!
-//! bitflags! {
-//! struct Flags: u32 {
-//! const A = 0b00000001;
-//! const B = 0b00000010;
-//! const C = 0b00000100;
-//! const ABC = Self::A.bits | Self::B.bits | Self::C.bits;
-//! }
-//! }
-//!
-//! fn main() {
-//! let e1 = Flags::A | Flags::C;
-//! let e2 = Flags::B | Flags::C;
-//! assert_eq!((e1 | e2), Flags::ABC); // union
-//! assert_eq!((e1 & e2), Flags::C); // intersection
-//! assert_eq!((e1 - e2), Flags::A); // set difference
-//! assert_eq!(!e2, Flags::A); // set complement
-//! }
-//! ```
-//!
-//! See [`example_generated::Flags`](./example_generated/struct.Flags.html) for documentation of code
-//! generated by the above `bitflags!` expansion.
-//!
-//! The generated `struct`s can also be extended with type and trait
-//! implementations:
-//!
-//! ```
-//! use std::fmt;
-//!
-//! use bitflags::bitflags;
-//!
-//! bitflags! {
-//! struct Flags: u32 {
-//! const A = 0b00000001;
-//! const B = 0b00000010;
-//! }
-//! }
-//!
-//! impl Flags {
-//! pub fn clear(&mut self) {
-//! self.bits = 0; // The `bits` field can be accessed from within the
-//! // same module where the `bitflags!` macro was invoked.
-//! }
-//! }
-//!
-//! impl fmt::Display for Flags {
-//! fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-//! write!(f, "hi!")
-//! }
-//! }
-//!
-//! fn main() {
-//! let mut flags = Flags::A | Flags::B;
-//! flags.clear();
-//! assert!(flags.is_empty());
-//! assert_eq!(format!("{}", flags), "hi!");
-//! assert_eq!(format!("{:?}", Flags::A | Flags::B), "A | B");
-//! assert_eq!(format!("{:?}", Flags::B), "B");
-//! }
-//! ```
-//!
-//! # Visibility
-//!
-//! The generated structs and their associated flag constants are not exported
-//! out of the current module by default. A definition can be exported out of
-//! the current module by adding `pub` before `struct`:
-//!
-//! ```
-//! mod example {
-//! use bitflags::bitflags;
-//!
-//! bitflags! {
-//! pub struct Flags1: u32 {
-//! const A = 0b00000001;
-//! }
-//!
-//! # pub
-//! struct Flags2: u32 {
-//! const B = 0b00000010;
-//! }
-//! }
-//! }
-//!
-//! fn main() {
-//! let flag1 = example::Flags1::A;
-//! let flag2 = example::Flags2::B; // error: const `B` is private
-//! }
-//! ```
-//!
-//! # Attributes
-//!
-//! Attributes can be attached to the generated `struct`s by placing them
-//! before the `struct` keyword.
-//!
-//! ## Representations
-//!
-//! It's valid to add a `#[repr(C)]` or `#[repr(transparent)]` attribute to a type
-//! generated by `bitflags!`. In these cases, the type is guaranteed to be a newtype.
-//!
-//! ```
-//! use bitflags::bitflags;
-//!
-//! bitflags! {
-//! #[repr(transparent)]
-//! struct Flags: u32 {
-//! const A = 0b00000001;
-//! const B = 0b00000010;
-//! const C = 0b00000100;
-//! }
-//! }
-//! ```
-//!
-//! # Trait implementations
-//!
-//! The `Copy`, `Clone`, `PartialEq`, `Eq`, `PartialOrd`, `Ord` and `Hash`
-//! traits are automatically derived for the `struct`s using the `derive` attribute.
-//! Additional traits can be derived by providing an explicit `derive`
-//! attribute on `struct`.
-//!
-//! The `Extend` and `FromIterator` traits are implemented for the `struct`s,
-//! too: `Extend` adds the union of the instances of the `struct` iterated over,
-//! while `FromIterator` calculates the union.
-//!
-//! The `Binary`, `Debug`, `LowerHex`, `Octal` and `UpperHex` traits are also
-//! implemented by displaying the bits value of the internal struct.
-//!
-//! ## Operators
-//!
-//! The following operator traits are implemented for the generated `struct`s:
-//!
-//! - `BitOr` and `BitOrAssign`: union
-//! - `BitAnd` and `BitAndAssign`: intersection
-//! - `BitXor` and `BitXorAssign`: toggle
-//! - `Sub` and `SubAssign`: set difference
-//! - `Not`: set complement
-//!
-//! # Methods
-//!
-//! The following methods are defined for the generated `struct`s:
-//!
-//! - `empty`: an empty set of flags
-//! - `all`: the set of all defined flags
-//! - `bits`: the raw value of the flags currently stored
-//! - `from_bits`: convert from underlying bit representation, unless that
-//! representation contains bits that do not correspond to a
-//! defined flag
-//! - `from_bits_truncate`: convert from underlying bit representation, dropping
-//! any bits that do not correspond to defined flags
-//! - `from_bits_unchecked`: convert from underlying bit representation, keeping
-//! all bits (even those not corresponding to defined
-//! flags)
-//! - `is_empty`: `true` if no flags are currently stored
-//! - `is_all`: `true` if currently set flags exactly equal all defined flags
-//! - `intersects`: `true` if there are flags common to both `self` and `other`
-//! - `contains`: `true` if all of the flags in `other` are contained within `self`
-//! - `insert`: inserts the specified flags in-place
-//! - `remove`: removes the specified flags in-place
-//! - `toggle`: the specified flags will be inserted if not present, and removed
-//! if they are.
-//! - `set`: inserts or removes the specified flags depending on the passed value
-//! - `intersection`: returns a new set of flags, containing only the flags present
-//! in both `self` and `other` (the argument to the function).
-//! - `union`: returns a new set of flags, containing any flags present in
-//! either `self` or `other` (the argument to the function).
-//! - `difference`: returns a new set of flags, containing all flags present in
-//! `self` without any of the flags present in `other` (the
-//! argument to the function).
-//! - `symmetric_difference`: returns a new set of flags, containing all flags
-//! present in either `self` or `other` (the argument
-//! to the function), but not both.
-//! - `complement`: returns a new set of flags, containing all flags which are
-//! not set in `self`, but which are allowed for this type.
-//!
-//! ## Default
-//!
-//! The `Default` trait is not automatically implemented for the generated structs.
-//!
-//! If your default value is equal to `0` (which is the same value as calling `empty()`
-//! on the generated struct), you can simply derive `Default`:
-//!
-//! ```
-//! use bitflags::bitflags;
-//!
-//! bitflags! {
-//! // Results in default value with bits: 0
-//! #[derive(Default)]
-//! struct Flags: u32 {
-//! const A = 0b00000001;
-//! const B = 0b00000010;
-//! const C = 0b00000100;
-//! }
-//! }
-//!
-//! fn main() {
-//! let derived_default: Flags = Default::default();
-//! assert_eq!(derived_default.bits(), 0);
-//! }
-//! ```
-//!
-//! If your default value is not equal to `0` you need to implement `Default` yourself:
-//!
-//! ```
-//! use bitflags::bitflags;
-//!
-//! bitflags! {
-//! struct Flags: u32 {
-//! const A = 0b00000001;
-//! const B = 0b00000010;
-//! const C = 0b00000100;
-//! }
-//! }
-//!
-//! // explicit `Default` implementation
-//! impl Default for Flags {
-//! fn default() -> Flags {
-//! Flags::A | Flags::C
-//! }
-//! }
-//!
-//! fn main() {
-//! let implemented_default: Flags = Default::default();
-//! assert_eq!(implemented_default, (Flags::A | Flags::C));
-//! }
-//! ```
-//!
-//! # Zero Flags
-//!
-//! Flags with a value equal to zero will have some strange behavior that one should be aware of.
-//!
-//! ```
-//! use bitflags::bitflags;
-//!
-//! bitflags! {
-//! struct Flags: u32 {
-//! const NONE = 0b00000000;
-//! const SOME = 0b00000001;
-//! }
-//! }
-//!
-//! fn main() {
-//! let empty = Flags::empty();
-//! let none = Flags::NONE;
-//! let some = Flags::SOME;
-//!
-//! // Zero flags are treated as always present
-//! assert!(empty.contains(Flags::NONE));
-//! assert!(none.contains(Flags::NONE));
-//! assert!(some.contains(Flags::NONE));
-//!
-//! // Zero flags will be ignored when testing for emptiness
-//! assert!(none.is_empty());
-//! }
-//! ```
-//!
-//! Users should generally avoid defining a flag with a value of zero.
-
-#![cfg_attr(not(test), no_std)]
-#![doc(html_root_url = "https://docs.rs/bitflags/1.3.2")]
-
-#[doc(hidden)]
-pub extern crate core as _core;
-
-/// The macro used to generate the flag structures.
-///
-/// See the [crate level docs](../bitflags/index.html) for complete documentation.
-///
-/// # Example
-///
-/// ```
-/// use bitflags::bitflags;
-///
-/// bitflags! {
-/// struct Flags: u32 {
-/// const A = 0b00000001;
-/// const B = 0b00000010;
-/// const C = 0b00000100;
-/// const ABC = Self::A.bits | Self::B.bits | Self::C.bits;
-/// }
-/// }
-///
-/// fn main() {
-/// let e1 = Flags::A | Flags::C;
-/// let e2 = Flags::B | Flags::C;
-/// assert_eq!((e1 | e2), Flags::ABC); // union
-/// assert_eq!((e1 & e2), Flags::C); // intersection
-/// assert_eq!((e1 - e2), Flags::A); // set difference
-/// assert_eq!(!e2, Flags::A); // set complement
-/// }
-/// ```
-///
-/// The generated `struct`s can also be extended with type and trait
-/// implementations:
-///
-/// ```
-/// use std::fmt;
-///
-/// use bitflags::bitflags;
-///
-/// bitflags! {
-/// struct Flags: u32 {
-/// const A = 0b00000001;
-/// const B = 0b00000010;
-/// }
-/// }
-///
-/// impl Flags {
-/// pub fn clear(&mut self) {
-/// self.bits = 0; // The `bits` field can be accessed from within the
-/// // same module where the `bitflags!` macro was invoked.
-/// }
-/// }
-///
-/// impl fmt::Display for Flags {
-/// fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-/// write!(f, "hi!")
-/// }
-/// }
-///
-/// fn main() {
-/// let mut flags = Flags::A | Flags::B;
-/// flags.clear();
-/// assert!(flags.is_empty());
-/// assert_eq!(format!("{}", flags), "hi!");
-/// assert_eq!(format!("{:?}", Flags::A | Flags::B), "A | B");
-/// assert_eq!(format!("{:?}", Flags::B), "B");
-/// }
-/// ```
-#[macro_export(local_inner_macros)]
-macro_rules! bitflags {
- (
- $(#[$outer:meta])*
- $vis:vis struct $BitFlags:ident: $T:ty {
- $(
- $(#[$inner:ident $($args:tt)*])*
- const $Flag:ident = $value:expr;
- )*
- }
-
- $($t:tt)*
- ) => {
- $(#[$outer])*
- #[derive(Copy, PartialEq, Eq, Clone, PartialOrd, Ord, Hash)]
- $vis struct $BitFlags {
- bits: $T,
- }
-
- __impl_bitflags! {
- $BitFlags: $T {
- $(
- $(#[$inner $($args)*])*
- $Flag = $value;
- )*
- }
- }
-
- bitflags! {
- $($t)*
- }
- };
- () => {};
-}
-
-// A helper macro to implement the `all` function.
-#[macro_export(local_inner_macros)]
-#[doc(hidden)]
-macro_rules! __impl_all_bitflags {
- (
- $BitFlags:ident: $T:ty {
- $(
- $(#[$attr:ident $($args:tt)*])*
- $Flag:ident = $value:expr;
- )+
- }
- ) => {
- // See `Debug::fmt` for why this approach is taken.
- #[allow(non_snake_case)]
- trait __BitFlags {
- $(
- const $Flag: $T = 0;
- )+
- }
- #[allow(non_snake_case)]
- impl __BitFlags for $BitFlags {
- $(
- __impl_bitflags! {
- #[allow(deprecated)]
- $(? #[$attr $($args)*])*
- const $Flag: $T = Self::$Flag.bits;
- }
- )+
- }
- Self { bits: $(<Self as __BitFlags>::$Flag)|+ }
- };
- (
- $BitFlags:ident: $T:ty { }
- ) => {
- Self { bits: 0 }
- };
-}
-
-#[macro_export(local_inner_macros)]
-#[doc(hidden)]
-macro_rules! __impl_bitflags {
- (
- $BitFlags:ident: $T:ty {
- $(
- $(#[$attr:ident $($args:tt)*])*
- $Flag:ident = $value:expr;
- )*
- }
- ) => {
- impl $crate::_core::fmt::Debug for $BitFlags {
- fn fmt(&self, f: &mut $crate::_core::fmt::Formatter) -> $crate::_core::fmt::Result {
- // This convoluted approach is to handle #[cfg]-based flag
- // omission correctly. For example it needs to support:
- //
- // #[cfg(unix)] const A: Flag = /* ... */;
- // #[cfg(windows)] const B: Flag = /* ... */;
-
- // Unconditionally define a check for every flag, even disabled
- // ones.
- #[allow(non_snake_case)]
- trait __BitFlags {
- $(
- #[inline]
- fn $Flag(&self) -> bool { false }
- )*
- }
-
- // Conditionally override the check for just those flags that
- // are not #[cfg]ed away.
- #[allow(non_snake_case)]
- impl __BitFlags for $BitFlags {
- $(
- __impl_bitflags! {
- #[allow(deprecated)]
- #[inline]
- $(? #[$attr $($args)*])*
- fn $Flag(&self) -> bool {
- if Self::$Flag.bits == 0 && self.bits != 0 {
- false
- } else {
- self.bits & Self::$Flag.bits == Self::$Flag.bits
- }
- }
- }
- )*
- }
-
- let mut first = true;
- $(
- if <Self as __BitFlags>::$Flag(self) {
- if !first {
- f.write_str(" | ")?;
- }
- first = false;
- f.write_str($crate::_core::stringify!($Flag))?;
- }
- )*
- let extra_bits = self.bits & !Self::all().bits();
- if extra_bits != 0 {
- if !first {
- f.write_str(" | ")?;
- }
- first = false;
- f.write_str("0x")?;
- $crate::_core::fmt::LowerHex::fmt(&extra_bits, f)?;
- }
- if first {
- f.write_str("(empty)")?;
- }
- Ok(())
- }
- }
- impl $crate::_core::fmt::Binary for $BitFlags {
- fn fmt(&self, f: &mut $crate::_core::fmt::Formatter) -> $crate::_core::fmt::Result {
- $crate::_core::fmt::Binary::fmt(&self.bits, f)
- }
- }
- impl $crate::_core::fmt::Octal for $BitFlags {
- fn fmt(&self, f: &mut $crate::_core::fmt::Formatter) -> $crate::_core::fmt::Result {
- $crate::_core::fmt::Octal::fmt(&self.bits, f)
- }
- }
- impl $crate::_core::fmt::LowerHex for $BitFlags {
- fn fmt(&self, f: &mut $crate::_core::fmt::Formatter) -> $crate::_core::fmt::Result {
- $crate::_core::fmt::LowerHex::fmt(&self.bits, f)
- }
- }
- impl $crate::_core::fmt::UpperHex for $BitFlags {
- fn fmt(&self, f: &mut $crate::_core::fmt::Formatter) -> $crate::_core::fmt::Result {
- $crate::_core::fmt::UpperHex::fmt(&self.bits, f)
- }
- }
-
- #[allow(dead_code)]
- impl $BitFlags {
- $(
- $(#[$attr $($args)*])*
- pub const $Flag: Self = Self { bits: $value };
- )*
-
- /// Returns an empty set of flags.
- #[inline]
- pub const fn empty() -> Self {
- Self { bits: 0 }
- }
-
- /// Returns the set containing all flags.
- #[inline]
- pub const fn all() -> Self {
- __impl_all_bitflags! {
- $BitFlags: $T {
- $(
- $(#[$attr $($args)*])*
- $Flag = $value;
- )*
- }
- }
- }
-
- /// Returns the raw value of the flags currently stored.
- #[inline]
- pub const fn bits(&self) -> $T {
- self.bits
- }
-
- /// Convert from underlying bit representation, unless that
- /// representation contains bits that do not correspond to a flag.
- #[inline]
- pub const fn from_bits(bits: $T) -> $crate::_core::option::Option<Self> {
- if (bits & !Self::all().bits()) == 0 {
- $crate::_core::option::Option::Some(Self { bits })
- } else {
- $crate::_core::option::Option::None
- }
- }
-
- /// Convert from underlying bit representation, dropping any bits
- /// that do not correspond to flags.
- #[inline]
- pub const fn from_bits_truncate(bits: $T) -> Self {
- Self { bits: bits & Self::all().bits }
- }
-
- /// Convert from underlying bit representation, preserving all
- /// bits (even those not corresponding to a defined flag).
- ///
- /// # Safety
- ///
- /// The caller of the `bitflags!` macro can chose to allow or
- /// disallow extra bits for their bitflags type.
- ///
- /// The caller of `from_bits_unchecked()` has to ensure that
- /// all bits correspond to a defined flag or that extra bits
- /// are valid for this bitflags type.
- #[inline]
- pub const unsafe fn from_bits_unchecked(bits: $T) -> Self {
- Self { bits }
- }
-
- /// Returns `true` if no flags are currently stored.
- #[inline]
- pub const fn is_empty(&self) -> bool {
- self.bits() == Self::empty().bits()
- }
-
- /// Returns `true` if all flags are currently set.
- #[inline]
- pub const fn is_all(&self) -> bool {
- Self::all().bits | self.bits == self.bits
- }
-
- /// Returns `true` if there are flags common to both `self` and `other`.
- #[inline]
- pub const fn intersects(&self, other: Self) -> bool {
- !(Self { bits: self.bits & other.bits}).is_empty()
- }
-
- /// Returns `true` if all of the flags in `other` are contained within `self`.
- #[inline]
- pub const fn contains(&self, other: Self) -> bool {
- (self.bits & other.bits) == other.bits
- }
-
- /// Inserts the specified flags in-place.
- #[inline]
- pub fn insert(&mut self, other: Self) {
- self.bits |= other.bits;
- }
-
- /// Removes the specified flags in-place.
- #[inline]
- pub fn remove(&mut self, other: Self) {
- self.bits &= !other.bits;
- }
-
- /// Toggles the specified flags in-place.
- #[inline]
- pub fn toggle(&mut self, other: Self) {
- self.bits ^= other.bits;
- }
-
- /// Inserts or removes the specified flags depending on the passed value.
- #[inline]
- pub fn set(&mut self, other: Self, value: bool) {
- if value {
- self.insert(other);
- } else {
- self.remove(other);
- }
- }
-
- /// Returns the intersection between the flags in `self` and
- /// `other`.
- ///
- /// Specifically, the returned set contains only the flags which are
- /// present in *both* `self` *and* `other`.
- ///
- /// This is equivalent to using the `&` operator (e.g.
- /// [`ops::BitAnd`]), as in `flags & other`.
- ///
- /// [`ops::BitAnd`]: https://doc.rust-lang.org/std/ops/trait.BitAnd.html
- #[inline]
- #[must_use]
- pub const fn intersection(self, other: Self) -> Self {
- Self { bits: self.bits & other.bits }
- }
-
- /// Returns the union of between the flags in `self` and `other`.
- ///
- /// Specifically, the returned set contains all flags which are
- /// present in *either* `self` *or* `other`, including any which are
- /// present in both (see [`Self::symmetric_difference`] if that
- /// is undesirable).
- ///
- /// This is equivalent to using the `|` operator (e.g.
- /// [`ops::BitOr`]), as in `flags | other`.
- ///
- /// [`ops::BitOr`]: https://doc.rust-lang.org/std/ops/trait.BitOr.html
- #[inline]
- #[must_use]
- pub const fn union(self, other: Self) -> Self {
- Self { bits: self.bits | other.bits }
- }
-
- /// Returns the difference between the flags in `self` and `other`.
- ///
- /// Specifically, the returned set contains all flags present in
- /// `self`, except for the ones present in `other`.
- ///
- /// It is also conceptually equivalent to the "bit-clear" operation:
- /// `flags & !other` (and this syntax is also supported).
- ///
- /// This is equivalent to using the `-` operator (e.g.
- /// [`ops::Sub`]), as in `flags - other`.
- ///
- /// [`ops::Sub`]: https://doc.rust-lang.org/std/ops/trait.Sub.html
- #[inline]
- #[must_use]
- pub const fn difference(self, other: Self) -> Self {
- Self { bits: self.bits & !other.bits }
- }
-
- /// Returns the [symmetric difference][sym-diff] between the flags
- /// in `self` and `other`.
- ///
- /// Specifically, the returned set contains the flags present which
- /// are present in `self` or `other`, but that are not present in
- /// both. Equivalently, it contains the flags present in *exactly
- /// one* of the sets `self` and `other`.
- ///
- /// This is equivalent to using the `^` operator (e.g.
- /// [`ops::BitXor`]), as in `flags ^ other`.
- ///
- /// [sym-diff]: https://en.wikipedia.org/wiki/Symmetric_difference
- /// [`ops::BitXor`]: https://doc.rust-lang.org/std/ops/trait.BitXor.html
- #[inline]
- #[must_use]
- pub const fn symmetric_difference(self, other: Self) -> Self {
- Self { bits: self.bits ^ other.bits }
- }
-
- /// Returns the complement of this set of flags.
- ///
- /// Specifically, the returned set contains all the flags which are
- /// not set in `self`, but which are allowed for this type.
- ///
- /// Alternatively, it can be thought of as the set difference
- /// between [`Self::all()`] and `self` (e.g. `Self::all() - self`)
- ///
- /// This is equivalent to using the `!` operator (e.g.
- /// [`ops::Not`]), as in `!flags`.
- ///
- /// [`Self::all()`]: Self::all
- /// [`ops::Not`]: https://doc.rust-lang.org/std/ops/trait.Not.html
- #[inline]
- #[must_use]
- pub const fn complement(self) -> Self {
- Self::from_bits_truncate(!self.bits)
- }
-
- }
-
- impl $crate::_core::ops::BitOr for $BitFlags {
- type Output = Self;
-
- /// Returns the union of the two sets of flags.
- #[inline]
- fn bitor(self, other: $BitFlags) -> Self {
- Self { bits: self.bits | other.bits }
- }
- }
-
- impl $crate::_core::ops::BitOrAssign for $BitFlags {
- /// Adds the set of flags.
- #[inline]
- fn bitor_assign(&mut self, other: Self) {
- self.bits |= other.bits;
- }
- }
-
- impl $crate::_core::ops::BitXor for $BitFlags {
- type Output = Self;
-
- /// Returns the left flags, but with all the right flags toggled.
- #[inline]
- fn bitxor(self, other: Self) -> Self {
- Self { bits: self.bits ^ other.bits }
- }
- }
-
- impl $crate::_core::ops::BitXorAssign for $BitFlags {
- /// Toggles the set of flags.
- #[inline]
- fn bitxor_assign(&mut self, other: Self) {
- self.bits ^= other.bits;
- }
- }
-
- impl $crate::_core::ops::BitAnd for $BitFlags {
- type Output = Self;
-
- /// Returns the intersection between the two sets of flags.
- #[inline]
- fn bitand(self, other: Self) -> Self {
- Self { bits: self.bits & other.bits }
- }
- }
-
- impl $crate::_core::ops::BitAndAssign for $BitFlags {
- /// Disables all flags disabled in the set.
- #[inline]
- fn bitand_assign(&mut self, other: Self) {
- self.bits &= other.bits;
- }
- }
-
- impl $crate::_core::ops::Sub for $BitFlags {
- type Output = Self;
-
- /// Returns the set difference of the two sets of flags.
- #[inline]
- fn sub(self, other: Self) -> Self {
- Self { bits: self.bits & !other.bits }
- }
- }
-
- impl $crate::_core::ops::SubAssign for $BitFlags {
- /// Disables all flags enabled in the set.
- #[inline]
- fn sub_assign(&mut self, other: Self) {
- self.bits &= !other.bits;
- }
- }
-
- impl $crate::_core::ops::Not for $BitFlags {
- type Output = Self;
-
- /// Returns the complement of this set of flags.
- #[inline]
- fn not(self) -> Self {
- Self { bits: !self.bits } & Self::all()
- }
- }
-
- impl $crate::_core::iter::Extend<$BitFlags> for $BitFlags {
- fn extend<T: $crate::_core::iter::IntoIterator<Item=Self>>(&mut self, iterator: T) {
- for item in iterator {
- self.insert(item)
- }
- }
- }
-
- impl $crate::_core::iter::FromIterator<$BitFlags> for $BitFlags {
- fn from_iter<T: $crate::_core::iter::IntoIterator<Item=Self>>(iterator: T) -> Self {
- let mut result = Self::empty();
- result.extend(iterator);
- result
- }
- }
- };
-
- // Every attribute that the user writes on a const is applied to the
- // corresponding const that we generate, but within the implementation of
- // Debug and all() we want to ignore everything but #[cfg] attributes. In
- // particular, including a #[deprecated] attribute on those items would fail
- // to compile.
- // https://github.com/bitflags/bitflags/issues/109
- //
- // Input:
- //
- // ? #[cfg(feature = "advanced")]
- // ? #[deprecated(note = "Use something else.")]
- // ? #[doc = r"High quality documentation."]
- // fn f() -> i32 { /* ... */ }
- //
- // Output:
- //
- // #[cfg(feature = "advanced")]
- // fn f() -> i32 { /* ... */ }
- (
- $(#[$filtered:meta])*
- ? #[cfg $($cfgargs:tt)*]
- $(? #[$rest:ident $($restargs:tt)*])*
- fn $($item:tt)*
- ) => {
- __impl_bitflags! {
- $(#[$filtered])*
- #[cfg $($cfgargs)*]
- $(? #[$rest $($restargs)*])*
- fn $($item)*
- }
- };
- (
- $(#[$filtered:meta])*
- // $next != `cfg`
- ? #[$next:ident $($nextargs:tt)*]
- $(? #[$rest:ident $($restargs:tt)*])*
- fn $($item:tt)*
- ) => {
- __impl_bitflags! {
- $(#[$filtered])*
- // $next filtered out
- $(? #[$rest $($restargs)*])*
- fn $($item)*
- }
- };
- (
- $(#[$filtered:meta])*
- fn $($item:tt)*
- ) => {
- $(#[$filtered])*
- fn $($item)*
- };
-
- // Every attribute that the user writes on a const is applied to the
- // corresponding const that we generate, but within the implementation of
- // Debug and all() we want to ignore everything but #[cfg] attributes. In
- // particular, including a #[deprecated] attribute on those items would fail
- // to compile.
- // https://github.com/bitflags/bitflags/issues/109
- //
- // const version
- //
- // Input:
- //
- // ? #[cfg(feature = "advanced")]
- // ? #[deprecated(note = "Use something else.")]
- // ? #[doc = r"High quality documentation."]
- // const f: i32 { /* ... */ }
- //
- // Output:
- //
- // #[cfg(feature = "advanced")]
- // const f: i32 { /* ... */ }
- (
- $(#[$filtered:meta])*
- ? #[cfg $($cfgargs:tt)*]
- $(? #[$rest:ident $($restargs:tt)*])*
- const $($item:tt)*
- ) => {
- __impl_bitflags! {
- $(#[$filtered])*
- #[cfg $($cfgargs)*]
- $(? #[$rest $($restargs)*])*
- const $($item)*
- }
- };
- (
- $(#[$filtered:meta])*
- // $next != `cfg`
- ? #[$next:ident $($nextargs:tt)*]
- $(? #[$rest:ident $($restargs:tt)*])*
- const $($item:tt)*
- ) => {
- __impl_bitflags! {
- $(#[$filtered])*
- // $next filtered out
- $(? #[$rest $($restargs)*])*
- const $($item)*
- }
- };
- (
- $(#[$filtered:meta])*
- const $($item:tt)*
- ) => {
- $(#[$filtered])*
- const $($item)*
- };
-}
-
-#[cfg(feature = "example_generated")]
-pub mod example_generated;
-
-#[cfg(test)]
-mod tests {
- use std::collections::hash_map::DefaultHasher;
- use std::hash::{Hash, Hasher};
-
- bitflags! {
- #[doc = "> The first principle is that you must not fool yourself — and"]
- #[doc = "> you are the easiest person to fool."]
- #[doc = "> "]
- #[doc = "> - Richard Feynman"]
- #[derive(Default)]
- struct Flags: u32 {
- const A = 0b00000001;
- #[doc = "<pcwalton> macros are way better at generating code than trans is"]
- const B = 0b00000010;
- const C = 0b00000100;
- #[doc = "* cmr bed"]
- #[doc = "* strcat table"]
- #[doc = "<strcat> wait what?"]
- const ABC = Self::A.bits | Self::B.bits | Self::C.bits;
- }
-
- struct _CfgFlags: u32 {
- #[cfg(unix)]
- const _CFG_A = 0b01;
- #[cfg(windows)]
- const _CFG_B = 0b01;
- #[cfg(unix)]
- const _CFG_C = Self::_CFG_A.bits | 0b10;
- }
-
- struct AnotherSetOfFlags: i8 {
- const ANOTHER_FLAG = -1_i8;
- }
-
- struct LongFlags: u32 {
- const LONG_A = 0b1111111111111111;
- }
- }
-
- bitflags! {
- struct EmptyFlags: u32 {
- }
- }
-
- #[test]
- fn test_bits() {
- assert_eq!(Flags::empty().bits(), 0b00000000);
- assert_eq!(Flags::A.bits(), 0b00000001);
- assert_eq!(Flags::ABC.bits(), 0b00000111);
-
- assert_eq!(AnotherSetOfFlags::empty().bits(), 0b00);
- assert_eq!(AnotherSetOfFlags::ANOTHER_FLAG.bits(), !0_i8);
-
- assert_eq!(EmptyFlags::empty().bits(), 0b00000000);
- }
-
- #[test]
- fn test_from_bits() {
- assert_eq!(Flags::from_bits(0), Some(Flags::empty()));
- assert_eq!(Flags::from_bits(0b1), Some(Flags::A));
- assert_eq!(Flags::from_bits(0b10), Some(Flags::B));
- assert_eq!(Flags::from_bits(0b11), Some(Flags::A | Flags::B));
- assert_eq!(Flags::from_bits(0b1000), None);
-
- assert_eq!(
- AnotherSetOfFlags::from_bits(!0_i8),
- Some(AnotherSetOfFlags::ANOTHER_FLAG)
- );
-
- assert_eq!(EmptyFlags::from_bits(0), Some(EmptyFlags::empty()));
- assert_eq!(EmptyFlags::from_bits(0b1), None);
- }
-
- #[test]
- fn test_from_bits_truncate() {
- assert_eq!(Flags::from_bits_truncate(0), Flags::empty());
- assert_eq!(Flags::from_bits_truncate(0b1), Flags::A);
- assert_eq!(Flags::from_bits_truncate(0b10), Flags::B);
- assert_eq!(Flags::from_bits_truncate(0b11), (Flags::A | Flags::B));
- assert_eq!(Flags::from_bits_truncate(0b1000), Flags::empty());
- assert_eq!(Flags::from_bits_truncate(0b1001), Flags::A);
-
- assert_eq!(
- AnotherSetOfFlags::from_bits_truncate(0_i8),
- AnotherSetOfFlags::empty()
- );
-
- assert_eq!(EmptyFlags::from_bits_truncate(0), EmptyFlags::empty());
- assert_eq!(EmptyFlags::from_bits_truncate(0b1), EmptyFlags::empty());
- }
-
- #[test]
- fn test_from_bits_unchecked() {
- let extra = unsafe { Flags::from_bits_unchecked(0b1000) };
- assert_eq!(unsafe { Flags::from_bits_unchecked(0) }, Flags::empty());
- assert_eq!(unsafe { Flags::from_bits_unchecked(0b1) }, Flags::A);
- assert_eq!(unsafe { Flags::from_bits_unchecked(0b10) }, Flags::B);
-
- assert_eq!(
- unsafe { Flags::from_bits_unchecked(0b11) },
- (Flags::A | Flags::B)
- );
- assert_eq!(
- unsafe { Flags::from_bits_unchecked(0b1000) },
- (extra | Flags::empty())
- );
- assert_eq!(
- unsafe { Flags::from_bits_unchecked(0b1001) },
- (extra | Flags::A)
- );
-
- let extra = unsafe { EmptyFlags::from_bits_unchecked(0b1000) };
- assert_eq!(
- unsafe { EmptyFlags::from_bits_unchecked(0b1000) },
- (extra | EmptyFlags::empty())
- );
- }
-
- #[test]
- fn test_is_empty() {
- assert!(Flags::empty().is_empty());
- assert!(!Flags::A.is_empty());
- assert!(!Flags::ABC.is_empty());
-
- assert!(!AnotherSetOfFlags::ANOTHER_FLAG.is_empty());
-
- assert!(EmptyFlags::empty().is_empty());
- assert!(EmptyFlags::all().is_empty());
- }
-
- #[test]
- fn test_is_all() {
- assert!(Flags::all().is_all());
- assert!(!Flags::A.is_all());
- assert!(Flags::ABC.is_all());
-
- let extra = unsafe { Flags::from_bits_unchecked(0b1000) };
- assert!(!extra.is_all());
- assert!(!(Flags::A | extra).is_all());
- assert!((Flags::ABC | extra).is_all());
-
- assert!(AnotherSetOfFlags::ANOTHER_FLAG.is_all());
-
- assert!(EmptyFlags::all().is_all());
- assert!(EmptyFlags::empty().is_all());
- }
-
- #[test]
- fn test_two_empties_do_not_intersect() {
- let e1 = Flags::empty();
- let e2 = Flags::empty();
- assert!(!e1.intersects(e2));
-
- assert!(AnotherSetOfFlags::ANOTHER_FLAG.intersects(AnotherSetOfFlags::ANOTHER_FLAG));
- }
-
- #[test]
- fn test_empty_does_not_intersect_with_full() {
- let e1 = Flags::empty();
- let e2 = Flags::ABC;
- assert!(!e1.intersects(e2));
- }
-
- #[test]
- fn test_disjoint_intersects() {
- let e1 = Flags::A;
- let e2 = Flags::B;
- assert!(!e1.intersects(e2));
- }
-
- #[test]
- fn test_overlapping_intersects() {
- let e1 = Flags::A;
- let e2 = Flags::A | Flags::B;
- assert!(e1.intersects(e2));
- }
-
- #[test]
- fn test_contains() {
- let e1 = Flags::A;
- let e2 = Flags::A | Flags::B;
- assert!(!e1.contains(e2));
- assert!(e2.contains(e1));
- assert!(Flags::ABC.contains(e2));
-
- assert!(AnotherSetOfFlags::ANOTHER_FLAG.contains(AnotherSetOfFlags::ANOTHER_FLAG));
-
- assert!(EmptyFlags::empty().contains(EmptyFlags::empty()));
- }
-
- #[test]
- fn test_insert() {
- let mut e1 = Flags::A;
- let e2 = Flags::A | Flags::B;
- e1.insert(e2);
- assert_eq!(e1, e2);
-
- let mut e3 = AnotherSetOfFlags::empty();
- e3.insert(AnotherSetOfFlags::ANOTHER_FLAG);
- assert_eq!(e3, AnotherSetOfFlags::ANOTHER_FLAG);
- }
-
- #[test]
- fn test_remove() {
- let mut e1 = Flags::A | Flags::B;
- let e2 = Flags::A | Flags::C;
- e1.remove(e2);
- assert_eq!(e1, Flags::B);
-
- let mut e3 = AnotherSetOfFlags::ANOTHER_FLAG;
- e3.remove(AnotherSetOfFlags::ANOTHER_FLAG);
- assert_eq!(e3, AnotherSetOfFlags::empty());
- }
-
- #[test]
- fn test_operators() {
- let e1 = Flags::A | Flags::C;
- let e2 = Flags::B | Flags::C;
- assert_eq!((e1 | e2), Flags::ABC); // union
- assert_eq!((e1 & e2), Flags::C); // intersection
- assert_eq!((e1 - e2), Flags::A); // set difference
- assert_eq!(!e2, Flags::A); // set complement
- assert_eq!(e1 ^ e2, Flags::A | Flags::B); // toggle
- let mut e3 = e1;
- e3.toggle(e2);
- assert_eq!(e3, Flags::A | Flags::B);
-
- let mut m4 = AnotherSetOfFlags::empty();
- m4.toggle(AnotherSetOfFlags::empty());
- assert_eq!(m4, AnotherSetOfFlags::empty());
- }
-
- #[test]
- fn test_operators_unchecked() {
- let extra = unsafe { Flags::from_bits_unchecked(0b1000) };
- let e1 = Flags::A | Flags::C | extra;
- let e2 = Flags::B | Flags::C;
- assert_eq!((e1 | e2), (Flags::ABC | extra)); // union
- assert_eq!((e1 & e2), Flags::C); // intersection
- assert_eq!((e1 - e2), (Flags::A | extra)); // set difference
- assert_eq!(!e2, Flags::A); // set complement
- assert_eq!(!e1, Flags::B); // set complement
- assert_eq!(e1 ^ e2, Flags::A | Flags::B | extra); // toggle
- let mut e3 = e1;
- e3.toggle(e2);
- assert_eq!(e3, Flags::A | Flags::B | extra);
- }
-
- #[test]
- fn test_set_ops_basic() {
- let ab = Flags::A.union(Flags::B);
- let ac = Flags::A.union(Flags::C);
- let bc = Flags::B.union(Flags::C);
- assert_eq!(ab.bits, 0b011);
- assert_eq!(bc.bits, 0b110);
- assert_eq!(ac.bits, 0b101);
-
- assert_eq!(ab, Flags::B.union(Flags::A));
- assert_eq!(ac, Flags::C.union(Flags::A));
- assert_eq!(bc, Flags::C.union(Flags::B));
-
- assert_eq!(ac, Flags::A | Flags::C);
- assert_eq!(bc, Flags::B | Flags::C);
- assert_eq!(ab.union(bc), Flags::ABC);
-
- assert_eq!(ac, Flags::A | Flags::C);
- assert_eq!(bc, Flags::B | Flags::C);
-
- assert_eq!(ac.union(bc), ac | bc);
- assert_eq!(ac.union(bc), Flags::ABC);
- assert_eq!(bc.union(ac), Flags::ABC);
-
- assert_eq!(ac.intersection(bc), ac & bc);
- assert_eq!(ac.intersection(bc), Flags::C);
- assert_eq!(bc.intersection(ac), Flags::C);
-
- assert_eq!(ac.difference(bc), ac - bc);
- assert_eq!(bc.difference(ac), bc - ac);
- assert_eq!(ac.difference(bc), Flags::A);
- assert_eq!(bc.difference(ac), Flags::B);
-
- assert_eq!(bc.complement(), !bc);
- assert_eq!(bc.complement(), Flags::A);
- assert_eq!(ac.symmetric_difference(bc), Flags::A.union(Flags::B));
- assert_eq!(bc.symmetric_difference(ac), Flags::A.union(Flags::B));
- }
-
- #[test]
- fn test_set_ops_const() {
- // These just test that these compile and don't cause use-site panics
- // (would be possible if we had some sort of UB)
- const INTERSECT: Flags = Flags::all().intersection(Flags::C);
- const UNION: Flags = Flags::A.union(Flags::C);
- const DIFFERENCE: Flags = Flags::all().difference(Flags::A);
- const COMPLEMENT: Flags = Flags::C.complement();
- const SYM_DIFFERENCE: Flags = UNION.symmetric_difference(DIFFERENCE);
- assert_eq!(INTERSECT, Flags::C);
- assert_eq!(UNION, Flags::A | Flags::C);
- assert_eq!(DIFFERENCE, Flags::all() - Flags::A);
- assert_eq!(COMPLEMENT, !Flags::C);
- assert_eq!(SYM_DIFFERENCE, (Flags::A | Flags::C) ^ (Flags::all() - Flags::A));
- }
-
- #[test]
- fn test_set_ops_unchecked() {
- let extra = unsafe { Flags::from_bits_unchecked(0b1000) };
- let e1 = Flags::A.union(Flags::C).union(extra);
- let e2 = Flags::B.union(Flags::C);
- assert_eq!(e1.bits, 0b1101);
- assert_eq!(e1.union(e2), (Flags::ABC | extra));
- assert_eq!(e1.intersection(e2), Flags::C);
- assert_eq!(e1.difference(e2), Flags::A | extra);
- assert_eq!(e2.difference(e1), Flags::B);
- assert_eq!(e2.complement(), Flags::A);
- assert_eq!(e1.complement(), Flags::B);
- assert_eq!(e1.symmetric_difference(e2), Flags::A | Flags::B | extra); // toggle
- }
-
- #[test]
- fn test_set_ops_exhaustive() {
- // Define a flag that contains gaps to help exercise edge-cases,
- // especially around "unknown" flags (e.g. ones outside of `all()`
- // `from_bits_unchecked`).
- // - when lhs and rhs both have different sets of unknown flags.
- // - unknown flags at both ends, and in the middle
- // - cases with "gaps".
- bitflags! {
- struct Test: u16 {
- // Intentionally no `A`
- const B = 0b000000010;
- // Intentionally no `C`
- const D = 0b000001000;
- const E = 0b000010000;
- const F = 0b000100000;
- const G = 0b001000000;
- // Intentionally no `H`
- const I = 0b100000000;
- }
- }
- let iter_test_flags =
- || (0..=0b111_1111_1111).map(|bits| unsafe { Test::from_bits_unchecked(bits) });
-
- for a in iter_test_flags() {
- assert_eq!(
- a.complement(),
- Test::from_bits_truncate(!a.bits),
- "wrong result: !({:?})",
- a,
- );
- assert_eq!(a.complement(), !a, "named != op: !({:?})", a);
- for b in iter_test_flags() {
- // Check that the named operations produce the expected bitwise
- // values.
- assert_eq!(
- a.union(b).bits,
- a.bits | b.bits,
- "wrong result: `{:?}` | `{:?}`",
- a,
- b,
- );
- assert_eq!(
- a.intersection(b).bits,
- a.bits & b.bits,
- "wrong result: `{:?}` & `{:?}`",
- a,
- b,
- );
- assert_eq!(
- a.symmetric_difference(b).bits,
- a.bits ^ b.bits,
- "wrong result: `{:?}` ^ `{:?}`",
- a,
- b,
- );
- assert_eq!(
- a.difference(b).bits,
- a.bits & !b.bits,
- "wrong result: `{:?}` - `{:?}`",
- a,
- b,
- );
- // Note: Difference is checked as both `a - b` and `b - a`
- assert_eq!(
- b.difference(a).bits,
- b.bits & !a.bits,
- "wrong result: `{:?}` - `{:?}`",
- b,
- a,
- );
- // Check that the named set operations are equivalent to the
- // bitwise equivalents
- assert_eq!(a.union(b), a | b, "named != op: `{:?}` | `{:?}`", a, b,);
- assert_eq!(
- a.intersection(b),
- a & b,
- "named != op: `{:?}` & `{:?}`",
- a,
- b,
- );
- assert_eq!(
- a.symmetric_difference(b),
- a ^ b,
- "named != op: `{:?}` ^ `{:?}`",
- a,
- b,
- );
- assert_eq!(a.difference(b), a - b, "named != op: `{:?}` - `{:?}`", a, b,);
- // Note: Difference is checked as both `a - b` and `b - a`
- assert_eq!(b.difference(a), b - a, "named != op: `{:?}` - `{:?}`", b, a,);
- // Verify that the operations which should be symmetric are
- // actually symmetric.
- assert_eq!(a.union(b), b.union(a), "asymmetry: `{:?}` | `{:?}`", a, b,);
- assert_eq!(
- a.intersection(b),
- b.intersection(a),
- "asymmetry: `{:?}` & `{:?}`",
- a,
- b,
- );
- assert_eq!(
- a.symmetric_difference(b),
- b.symmetric_difference(a),
- "asymmetry: `{:?}` ^ `{:?}`",
- a,
- b,
- );
- }
- }
- }
-
- #[test]
- fn test_set() {
- let mut e1 = Flags::A | Flags::C;
- e1.set(Flags::B, true);
- e1.set(Flags::C, false);
-
- assert_eq!(e1, Flags::A | Flags::B);
- }
-
- #[test]
- fn test_assignment_operators() {
- let mut m1 = Flags::empty();
- let e1 = Flags::A | Flags::C;
- // union
- m1 |= Flags::A;
- assert_eq!(m1, Flags::A);
- // intersection
- m1 &= e1;
- assert_eq!(m1, Flags::A);
- // set difference
- m1 -= m1;
- assert_eq!(m1, Flags::empty());
- // toggle
- m1 ^= e1;
- assert_eq!(m1, e1);
- }
-
- #[test]
- fn test_const_fn() {
- const _M1: Flags = Flags::empty();
-
- const M2: Flags = Flags::A;
- assert_eq!(M2, Flags::A);
-
- const M3: Flags = Flags::C;
- assert_eq!(M3, Flags::C);
- }
-
- #[test]
- fn test_extend() {
- let mut flags;
-
- flags = Flags::empty();
- flags.extend([].iter().cloned());
- assert_eq!(flags, Flags::empty());
-
- flags = Flags::empty();
- flags.extend([Flags::A, Flags::B].iter().cloned());
- assert_eq!(flags, Flags::A | Flags::B);
-
- flags = Flags::A;
- flags.extend([Flags::A, Flags::B].iter().cloned());
- assert_eq!(flags, Flags::A | Flags::B);
-
- flags = Flags::B;
- flags.extend([Flags::A, Flags::ABC].iter().cloned());
- assert_eq!(flags, Flags::ABC);
- }
-
- #[test]
- fn test_from_iterator() {
- assert_eq!([].iter().cloned().collect::<Flags>(), Flags::empty());
- assert_eq!(
- [Flags::A, Flags::B].iter().cloned().collect::<Flags>(),
- Flags::A | Flags::B
- );
- assert_eq!(
- [Flags::A, Flags::ABC].iter().cloned().collect::<Flags>(),
- Flags::ABC
- );
- }
-
- #[test]
- fn test_lt() {
- let mut a = Flags::empty();
- let mut b = Flags::empty();
-
- assert!(!(a < b) && !(b < a));
- b = Flags::B;
- assert!(a < b);
- a = Flags::C;
- assert!(!(a < b) && b < a);
- b = Flags::C | Flags::B;
- assert!(a < b);
- }
-
- #[test]
- fn test_ord() {
- let mut a = Flags::empty();
- let mut b = Flags::empty();
-
- assert!(a <= b && a >= b);
- a = Flags::A;
- assert!(a > b && a >= b);
- assert!(b < a && b <= a);
- b = Flags::B;
- assert!(b > a && b >= a);
- assert!(a < b && a <= b);
- }
-
- fn hash<T: Hash>(t: &T) -> u64 {
- let mut s = DefaultHasher::new();
- t.hash(&mut s);
- s.finish()
- }
-
- #[test]
- fn test_hash() {
- let mut x = Flags::empty();
- let mut y = Flags::empty();
- assert_eq!(hash(&x), hash(&y));
- x = Flags::all();
- y = Flags::ABC;
- assert_eq!(hash(&x), hash(&y));
- }
-
- #[test]
- fn test_default() {
- assert_eq!(Flags::empty(), Flags::default());
- }
-
- #[test]
- fn test_debug() {
- assert_eq!(format!("{:?}", Flags::A | Flags::B), "A | B");
- assert_eq!(format!("{:?}", Flags::empty()), "(empty)");
- assert_eq!(format!("{:?}", Flags::ABC), "A | B | C | ABC");
- let extra = unsafe { Flags::from_bits_unchecked(0xb8) };
- assert_eq!(format!("{:?}", extra), "0xb8");
- assert_eq!(format!("{:?}", Flags::A | extra), "A | 0xb8");
-
- assert_eq!(
- format!("{:?}", Flags::ABC | extra),
- "A | B | C | ABC | 0xb8"
- );
-
- assert_eq!(format!("{:?}", EmptyFlags::empty()), "(empty)");
- }
-
- #[test]
- fn test_binary() {
- assert_eq!(format!("{:b}", Flags::ABC), "111");
- assert_eq!(format!("{:#b}", Flags::ABC), "0b111");
- let extra = unsafe { Flags::from_bits_unchecked(0b1010000) };
- assert_eq!(format!("{:b}", Flags::ABC | extra), "1010111");
- assert_eq!(format!("{:#b}", Flags::ABC | extra), "0b1010111");
- }
-
- #[test]
- fn test_octal() {
- assert_eq!(format!("{:o}", LongFlags::LONG_A), "177777");
- assert_eq!(format!("{:#o}", LongFlags::LONG_A), "0o177777");
- let extra = unsafe { LongFlags::from_bits_unchecked(0o5000000) };
- assert_eq!(format!("{:o}", LongFlags::LONG_A | extra), "5177777");
- assert_eq!(format!("{:#o}", LongFlags::LONG_A | extra), "0o5177777");
- }
-
- #[test]
- fn test_lowerhex() {
- assert_eq!(format!("{:x}", LongFlags::LONG_A), "ffff");
- assert_eq!(format!("{:#x}", LongFlags::LONG_A), "0xffff");
- let extra = unsafe { LongFlags::from_bits_unchecked(0xe00000) };
- assert_eq!(format!("{:x}", LongFlags::LONG_A | extra), "e0ffff");
- assert_eq!(format!("{:#x}", LongFlags::LONG_A | extra), "0xe0ffff");
- }
-
- #[test]
- fn test_upperhex() {
- assert_eq!(format!("{:X}", LongFlags::LONG_A), "FFFF");
- assert_eq!(format!("{:#X}", LongFlags::LONG_A), "0xFFFF");
- let extra = unsafe { LongFlags::from_bits_unchecked(0xe00000) };
- assert_eq!(format!("{:X}", LongFlags::LONG_A | extra), "E0FFFF");
- assert_eq!(format!("{:#X}", LongFlags::LONG_A | extra), "0xE0FFFF");
- }
-
- mod submodule {
- bitflags! {
- pub struct PublicFlags: i8 {
- const X = 0;
- }
-
- struct PrivateFlags: i8 {
- const Y = 0;
- }
- }
-
- #[test]
- fn test_private() {
- let _ = PrivateFlags::Y;
- }
- }
-
- #[test]
- fn test_public() {
- let _ = submodule::PublicFlags::X;
- }
-
- mod t1 {
- mod foo {
- pub type Bar = i32;
- }
-
- bitflags! {
- /// baz
- struct Flags: foo::Bar {
- const A = 0b00000001;
- #[cfg(foo)]
- const B = 0b00000010;
- #[cfg(foo)]
- const C = 0b00000010;
- }
- }
- }
-
- #[test]
- fn test_in_function() {
- bitflags! {
- struct Flags: u8 {
- const A = 1;
- #[cfg(any())] // false
- const B = 2;
- }
- }
- assert_eq!(Flags::all(), Flags::A);
- assert_eq!(format!("{:?}", Flags::A), "A");
- }
-
- #[test]
- fn test_deprecated() {
- bitflags! {
- pub struct TestFlags: u32 {
- #[deprecated(note = "Use something else.")]
- const ONE = 1;
- }
- }
- }
-
- #[test]
- fn test_pub_crate() {
- mod module {
- bitflags! {
- pub (crate) struct Test: u8 {
- const FOO = 1;
- }
- }
- }
-
- assert_eq!(module::Test::FOO.bits(), 1);
- }
-
- #[test]
- fn test_pub_in_module() {
- mod module {
- mod submodule {
- bitflags! {
- // `pub (in super)` means only the module `module` will
- // be able to access this.
- pub (in super) struct Test: u8 {
- const FOO = 1;
- }
- }
- }
-
- mod test {
- // Note: due to `pub (in super)`,
- // this cannot be accessed directly by the testing code.
- pub(super) fn value() -> u8 {
- super::submodule::Test::FOO.bits()
- }
- }
-
- pub fn value() -> u8 {
- test::value()
- }
- }
-
- assert_eq!(module::value(), 1)
- }
-
- #[test]
- fn test_zero_value_flags() {
- bitflags! {
- struct Flags: u32 {
- const NONE = 0b0;
- const SOME = 0b1;
- }
- }
-
- assert!(Flags::empty().contains(Flags::NONE));
- assert!(Flags::SOME.contains(Flags::NONE));
- assert!(Flags::NONE.is_empty());
-
- assert_eq!(format!("{:?}", Flags::empty()), "NONE");
- assert_eq!(format!("{:?}", Flags::SOME), "SOME");
- }
-
- #[test]
- fn test_empty_bitflags() {
- bitflags! {}
- }
-
- #[test]
- fn test_u128_bitflags() {
- bitflags! {
- struct Flags128: u128 {
- const A = 0x0000_0000_0000_0000_0000_0000_0000_0001;
- const B = 0x0000_0000_0000_1000_0000_0000_0000_0000;
- const C = 0x8000_0000_0000_0000_0000_0000_0000_0000;
- const ABC = Self::A.bits | Self::B.bits | Self::C.bits;
- }
- }
-
- assert_eq!(Flags128::ABC, Flags128::A | Flags128::B | Flags128::C);
- assert_eq!(Flags128::A.bits, 0x0000_0000_0000_0000_0000_0000_0000_0001);
- assert_eq!(Flags128::B.bits, 0x0000_0000_0000_1000_0000_0000_0000_0000);
- assert_eq!(Flags128::C.bits, 0x8000_0000_0000_0000_0000_0000_0000_0000);
- assert_eq!(
- Flags128::ABC.bits,
- 0x8000_0000_0000_1000_0000_0000_0000_0001
- );
- assert_eq!(format!("{:?}", Flags128::A), "A");
- assert_eq!(format!("{:?}", Flags128::B), "B");
- assert_eq!(format!("{:?}", Flags128::C), "C");
- assert_eq!(format!("{:?}", Flags128::ABC), "A | B | C | ABC");
- }
-
- #[test]
- fn test_serde_bitflags_serialize() {
- let flags = SerdeFlags::A | SerdeFlags::B;
-
- let serialized = serde_json::to_string(&flags).unwrap();
-
- assert_eq!(serialized, r#"{"bits":3}"#);
- }
-
- #[test]
- fn test_serde_bitflags_deserialize() {
- let deserialized: SerdeFlags = serde_json::from_str(r#"{"bits":12}"#).unwrap();
-
- let expected = SerdeFlags::C | SerdeFlags::D;
-
- assert_eq!(deserialized.bits, expected.bits);
- }
-
- #[test]
- fn test_serde_bitflags_roundtrip() {
- let flags = SerdeFlags::A | SerdeFlags::B;
-
- let deserialized: SerdeFlags = serde_json::from_str(&serde_json::to_string(&flags).unwrap()).unwrap();
-
- assert_eq!(deserialized.bits, flags.bits);
- }
-
- bitflags! {
- #[derive(serde::Serialize, serde::Deserialize)]
- struct SerdeFlags: u32 {
- const A = 1;
- const B = 2;
- const C = 4;
- const D = 8;
- }
- }
-}
diff --git a/vendor/bitflags-1.3.2/tests/basic.rs b/vendor/bitflags-1.3.2/tests/basic.rs
deleted file mode 100644
index 73a52be..0000000
--- a/vendor/bitflags-1.3.2/tests/basic.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-#![no_std]
-
-use bitflags::bitflags;
-
-bitflags! {
- /// baz
- struct Flags: u32 {
- const A = 0b00000001;
- #[doc = "bar"]
- const B = 0b00000010;
- const C = 0b00000100;
- #[doc = "foo"]
- const ABC = Flags::A.bits | Flags::B.bits | Flags::C.bits;
- }
-}
-
-#[test]
-fn basic() {
- assert_eq!(Flags::ABC, Flags::A | Flags::B | Flags::C);
-}
diff --git a/vendor/bitflags-1.3.2/tests/compile-fail/impls/copy.rs b/vendor/bitflags-1.3.2/tests/compile-fail/impls/copy.rs
deleted file mode 100644
index 38f4822..0000000
--- a/vendor/bitflags-1.3.2/tests/compile-fail/impls/copy.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-use bitflags::bitflags;
-
-bitflags! {
- #[derive(Clone, Copy)]
- struct Flags: u32 {
- const A = 0b00000001;
- }
-}
-
-fn main() {}
diff --git a/vendor/bitflags-1.3.2/tests/compile-fail/impls/copy.stderr.beta b/vendor/bitflags-1.3.2/tests/compile-fail/impls/copy.stderr.beta
deleted file mode 100644
index 0c13aa5..0000000
--- a/vendor/bitflags-1.3.2/tests/compile-fail/impls/copy.stderr.beta
+++ /dev/null
@@ -1,27 +0,0 @@
-error[E0119]: conflicting implementations of trait `std::clone::Clone` for type `Flags`
- --> $DIR/copy.rs:3:1
- |
-3 | / bitflags! {
-4 | | #[derive(Clone, Copy)]
- | | ----- first implementation here
-5 | | struct Flags: u32 {
-6 | | const A = 0b00000001;
-7 | | }
-8 | | }
- | |_^ conflicting implementation for `Flags`
- |
- = note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error[E0119]: conflicting implementations of trait `std::marker::Copy` for type `Flags`
- --> $DIR/copy.rs:3:1
- |
-3 | / bitflags! {
-4 | | #[derive(Clone, Copy)]
- | | ---- first implementation here
-5 | | struct Flags: u32 {
-6 | | const A = 0b00000001;
-7 | | }
-8 | | }
- | |_^ conflicting implementation for `Flags`
- |
- = note: this error originates in the derive macro `Copy` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/vendor/bitflags-1.3.2/tests/compile-fail/impls/eq.rs b/vendor/bitflags-1.3.2/tests/compile-fail/impls/eq.rs
deleted file mode 100644
index 4abbd63..0000000
--- a/vendor/bitflags-1.3.2/tests/compile-fail/impls/eq.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-use bitflags::bitflags;
-
-bitflags! {
- #[derive(PartialEq, Eq)]
- struct Flags: u32 {
- const A = 0b00000001;
- }
-}
-
-fn main() {}
diff --git a/vendor/bitflags-1.3.2/tests/compile-fail/impls/eq.stderr.beta b/vendor/bitflags-1.3.2/tests/compile-fail/impls/eq.stderr.beta
deleted file mode 100644
index 8a1a3b4..0000000
--- a/vendor/bitflags-1.3.2/tests/compile-fail/impls/eq.stderr.beta
+++ /dev/null
@@ -1,55 +0,0 @@
-error[E0119]: conflicting implementations of trait `std::cmp::PartialEq` for type `Flags`
- --> $DIR/eq.rs:3:1
- |
-3 | / bitflags! {
-4 | | #[derive(PartialEq, Eq)]
- | | --------- first implementation here
-5 | | struct Flags: u32 {
-6 | | const A = 0b00000001;
-7 | | }
-8 | | }
- | |_^ conflicting implementation for `Flags`
- |
- = note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error[E0119]: conflicting implementations of trait `std::cmp::Eq` for type `Flags`
- --> $DIR/eq.rs:3:1
- |
-3 | / bitflags! {
-4 | | #[derive(PartialEq, Eq)]
- | | -- first implementation here
-5 | | struct Flags: u32 {
-6 | | const A = 0b00000001;
-7 | | }
-8 | | }
- | |_^ conflicting implementation for `Flags`
- |
- = note: this error originates in the derive macro `Eq` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error[E0119]: conflicting implementations of trait `std::marker::StructuralPartialEq` for type `Flags`
- --> $DIR/eq.rs:3:1
- |
-3 | / bitflags! {
-4 | | #[derive(PartialEq, Eq)]
- | | --------- first implementation here
-5 | | struct Flags: u32 {
-6 | | const A = 0b00000001;
-7 | | }
-8 | | }
- | |_^ conflicting implementation for `Flags`
- |
- = note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error[E0119]: conflicting implementations of trait `std::marker::StructuralEq` for type `Flags`
- --> $DIR/eq.rs:3:1
- |
-3 | / bitflags! {
-4 | | #[derive(PartialEq, Eq)]
- | | -- first implementation here
-5 | | struct Flags: u32 {
-6 | | const A = 0b00000001;
-7 | | }
-8 | | }
- | |_^ conflicting implementation for `Flags`
- |
- = note: this error originates in the derive macro `Eq` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/vendor/bitflags-1.3.2/tests/compile-fail/non_integer_base/all_defined.rs b/vendor/bitflags-1.3.2/tests/compile-fail/non_integer_base/all_defined.rs
deleted file mode 100644
index c2856b1..0000000
--- a/vendor/bitflags-1.3.2/tests/compile-fail/non_integer_base/all_defined.rs
+++ /dev/null
@@ -1,123 +0,0 @@
-use std::{
- fmt::{
- self,
- Debug,
- Display,
- LowerHex,
- UpperHex,
- Octal,
- Binary,
- },
- ops::{
- BitAnd,
- BitOr,
- BitXor,
- BitAndAssign,
- BitOrAssign,
- BitXorAssign,
- Not,
- },
-};
-
-use bitflags::bitflags;
-
-// Ideally we'd actually want this to work, but currently need something like `num`'s `Zero`
-// With some design work it could be made possible
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-struct MyInt(u8);
-
-impl BitAnd for MyInt {
- type Output = Self;
-
- fn bitand(self, other: Self) -> Self {
- MyInt(self.0 & other.0)
- }
-}
-
-impl BitOr for MyInt {
- type Output = Self;
-
- fn bitor(self, other: Self) -> Self {
- MyInt(self.0 | other.0)
- }
-}
-
-impl BitXor for MyInt {
- type Output = Self;
-
- fn bitxor(self, other: Self) -> Self {
- MyInt(self.0 ^ other.0)
- }
-}
-
-impl BitAndAssign for MyInt {
- fn bitand_assign(&mut self, other: Self) {
- self.0 &= other.0
- }
-}
-
-impl BitOrAssign for MyInt {
- fn bitor_assign(&mut self, other: Self) {
- self.0 |= other.0
- }
-}
-
-impl BitXorAssign for MyInt {
- fn bitxor_assign(&mut self, other: Self) {
- self.0 ^= other.0
- }
-}
-
-impl Debug for MyInt {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- Debug::fmt(&self.0, f)
- }
-}
-
-impl Display for MyInt {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- Display::fmt(&self.0, f)
- }
-}
-
-impl LowerHex for MyInt {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- LowerHex::fmt(&self.0, f)
- }
-}
-
-impl UpperHex for MyInt {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- UpperHex::fmt(&self.0, f)
- }
-}
-
-impl Octal for MyInt {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- Octal::fmt(&self.0, f)
- }
-}
-
-impl Binary for MyInt {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- Binary::fmt(&self.0, f)
- }
-}
-
-impl Not for MyInt {
- type Output = MyInt;
-
- fn not(self) -> Self {
- MyInt(!self.0)
- }
-}
-
-bitflags! {
- struct Flags128: MyInt {
- const A = MyInt(0b0000_0001u8);
- const B = MyInt(0b0000_0010u8);
- const C = MyInt(0b0000_0100u8);
- }
-}
-
-fn main() {}
diff --git a/vendor/bitflags-1.3.2/tests/compile-fail/non_integer_base/all_defined.stderr.beta b/vendor/bitflags-1.3.2/tests/compile-fail/non_integer_base/all_defined.stderr.beta
deleted file mode 100644
index 1f0fb5c..0000000
--- a/vendor/bitflags-1.3.2/tests/compile-fail/non_integer_base/all_defined.stderr.beta
+++ /dev/null
@@ -1,27 +0,0 @@
-error[E0308]: mismatched types
- --> $DIR/all_defined.rs:115:1
- |
-115 | / bitflags! {
-116 | | struct Flags128: MyInt {
-117 | | const A = MyInt(0b0000_0001u8);
-118 | | const B = MyInt(0b0000_0010u8);
-119 | | const C = MyInt(0b0000_0100u8);
-120 | | }
-121 | | }
- | |_^ expected struct `MyInt`, found integer
- |
- = note: this error originates in the macro `__impl_all_bitflags` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error[E0308]: mismatched types
- --> $DIR/all_defined.rs:115:1
- |
-115 | / bitflags! {
-116 | | struct Flags128: MyInt {
-117 | | const A = MyInt(0b0000_0001u8);
-118 | | const B = MyInt(0b0000_0010u8);
-119 | | const C = MyInt(0b0000_0100u8);
-120 | | }
-121 | | }
- | |_^ expected struct `MyInt`, found integer
- |
- = note: this error originates in the macro `__impl_bitflags` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/vendor/bitflags-1.3.2/tests/compile-fail/non_integer_base/all_missing.rs b/vendor/bitflags-1.3.2/tests/compile-fail/non_integer_base/all_missing.rs
deleted file mode 100644
index fff6b2c..0000000
--- a/vendor/bitflags-1.3.2/tests/compile-fail/non_integer_base/all_missing.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-use bitflags::bitflags;
-
-struct MyInt(u8);
-
-bitflags! {
- struct Flags128: MyInt {
- const A = MyInt(0b0000_0001);
- const B = MyInt(0b0000_0010);
- const C = MyInt(0b0000_0100);
- }
-}
-
-fn main() {}
diff --git a/vendor/bitflags-1.3.2/tests/compile-fail/non_integer_base/all_missing.stderr.beta b/vendor/bitflags-1.3.2/tests/compile-fail/non_integer_base/all_missing.stderr.beta
deleted file mode 100644
index ee95f83..0000000
--- a/vendor/bitflags-1.3.2/tests/compile-fail/non_integer_base/all_missing.stderr.beta
+++ /dev/null
@@ -1,13 +0,0 @@
-error[E0204]: the trait `Copy` may not be implemented for this type
- --> $DIR/all_missing.rs:5:1
- |
-5 | / bitflags! {
-6 | | struct Flags128: MyInt {
-7 | | const A = MyInt(0b0000_0001);
-8 | | const B = MyInt(0b0000_0010);
-9 | | const C = MyInt(0b0000_0100);
-10 | | }
-11 | | }
- | |_^ this field does not implement `Copy`
- |
- = note: this error originates in the derive macro `Copy` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/vendor/bitflags-1.3.2/tests/compile-fail/visibility/private_field.rs b/vendor/bitflags-1.3.2/tests/compile-fail/visibility/private_field.rs
deleted file mode 100644
index a6a3912..0000000
--- a/vendor/bitflags-1.3.2/tests/compile-fail/visibility/private_field.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-mod example {
- use bitflags::bitflags;
-
- bitflags! {
- pub struct Flags1: u32 {
- const FLAG_A = 0b00000001;
- }
- }
-}
-
-fn main() {
- let flag1 = example::Flags1::FLAG_A.bits;
-}
diff --git a/vendor/bitflags-1.3.2/tests/compile-fail/visibility/private_field.stderr.beta b/vendor/bitflags-1.3.2/tests/compile-fail/visibility/private_field.stderr.beta
deleted file mode 100644
index 58a0466..0000000
--- a/vendor/bitflags-1.3.2/tests/compile-fail/visibility/private_field.stderr.beta
+++ /dev/null
@@ -1,10 +0,0 @@
-error[E0616]: field `bits` of struct `Flags1` is private
- --> $DIR/private_field.rs:12:41
- |
-12 | let flag1 = example::Flags1::FLAG_A.bits;
- | ^^^^ private field
- |
-help: a method `bits` also exists, call it with parentheses
- |
-12 | let flag1 = example::Flags1::FLAG_A.bits();
- | ^^
diff --git a/vendor/bitflags-1.3.2/tests/compile-fail/visibility/private_flags.rs b/vendor/bitflags-1.3.2/tests/compile-fail/visibility/private_flags.rs
deleted file mode 100644
index 85a5b18..0000000
--- a/vendor/bitflags-1.3.2/tests/compile-fail/visibility/private_flags.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-mod example {
- use bitflags::bitflags;
-
- bitflags! {
- pub struct Flags1: u32 {
- const FLAG_A = 0b00000001;
- }
-
- struct Flags2: u32 {
- const FLAG_B = 0b00000010;
- }
- }
-}
-
-fn main() {
- let flag1 = example::Flags1::FLAG_A;
- let flag2 = example::Flags2::FLAG_B;
-}
diff --git a/vendor/bitflags-1.3.2/tests/compile-fail/visibility/private_flags.stderr.beta b/vendor/bitflags-1.3.2/tests/compile-fail/visibility/private_flags.stderr.beta
deleted file mode 100644
index d23f832..0000000
--- a/vendor/bitflags-1.3.2/tests/compile-fail/visibility/private_flags.stderr.beta
+++ /dev/null
@@ -1,18 +0,0 @@
-error[E0603]: struct `Flags2` is private
- --> $DIR/private_flags.rs:17:26
- |
-17 | let flag2 = example::Flags2::FLAG_B;
- | ^^^^^^ private struct
- |
-note: the struct `Flags2` is defined here
- --> $DIR/private_flags.rs:4:5
- |
-4 | / bitflags! {
-5 | | pub struct Flags1: u32 {
-6 | | const FLAG_A = 0b00000001;
-7 | | }
-... |
-11 | | }
-12 | | }
- | |_____^
- = note: this error originates in the macro `bitflags` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/vendor/bitflags-1.3.2/tests/compile-fail/visibility/pub_const.rs b/vendor/bitflags-1.3.2/tests/compile-fail/visibility/pub_const.rs
deleted file mode 100644
index b90f0ce..0000000
--- a/vendor/bitflags-1.3.2/tests/compile-fail/visibility/pub_const.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-use bitflags::bitflags;
-
-bitflags! {
- pub struct Flags1: u32 {
- pub const FLAG_A = 0b00000001;
- }
-}
-
-fn main() {}
diff --git a/vendor/bitflags-1.3.2/tests/compile-fail/visibility/pub_const.stderr.beta b/vendor/bitflags-1.3.2/tests/compile-fail/visibility/pub_const.stderr.beta
deleted file mode 100644
index b01122c..0000000
--- a/vendor/bitflags-1.3.2/tests/compile-fail/visibility/pub_const.stderr.beta
+++ /dev/null
@@ -1,5 +0,0 @@
-error: no rules expected the token `pub`
- --> $DIR/pub_const.rs:5:9
- |
-5 | pub const FLAG_A = 0b00000001;
- | ^^^ no rules expected this token in macro call
diff --git a/vendor/bitflags-1.3.2/tests/compile-pass/impls/convert.rs b/vendor/bitflags-1.3.2/tests/compile-pass/impls/convert.rs
deleted file mode 100644
index 1f02982..0000000
--- a/vendor/bitflags-1.3.2/tests/compile-pass/impls/convert.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-use bitflags::bitflags;
-
-bitflags! {
- struct Flags: u32 {
- const A = 0b00000001;
- }
-}
-
-impl From<u32> for Flags {
- fn from(v: u32) -> Flags {
- Flags::from_bits_truncate(v)
- }
-}
-
-fn main() {
-
-}
diff --git a/vendor/bitflags-1.3.2/tests/compile-pass/impls/default.rs b/vendor/bitflags-1.3.2/tests/compile-pass/impls/default.rs
deleted file mode 100644
index a97b653..0000000
--- a/vendor/bitflags-1.3.2/tests/compile-pass/impls/default.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-use bitflags::bitflags;
-
-bitflags! {
- #[derive(Default)]
- struct Flags: u32 {
- const A = 0b00000001;
- }
-}
-
-fn main() {}
diff --git a/vendor/bitflags-1.3.2/tests/compile-pass/impls/inherent_methods.rs b/vendor/bitflags-1.3.2/tests/compile-pass/impls/inherent_methods.rs
deleted file mode 100644
index 3052c46..0000000
--- a/vendor/bitflags-1.3.2/tests/compile-pass/impls/inherent_methods.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-use bitflags::bitflags;
-
-bitflags! {
- struct Flags: u32 {
- const A = 0b00000001;
- }
-}
-
-impl Flags {
- pub fn new() -> Flags {
- Flags::A
- }
-}
-
-fn main() {}
diff --git a/vendor/bitflags-1.3.2/tests/compile-pass/redefinition/core.rs b/vendor/bitflags-1.3.2/tests/compile-pass/redefinition/core.rs
deleted file mode 100644
index 4754921..0000000
--- a/vendor/bitflags-1.3.2/tests/compile-pass/redefinition/core.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-use bitflags::bitflags;
-
-// Checks for possible errors caused by overriding names used by `bitflags!` internally.
-
-mod core {}
-mod _core {}
-
-bitflags! {
- struct Test: u8 {
- const A = 1;
- }
-}
-
-fn main() {}
diff --git a/vendor/bitflags-1.3.2/tests/compile-pass/redefinition/stringify.rs b/vendor/bitflags-1.3.2/tests/compile-pass/redefinition/stringify.rs
deleted file mode 100644
index b04f2f6..0000000
--- a/vendor/bitflags-1.3.2/tests/compile-pass/redefinition/stringify.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-use bitflags::bitflags;
-
-// Checks for possible errors caused by overriding names used by `bitflags!` internally.
-
-#[allow(unused_macros)]
-macro_rules! stringify {
- ($($t:tt)*) => { "..." };
-}
-
-bitflags! {
- struct Test: u8 {
- const A = 1;
- }
-}
-
-fn main() {
- // Just make sure we don't call the redefined `stringify` macro
- assert_eq!(format!("{:?}", Test::A), "A");
-}
diff --git a/vendor/bitflags-1.3.2/tests/compile-pass/repr/c.rs b/vendor/bitflags-1.3.2/tests/compile-pass/repr/c.rs
deleted file mode 100644
index 6feba36..0000000
--- a/vendor/bitflags-1.3.2/tests/compile-pass/repr/c.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-use bitflags::bitflags;
-
-bitflags! {
- #[repr(C)]
- struct Flags: u32 {
- const A = 0b00000001;
- }
-}
-
-fn main() {}
diff --git a/vendor/bitflags-1.3.2/tests/compile-pass/repr/transparent.rs b/vendor/bitflags-1.3.2/tests/compile-pass/repr/transparent.rs
deleted file mode 100644
index e38db4d..0000000
--- a/vendor/bitflags-1.3.2/tests/compile-pass/repr/transparent.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-use bitflags::bitflags;
-
-bitflags! {
- #[repr(transparent)]
- struct Flags: u32 {
- const A = 0b00000001;
- }
-}
-
-fn main() {}
diff --git a/vendor/bitflags-1.3.2/tests/compile-pass/visibility/bits_field.rs b/vendor/bitflags-1.3.2/tests/compile-pass/visibility/bits_field.rs
deleted file mode 100644
index 33a7967..0000000
--- a/vendor/bitflags-1.3.2/tests/compile-pass/visibility/bits_field.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-use bitflags::bitflags;
-
-bitflags! {
- pub struct Flags1: u32 {
- const FLAG_A = 0b00000001;
- }
-}
-
-fn main() {
- assert_eq!(0b00000001, Flags1::FLAG_A.bits);
-}
diff --git a/vendor/bitflags-1.3.2/tests/compile-pass/visibility/pub_in.rs b/vendor/bitflags-1.3.2/tests/compile-pass/visibility/pub_in.rs
deleted file mode 100644
index c11050e..0000000
--- a/vendor/bitflags-1.3.2/tests/compile-pass/visibility/pub_in.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-mod a {
- mod b {
- use bitflags::bitflags;
-
- bitflags! {
- pub(in crate::a) struct Flags: u32 {
- const FLAG_A = 0b00000001;
- }
- }
- }
-
- pub fn flags() -> u32 {
- b::Flags::FLAG_A.bits()
- }
-}
-
-fn main() {
- assert_eq!(0b00000001, a::flags());
-}
diff --git a/vendor/bitflags-1.3.2/tests/compile.rs b/vendor/bitflags-1.3.2/tests/compile.rs
deleted file mode 100644
index ed02d01..0000000
--- a/vendor/bitflags-1.3.2/tests/compile.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-use std::{
- fs,
- ffi::OsStr,
- io,
- path::Path,
-};
-
-use walkdir::WalkDir;
-
-#[test]
-fn fail() {
- prepare_stderr_files("tests/compile-fail").unwrap();
-
- let t = trybuild::TestCases::new();
- t.compile_fail("tests/compile-fail/**/*.rs");
-}
-
-#[test]
-fn pass() {
- let t = trybuild::TestCases::new();
- t.pass("tests/compile-pass/**/*.rs");
-}
-
-// Compiler messages may change between versions
-// We don't want to have to track these too closely for `bitflags`, but
-// having some message to check makes sure user-facing errors are sensical.
-//
-// The approach we use is to run the test on all compilers, but only check stderr
-// output on beta (which is the next stable release). We do this by default ignoring
-// any `.stderr` files in the `compile-fail` directory, and copying `.stderr.beta` files
-// when we happen to be running on a beta compiler.
-fn prepare_stderr_files(path: impl AsRef<Path>) -> io::Result<()> {
- for entry in WalkDir::new(path) {
- let entry = entry?;
-
- if entry.path().extension().and_then(OsStr::to_str) == Some("beta") {
- let renamed = entry.path().with_extension("");
-
- // Unconditionally remove a corresponding `.stderr` file for a `.stderr.beta`
- // file if it exists. On `beta` compilers, we'll recreate it. On other compilers,
- // we don't want to end up checking it anyways.
- if renamed.exists() {
- fs::remove_file(&renamed)?;
- }
-
- rename_beta_stderr(entry.path(), renamed)?;
- }
- }
-
- Ok(())
-}
-
-#[rustversion::beta]
-fn rename_beta_stderr(from: impl AsRef<Path>, to: impl AsRef<Path>) -> io::Result<()> {
- fs::copy(from, to)?;
-
- Ok(())
-}
-
-#[rustversion::not(beta)]
-fn rename_beta_stderr(_: impl AsRef<Path>, _: impl AsRef<Path>) -> io::Result<()> {
- Ok(())
-}
--
cgit v1.2.3