falconGitHub

valid-regexps

Same as valid_regexps in Dart lints

Path
lint/correctness/valid-regexps
Default
On (recommended)
Origin
Dart lints
Rule
510 of 512
recommended

Disallow statically known invalid dart:core regular expressions.

Validate decoded literal patterns with an ECMAScript parser, including the constructor's literal unicode: true flag, matching the SDK lint.

Invalid

example.dartdart
// Bad: literal patterns that are structurally invalid regular expressions.
void examples() {
  final a = RegExp('(');
  final b = RegExp(')');
  final c = RegExp('[a-z');
  final d = RegExp('(abc');
  final e = RegExp('a(b(c)');
  final f = new RegExp('foo)');
  final g = RegExp('*abc');
  final h = RegExp('[z-a]');
  final i = RegExp(r'\xG0', unicode: true);
  final j = RegExp('a{3,2}');
  final k = RegExp(r'[z-a]');
  final l = RegExp(r'\d{3,2}');
  final adjacent = RegExp('(' r'\d');
  print([a, b, c, d, e, f, g, h, i, j, k, l]);
  RegExp('{', unicode: true);
  RegExp(r'\q', unicode: true);
  RegExp(r'(?invalid)');
  RegExp(r'(?<x>a)(?<x>b)');
  RegExp(r'(?<=a)+');
  RegExp('\\xG0', unicode: true);
  RegExp('\\');
}
Use a valid regular expression.
2void examples() {
3 final a = RegExp('(');
Use a valid regular expression.
3 final a = RegExp('(');
4 final b = RegExp(')');
Use a valid regular expression.
4 final b = RegExp(')');
5 final c = RegExp('[a-z');
Use a valid regular expression.
5 final c = RegExp('[a-z');
6 final d = RegExp('(abc');
Use a valid regular expression.
6 final d = RegExp('(abc');
7 final e = RegExp('a(b(c)');
Use a valid regular expression.
7 final e = RegExp('a(b(c)');
8 final f = new RegExp('foo)');
Use a valid regular expression.
8 final f = new RegExp('foo)');
9 final g = RegExp('*abc');
Use a valid regular expression.
9 final g = RegExp('*abc');
10 final h = RegExp('[z-a]');
Use a valid regular expression.
10 final h = RegExp('[z-a]');
11 final i = RegExp(r'\xG0', unicode: true);
Use a valid regular expression.
11 final i = RegExp(r'\xG0', unicode: true);
12 final j = RegExp('a{3,2}');
Use a valid regular expression.
12 final j = RegExp('a{3,2}');
13 final k = RegExp(r'[z-a]');
Use a valid regular expression.
13 final k = RegExp(r'[z-a]');
14 final l = RegExp(r'\d{3,2}');
Use a valid regular expression.
14 final l = RegExp(r'\d{3,2}');
15 final adjacent = RegExp('(' r'\d');
Use a valid regular expression.
16 print([a, b, c, d, e, f, g, h, i, j, k, l]);
17 RegExp('{', unicode: true);
Use a valid regular expression.
17 RegExp('{', unicode: true);
18 RegExp(r'\q', unicode: true);
Use a valid regular expression.
18 RegExp(r'\q', unicode: true);
19 RegExp(r'(?invalid)');
Use a valid regular expression.
19 RegExp(r'(?invalid)');
20 RegExp(r'(?<x>a)(?<x>b)');
Use a valid regular expression.
20 RegExp(r'(?<x>a)(?<x>b)');
21 RegExp(r'(?<=a)+');
Use a valid regular expression.
21 RegExp(r'(?<=a)+');
22 RegExp('\\xG0', unicode: true);
Use a valid regular expression.
22 RegExp('\\xG0', unicode: true);
23 RegExp('\\');

Valid

example.dartdart
// Good: valid patterns, or patterns that are not statically checkable literals.
void examples(String dynamicPattern) {
  final a = RegExp('abc');
  final b = RegExp('[a-z]+');
  final c = RegExp('(foo|bar)');
  final d = RegExp('a(b(c)d)e'); // balanced nested groups
  final e = RegExp(r'\d{3}-\d{4}'); // raw string, balanced
  final f = RegExp('\\d+'); // decoded non-raw pattern
  final g = RegExp(dynamicPattern); // not a literal, skipped
  final h = RegExp('prefix-${dynamicPattern}'); // interpolated, skipped
  final i = RegExp(r'(?=foo)foo'); // lookahead
  final j = RegExp(r'(?:foo)*?'); // non-capturing group and lazy quantifier
  final k = RegExp('[]'); // ECMAScript empty character class
  final l = RegExp('[a-]'); // trailing hyphen is a literal, not a range
  final m = RegExp(r'[a-' r'z]');
  final n = RegExp(r'\d{1,' r'3}');
  final o = RegExp('[a-' 'z]');
  final p = RegExp(r'''[a-z]+''');
  final adjacent = RegExp('(' r'\d' ')');
  print([a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p]);
  RegExp('{');
  RegExp('a{not-a-quantifier}');
  RegExp(r'\xG0');
  RegExp(r'\uZZZZ');
  RegExp(r'\q');
  RegExp(r'(?<=a)b');
  RegExp(r'(?<!a)b');
  RegExp(r'(?<word>a)\k<word>');
  RegExp(r'(?=a)+');
  RegExp(r'\p{Letter}+', unicode: true);
  RegExp(r'\u{1F600}', unicode: true);
}

Configure valid-regexps

Set its severity in falcon.json. See the configuration guide.

falcon.jsonjson
{
  "linter": {
    "rules": {
      "correctness": {
        "valid-regexps": "error"
      }
    }
  }
}

Or silence one occurrence with a suppression comment; the reason is required.

example.dartdart
// falcon-ignore lint/correctness/valid-regexps: <reason>