Please permit nameof(global::N)

[gafter]

@Przemyslaw-W commented on Tue Aug 29 2017

Hi,

Consider code:

namespace N
{
    class C
    {
        void Foo()
        {
            Console.WriteLine(nameof(global::N.C));
            Console.WriteLine(nameof(global::N));
        }
    }
}

First statement compiles just fine, second emits error. Why is handling of namespace and class different here?

---

@svick commented on Tue Aug 29 2017

Why is handling of namespace and class different here?

It's not. The error is "error CS8083: An alias-qualified name is not an expression." And that's the issue: syntactically, the code inside nameof has to be an expression. A, A.B and global::A.B are all syntactically valid expressions, but global::A is not.

So, the difference isn't between namespace and class, it's about the exact syntax used. This means that nameof(global::N.M) is valid, even though N.M is a namespace. And nameof(global::C) is not valid, even for class C that's in the global namespace.

The decision to make nameof accept only code that's syntactically an expression means it has some other annoying restrictions (see #702). If lifting those restrictions was considered, maybe the global::N case could be considered at the same time?

---

@Przemyslaw-W commented on Wed Aug 30 2017

Now I can see what the issue is, thanks.

Imo this restriction seems a bit artificial and alias qualified names should be legal inside nameof. Please treat this issue as vote up for lifting these restrictions.

[bondsbw]

It's not. The error is "error CS8083: An alias-qualified name is not an expression." And that's the issue: syntactically, the code inside nameof has to be an expression. A, A.B and global::A.B are all syntactically valid expressions, but global::A is not.

This does seem like a strange way to specify what is allowed. There are plenty of expressions for which nameof is not legal.

[gafter]

This does seem like a strange way to specify what is allowed. There are plenty of expressions for which nameof is not legal.

Just because the argument of nameof has to be an expression, doesn't mean that every expression is a valid argument for nameof.

Syntactically, nameof is just a method invocation. That's why the argument has to be an expression. Of course 2 doesn't have a name.

[daiplusplus]

@gafter:

the argument of nameof has to be an expression

Hold on, but what about this?

using Microsoft;
using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Authentication;

// ...

// This works, even though `Microsoft.AspNetCore` is a namespace, not an expression:
String ns1 = nameof(Microsoft) + "." + nameof(global::Microsoft.AspNetCore);

// As does this:
String ns2 = nameof(Microsoft) + "." + nameof(Microsoft.AspNetCore);

// And these two too:
String ns3 = nameof(Microsoft) + "." + nameof(Microsoft.AspNetCore);
String ns4 = nameof(Microsoft) + "." + nameof(Microsoft.AspNetCore) + "." + nameof(Microsoft.AspNetCore.Authentication);

// But this fails:
String ns5 = nameof(global::Microsoft) + "." + nameof(global::Microsoft.AspNetCore);

Screenshot proof in VS2017, compiler set to C# 7.3:

Why are namespace names with at least two components allowed, but not single name components?

[svick]

@Jehoel

This works, even though Microsoft.AspNetCore is a namespace, not an expression

Syntactically (and syntax is all that matters here), global::Microsoft.AspNetCore is a valid expression, because Microsoft could have been the name of a type in the global namespace and AspNetCore could have been its member. That this is not the case is only determined at the semantic layer.

On the other hand, global::Microsoft is syntactically not a valid expression.

[mgravell]

Came up here: https://stackoverflow.com/questions/69116668/why-can-nameof-not-be-used-with-alias-qualified-types-at-the-root-level

Sorry to resurrect, but to add:

Keep in mind that N can be a type here (in the namespace root) - it isn't common, but it is entirely valid, and yet is disallowed currently:

// note: no namespace here
public class N
{
    public class C {}
}

Here, nameof(global::N.C) works ("C"), and nameof(global::N) causes a CS8083 error.

On the other hand, global::Microsoft is syntactically not a valid expression.

It isn't a valid nameof_expression according to spec, but that's a circular argument; the underlying question is "why is that not permitted by the spec, and can/should it be changed?". Since global::N makes sense in every other usage where you would want to use it, it feels very odd that nameof gets fussy about it. (@svick)

[daiplusplus]

while we're at it, let's get pathof() - that way I don't have to have ugly const string expressions with lots of concatenation.

e.g.

const string s1 = pathof(global::Microsoft);
const string s1 = pathof(System.Collections.Generic.List<String>);
const string s3 = pathof( new List<Int32>().Count ); // <-- Yes, this is a silly example

Console.WriteLine( s1 ); // "global::Microsoft"
Console.WriteLine( s2 ); // "global::System.Collections.Generic.List<String>"
Console.WriteLine( s3 ); // "global::System.Collections.Generic.List<Int32>.Count"

[svick]

That is a duplicate of #701, where it's called fullnameof. (Though I don't see why the result would include the global:: prefix.)

[daiplusplus]

@svick Oooh, thanks. No wonder why I couldn't find it, I never thought to use that term instead.