diff --git a/docs/csharp/language-reference/compiler-messages/feature-version-errors.md b/docs/csharp/language-reference/compiler-messages/feature-version-errors.md index d3eaae9a09ee4..8e24424487f6a 100644 --- a/docs/csharp/language-reference/compiler-messages/feature-version-errors.md +++ b/docs/csharp/language-reference/compiler-messages/feature-version-errors.md @@ -39,6 +39,7 @@ f1_keywords: - "CS8929" - "CS8957" # ERR_NoImplicitConvTargetTypedConditional Conditional expression is not valid in language version {0} because a common type was not found between '{1}' and '{2}' - "CS8912" # ERR_InheritingFromRecordWithSealedToString Inheriting from a record with a sealed 'Object.ToString' is not supported + - "CS9041" # ERR_UnsupportedCompilerFeature '{0}' requires compiler feature '{1}', which is not supported by this version of the C# compiler. - "CS9014" # ERR_UseDefViolationPropertyUnsupportedVersion Use of possibly unassigned property - "CS9015" # ERR_UseDefViolationFieldUnsupportedVersion Use of possibly unassigned field - "CS9016" # WRN_UseDefViolationPropertyUnsupportedVersion Use of possibly unassigned property @@ -98,6 +99,7 @@ helpviewer_keywords: - "CS8912" - "CS8919" - "CS8929" + - "CS9041" - "CS9014" - "CS9015" - "CS9016" @@ -150,6 +152,7 @@ That's be design. The text closely matches the text of the compiler error / warn - **CS8929**: *Method cannot implement interface member in type because the target runtime doesn't support static abstract members in interfaces.* - **CS8957**: *Conditional expression is not valid in language version because a common type was not found between types.* - **CS8967**: *Newlines inside a non-verbatim interpolated string are not supported in C#* +- **CS9041**: *Requires compiler feature, which is not supported by this version of the C# compiler.* - **CS9014**: *Error: Use of possibly unassigned property. Upgrade to auto-default the property.* - **CS9015**: *Error: Use of possibly unassigned field. Upgrade to auto-default the field.* - **CS9016**: *Warning: Use of possibly unassigned property. Upgrade to auto-default the property.* diff --git a/docs/csharp/language-reference/compiler-messages/overloaded-operator-errors.md b/docs/csharp/language-reference/compiler-messages/overloaded-operator-errors.md index 555ec6ab4b978..3815b8d86829f 100644 --- a/docs/csharp/language-reference/compiler-messages/overloaded-operator-errors.md +++ b/docs/csharp/language-reference/compiler-messages/overloaded-operator-errors.md @@ -71,6 +71,7 @@ helpviewer_keywords: - "CS9023" - "CS9024" - "CS9025" + - "CS9027" - "CS9308" - "CS9310" - "CS9311" @@ -119,6 +120,7 @@ That's by design. The text closely matches the text of the compiler error / warn - [**CS9023**](#checked-operators): *Operator cannot be made checked.* - [**CS9024**](#checked-operators): *Operator cannot be made unchecked.* - [**CS9025**](#checked-operators): *Operator requires a matching non-checked version to also be declared.* +- [**CS9027**](#checked-operators): *Unexpected keyword 'unchecked'.* - [**CS9308**](#operator-declaration-requirements): *User-defined operator must be declared public.* - [**CS9310**](#operator-signature-requirements): *The return type for this operator must be void.* - [**CS9311**](#interface-and-inheritance-requirements): *Type does not implement interface member. The type cannot implement member because one of them is not an operator.* @@ -386,11 +388,13 @@ public class C4 - **CS9023**: *Operator can't be made checked* - **CS9024**: *Operator can't be made unchecked* - **CS9025**: *Checked operator requires a matching non-checked version to also be declared* +- **CS9027**: *Unexpected keyword 'unchecked'* To use checked operators correctly, follow these requirements. For more information, see [Arithmetic operators](../operators/arithmetic-operators.md#user-defined-checked-operators) and [User-defined checked operators](~/_csharplang/proposals/csharp-11.0/checked-user-defined-operators.md). - Apply `checked` or `unchecked` keywords only to supported arithmetic operators: `+`, `-`, `*`, `/`, `++`, `--`, and explicit conversions (**CS9023**, **CS9024**). - Provide both checked and unchecked versions when declaring a checked operator (**CS9025**). The compiler needs both to handle different contexts. +- Use the `unchecked` keyword only in valid operator declaration contexts (**CS9027**). Don't place it in locations where it's syntactically unexpected. ## Interface and inheritance requirements diff --git a/docs/csharp/language-reference/compiler-messages/source-generator-errors.md b/docs/csharp/language-reference/compiler-messages/source-generator-errors.md index 0acfb3b8e39ef..465aa81bef996 100644 --- a/docs/csharp/language-reference/compiler-messages/source-generator-errors.md +++ b/docs/csharp/language-reference/compiler-messages/source-generator-errors.md @@ -37,6 +37,8 @@ f1_keywords: - "CS9234" - "CS9235" - "CS9270" + - "CS9057" + - "CS9067" helpviewer_keywords: - "CS9137" - "CS9138" @@ -73,7 +75,9 @@ helpviewer_keywords: - "CS9234" - "CS9235" - "CS9270" -ms.date: 05/23/2025 + - "CS9057" + - "CS9067" +ms.date: 01/27/2026 --- # Errors and warnings associated with source generators and interceptors @@ -115,6 +119,8 @@ The following warnings are generated when source generators or interceptors are - [**CS8784**](#incorrect-interceptor-declaration): *Generator '`YourSourceGeneratorName`' failed to initialize. It will not contribute to the output and compilation errors may occur as a result.* - [**CS8785**](#incorrect-interceptor-declaration): *Generator '`YourSourceGeneratorName`' failed to generate source. It will not contribute to the output and compilation errors may occur as a result.* +- [**CS9057**](#analyzer-compatibility): *Analyzer assembly cannot be used because it references a newer version of the compiler than the currently running version.* +- [**CS9067**](#analyzer-compatibility): *Analyzer reference specified multiple times.* - [**CS9154**](#signature-mismatch): *Intercepting a call to `M` with interceptor `V`, but the signatures do not match.* - [**CS9158**](#signature-mismatch): *Nullability of reference types in return type doesn't match interceptable method.* - [**CS9159**](#signature-mismatch): *Nullability of reference types in type of parameter doesn't match interceptable method.* @@ -124,17 +130,13 @@ These errors and warnings follow these themes: ## Interceptors are experimental -This error indicates you must enable the experimental feature. - - **CS9137**: *The 'interceptors' experimental feature is not enabled. Add `InterceptorsPreview` to your project.* -In C# 12, interceptors are experimental. Interceptors are subject to breaking changes or removal in a future release. Therefore, it is not recommended for production or released applications. - -In order to use interceptors, you must set the `InterceptorsPreview` element in your project file. Without this flag, interceptors are disabled, even when other C# 12 features are enabled. +To use interceptors, add the `InterceptorsPreview` element to your project file within a `` section (**CS9137**), because interceptors are an experimental feature that isn't enabled by default. This explicit opt-in is required because interceptors are subject to breaking changes or removal in future releases, and the compiler needs confirmation that you understand the risks before allowing their use. For more information about interceptors and their capabilities, see [Interceptors](../../whats-new/csharp-12.md#interceptors) in the C# 12 features documentation. ## Signature mismatch -The following errors indicate a mismatch between the interceptor method and the interceptable method, or a violation of the rules regarding interceptor method declarations: +The following errors and warnings indicate a mismatch between the interceptor method and the interceptable method. - **CS9144**: *Cannot intercept method `M` with interceptor `V` because the signatures do not match.* - **CS9148**: *Interceptor must have a `this` parameter matching parameter.* @@ -151,13 +153,15 @@ In addition, the following warnings indicate a mismatch in the signatures of the - **CS9159**: *Nullability of reference types in type of parameter doesn't match interceptable method.* - **CS9270**: *'`InterceptsLocationAttribute(string, int, int)`' is not supported. Move to 'InterceptableLocation'-based generation of these attributes instead. [(https://github.com/dotnet/roslyn/issues/72133)](https://github.com/dotnet/roslyn/issues/72133)* -The interceptor method must be compatible with the interceptable method. You must follow these rules: +To correct these issues, ensure your interceptor method matches the interceptable method's signature and access requirements: -- Instance methods can intercept instance methods, not static methods. Similarly, static methods can only intercept static methods, not instance methods. -- The method signatures for the interceptor and the interceptable method must match: They must have the same parameters with the same modifiers in the same order. The return types must also match. -- The ref safe contexts must match. In other words, corresponding `ref` parameters must be either `scoped` or not `scoped`. -- They methods must both be non-generic, or both must have the same number of type parameters. -- An updated `InterceptorLocationAttribute` constructor signature is preferred. +- Ensure the interceptor method signature exactly matches the interceptable method (**CS9144**, **CS9154**). The parameter types, modifiers, order, and return type must be identical. Review both method declarations and align their signatures. +- Add a `this` parameter to your interceptor when the interceptable method is an instance method (**CS9148**), or remove the `this` parameter when the interceptable method is static (**CS9149**). Instance interceptors require a `this` parameter of the declaring type, while static interceptors must not have one. +- Declare your interceptor in a location where the interceptable method is accessible (**CS9155**). If the interceptable method is `internal`, the interceptor must be in the same assembly. If it's `private`, the interceptor must be in the same type or a nested type. +- Match the `scoped` modifiers and `[UnscopedRef]` attributes on corresponding `ref` parameters (**CS9156**). Each `ref` parameter in the interceptor must have the same lifetime annotations as the corresponding parameter in the interceptable method to ensure memory safety. +- Ensure both methods have matching generic arity (**CS9177**, **CS9178**). If the interceptable method is non-generic, the interceptor must also be non-generic. If the interceptable method has type parameters, the interceptor must have the same number of type parameters with compatible constraints. +- Match the nullability annotations in the return type (**CS9158**) and parameter types (**CS9159**). Enable nullable reference types in your project and ensure the interceptor's nullability annotations match the interceptable method exactly to maintain type safety. +- Use the updated `InterceptableLocation`-based generation for `InterceptsLocationAttribute` instead of the deprecated `(string, int, int)` constructor (**CS9270**). The newer format provides better tooling support and compile-time validation. See the [GitHub issue](https://github.com/dotnet/roslyn/issues/72133) for migration guidance. ## Incorrect mapping @@ -173,15 +177,19 @@ Interceptors require a source mapping that maps the interceptable method and the - **CS9150**: *Interceptor cannot have a `null` file path.* - **CS9157**: *Line and character numbers provided to `InterceptsLocationAttribute` must be positive.* +To correct mapping errors, ensure your `InterceptsLocationAttribute` contains valid file paths and accurate position information: + +- Verify the file path matches a file in your compilation exactly (**CS9139**, **CS9140**). Use the exact path as it appears in your project, including correct casing and directory separators. If the compiler suggests an alternative path, update your attribute to use that path. +- Use mapped file paths when working with source generators that transform file paths (**CS9145**). Source generators often remap paths for generated files, and you must use the mapped path that the compiler recognizes, not the original source path. +- Ensure the file path isn't `null` in your `InterceptsLocationAttribute` (**CS9150**). Every interception must specify a valid, non-null file path that identifies the source file containing the call to intercept. +- Provide positive, 1-based line and character numbers (**CS9157**). Line numbers and character positions must start at 1, not 0. Verify your source generator uses 1-based indexing when calculating positions. +- Point to the exact start of the method name token (**CS9141**, **CS9147**). The line and character numbers must identify the first character of the method name in the invocation, not whitespace, operators, or other tokens. If the compiler suggests alternative coordinates, use those to target the correct token start. +- Stay within the file's bounds (**CS9142**, **CS9143**). Verify the line number doesn't exceed the total line count and the character number doesn't exceed the line length. Recalculate positions if the source file has changed since the attribute was generated. + ## Incorrect interceptor declaration The following errors indicate issues with interceptor declarations, including problems with the `InterceptsLocationAttribute` format or violations of interceptor rules: -- **CS9231**: *The data argument to InterceptsLocationAttribute is not in the correct format.* -- **CS9232**: *Version 'version' of the interceptors format is not supported. The latest supported version is '1'.* -- **CS9233**: *Cannot intercept a call in file 'file' because it is duplicated elsewhere in the compilation.* -- **CS9234**: *Cannot intercept a call in file 'file' because a matching file was not found in the compilation.* -- **CS9235**: *The data argument to InterceptsLocationAttribute refers to an invalid position in file 'file'.* - **CS9138**: *Method cannot be used as an interceptor because it or its containing type has type parameters.* - **CS9146**: *An interceptor method must be an ordinary member method.* - **CS9151**: *Possible method name `M` cannot be intercepted because it is not being invoked.* @@ -191,20 +199,35 @@ The following errors indicate issues with interceptor declarations, including pr - **CS9161**: *An interceptor cannot be marked with `UnmanagedCallersOnlyAttribute`.* - **CS9206**: *An interceptor cannot be declared in the global namespace.* - **CS9207**: *Cannot intercept because method is not an invocation of an ordinary member method.* +- **CS9231**: *The data argument to InterceptsLocationAttribute is not in the correct format.* +- **CS9232**: *Version 'version' of the interceptors format is not supported. The latest supported version is '1'.* +- **CS9233**: *Cannot intercept a call in file 'file' because it is duplicated elsewhere in the compilation.* +- **CS9234**: *Cannot intercept a call in file 'file' because a matching file was not found in the compilation.* +- **CS9235**: *The data argument to InterceptsLocationAttribute refers to an invalid position in file 'file'.* + +To correct interceptor declaration errors, follow these rules for valid interceptor declarations and `InterceptsLocationAttribute` usage: + +- Format the `InterceptsLocationAttribute` data argument correctly (**CS9231**). The attribute requires specifically structured data that encodes file path and position information. Ensure your source generator produces data in the expected format matching the current interceptors specification. +- Use version '1' in your `InterceptsLocationAttribute` (**CS9232**), because it's the latest supported version. Update your source generator to output version 1 format attributes rather than unsupported version numbers. +- Ensure unique file paths in your compilation (**CS9233**, **CS9234**). When the compilation contains duplicate file paths, rename or reorganize files to make each path unique. Verify that the file path in the attribute matches a file actually included in the compilation. +- Validate position data points to valid code locations (**CS9235**). The line and character numbers must reference a valid interception point within the specified file. Regenerate the attribute if the source file has changed or if the position falls outside the file's bounds. +- Declare non-generic interceptor methods in non-generic types (**CS9138**). Interceptors can't have type parameters on the method itself or on their containing type. If you need to intercept a generic method, create a non-generic interceptor that works with the specific constructed type. +- Make interceptors ordinary member methods (**CS9146**). Interceptors can't be operators, constructors, finalizers, properties, or indexers. Declare your interceptor as a regular static or instance method. +- Intercept actual method invocations, not expressions (**CS9151**, **CS9207**). You can only intercept calls to ordinary member methods that are being invoked. You can't intercept method groups, delegates, or methods referenced without being called. Ensure the interceptable location identifies an actual method call. +- Remove duplicate interception attempts (**CS9153**). Each method call can only be intercepted once. If multiple `InterceptsLocationAttribute` instances target the same call, remove all but one to resolve the ambiguity. +- Don't intercept `nameof` operators (**CS9160**). The `nameof` operator doesn't invoke methods at runtime, so it can't be intercepted. Only intercept actual method calls that execute at runtime. +- Remove `UnmanagedCallersOnlyAttribute` from interceptors (**CS9161**). Interceptors must be callable from managed code and can't be marked with `UnmanagedCallersOnlyAttribute`. Remove the attribute from your interceptor method declaration. +- Declare interceptors within a namespace (**CS9206**). Interceptors can't be declared in the global namespace and must be contained within at least one namespace declaration. Wrap your interceptor class in a namespace. +- Resolve duplicate file paths at the compilation level (**CS9152**). When multiple files share the same path in the compilation, the compiler can't determine which file to intercept in. Ensure build configuration produces unique file paths or use a different organization strategy for your source files. + +## Analyzer compatibility + +The following warnings indicate issues with analyzer or source generator assemblies: + +- **CS9057**: *Analyzer assembly cannot be used because it references a newer version of the compiler than the currently running version.* +- **CS9067**: *Analyzer reference specified multiple times.* + +These warnings occur when there are compatibility issues with analyzer assemblies: -These errors occur when interceptor declarations violate the rules for interceptors or when the `InterceptsLocationAttribute` contains invalid data: - -- **CS9231** is generated when the data format doesn't match the expected structure. The attribute requires specifically formatted data that encodes the file path and position information. -- **CS9232** indicates you're using a version number that isn't supported. The interceptors feature uses version '1' format. Update your source generator to use the supported version. -- **CS9233** happens when the compilation contains multiple files with the same path, making it ambiguous which file to intercept in. Ensure each file in your compilation has a unique path. -- **CS9234** is emitted when the file path specified in the attribute doesn't match any file in the current compilation. Verify the file path is correct and the file is included in the compilation. -- **CS9235** occurs when the position data (line and character numbers) points to an invalid location in the specified file. This can happen if the position is outside the file's bounds or doesn't correspond to a valid interception point. -- **CS9138** prevents generic methods or members of generic classes from being interceptors. -- **CS9146** requires interceptors to be ordinary members (not operators, constructors, or finalizers). -- **CS9151** prevents intercepting methods that are never invoked. -- **CS9152** detects duplicate file paths in the compilation. -- **CS9153** prevents multiple interceptions of the same call. -- **CS9160** prevents intercepting `nameof` operators. -- **CS9161** prevents interceptors from being marked with `UnmanagedCallersOnlyAttribute`. -- **CS9206** requires interceptors to be contained in a namespace (not global). -- **CS9207** requires interceptable methods to be ordinary member invocations. +- **CS9057** is generated when an analyzer assembly references a version of the Roslyn compiler that is newer than the one currently running. This prevents the analyzer from loading because it may depend on APIs or behaviors not available in the current compiler version. To resolve this, either upgrade your compiler/SDK to match the analyzer's requirements or use a version of the analyzer compatible with your current compiler version. +- **CS9067** warns when the same analyzer assembly is referenced multiple times in your project. This typically happens when an analyzer is included through multiple paths or package references. While not an error, duplicate references can impact build performance and may cause unexpected behavior. Remove the duplicate references to resolve this warning. diff --git a/docs/csharp/language-reference/compiler-messages/unsafe-code-errors.md b/docs/csharp/language-reference/compiler-messages/unsafe-code-errors.md index 0e010be079538..de67f07aa65dc 100644 --- a/docs/csharp/language-reference/compiler-messages/unsafe-code-errors.md +++ b/docs/csharp/language-reference/compiler-messages/unsafe-code-errors.md @@ -29,6 +29,7 @@ f1_keywords: - "CS1716" - "CS1919" - "CS8812" + - "CS9049" - "CS9123" helpviewer_keywords: - "CS0193" @@ -58,8 +59,9 @@ helpviewer_keywords: - "CS4004" - "CS1919" - "CS8812" + - "CS9049" - "CS9123" -ms.date: 10/21/2025 +ms.date: 01/27/2026 ai-usage: ai-assisted --- # Resolve errors and warnings in unsafe code constructs @@ -96,6 +98,7 @@ That's by design. The text closely matches the text of the compiler error / warn - [**CS1919**](#unsafe-context-restrictions): *Unsafe type 'type name' cannot be used in object creation.* - [**CS4004**](#unsafe-context-restrictions): *Cannot `await` in an unsafe context* - [**CS8812**](#function-pointers): *Cannot convert `&Method` group to non-function pointer type.* +- [**CS9049**](#fixed-size-buffers): *A fixed field must not be a ref field.* - [**CS9123**](#unsafe-context-restrictions): *The '`&`' operator should not be used on parameters or local variables in async methods.* ## Pointer operations and dereferencing @@ -106,7 +109,7 @@ That's by design. The text closely matches the text of the compiler error / warn To use pointer operations correctly, follow the rules for dereferencing, indexing, and arithmetic operations. For more information, see [Pointer types](../unsafe-code.md#pointer-types) and [Function pointers](../unsafe-code.md#function-pointers). -- Apply the `*` or `->` operator only to data pointers (**CS0193**). Don't use these operators with nonpointer types or function pointers. Function pointers can't be dereferenced in C#, unlike in C/C++. +- Apply the `*` or `->` operator only to data pointers (**CS0193**). Don't use these operators with nonpointer types or function pointers. Unlike in C/C++, you can't dereference function pointers in C#. - Index pointers with only one value (**CS0196**). Multidimensional indexing isn't supported on pointers. - Avoid operations that are undefined on void pointers (**CS0242**). For example, don't increment a void pointer because the compiler doesn't know the size of the data being pointed to. @@ -159,12 +162,12 @@ These errors occur when you use unsafe code constructs without proper unsafe con To use unsafe code correctly: -- Mark methods, types, or code blocks that use pointers or fixed-size buffers with the `unsafe` keyword (**CS0214**). +- Mark methods, types, or code blocks that use pointers or fixed-size buffers by using the `unsafe` keyword (**CS0214**). - Enable the [**AllowUnsafeBlocks**](../compiler-options/language.md#allowunsafeblocks) compiler option in your project settings when using the `unsafe` keyword (**CS0227**). - Don't use the [`is`](../operators/type-testing-and-cast.md#the-is-operator) or [`as`](../operators/type-testing-and-cast.md#the-as-operator) operators with pointer types (**CS0244**). These type-testing operators aren't valid for pointers. - Don't use the `new` operator to create pointer type instances (**CS1919**). To create objects in unmanaged memory, use interop to call native methods that return pointers. - Keep unsafe code separate from async code (**CS4004**). Create separate methods for unsafe operations and call them from async methods. -- Don't use the address-of operator (`&`) on parameters or local variables in async methods (**CS9123**). The variable may not exist when the async operation completes. +- Don't use the address-of operator (`&`) on parameters or local variables in async methods (**CS9123**). The variable might not exist when the async operation completes. ## Fixed-size buffers @@ -175,6 +178,7 @@ To use unsafe code correctly: - **CS1666**: *You cannot use fixed size buffers contained in unfixed expressions. Try using the fixed statement* - **CS1708**: *Fixed size buffers can only be accessed through locals or fields* - **CS1716**: *Do not use 'System.Runtime.CompilerServices.FixedBuffer' attribute. Use the 'fixed' field modifier instead* +- **CS9049**: *A fixed field must not be a ref field* These errors occur when you work with fixed-size buffers. Fixed-size buffers are arrays embedded directly in structs and are primarily used for interop scenarios. For more information, see [Fixed-size buffers](../unsafe-code.md#fixed-size-buffers). @@ -186,9 +190,10 @@ To declare and use fixed-size buffers correctly: - Use a `fixed` statement to pin the containing struct before accessing the buffer (**CS1666**). - Access fixed-size buffers only through locals or fields, not through intermediate expressions (**CS1708**). - Use the `fixed` field modifier instead of the `System.Runtime.CompilerServices.FixedBuffer` attribute (**CS1716**). +- Don't declare fixed-size buffers as `ref` fields (**CS9049**). Fixed-size buffers must be value fields. ## Function pointers - **CS8812**: *Cannot convert `&Method` group to non-function pointer type* -To obtain a function pointer, use the address-of operator with an explicit function pointer type cast. Don't use the [address-of operator `&`](../operators/pointer-related-operators.md#address-of-operator-) to assign method groups to `void*` or other non-function pointer types. For more information, see [Function pointers](../unsafe-code.md#function-pointers). +To get a function pointer, use the address-of operator with an explicit function pointer type cast. Don't use the [address-of operator `&`](../operators/pointer-related-operators.md#address-of-operator-) to assign method groups to `void*` or other non-function pointer types. For more information, see [Function pointers](../unsafe-code.md#function-pointers). diff --git a/docs/csharp/language-reference/toc.yml b/docs/csharp/language-reference/toc.yml index 82aff46850dba..7db7bac4fec10 100644 --- a/docs/csharp/language-reference/toc.yml +++ b/docs/csharp/language-reference/toc.yml @@ -479,8 +479,8 @@ items: CS8058, CS8059, CS8107, CS8192, CS8302, CS8303, CS8304, CS8305, CS8306, CS8314, CS8320, CS8370, CS8371, CS8400, CS8401, CS8511, CS8627, CS8630, CS8652, CS8703, CS8704, CS8706, CS8773, CS8912, CS8919, CS8929, CS8936, CS8957, CS8967, CS9014, - CS9015, CS9016, CS9017, CS9058, CS9064, CS9103, CS9171, CS9194, CS9202, CS9204, - CS9240, CS9260, CS9268, CS9269, CS9271, CS9327, CS9328 + CS9015, CS9016, CS9017, CS9041, CS9058, CS9064, CS9103, CS9171, CS9194, CS9202, + CS9204, CS9240, CS9260, CS9268, CS9269, CS9271, CS9327, CS9328 - name: Assembly references href: ./compiler-messages/assembly-references.md displayName: > @@ -510,7 +510,7 @@ items: CS0056, CS0057, CS0215, CS0216, CS0217, CS0218, CS0448, CS0552, CS0553, CS0554, CS0555, CS0556, CS0557, CS0558, CS0559, CS0562, CS0563, CS0564, CS0567, CS0590, CS0660, CS0661, CS0715, CS1037, CS1553, CS1554, CS8930, CS8931, CS9023, CS9024, - CS9025, CS9308, CS9310, CS9311, CS9312, CS9313, CS9340, CS9341, CS9342 + CS9025, CS9027, CS9308, CS9310, CS9311, CS9312, CS9313, CS9340, CS9341, CS9342 - name: Parameter / argument mismatch href: ./compiler-messages/parameter-argument-mismatch.md displayName: > @@ -653,10 +653,10 @@ items: - name: Source generators href: ./compiler-messages/source-generator-errors.md displayName: > - CS9137, CS9138, CS9139, CS9140, CS9141, CS9142, CS9143, CS9144, CS9145, CS9146, - CS9147, CS9148, CS9149, CS9150, CS9151, CS9152, CS9153, CS9154, CS9155, CS9156, - CS9157, CS9158, CS9159, CS9160, CS9161, CS9177, CS9178, CS9206, CS9207, CS9231, - CS9232, CS9233, CS9234, CS9235, CS9270 + CS9057, CS9067, CS9137, CS9138, CS9139, CS9140, CS9141, CS9142, CS9143, CS9144, + CS9145, CS9146, CS9147, CS9148, CS9149, CS9150, CS9151, CS9152, CS9153, CS9154, + CS9155, CS9156, CS9157, CS9158, CS9159, CS9160, CS9161, CS9177, CS9178, CS9206, + CS9207, CS9231, CS9232, CS9233, CS9234, CS9235, CS9270 - name: File local types href: ./compiler-messages/file-local-types.md displayName: > @@ -680,7 +680,7 @@ items: displayName: > CS0193, CS0196, CS0208, CS0209, CS0210, CS0211, CS0212, CS0213, CS0214, CS0227, CS0233, CS0242, CS0244, CS0254, CS0459, CS0821, CS1641, CS1642, CS1656, CS1663, - CS1665, CS1666, CS1708, CS1716, CS1919, CS4004, CS8812, CS9123 + CS1665, CS1666, CS1708, CS1716, CS1919, CS4004, CS8812, CS9049, CS9123 - name: Warning waves href: ./compiler-messages/warning-waves.md displayName: > diff --git a/docs/csharp/misc/sorry-we-don-t-have-specifics-on-this-csharp-error.md b/docs/csharp/misc/sorry-we-don-t-have-specifics-on-this-csharp-error.md index 9b760c8339497..418261182c03b 100644 --- a/docs/csharp/misc/sorry-we-don-t-have-specifics-on-this-csharp-error.md +++ b/docs/csharp/misc/sorry-we-don-t-have-specifics-on-this-csharp-error.md @@ -451,13 +451,27 @@ f1_keywords: - "CS9020" - "CS9021" - "CS9022" - - "CS9027" - - "CS9041" - "CS9044" - "CS9046" - - "CS9049" - "CS9064" - - "CS9067" +# Coming in C# 15 + - "CS9343" + - "CS9344" + - "CS9345" + - "CS9346" + - "CS9347" + - "CS9348" + - "CS9349" + - "CS9350" + - "CS9351" + - "CS9352" + - "CS9353" + - "CS9354" + - "CS9355" + - "CS9356" + - "CS9357" + - "CS9358" + - "CS9359" helpviewer_keywords: - "errors [C#], additional information" ---