Positive lookahead isn't working

[revosw]

In my language definition, a function is defined by this
/\b[a-z]\w*(?=\()/

Word boundary, followed by a lowercase letter, followed by zero or more word characters, up to but not including the left parenthesis. However, the positive lookahead isn't working.

This is the result from the regex defined above, with the positive lookahead:
Pastebin

And this is for this regex: /\b[a-z]\w*(/
Basically the same, except up to but including the left parenthesis

My code looks like this:

function(hljs) {
  return {
    alias: ["e2", "wire_e2", "expression2", "exp2", "expr2"],
    keywords: 'if elseif else for foreach while break continue local switch case default function return',
    illegal: "'",
    contains: [
      {
        className: 'string',
        begin: /(")(\\[\s\S]|(?!\1)[^\\])*\1/g,
        relevance: 0
      },
      {
        className: 'ppcommand',
        begin: /#(include|ifdef|ifndef|else|endif)/,
        relevance: 10
      },
      hljs.COMMENT('#\\[', ']#'),
      hljs.HASH_COMMENT_MODE,
      {
        className: 'directive',
        begin: /@(name.*|model.*|inputs|outputs|persist|trigger|autoupdate)/,
        relevance: 10
      },
      {
        className: 'constant',
        begin: /\b_[A-Z0-9_]+/
      },
      {
        className: 'variable',
        begin: /\b[A-Z]\w*/,
        relevance: 0
      },
      {
        className: 'function',
        begin: /\b[a-z]\w*\(/,
        relevance: 0
      },
      {
        // (angle|array|bone|complex|entity|matrix[24]?|number|quaternion|ranger|string|table|vector[24]?|void|wirelink)
        className: 'type',
        begin: /\b(angle|array|bone|complex|entity|matrix[24]?|number|quaternion|ranger|string|table|vector[24]?|void|wirelink)(?!\()\b/g,
        illegal: "\\(",
        relevance: 0
      },
      {
        className: 'number',
        begin: /(-?)(\b0x[A-F0-9]+|\b0b[01]+|(\b\d+(\.\d*)?|\.\d+)(e[-+]?\d+)?)/,
        relevance: 0
      }
    ]
  }
}

If there are any workarounds to this, suggestions are gladly appreciated

[jandamm]

I found this issue as well.
It's actually not the lookahead itself that is not working.

In my case the issue was slightly different:

/\b[a-z][\w\u00C0-\u02B8\']*\b(?![\(])/g is for variables and /\b[a-z][\w\u00C0-\u02B8\']*(?=\()/g is for methods. The variable Regex comes first.

Now running the compiled language over makeIterator() combines the regexes to this /\b[a-z][\w\u00C0-\u02B8\']*\b(?![\(])|\b[a-z][\w\u00C0-\u02B8\']*(?=\( which is of course true as it includes both cases.
Afterwards, it only runs the match as lexeme over a substring which would succeed in both cases.

So the matching seems not right. As soon as there are two very similar regexes in one group, it does not work anymore.

[ArthaTi]

Only positive lookaheads don't work. You know what that means? Simple lookaheads are possible.

You can replace

(?=[a])

with

(?![^a])

@revosw Looks like your case is identical to mine. You can use /\b[a-z]\w*(?![^(])/ instead of /\b[a-z]\w*(?=\()/. Check if that works.

[GegznaV]

Seems to be related to #1349

[joshgoebel]

Closing this as a dupe of #1696.

We’ll leave that as the open issue for purposes of discussion, but I already have a PR in that solves this, though it might be a just a bit longer before it’s merged.