What does the regex (?!\G) do in language grammars

Question

I keep seeing this regex in language-grammars which allow editors to highlight syntax.

I know what the regex is trying to convey:

(?!\G) Negative Lookahead - Assert that it is impossible to match the regex below
\G assert position at the end of the previous match or the start of the string for the first match

Here's the snippet which caught my attention:

console

# console.log(arg1, "arg2", [...])
'begin': '\\bconsole\\b'
'beginCaptures':
  '0':
    'name': 'entity.name.type.object.console.js'
'end': '(?!\\G)'
'patterns': [
  {
    'begin': '\\s*(\\.)\\s*(assert|clear|debug|error|info|log|profile|profileEnd|time|timeEnd|warn)\\s*(?=\\()'
    'beginCaptures':
      '1':
        'name': 'meta.delimiter.method.period.js'
      '2':
        'name': 'support.function.console.js'
    'end': '(?<=\\))'
    'name': 'meta.method-call.js'
    'patterns': [
      {
        'include': '#arguments'
      }
    ]
  }
]

The above snippet is from atom/language-javascript package.

From what I've understood by browsing various text-mate forums is that for highlighting, the editor would start at begin and go on till the end regex. Here it starts by matching the console keyword and then goes on till it matches the end regex, which I'm not able to understand, as in, where would it stop?

Could somebody explain it?

Answer 1

See some Language Grammars reference first:

There are two ways a rule can match the document. It can either provide a single regular expression, or two. As with the match key in the first rule above (lines 6-8), everything which matches that regular expression will then get the name specified by that rule. ... The other type of match is the one used by the second rule (lines 9-17). Here two regular expressions are given using the begin and end keys. The name of the rule will be assigned from where the begin pattern matches to where the end pattern matches (including both matches). If there is no match for the end pattern, the end of the document is used.

In this latter form, the rule can have sub-rules which are matched against the part between the begin and end matches.

Note that the regular expressions are matched against only a single line of the document at a time. That means it is not possible to use a pattern that matches multiple lines.

begin, end — these keys allow matches which span several lines and must both be mutually exclusive with the match key. Each is a regular expression pattern. begin is the pattern that starts the block and end is the pattern which ends the block.

The rules you supplied match text like console.log and highlight the 3 different parts: console, . and log.

'begin': '\\bconsole\\b'
'beginCaptures':
  '0':
    'name': 'entity.name.type.object.console.js'
'end': '(?!\\G)'

Here, the console as a whole word is matched, the whole match (as the 0th group is the whole match) is named entity.name.type.object.console.js and then the regex matches any character up to (?!\G) that matches any position that is not the end of the last successful match and not the beginning of a string. This is necessary to let the other nested rules to work, i.e. those that match '\\s*(\\.)\\s*(assert|clear|debug|error|info|log|profile|profileEnd|time|timeEnd|warn)\\s*(?=\\()' pattern. Otherwise, the block would be complete before, and the method names would be skipped from matching.