Add support for nameof and open generic types

BillWagner · BillWagner · commit b1439738da17 · 2025-02-10T16:46:45.000-05:00
Fixes dotnet#44182 Add that `nameof` now supports open generic types. This is the first C# 14 feature I've added, so create the C# 14 file, and update the language version tables accordingly.
diff --git a/.openpublishing.redirection.csharp.json b/.openpublishing.redirection.csharp.json
@@ -4282,7 +4282,7 @@
         },
         {
             "source_path_from_root": "/docs/csharp/whats-new.md",
-            "redirect_url": "/dotnet/csharp/whats-new/csharp-13",
+            "redirect_url": "/dotnet/csharp/whats-new/csharp-14",
             "redirect_document_id": true
         },
         {
diff --git a/docs/csharp/index.yml b/docs/csharp/index.yml
@@ -32,7 +32,7 @@ highlightedContent:
     # Card
     - title: What's new
       itemType: whats-new
-      url: ./whats-new/csharp-13.md
+      url: ./whats-new/csharp-14.md
     # Card
     - title: Learn C# video series
       itemType: video
diff --git a/docs/csharp/language-reference/configure-language-version.md b/docs/csharp/language-reference/configure-language-version.md
@@ -2,7 +2,7 @@
 title: Configure language version
 description: Learn how to override the default C# language version manually. The C# compiler can support any language version up to the version in the installed SDK.
 ms.custom: "updateeachrelease"
-ms.date: 09/17/2024
+ms.date: 01/31/2025
 ---
 
 # Configure C# language version
@@ -17,7 +17,7 @@ If you need a specific language version that differs from the one automatically
 
 > [!WARNING]
 >
-> Setting the `LangVersion` element to `latest` is discouraged. The `latest` setting means the installed compiler uses its latest version. That can change from machine to machine, making builds unreliable. In addition, it enables language features that may require runtime or library features not included in the current SDK.
+> Setting the `LangVersion` element to `latest` is discouraged. The `latest` setting means the installed compiler uses its latest version. The value of `latest` can change from machine to machine, making builds unreliable. In addition, it enables language features that might require runtime or library features not included in the current SDK.
 
 If you must specify your C# version explicitly, you can do so in several ways:
 
@@ -28,19 +28,19 @@ If you must specify your C# version explicitly, you can do so in several ways:
 > [!TIP]
 > You can see the language version in Visual Studio in the project properties page. Under the *Build* tab, the *Advanced* pane displays the version selected.
 >
-> To know what language version you're currently using, put `#error version` (case sensitive) in your code. This makes the compiler report a compiler error, CS8304, with a message containing the compiler version being used and the current selected language version. For more information about this pragma, see [#error (C# Reference)](preprocessor-directives.md#error-and-warning-information).
+> To know what language version you're currently using, put `#error version` (case sensitive) in your code. This pragma makes the compiler report a compiler error, CS8304, with a message containing the compiler version used and the current selected language version. For more information about this pragma, see [#error (C# Reference)](preprocessor-directives.md#error-and-warning-information).
 
 ## Edit the project file
 
-You can set the language version in your project file. For example, if you explicitly want access to preview features, add an element like this:
+You can set the language version in your project file. For example, if you explicitly want access to preview features, add an element like the following example:
 
 ```xml
 <PropertyGroup>
    <LangVersion>preview</LangVersion>
 </PropertyGroup>
 ```
 
-The value `preview` uses the latest available preview C# language version that your compiler supports.
+The value `preview` uses the latest available preview C# language version your compiler supports.
 
 ## Configure multiple projects
 
@@ -58,7 +58,7 @@ Builds in all subdirectories of the directory containing that file now use the p
 
 > [!NOTE]
 >
-> The versions for C# and VB are different. Don't use the *Directory.Build.Props* file for a folder where subdirectories contain projects for both languages. The versions won't match.
+> The versions for C# and VB are different. Don't use the *Directory.Build.Props* file for a folder where subdirectories contain projects for both languages. The versions don't match.
 
 ## C# language version reference
 
diff --git a/docs/csharp/language-reference/includes/default-langversion-table.md b/docs/csharp/language-reference/includes/default-langversion-table.md
@@ -4,6 +4,7 @@ ms.custom: "updateeachrelease"
 
 | Target           | Version | C# language version default |
 |------------------|---------|-----------------------------|
+| .NET             | 10.x    | C# 14                       |
 | .NET             | 9.x     | C# 13                       |
 | .NET             | 8.x     | C# 12                       |
 | .NET             | 7.x     | C# 11                       |
diff --git a/docs/csharp/language-reference/includes/langversion-table.md b/docs/csharp/language-reference/includes/langversion-table.md
@@ -7,6 +7,7 @@ ms.custom: "updateeachrelease"
 | `preview`                     | The compiler accepts all valid language syntax from the latest preview version.                         |
 | `latest`                      | The compiler accepts syntax from the latest released version of the compiler (including minor version). |
 | `latestMajor`<br>or `default` | The compiler accepts syntax from the latest released major version of the compiler.                     |
+| `14.0`                        | The compiler accepts only syntax that is included in C# 14 or lower.                                    |
 | `13.0`                        | The compiler accepts only syntax that is included in C# 13 or lower.                                    |
 | `12.0`                        | The compiler accepts only syntax that is included in C# 12 or lower.                                    |
 | `11.0`                        | The compiler accepts only syntax that is included in C# 11 or lower.                                    |
diff --git a/docs/csharp/language-reference/operators/nameof.md b/docs/csharp/language-reference/operators/nameof.md
@@ -1,7 +1,7 @@
 ---
 title: "The nameof expression - evaluate the text name of a symbol"
 description: "The C# `nameof` expression produces the name of its operand. You use it whenever you need to use the name of a symbol as text"
-ms.date: 11/28/2022
+ms.date: 01/31/2025
 f1_keywords:
   - "nameof_CSharpKeyword"
   - "nameof"
@@ -14,21 +14,23 @@ helpviewer_keywords:
 
 A `nameof` expression produces the name of a variable, type, or member as the string constant. A `nameof` expression is evaluated at compile time and has no effect at run time. When the operand is a type or a namespace, the produced name isn't [fully qualified](~/_csharpstandard/standard/basic-concepts.md#783-fully-qualified-names). The following example shows the use of a `nameof` expression:
 
-[!code-csharp-interactive[nameof expression](snippets/shared/NameOfOperator.cs#Examples)]
+:::code language="csharp" interactive="try-dotnet-method" source="snippets/shared/NameOfOperator.cs" id="Examples":::
 
 You can use a `nameof` expression to make the argument-checking code more maintainable:
 
-[!code-csharp[nameof and argument check](snippets/shared/NameOfOperator.cs#ExceptionMessage)]
+:::code language="csharp" interactive="try-dotnet-method" source="snippets/shared/NameOfOperator.cs" id="ExceptionMessage":::
 
 Beginning with C# 11, you can use a `nameof` expression with a method parameter inside an [attribute](../../advanced-topics/reflection-and-attributes/index.md) on a method or its parameter. The following code shows how to do that for an attribute on a method, a local function, and the parameter of a lambda expression:
 
-:::code language="csharp" source="snippets/shared/NameOfOperator.cs" id="SnippetNameOfParameter":::
+:::code language="csharp" interactive="try-dotnet-method" source="snippets/shared/NameOfOperator.cs" id="SnippetNameOfParameter":::
 
 A `nameof` expression with a parameter is useful when you use the [nullable analysis attributes](../attributes/nullable-analysis.md) or the [CallerArgumentExpression attribute](../attributes/caller-information.md#argument-expressions).
 
 When the operand is a [verbatim identifier](../tokens/verbatim.md), the `@` character isn't part of the name, as the following example shows:
 
-[!code-csharp-interactive[nameof verbatim](snippets/shared/NameOfOperator.cs#Verbatim)]
+:::code language="csharp" interactive="try-dotnet-method" source="snippets/shared/NameOfOperator.cs" id="Verbatim":::
+
+Beginning with C# 14, the argument can be an unbound generic type, such as `List<>`. The `nameof(List<>)` expression evaluates to `List`. If you use a closed generic type, such as `List<int>`, the output is the generic type, not the closed instantiation:  `List`.
 
 ## C# language specification
 
diff --git a/docs/csharp/toc.yml b/docs/csharp/toc.yml
@@ -148,6 +148,8 @@ items:
   items:
   - name: C# 14
     items:
+    - name: What's new in C# 14
+      href: whats-new/csharp-14.md
     - name: Breaking changes since C# 13
       href: ../../_roslyn/docs/compilers/CSharp/Compiler%20Breaking%20Changes%20-%20DotNet%2010.md
   - name: C# 13
diff --git a/docs/csharp/whats-new/csharp-14.md b/docs/csharp/whats-new/csharp-14.md
@@ -0,0 +1,39 @@
+---
+title: What's new in C# 14
+description: Get an overview of the new features in C# 13.
+ms.date: 01/31/2025
+ms.topic: whats-new
+---
+# What's new in C# 14
+
+C# 14 includes the following new features. You can try these features using the latest [Visual Studio 2022](https://visualstudio.microsoft.com/vs/preview/) version or the [.NET 10 SDK](https://dotnet.microsoft.com/download/dotnet):
+
+- [`nameof` supports unbound generic types](#unbound-generic-types-and-nameof)
+
+C# 14 includes the [`field`](#the-field-keyword) contextual keyword as a preview feature.
+
+C# 14 is supported on **.NET 10**. For more information, see [C# language versioning](../language-reference/configure-language-version.md).
+
+You can download the latest .NET 10 SDK from the [.NET downloads page](https://dotnet.microsoft.com/download). You can also download [Visual Studio 2022](https://visualstudio.microsoft.com/vs/), which includes the .NET 10 SDK.
+
+New features are added to the "What's new in C#" page when they're available in public preview releases. The [working set](https://github.com/dotnet/roslyn/blob/main/docs/Language%20Feature%20Status.md#working-set) section of the [roslyn feature status page](https://github.com/dotnet/roslyn/blob/main/docs/Language%20Feature%20Status.md) tracks when upcoming features are merged into the main branch.
+
+You can find any breaking changes introduced in C# 14 in our article on [breaking changes](~/_roslyn/docs/compilers/CSharp/Compiler%20Breaking%20Changes%20-%20DotNet%2010.md).
+
+[!INCLUDE [released-version-feedback](./includes/released-feedback.md)]
+
+## The `field` keyword
+
+The [`field`](../language-reference/keywords/field.md) contextual keyword is in C# 13 as a preview feature. The token `field` accesses the compiler synthesized backing field in a property accessor. It enables you to write an accessor body without declaring an explicit backing field in your type declaration. You can declare a body for one or both accessors for a field backed property.
+
+The `field` feature is released as a preview feature. We want to learn from your experiences using it. There's a potential breaking change or confusion reading code in types that also include a field named `field`. You can use `@field` or `this.field` to disambiguate between the `field` keyword and the identifier.
+
+[!INCLUDE[field-preview](../includes/field-preview.md)]
+
+If you try this feature and have feedback, add it to the [feature issue](https://github.com/dotnet/csharplang/issues/140) in the `csharplang` repository.
+
+## Unbound generic types and nameof
+
+Beginning with C# 14, the argument to `nameof` can be an unbound generic type. For example, `nameof(List<>)` evaluates to `List`. In earlier versions of C#, only closed generic types, such as `List<int>` had to be used to produce `List`.
+
+<!-- Add link to What's new in .NET 10 once it's published -->

Original file line number	Diff line number	Diff line change
`@@ -4282,7 +4282,7 @@`
`4282`	`4282`	`},`
`4283`	`4283`	`{`
`4284`	`4284`	`"source_path_from_root": "/docs/csharp/whats-new.md",`
`4285`		`- "redirect_url": "/dotnet/csharp/whats-new/csharp-13",`
	`4285`	`+ "redirect_url": "/dotnet/csharp/whats-new/csharp-14",`
`4286`	`4286`	`"redirect_document_id": true`
`4287`	`4287`	`},`
`4288`	`4288`	`{`