[Proposal]: Extended identifier syntax

[leppie]

Extended identifier syntax

• Proposed
• Prototype: Not Started
• Implementation: Not Started
• Specification: Not Started

Summary

Allow non-standard identifier syntax in C#.

Motivation

Allow C# to reference any allowable CLR identifier in assemblies produced by non-C# languages for interop purposes.

Detailed design

Some languages do not conform to the C# identifier syntax, but still are valid within the CLR specification.

This proposal introduces a (lexical) syntax extension that is compatable with the C# lexical specification and also allow other language names to be referenced without having to resort to reflection or other means (ie post-processing or raw IL).

In the spirit of Markdown, I suggest the ability to escape any identifier between 2 backquotes.

Examples:

`a-b`
`+`  
`$/bitcoin`
`SQL column name`

The resulting text between the two backquotes will exactly reference (and resolve, when used) a single valid CLR identifier.

Usage (using and calling a static method);

using `F#/C#`;
`$bob`.`an-alice!`(typeof(`@terrajobst`));

Justification

Shameless plug: https://github.com/IronScheme (but specifically IronScheme.Glue.il needed for interop).

Another common use case would be preserving quoted SQL identifiers. See example above.

Drawbacks

It is ugly, but it is ugly for a reason. General usage should not be encouraged.

Potential parsing issues with comments, preprocessor directives and other existing lexical tokens.

Alternatives

There are no static alternatives except raw IL or post-processing like Fody.

Unresolved questions

To discourage usage even more, a compiler flag/property could/should be added.

Design meetings

[333fred]

As documented in our README, all proposals start out as discussions, not issues.

[leppie]

Sorry

[GabeSchaffer]

Would this make 'unspeakable' identifiers (e.g. those used for display classes) actually 'speakable'?

[RikkiGibson]

I think the language could still define these to not be accessible from source code, but it introduces a problem where the user might define something which collides with what the compiler wants to generate.

[leppie]

That is a potential issue. Thanks for pointing out.

Again, this is why this feature should be as 'unusable' as possible (compiler flag?).

However, I dont see any issues abusing 'closure' types in C# (if you really wanted to, you can just go wild in the debugger).

Edit: Correct me if I am wrong (would be enlightening to me).

[AartBluestoke]

Resolved with a clause in the language spec that says all access to unspeakable classes invokes implementation defined behaviour. You can do it now with reflection anyway..
(Does c# have separate concepts for "implementation defined"(something specific chosen by the implementation) vs "undefined" (ie, what happens can change per execution- eg, unsafe access to a pointer that has been garbage collected)

[RikkiGibson]

I am curious if an F#-style verbatim identifier feature would address this use case. (I couldn't find prior issues for this, but they must exist, here or elsewhere..)

e.g. in F# we can say let ``$.weird identifier`` = ...

[leppie]

This should make them directly referencable. Had no idea F# had this.

I have no problem using double backquotes for the syntax, but single ones would suffice in C#.

[leppie]

Does F# allow you to reference these identifiers in non-F# assemblies?