[ruby-core:18861] tokenizing regular expressions when passed as method params

Hi,

I'm working on an upgrade to the Ruby language module in a Mac OS X text editor.

The language module itself is written in C++ (ie, it's compiled code,
runs as a plugin/library), and is responsible for syntax coloring, and
for identifying language structure (for the editor's code-navigation
features and code folding).

The Ruby module has been working well, but we've had numerous bug
reports related to regular expressions when passed as method
arguments.

This was not unexpected. When I first wrote the module, I punted on
this issue because I couldn't see a way to reliably identify regular
expressions.

If the method call is parenthesized, there's no problem:

  foo.bar( /regex/, bat )

If the regular expression is not the first parameter, there's no problem:

  foo.bar bat, /regex/

However, if there are no parentheses and the regular expression is the
first parameter, there is definitely a problem:

  foo.bar /regex/, bat

I can't figure out how to tell if that '/' is dividing foo.bar by
whatever comes next, or if it's a regular expression.

This can be a serious problem, because if the regular expression is
not detected correctly (that is, if I mistake the '/' for a division
operator) then the contents of the regular expression can throw off my
perception of everything that comes after the regular expression. For
example:

  title.gsub /some word "/, ' '

My tokenzier currently does not see a regular expression there, but
instead it will see the double-quote within it as the beginning of a
string.

Is there any way to unambiguously identify regular expressions in this
situation, or is this just a bug we'll have to live with?

(I hope messages like this are acceptable here. I only signed up a few
minutes ago, at the prompting of someone more knowledgeable about the
Ruby core group than I am.)

Thanks for any help anyone can offer!

Seth