api: introduce new regex-lite crate

Closes #961

Author: BurntSushi

.github/workflows/ci.yml

@@ -122,6 +122,8 @@ jobs:
     - name: Run subset of regex-automata tests
       if: matrix.build != 'win-gnu'  # Just horrifically slow.
       run: ${{ env.CARGO }} test --verbose --manifest-path regex-automata/Cargo.toml $TARGET
+    - name: Run regex-lite tests
+      run: ${{ env.CARGO }} test --verbose --manifest-path regex-lite/Cargo.toml $TARGET
 
   # This job runs a stripped down version of CI to test the MSRV. The specific
   # reason for doing this is that the regex crate's dev-dependencies tend to

Cargo.toml

@@ -22,6 +22,7 @@ members = [
   "regex-automata",
   "regex-capi",
   "regex-cli",
+  "regex-lite",
   "regex-syntax",
   "regex-test",
 ]

regex-cli/Cargo.toml

@@ -30,6 +30,7 @@ log = { version = "0.4.17", features = ["std"] }
 memmap2 = "0.5.10"
 regex = { path = ".." }
 regex-automata = { path = "../regex-automata", features = ["logging"] }
+regex-lite = { path = "../regex-lite" }
 regex-syntax = { path = "../regex-syntax" }
 tabwriter = { version = "1.2.1", features = ["ansi_formatting"] }
 textwrap = { version = "0.16.0", default-features = false }

regex-cli/args/lite.rs

@@ -0,0 +1,84 @@
+use {
+    lexopt::{Arg, Parser},
+    regex_automata::util::syntax,
+    regex_lite::Regex,
+};
+
+use crate::args::{self, Configurable, Usage};
+
+/// Exposes the configuration for the top-level `Regex` API.
+#[derive(Debug, Default)]
+pub struct Config {
+    size_limit: Option<usize>,
+}
+
+impl Config {
+    /// Builds a `Regex` from the given syntax configuration and sequence of
+    /// patterns. This returns an error is `patterns.len() != 1`.
+    ///
+    /// Note that this also returns an error if any syntax options are set
+    /// that aren't supported by `regex-lite`.
+    pub fn from_patterns(
+        &self,
+        syntax: &syntax::Config,
+        patterns: &[String],
+    ) -> anyhow::Result<Regex> {
+        anyhow::ensure!(
+            patterns.len() == 1,
+            "API-level regex requires exactly one pattern, \
+                 but {} were given",
+            patterns.len(),
+        );
+        anyhow::ensure!(
+            !syntax.get_octal(),
+            "regex-lite does not support octal mode",
+        );
+        anyhow::ensure!(
+            syntax.get_utf8(),
+            "regex-lite does not support disabling UTF-8 mode",
+        );
+        anyhow::ensure!(
+            syntax.get_unicode(),
+            "regex-lite does not support disabling Unicode mode",
+        );
+        let mut b = regex_lite::RegexBuilder::new(&patterns[0]);
+        b.case_insensitive(syntax.get_case_insensitive());
+        b.multi_line(syntax.get_multi_line());
+        b.crlf(syntax.get_crlf());
+        b.dot_matches_new_line(syntax.get_dot_matches_new_line());
+        b.swap_greed(syntax.get_swap_greed());
+        b.ignore_whitespace(syntax.get_ignore_whitespace());
+        b.nest_limit(syntax.get_nest_limit());
+        b.size_limit(self.size_limit.unwrap_or(usize::MAX));
+        b.build().map_err(anyhow::Error::from)
+    }
+}
+
+impl Configurable for Config {
+    fn configure(
+        &mut self,
+        p: &mut Parser,
+        arg: &mut Arg,
+    ) -> anyhow::Result<bool> {
+        match *arg {
+            Arg::Long("size-limit") => {
+                self.size_limit = args::parse_maybe(p, "--size-limit")?;
+            }
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+
+    fn usage(&self) -> &[Usage] {
+        const USAGES: &'static [Usage] = &[Usage::new(
+            "--size-limit",
+            "Set a limit on heap used by a regex.",
+            r#"
+This sets a limit, in bytes, on the heap memory used by a regex.
+
+The special value 'none' indicates that no size limit should be imposed.
+"#,
+        )];
+        USAGES
+    }
+}

regex-cli/args/mod.rs

@@ -16,6 +16,7 @@ pub mod flags;
 pub mod haystack;
 pub mod hybrid;
 pub mod input;
+pub mod lite;
 pub mod meta;
 pub mod onepass;
 pub mod overlapping;

regex-cli/cmd/find/capture/mod.rs

@@ -32,6 +32,7 @@ USAGE:
 
 ENGINES:
     backtrack  Search with the bounded backtracker regex engine.
+    lite       Search with the regex-lite engine.
     meta       Search with the meta regex engine.
     onepass    Search with the one-pass DFA regex engine.
     pikevm     Search with the PikeVM regex engine.
@@ -40,6 +41,7 @@ ENGINES:
     let cmd = args::next_as_command(USAGE, p)?;
     match &*cmd {
         "backtrack" => nfa::run_backtrack(p),
+        "lite" => run_lite(p),
         "meta" => run_meta(p),
         "onepass" => dfa::run_onepass(p),
         "pikevm" => nfa::run_pikevm(p),
@@ -219,6 +221,107 @@ OPTIONS:
     Ok(())
 }
 
+fn run_lite(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search for full matches using the top-level regex-lite engine.
+
+USAGE:
+    regex-cli find capture lite [-p <pattern> ...] <haystack-path>
+    regex-cli find capture lite [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut lite = args::lite::Config::default();
+    let mut find = super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut lite,
+            &mut find,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let syn = syntax.syntax()?;
+    let mut table = Table::empty();
+    let (re, time) = util::timeitr(|| lite.from_patterns(&syn, &pats))?;
+    table.add("build regex time", time);
+
+    // Check that the haystack is valid UTF-8 since regex-lite doesn't support
+    // searching arbitrary byte sequences. (At time of writing.)
+    haystack.get()?.to_str()?;
+
+    // The top-level API doesn't support regex-automata's more granular Input
+    // abstraction.
+    let input = args::input::Config::default();
+    // The top-level API also doesn't use 'Captures' from regex-automata
+    // directly, but we can map between them with some annoyance.
+    let group_info = GroupInfo::new([re.capture_names()])
+        .context("could not build capture group info")?;
+    let mut locs = re.capture_locations();
+    let search = |input: &Input<'_>, caps: &mut Captures| {
+        let haystack = input.haystack().to_str().unwrap();
+        caps.set_pattern(None);
+        if !re.captures_read_at(&mut locs, haystack, input.start()).is_some() {
+            return Ok(());
+        }
+        caps.set_pattern(Some(PatternID::ZERO));
+        for i in 0..locs.len() {
+            use regex_automata::util::primitives::NonMaxUsize;
+
+            let slot_start = i * 2;
+            let slot_end = slot_start + 1;
+            match locs.get(i) {
+                None => {
+                    caps.slots_mut()[slot_start] = None;
+                    caps.slots_mut()[slot_end] = None;
+                }
+                Some((start, end)) => {
+                    caps.slots_mut()[slot_start] = NonMaxUsize::new(start);
+                    caps.slots_mut()[slot_end] = NonMaxUsize::new(end);
+                }
+            }
+        }
+        Ok(())
+    };
+    if find.count {
+        run_counts(
+            &mut table,
+            &common,
+            &find,
+            &input,
+            &haystack,
+            &group_info,
+            search,
+        )?;
+    } else {
+        run_search(
+            &mut table,
+            &common,
+            &find,
+            &input,
+            &haystack,
+            &group_info,
+            search,
+        )?;
+    }
+    Ok(())
+}
+
 /// A function that takes in a bunch of configuration, runs the given search
 /// routine, and prints out a table of counts.
 fn run_counts(

regex-cli/cmd/find/match/mod.rs

@@ -26,6 +26,7 @@ ENGINES:
     backtrack  Search with the bounded backtracker regex engine.
     dense      Search with the dense DFA regex engine.
     hybrid     Search with the lazy DFA regex engine.
+    lite       Search with the regex-lite engine.
     meta       Search with the meta regex engine.
     onepass    Search with the one-pass DFA regex engine.
     pikevm     Search with the PikeVM regex engine.
@@ -37,6 +38,7 @@ ENGINES:
         "backtrack" => nfa::run_backtrack(p),
         "dense" => dfa::run_dense(p),
         "hybrid" => dfa::run_hybrid(p),
+        "lite" => run_lite(p),
         "meta" => run_meta(p),
         "onepass" => dfa::run_onepass(p),
         "pikevm" => nfa::run_pikevm(p),
@@ -164,6 +166,71 @@ OPTIONS:
     Ok(())
 }
 
+fn run_lite(p: &mut lexopt::Parser) -> anyhow::Result<()> {
+    const USAGE: &'static str = "\
+Executes a search for full matches using the top-level regex-lite engine.
+
+Note that since the regex-lite crate doesn't have an API for search arbitrary
+byte slices, the haystack must be valid UTF-8. If it isn't, this command will
+report an error.
+
+USAGE:
+    regex-cli find match lite [-p <pattern> ...] <haystack-path>
+    regex-cli find match lite [-p <pattern> ...] -y <haystack>
+
+TIP:
+    use -h for short docs and --help for long docs
+
+OPTIONS:
+%options%
+";
+
+    let mut common = args::common::Config::default();
+    let mut patterns = args::patterns::Config::only_flags();
+    let mut haystack = args::haystack::Config::default();
+    let mut syntax = args::syntax::Config::default();
+    let mut lite = args::lite::Config::default();
+    let mut find = super::Config::default();
+    args::configure(
+        p,
+        USAGE,
+        &mut [
+            &mut common,
+            &mut patterns,
+            &mut haystack,
+            &mut syntax,
+            &mut lite,
+            &mut find,
+        ],
+    )?;
+
+    let pats = patterns.get()?;
+    let syn = syntax.syntax()?;
+    let mut table = Table::empty();
+    let (re, time) = util::timeitr(|| lite.from_patterns(&syn, &pats))?;
+    table.add("build regex time", time);
+
+    // Check that the haystack is valid UTF-8 since regex-lite doesn't support
+    // searching arbitrary byte sequences. (At time of writing.)
+    haystack.get()?.to_str()?;
+
+    // The top-level regex-lite API doesn't support regex-automata's more
+    // granular Input abstraction.
+    let input = args::input::Config::default();
+    let search = |input: &Input<'_>| {
+        let haystack = input.haystack().to_str().unwrap();
+        Ok(re
+            .find_at(haystack, input.start())
+            .map(|m| Match::new(PatternID::ZERO, m.start()..m.end())))
+    };
+    if find.count {
+        run_counts(&mut table, &common, &find, &input, &haystack, 1, search)?;
+    } else {
+        run_search(&mut table, &common, &find, &input, &haystack, search)?;
+    }
+    Ok(())
+}
+
 /// A function that takes in a bunch of configuration, runs the given search
 /// routine, and prints out a table of counts.
 fn run_counts(

regex-lite/Cargo.toml

@@ -0,0 +1,36 @@
+[package]
+name = "regex-lite"
+version = "0.1.0"  #:version
+authors = ["The Rust Project Developers", "Andrew Gallant <jamslam@gmail.com>"]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/rust-lang/regex/tree/master/regex-lite"
+documentation = "https://docs.rs/regex-lite"
+description = """
+A lightweight regex engine that optimizes for binary size and compilation time.
+"""
+workspace = ".."
+edition = "2021"
+rust-version = "1.60.0"
+autotests = false
+
+# Features are documented in the "Crate features" section of the crate docs:
+# https://docs.rs/regex-syntax/*/#crate-features
+[features]
+default = ["std"]
+std = []
+
+[dev-dependencies]
+anyhow = "1.0.69"
+regex-test = { path = "../regex-test", version = "0.1.0" }
+
+[[test]]
+path = "tests/lib.rs"
+name = "integration"
+
+[package.metadata.docs.rs]
+# We want to document all features.
+all-features = true
+# To test this locally, run:
+#
+#     RUSTDOCFLAGS="--cfg docsrs" cargo +nightly doc --all-features
+rustdoc-args = ["--cfg", "docsrs"]

regex-lite/LICENSE-APACHE

@@ -0,0 +1,201 @@
+                              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.

regex-lite/LICENSE-MIT

@@ -0,0 +1,25 @@
+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.

regex-lite/README.md

@@ -0,0 +1 @@
+WIP

regex-lite/src/error.rs

@@ -0,0 +1,19 @@
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Error {
+    msg: &'static str,
+}
+
+impl Error {
+    pub(crate) fn new(msg: &'static str) -> Error {
+        Error { msg }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for Error {}
+
+impl core::fmt::Display for Error {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "{}", self.msg)
+    }
+}

regex-lite/src/hir/mod.rs

@@ -0,0 +1,56 @@
+use core::num::NonZeroUsize;
+
+/// An extension trait that adds routines to the `u32` primitive type.
+pub(crate) trait U32 {
+    fn as_usize(self) -> usize;
+}
+
+impl U32 for u32 {
+    fn as_usize(self) -> usize {
+        // OK because we require 32 or 64 bit targets. Therefore, every u32
+        // necessarily fits into a usize.
+        self as usize
+    }
+}
+
+/// A `usize` that can never be `usize::MAX`.
+///
+/// This is similar to `core::num::NonZeroUsize`, but instead of not permitting
+/// a zero value, this does not permit a max value.
+///
+/// This is useful in certain contexts where one wants to optimize the memory
+/// usage of things that contain match offsets. Namely, since Rust slices
+/// are guaranteed to never have a length exceeding `isize::MAX`, we can use
+/// `usize::MAX` as a sentinel to indicate that no match was found. Indeed,
+/// types like `Option<NonMaxUsize>` have exactly the same size in memory as a
+/// `usize`.
+///
+/// This type is defined to be `repr(transparent)` for
+/// `core::num::NonZeroUsize`, which is in turn defined to be
+/// `repr(transparent)` for `usize`.
+#[derive(Clone, Copy, Eq, Hash, PartialEq, PartialOrd, Ord)]
+#[repr(transparent)]
+pub(crate) struct NonMaxUsize(NonZeroUsize);
+
+impl NonMaxUsize {
+    /// Create a new `NonMaxUsize` from the given value.
+    ///
+    /// This returns `None` only when the given value is equal to `usize::MAX`.
+    pub(crate) fn new(value: usize) -> Option<NonMaxUsize> {
+        NonZeroUsize::new(value.wrapping_add(1)).map(NonMaxUsize)
+    }
+
+    /// Return the underlying `usize` value. The returned value is guaranteed
+    /// to not equal `usize::MAX`.
+    pub(crate) fn get(self) -> usize {
+        self.0.get().wrapping_sub(1)
+    }
+}
+
+// We provide our own Debug impl because seeing the internal repr can be quite
+// surprising if you aren't expecting it. e.g., 'NonMaxUsize(5)' vs just '5'.
+impl core::fmt::Debug for NonMaxUsize {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "{:?}", self.get())
+    }
+}

regex-lite/src/hir/parse.rs

@@ -0,0 +1,32 @@
+/*!
+TODO
+*/
+
+#![allow(warnings)]
+#![no_std]
+#![forbid(unsafe_code)]
+// #![deny(missing_docs, rustdoc::broken_intra_doc_links)]
+#![warn(missing_debug_implementations)]
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+
+#[cfg(not(feature = "std"))]
+compile_error!("'std' is currently a required feature, please file an issue");
+
+#[cfg(not(any(target_pointer_width = "32", target_pointer_width = "64")))]
+compile_error!("not supported on non-{32,64}, please file an issue");
+
+extern crate alloc;
+#[cfg(any(test, feature = "std"))]
+extern crate std;
+
+pub use self::{error::Error, hir::escape, string::*};
+
+mod error;
+mod hir;
+mod int;
+mod interpolate;
+mod nfa;
+mod pikevm;
+mod pool;
+mod string;
+mod utf8;

regex-lite/src/int.rs

@@ -0,0 +1,160 @@
+use core::{
+    cell::UnsafeCell,
+    panic::{RefUnwindSafe, UnwindSafe},
+    sync::atomic::{AtomicBool, Ordering},
+};
+
+use alloc::{boxed::Box, vec, vec::Vec};
+
+use crate::pikevm;
+
+// Literally the only reason that this crate requires 'std' currently.
+//
+// In regex-automata, we support the no-std use case by rolling our own
+// spin-lock based Mutex. That's questionable on its own, but it's not clear if
+// we should be doing that here. It will require introducing non-safe code in a
+// crate that is otherwise safe. But maybe it's worth doing?
+use std::sync::Mutex;
+
+/// A type alias for our pool of meta::Cache that fixes the type parameters to
+/// what we use for the meta regex below.
+pub(crate) type CachePool = Pool<pikevm::Cache, CachePoolFn>;
+
+/// Same as above, but for the guard returned by a pool.
+pub(crate) type CachePoolGuard<'a> = PoolGuard<'a, pikevm::Cache, CachePoolFn>;
+
+/// The type of the closure we use to create new caches. We need to spell out
+/// all of the marker traits or else we risk leaking !MARKER impls.
+pub(crate) type CachePoolFn =
+    Box<dyn Fn() -> pikevm::Cache + Send + Sync + UnwindSafe + RefUnwindSafe>;
+
+/// A thread safe pool utilizing alloc-only features.
+///
+/// Unlike the pool in regex-automata, this has no "fast path." We could add
+/// it, but it's more code and requires reasoning about safety.
+pub(super) struct Pool<T, F> {
+    /// A stack of T values to hand out. These are used when a Pool is
+    /// accessed by a thread that didn't create it.
+    stack: Mutex<Vec<Box<T>>>,
+    /// A function to create more T values when stack is empty and a caller
+    /// has requested a T.
+    create: F,
+}
+
+// If T is UnwindSafe, then since we provide exclusive access to any
+// particular value in the pool, it should therefore also be considered
+// RefUnwindSafe.
+impl<T: UnwindSafe, F: UnwindSafe> RefUnwindSafe for Pool<T, F> {}
+
+impl<T, F> Pool<T, F> {
+    /// Create a new pool. The given closure is used to create values in
+    /// the pool when necessary.
+    pub(super) const fn new(create: F) -> Pool<T, F> {
+        Pool { stack: Mutex::new(vec![]), create }
+    }
+}
+
+impl<T: Send, F: Fn() -> T> Pool<T, F> {
+    /// Get a value from the pool. This may block if another thread is also
+    /// attempting to retrieve a value from the pool.
+    pub(super) fn get(&self) -> PoolGuard<'_, T, F> {
+        let mut stack = self.stack.lock().unwrap();
+        let value = match stack.pop() {
+            None => Box::new((self.create)()),
+            Some(value) => value,
+        };
+        PoolGuard { pool: self, value: Some(value) }
+    }
+
+    fn put(&self, guard: PoolGuard<'_, T, F>) {
+        let mut guard = core::mem::ManuallyDrop::new(guard);
+        if let Some(value) = guard.value.take() {
+            self.put_value(value);
+        }
+    }
+
+    /// Puts a value back into the pool. Callers don't need to call this.
+    /// Once the guard that's returned by 'get' is dropped, it is put back
+    /// into the pool automatically.
+    fn put_value(&self, value: Box<T>) {
+        let mut stack = self.stack.lock().unwrap();
+        stack.push(value);
+    }
+}
+
+impl<T: core::fmt::Debug, F> core::fmt::Debug for Pool<T, F> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("Pool").field("stack", &self.stack).finish()
+    }
+}
+
+/// A guard that is returned when a caller requests a value from the pool.
+pub(super) struct PoolGuard<'a, T: Send, F: Fn() -> T> {
+    /// The pool that this guard is attached to.
+    pool: &'a Pool<T, F>,
+    /// This is None after the guard has been put back into the pool.
+    value: Option<Box<T>>,
+}
+
+impl<'a, T: Send, F: Fn() -> T> PoolGuard<'a, T, F> {
+    /// Return the underlying value.
+    pub(super) fn value(&self) -> &T {
+        self.value.as_deref().unwrap()
+    }
+
+    /// Return the underlying value as a mutable borrow.
+    pub(super) fn value_mut(&mut self) -> &mut T {
+        self.value.as_deref_mut().unwrap()
+    }
+
+    /// Consumes this guard and puts it back into the pool.
+    pub(super) fn put(this: PoolGuard<'_, T, F>) {
+        // Since this is effectively consuming the guard and putting the
+        // value back into the pool, there's no reason to run its Drop
+        // impl after doing this. I don't believe there is a correctness
+        // problem with doing so, but there's definitely a perf problem
+        // by redoing this work. So we avoid it.
+        let mut this = core::mem::ManuallyDrop::new(this);
+        this.put_imp();
+    }
+
+    /// Puts this guard back into the pool by only borrowing the guard as
+    /// mutable. This should be called at most once.
+    #[inline(always)]
+    fn put_imp(&mut self) {
+        if let Some(value) = self.value.take() {
+            self.pool.put_value(value);
+        }
+    }
+}
+
+impl<'a, T: Send, F: Fn() -> T> Drop for PoolGuard<'a, T, F> {
+    fn drop(&mut self) {
+        self.put_imp();
+    }
+}
+
+impl<'a, T: Send, F: Fn() -> T> core::ops::Deref for PoolGuard<'a, T, F> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        self.value()
+    }
+}
+
+impl<'a, T: Send, F: Fn() -> T> core::ops::DerefMut for PoolGuard<'a, T, F> {
+    fn deref_mut(&mut self) -> &mut T {
+        self.value_mut()
+    }
+}
+
+impl<'a, T: Send + core::fmt::Debug, F: Fn() -> T> core::fmt::Debug
+    for PoolGuard<'a, T, F>
+{
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        f.debug_struct("PoolGuard")
+            .field("pool", &self.pool)
+            .field("value", &self.value)
+            .finish()
+    }
+}

regex-lite/src/interpolate.rs

@@ -0,0 +1,34 @@
+#[test]
+fn captures_wrong_order() {
+    let data = include_bytes!(
+        "testdata/crash-a886ce2b0d64963f1232f9b08b8c9ad4740c26f5"
+    );
+    let _ = run(data);
+}
+
+#[test]
+fn captures_wrong_order_min() {
+    let data = include_bytes!(
+        "testdata/minimized-from-298f84f9dbb2589cb9938a63334fa4083b609f34"
+    );
+    let _ = run(data);
+}
+
+// This is the fuzz target function. We duplicate it here since this is the
+// thing we use to interpret the data. It is ultimately what we want to
+// succeed.
+fn run(data: &[u8]) -> Option<()> {
+    if data.len() < 2 {
+        return None;
+    }
+    let mut split_at = usize::from(data[0]);
+    let data = std::str::from_utf8(&data[1..]).ok()?;
+    // Split data into a regex and haystack to search.
+    let len = usize::try_from(data.chars().count()).ok()?;
+    split_at = std::cmp::max(split_at, 1) % len;
+    let char_index = data.char_indices().nth(split_at)?.0;
+    let (pattern, input) = data.split_at(char_index);
+    let re = regex_lite::Regex::new(pattern).ok()?;
+    re.is_match(input);
+    Some(())
+}

regex-lite/src/lib.rs

@@ -0,0 +1,51 @@
+mod fuzz;
+mod string;
+
+const BLACKLIST: &[&str] = &[
+    // CRLF-aware line anchors aren't supported in regex API yet.
+    "crlf",
+    // Custom line terminators aren't supported in regex-lite. We could add it,
+    // but it didn't seem worth it.
+    "line-terminator",
+];
+
+fn suite() -> anyhow::Result<regex_test::RegexTests> {
+    let mut tests = regex_test::RegexTests::new();
+    macro_rules! load {
+        ($name:expr) => {{
+            const DATA: &[u8] =
+                include_bytes!(concat!("../../testdata/", $name, ".toml"));
+            tests.load_slice($name, DATA)?;
+        }};
+    }
+
+    load!("anchored");
+    load!("bytes");
+    load!("crazy");
+    load!("crlf");
+    load!("earliest");
+    load!("empty");
+    load!("expensive");
+    load!("flags");
+    load!("iter");
+    load!("leftmost-all");
+    load!("line-terminator");
+    load!("misc");
+    load!("multiline");
+    load!("no-unicode");
+    load!("overlapping");
+    load!("regression");
+    load!("set");
+    load!("substring");
+    load!("unicode");
+    load!("utf8");
+    load!("word-boundary");
+    load!("fowler/basic");
+    load!("fowler/nullsubexpr");
+    load!("fowler/repetition");
+
+    // Special tests for regex-lite specifically.
+    load!("regex-lite");
+
+    Ok(tests)
+}

regex-lite/src/nfa.rs

@@ -0,0 +1,150 @@
+use {
+    anyhow::Result,
+    regex_lite::{Regex, RegexBuilder},
+    regex_test::{
+        CompiledRegex, Match, RegexTest, Span, TestResult, TestRunner,
+    },
+};
+
+/// Tests the default configuration of the hybrid NFA/DFA.
+#[test]
+fn default() -> Result<()> {
+    let mut runner = TestRunner::new()?;
+    runner
+        .expand(&["is_match", "find", "captures"], |test| test.compiles())
+        .blacklist_iter(super::BLACKLIST)
+        .test_iter(crate::suite()?.iter(), compiler)
+        .assert();
+    Ok(())
+}
+
+fn run_test(re: &Regex, test: &RegexTest) -> TestResult {
+    let hay = match std::str::from_utf8(test.haystack()) {
+        Ok(hay) => hay,
+        Err(err) => {
+            return TestResult::fail(&format!(
+                "haystack is not valid UTF-8: {}",
+                err
+            ));
+        }
+    };
+    match test.additional_name() {
+        "is_match" => TestResult::matched(re.is_match(hay)),
+        "find" => TestResult::matches(
+            re.find_iter(hay)
+                .take(test.match_limit().unwrap_or(std::usize::MAX))
+                .map(|m| Match {
+                    id: 0,
+                    span: Span { start: m.start(), end: m.end() },
+                }),
+        ),
+        "captures" => {
+            let it = re
+                .captures_iter(hay)
+                .take(test.match_limit().unwrap_or(std::usize::MAX))
+                .map(|caps| testify_captures(&caps));
+            TestResult::captures(it)
+        }
+        name => TestResult::fail(&format!("unrecognized test name: {}", name)),
+    }
+}
+
+/// Converts the given regex test to a closure that searches with a
+/// `bytes::Regex`. If the test configuration is unsupported, then a
+/// `CompiledRegex` that skips the test is returned.
+fn compiler(
+    test: &RegexTest,
+    _patterns: &[String],
+) -> anyhow::Result<CompiledRegex> {
+    let Some(pattern) = skip_or_get_pattern(test) else {
+        return Ok(CompiledRegex::skip());
+    };
+    let re = RegexBuilder::new(pattern)
+        .case_insensitive(test.case_insensitive())
+        .build()?;
+    Ok(CompiledRegex::compiled(move |test| run_test(&re, test)))
+}
+
+/// Whether we should skip the given test or not. If not, return the single
+/// pattern from the given test.
+fn skip_or_get_pattern(test: &RegexTest) -> Option<&str> {
+    // We're only testing Regex here, which supports one pattern only.
+    let pattern = match test.regexes().len() {
+        1 => &test.regexes()[0],
+        _ => return None,
+    };
+    // If the test name contains 'regex-lite', then we ALWAYS run it. Because
+    // those tests are specifically designed for regex-lite. So if they fail,
+    // then something needs attention.
+    if test.full_name().contains("regex-lite/") {
+        return Some(pattern);
+    }
+    // If the pattern has a \p in it, then we almost certainly don't support
+    // it. This probably skips more than we intend, but there are likely very
+    // few tests that contain a \p that isn't also a Unicode class.
+    if pattern.contains(r"\p") || pattern.contains(r"\P") {
+        return None;
+    }
+    // Similar deal for Perl classes, but we can abide them if the haystack
+    // is ASCII-only.
+    if !test.haystack().is_ascii() {
+        if pattern.contains(r"\d") || pattern.contains(r"\D") {
+            return None;
+        }
+        if pattern.contains(r"\s") || pattern.contains(r"\S") {
+            return None;
+        }
+        if pattern.contains(r"\w") || pattern.contains(r"\W") {
+            return None;
+        }
+    }
+    // And also same deal for word boundaries.
+    if !test.haystack().is_ascii() {
+        if pattern.contains(r"\b") || pattern.contains(r"\B") {
+            return None;
+        }
+    }
+    // We only test is_match, find_iter and captures_iter. All of those are
+    // leftmost searches.
+    if !matches!(test.search_kind(), regex_test::SearchKind::Leftmost) {
+        return None;
+    }
+    // The top-level single-pattern regex API always uses leftmost-first.
+    if !matches!(test.match_kind(), regex_test::MatchKind::LeftmostFirst) {
+        return None;
+    }
+    // The top-level regex API always runs unanchored searches. ... But we can
+    // handle tests that are anchored but have only one match.
+    if test.anchored() && test.match_limit() != Some(1) {
+        return None;
+    }
+    // We don't support tests with explicit search bounds. We could probably
+    // support this by using the 'find_at' (and such) APIs.
+    let bounds = test.bounds();
+    if !(bounds.start == 0 && bounds.end == test.haystack().len()) {
+        return None;
+    }
+    // The Regex API specifically does not support disabling UTF-8 mode because
+    // it can only search &str which is always valid UTF-8.
+    if !test.utf8() {
+        return None;
+    }
+    // regex-lite doesn't support Unicode-aware case insensitive matching.
+    if test.case_insensitive()
+        && (!pattern.is_ascii() || !test.haystack().is_ascii())
+    {
+        return None;
+    }
+    Some(pattern)
+}
+
+/// Convert `Captures` into the test suite's capture values.
+fn testify_captures(caps: &regex_lite::Captures<'_>) -> regex_test::Captures {
+    let spans = caps.iter().map(|group| {
+        group.map(|m| regex_test::Span { start: m.start(), end: m.end() })
+    });
+    // This unwrap is OK because we assume our 'caps' represents a match, and
+    // a match always gives a non-zero number of groups with the first group
+    // being non-None.
+    regex_test::Captures::new(0, spans).unwrap()
+}

regex-lite/src/pikevm.rs

@@ -0,0 +1,98 @@
+# These tests are specifically written to test the regex-lite crate. While it
+# largely has the same semantics as the regex crate, there are some differences
+# around Unicode support and UTF-8.
+#
+# To be clear, regex-lite supports far fewer patterns because of its lack of
+# Unicode support, nested character classes and character class set operations.
+# What we're talking about here are the patterns that both crates support but
+# where the semantics might differ.
+
+# regex-lite uses ASCII definitions for Perl character classes.
+[[test]]
+name = "perl-class-decimal"
+regex = '\d'
+haystack = '᠕'
+matches = []
+unicode = true
+
+# regex-lite uses ASCII definitions for Perl character classes.
+[[test]]
+name = "perl-class-space"
+regex = '\s'
+haystack = "\u2000"
+matches = []
+unicode = true
+
+# regex-lite uses ASCII definitions for Perl character classes.
+[[test]]
+name = "perl-class-word"
+regex = '\w'
+haystack = 'δ'
+matches = []
+unicode = true
+
+# regex-lite uses the ASCII definition of word for word boundary assertions.
+[[test]]
+name = "word-boundary"
+regex = '\b'
+haystack = 'δ'
+matches = []
+unicode = true
+
+# regex-lite uses the ASCII definition of word for negated word boundary
+# assertions. But note that it should still not split codepoints!
+[[test]]
+name = "word-boundary-negated"
+regex = '\B'
+haystack = 'δ'
+matches = [[0, 0], [2, 2]]
+unicode = true
+
+# While we're here, the empty regex---which matches at every
+# position---shouldn't split a codepoint either.
+[[test]]
+name = "empty-no-split-codepoint"
+regex = ''
+haystack = '💩'
+matches = [[0, 0], [4, 4]]
+unicode = true
+
+# A dot always matches a full codepoint.
+[[test]]
+name = "dot-always-matches-codepoint"
+regex = '.'
+haystack = '💩'
+matches = [[0, 4]]
+unicode = false
+
+# A negated character class also always matches a full codepoint.
+[[test]]
+name = "negated-class-always-matches-codepoint"
+regex = '[^a]'
+haystack = '💩'
+matches = [[0, 4]]
+unicode = false
+
+# regex-lite only supports ASCII-aware case insensitive matching.
+[[test]]
+name = "case-insensitive-is-ascii-only"
+regex = 's'
+haystack = 'ſ'
+matches = []
+unicode = true
+case-insensitive = true
+
+# Negated word boundaries shouldn't split a codepoint, but they will match
+# between invalid UTF-8.
+#
+# This test is only valid for a 'bytes' API, but that doesn't (yet) exist in
+# regex-lite. This can't happen in the main API because &str can't contain
+# invalid UTF-8.
+# [[test]]
+# name = "word-boundary-invalid-utf8"
+# regex = '\B'
+# haystack = '\xFF\xFF\xFF\xFF'
+# unescape = true
+# matches = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4]]
+# unicode = true
+# utf8 = false

regex-lite/src/pool.rs

@@ -662,3 +662,12 @@ name = "word-boundary-interact-poorly-with-literal-optimizations"
 regex = '(?i:(?:\b|_)win(?:32|64|dows)?(?:\b|_))'
 haystack = 'ubi-Darwin-x86_64.tar.gz'
 matches = []
+
+# This was found during fuzz testing in regex-lite. The regex crate never
+# suffered from this bug, but it causes regex-lite to incorrectly compile
+# captures.
+[[test]]
+name = "captures-wrong-order"
+regex = '(a){0}(a)'
+haystack = 'a'
+matches = [[[0, 1], [], [0, 1]]]