grep: warn on leading ERE repeat operators

Author: wondr-wclabs

src/matcher.rs

@@ -10,6 +10,7 @@ use onig::{
 };
 use onig_sys::{OnigEncCtype_ONIGENC_CTYPE_WORD, OnigEncodingUTF8};
 use uucore::error::{UResult, USimpleError};
+use uucore::show_warning;
 
 pub struct Matcher<'a> {
     config: &'a Config<'a>,
@@ -215,6 +216,17 @@ impl CompiledPattern {
             // GNU grep supports `{,n}` as an alias for `{0,n}`.
             syntax.enable_behavior(SyntaxBehavior::SYNTAX_BEHAVIOR_ALLOW_INTERVAL_LOW_ABBREV);
         }
+        let mut normalized_pattern = None;
+        let pattern = if config.regex_mode == RegexMode::Extended {
+            if let Some((op, rest)) = strip_leading_repeat_operator(pattern) {
+                show_warning!("{op} at start of expression");
+                normalized_pattern = Some(rest.to_string());
+            }
+            normalized_pattern.as_deref().unwrap_or(pattern)
+        } else {
+            pattern
+        };
+
         if config.regex_mode == RegexMode::Perl {
             // GNU grep supports `(?P<name>...)`.
             // Unfortunately, the onig crate defines the OP2 flag without the
@@ -289,3 +301,22 @@ impl CompiledPattern {
             .is_some()
     }
 }
+
+fn strip_leading_repeat_operator(pattern: &str) -> Option<(&'static str, &str)> {
+    match pattern.as_bytes().first()? {
+        b'?' => Some(("?", &pattern[1..])),
+        b'*' => Some(("*", &pattern[1..])),
+        b'+' => Some(("+", &pattern[1..])),
+        b'{' => strip_leading_interval_repeat(pattern).map(|rest| ("{...}", rest)),
+        _ => None,
+    }
+}
+
+fn strip_leading_interval_repeat(pattern: &str) -> Option<&str> {
+    let close = pattern.as_bytes().iter().position(|&b| b == b'}')?;
+    let body = &pattern[1..close];
+    let is_interval = !body.is_empty()
+        && body.bytes().all(|b| b.is_ascii_digit() || b == b',')
+        && body.bytes().any(|b| b.is_ascii_digit());
+    is_interval.then_some(&pattern[close + 1..])
+}

tests/test_grep.rs

@@ -126,6 +126,32 @@ fn ere_invalid_pattern_is_error() {
         .stderr_contains("invalid pattern");
 }
 
+#[test]
+fn ere_leading_repeat_operators_warn_and_match_empty() {
+    let cases = [
+        ("?", "warning: ? at start of expression"),
+        ("*", "warning: * at start of expression"),
+        ("+", "warning: + at start of expression"),
+        ("{2}", "warning: {...} at start of expression"),
+        ("{,2}", "warning: {...} at start of expression"),
+    ];
+
+    for (pattern, warning) in cases {
+        let (_s, mut c) = ucmd();
+        c.args(&["-E", "-e", pattern])
+            .pipe_in("abc\n")
+            .succeeds()
+            .stdout_is("abc\n")
+            .stderr_contains(warning);
+    }
+
+    let (_s, mut c) = ucmd();
+    c.args(&["*foo"])
+        .pipe_in("*foo\nfoo\n")
+        .succeeds()
+        .stdout_only("*foo\n");
+}
+
 #[test]
 fn fixed_string_is_literal() {
     // Metacharacters are not interpreted.