C# improvements

[RunDevelopment]

This PR is mainly about an improved detection of type names and better support for generic parameters in C#.

It also adds support for the nameof operator and now highlights type parameters the same as classes.

[mAAdhaTTah]

Minor note: you'll need to commit the minified file for C#. Otherwise, I'll defer to my co-maintainers to review the Regex here.

[RunDevelopment]

I added support for foreach variable declarations and improved the number highlighting.

[Golmote]

Hi! Thanks for contributing.

During this review, I struggled a bit to understand what each pattern was trying to do. It would be great if the test files reflected the structure of the language definition. That is, there should be one test file per pattern name ("number_feature.test", "keyword_feature.test"), and if you want you can split a complicated pattern (I'm looking at you, "class-name") between multiple test files but please refer each one to its corresponding pattern by "naming" them using a comment.

Doing so, the tests files might get a bit redundant sometimes, when a pattern needs to be next to another pattern to be valid. But at least it makes it obvious what your regexps are trying to match.

[RunDevelopment]

Maybe I should explain the main part that matches almost every class name. That is this:

/[A-Z]\w*(?:\.\w+)*(?:<(?:[^>\n=;{}]+|>(?=\s*(?:\[\s*(?:,\s*)*\]\s*)*[,.>?)]))+?>)?(?:\.\w+)*(?:\[\s*(?:,\s*)*\])*/

Seems complicated? Things get a little easier when you take out the part responsable for generics. Then we get:

/[A-Z]\w*(?:\.\w+)*(?:\[\s*(?:,\s*)*\])*/

Now that's friendlier. (I removed the redundant (?:\.\w+)*)
All this does is to match classes, subclasses and their namespace. At the end we include possible array brackets and that's it.

Ok back to the part for generics:

/(?:<(?:[^>\n=;{}]+|>(?=\s*(?:\[\s*(?:,\s*)*\]\s*)*[,.>?)]))+?>)?/

The main problem here is that we try to accomplish the impossible. We try to match structures like Foo<A<B<C<D>, E<F<G>, H>, I<J<K<L>>>>, M>> which require a context free grammar with regular expressions.
Have fun with that, because regular expressions can't count the pointy brackets!

And fun I had. What I did, was to say that there are only a limited number of characters which can follow after a >, if that > is not the one closing the initiale class name.
This yields quite good results but is neither perfect nor very fast. In my testing it's on average about 2~5 times slower than (?:<[^>]+>)? (which can't match nested generic types). In certain edge case it also matches too much but that can be avoided by using lookarounds and cleverly ordering of the different patterns.

I know that this is far from perfect but it work quite reliably in all of my tests and code examples.

[RunDevelopment]

I'm also thinking of adding real support for nullables, because with C# 8.0 coming it might be important.
Needless to say, this will make thinks even more complicated...

[Golmote]

The main problem here is that we try to accomplish the impossible. We try to match structures like Foo<A<B<C, E<F, H>, I<J<K>>>, M>> which require a context free grammar with regular expressions.
Have fun with that, because regular expressions can't count the pointy brackets!

In my testing it's on average about 2~5 times slower than (?:<[^>]+>)? (which can't match nested generic types).

Do people really do 5 nested levels of generics in real-world code? The regexp could certainly be faster if we limited Prism's support to a certain number of nested levels (like 2... or maybe 3. Above, the regexp will get really ugly).

[RunDevelopment]

Do people really do 5 nested levels of generics in real-world code?

I certainly hope not, but generics can get messy. (Hopefully not that messy...)

like 2... or maybe 3. Above, the regexp will get really ugly

/<(?:[^<>]+|<(?:[^<>]+|<(?:[^<>]+|<[^<>]+>)+>)+>)+>/

I settled for 4 as the maximum depth. A depth of 3 should be enough for everything I do and 4 should satisfy even hardliners. It's probably a little overkill but better safe than sorry.
I also choose to not do any other validation as before to include things like arrays, tuples and nullables. This means that it also includes trash like Foo<.............>, but we're not a code validator, are we?

Btw. That beauty above is 9 characters less than its predecessor.

[Golmote]

but we're not a code validator, are we?

We're definitely not!

The regexp in your last message looks ok to me. I'll review again once the PR gets updated.

[RunDevelopment]

Now there is a small problem. Consider the regex for generic methods simplified for a max depth of 2:

/\w+\s*<(?:[^<>]+|<[^<>]+>)+>(?=\s*\()/

Just try to match the text

for (Int32 i = 0; i < count; i++); foreach (Foo e in Elements);

and see how long it takes for you. It will terminate returning that no match was found, but only after exponential time.
To match this text it will take my computer approximately 30 minutes...

[magkal]

Any updates on this PR? Would be awesome if it could get merged within a few months. I realize you seem to be swamped with work.

[RunDevelopment]

I will redo this PR once #1538, #1664, and #1679 are through.

[RunDevelopment]

So here's an update for this PR. Aside from explicit implementation (which I can't do without #1679) and C# 8.0 ranges edit: added, every feature of C# I know about is supported.

Added features include:

• String interpolation
• New C# 8.0 keywords
• Nullable reference types
• Named arguments
• Ranges

[NotoriousRebel]

any updates on this?

[RunDevelopment]

It just needs someone to review.

[RunDevelopment]

Thanks for the review @Golmote!

Apparently, Travis is taking the day off. I'll try to get it to run and then merge.

[RunDevelopment]

Ok. Travis actually ran and succeeded but the status isn't displayed here on GH.
Interesting.