How-to determine if an "nameof" IdentifierToken is a contextual keyword

[bernd5]

I'd like to do something with nameof expressions. Unfortunately there seems to be no public API to detect if an identifier is a contextual nameof keyword or not.

In the roslyn code I found out that there is a Field called RawContextualKind which contains the data e.g. NameOfKeyword - but it is internal.

Could you make it public, please?

In addition it is not handled correctly for example by "RoslynQuoter": https://dotnetfiddle.net/J6NPUK.

So if you just copy all public property you get errors. But it works if RawKind is filled with a ContextualKind like:

IdentifierName(Identifier(TriviaList(), SyntaxKind.NameOfKeyword, "nameof", "nameof", TriviaList()))

[CyrusNajmabadi]

The right way to do you is to actually check if the name is 'nameof'. It's not a special keyword.

In terms of roslyn quoter, it needs to call 'ParseToken' to get the right token here unfortunately.

[CyrusNajmabadi]

I could query the semantic model for a constant value

Yes.

but this is very slow compared to check a flag...

No flag can be provided here. This is how the language works. nameof(x) could bind to a method call (or other symbol). You have to perform semantics to determine what is going on. This is what the compiler needs to do as well.

[bernd5]

Yes, that was what I thought should go on - I was just surprised that it does not work with a regular identifier (produced via SyntaxFactory).
But the reason is that such keywords are classified during lexing as "potential contextual keywords" - if this missing further checks are skipped later.
From a user perspective this behaviour is weird - but anyway thank you!

[CyrusNajmabadi]

Unfortunately, by design. The only way to get trees that are 100% certain to be accepted by the compiler is to go through the parser. That's the only contract we support. Anything else may or may not work. :) FYI, you may find gitter/discord more suitable for tehse sorts of quick questions.

[bernd5]

Unfortunately the behaviour is still strange:
Take the following code:

Code:

using System;
using System.Linq;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

/*
var @class = 12;
System.Console.WriteLine(nameof(@class));
*/

void DoWithTree(SyntaxTree tree){
	Console.WriteLine(tree.GetRoot().NormalizeWhitespace().ToFullString());
	
	var refApis = AppDomain.CurrentDomain.GetAssemblies().Select(a => MetadataReference.CreateFromFile(a.Location));
	var com = CSharpCompilation.Create("something", new []{ tree }, refApis );
	var model = com.GetSemanticModel(tree);

	var nameof = tree.GetRoot().DescendantNodes().OfType<InvocationExpressionSyntax>().Skip(1).First();
	var constVal = model.GetConstantValue(nameof).Value;
	Console.WriteLine($"Value: {constVal}");

	var diag =com.GetDiagnostics().Where(e => e.Severity == DiagnosticSeverity.Error).ToList();

	foreach(var d in diag)
	{
	  Console.WriteLine(d);	
	}
	Console.WriteLine("--------------------------");
}	


var tree1 = SyntaxTree(SyntaxFactory.ParseCompilationUnit(@"var @class = 12;
System.Console.WriteLine(nameof(@class));"));


var tree2 = SyntaxTree(
//CODE FROM ROSLYN QUOTER:
CompilationUnit()
.WithMembers(
    List<MemberDeclarationSyntax>(
        new MemberDeclarationSyntax[]{
            GlobalStatement(
                LocalDeclarationStatement(
                    VariableDeclaration(
                        IdentifierName("var"))
                    .WithVariables(
                        SingletonSeparatedList<VariableDeclaratorSyntax>(
                            VariableDeclarator(
                                Identifier(@"@class"))
                            .WithInitializer(
                                EqualsValueClause(
                                    LiteralExpression(
                                        SyntaxKind.NumericLiteralExpression,
                                        Literal(12)))))))),
            GlobalStatement(
                ExpressionStatement(
                    InvocationExpression(
                        MemberAccessExpression(
                            SyntaxKind.SimpleMemberAccessExpression,
                            MemberAccessExpression(
                                SyntaxKind.SimpleMemberAccessExpression,
                                IdentifierName("System"),
                                IdentifierName("Console")),
                            IdentifierName("WriteLine")))
                    .WithArgumentList(
                        ArgumentList(
                            SingletonSeparatedList<ArgumentSyntax>(
                                Argument(
                                    InvocationExpression(
                                        IdentifierName(ParseToken("nameof")))
                                    .WithArgumentList(
                                        ArgumentList(
                                            SingletonSeparatedList<ArgumentSyntax>(
                                                Argument(
                                                    IdentifierName(@"@class")))))))))))}))
.NormalizeWhitespace()
//END
);

var tree3 = SyntaxTree(
//CODE FROM ROSLYN QUOTER:
CompilationUnit()
.WithMembers(
    List<MemberDeclarationSyntax>(
        new MemberDeclarationSyntax[]{
            GlobalStatement(
                LocalDeclarationStatement(
                    VariableDeclaration(
                        IdentifierName("var"))
                    .WithVariables(
                        SingletonSeparatedList<VariableDeclaratorSyntax>(
                            VariableDeclarator(
                                Identifier(@"@class"))
                            .WithInitializer(
                                EqualsValueClause(
                                    LiteralExpression(
                                        SyntaxKind.NumericLiteralExpression,
                                        Literal(12)))))))),
            GlobalStatement(
                ExpressionStatement(
                    InvocationExpression(
                        MemberAccessExpression(
                            SyntaxKind.SimpleMemberAccessExpression,
                            MemberAccessExpression(
                                SyntaxKind.SimpleMemberAccessExpression,
                                IdentifierName("System"),
                                IdentifierName("Console")),
                            IdentifierName("WriteLine")))
                    .WithArgumentList(
                        ArgumentList(
                            SingletonSeparatedList<ArgumentSyntax>(
                                Argument(
                                    ParseExpression(@"nameof(@class)")
                                    ))))))}))
.NormalizeWhitespace()
//END
);

DoWithTree(tree1);
DoWithTree(tree2);
DoWithTree(tree3);

It triggers no errors with tree2 but the constant value becomes "@Class" instead of "class" - but why?

[CyrusNajmabadi]

Don't do: IdentifierName(@"@class")
Do: ParseExpression("@class")

It's a problem with the quoter. It often doesn't do literals/expressions as precisely as necessary.