Proposal: disallow regular expressions with the global match flag `g` at the module level

Please describe what the rule should do:

Regular expressions with the g flag maintain state, which can cause confusion and subtle bugs if the regex is defined at the module level. It would be nice if there was an eslint rule to prevent this.

It might also be worth flagging regexes with the g flag in the global scope.

What category of rule is this? (place an “X” next to just one item)

[ ] Enforces code style [x] Warns about a potential error [ ] Suggests an alternate way of doing something [ ] Other (please specify:)

Provide 2-3 code examples that this rule will warn about:

Bad:

const foo = /./g;

const foo = /./gi;

const bar = new RegExp('.', 'g');

const baz = new RegExp(/./, 'g');

Okay:

function() {
  const foo = /./g;
}

function() {
  const bar = new RegExp('.', 'g');
}

const foo = /./;

const bar = new RegExp('.');

Why should this rule be included in ESLint (instead of a plugin)?

This is a source of bugs in a core part of the language.

cc @ljharb

[not-an-aardvark]

The point of a rule isn’t necessarily to cover all cases, it’s often to do the safe/best thing in the common case.

Definitely agree. I’m just concerned about whether the “common case” for this rule (accidental mutation) for this rule is actually much more common than the safe case. Sure, people can use override comments for exceptional cases, but if they need to be used for a very significant percentage of errors reported by a rule, then the rule can be sort of irritating to use.

[ljharb]

This bit me specifically because I thought about lastIndex, and intentionally used the g flag, thinking it would protect me from the mutation - when in fact, it was the reverse.

Essentially this rule should warn whenever a regex literal (or new RegExp) with the global flag g (or the sticky flag y, which also suffers from this issue) is re-used across scopes.