Report diagnostic for field and value identifiers in property accessors where the meaning would change as contextual keywords

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -6865,6 +6865,12 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="INF_TooManyBoundLambdas_Title" xml:space="preserve">
     <value>Compiling requires binding the lambda expression many times. Consider declaring the lambda expression with explicit parameter types, or if the containing method call is generic, consider using explicit type arguments.</value>
   </data>
+  <data name="INF_IdentifierConflictWithContextualKeyword" xml:space="preserve">
+    <value>'{0}' is a contextual keyword, with a specific meaning, starting in language version {1}. Use '@{0}' to avoid a breaking change when compiling with language version {1} or later.</value>
+  </data>
+  <data name="INF_IdentifierConflictWithContextualKeyword_Title" xml:space="preserve">
+    <value>Identifier is a contextual keyword, with a specific meaning, in a later language version.</value>
+  </data>
   <data name="ERR_EqualityContractRequiresGetter" xml:space="preserve">
     <value>Record equality contract property '{0}' must have a get accessor.</value>
   </data>
@@ -7920,6 +7926,9 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="IDS_FeatureRefUnsafeInIteratorAsync" xml:space="preserve">
     <value>ref and unsafe in async and iterator methods</value>
   </data>
+  <data name="IDS_FeatureFieldAndValueKeywords" xml:space="preserve">
+    <value>field and value keywords</value>
+  </data>
   <data name="ERR_RefLocalAcrossAwait" xml:space="preserve">
     <value>A 'ref' local cannot be preserved across 'await' or 'yield' boundary.</value>
   </data>

src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs

@@ -1782,10 +1782,20 @@ syntaxNode is ConstructorDeclarationSyntax constructorSyntax &&
                     assertBindIdentifierTargets(inMethodBinder, identifierMap, methodBody, diagnostics);
 #endif
 
+                    var compilation = bodyBinder.Compilation;
+
+                    if (method.MethodKind is MethodKind.PropertyGet or MethodKind.PropertySet or MethodKind.EventAdd or MethodKind.EventRemove)
+                    {
+                        var requiredVersion = MessageID.IDS_FeatureFieldAndValueKeywords.RequiredVersion();
+                        if (requiredVersion > compilation.LanguageVersion)
+                        {
+                            ReportFieldOrValueContextualKeywordConflicts(method, methodBody, diagnostics);
+                        }
+                    }
+
                     BoundNode methodBodyForSemanticModel = methodBody;
                     NullableWalker.SnapshotManager? snapshotManager = null;
                     ImmutableDictionary<Symbol, Symbol>? remappedSymbols = null;
-                    var compilation = bodyBinder.Compilation;
 
                     nullableInitialState = getInitializerState(methodBody);
 
@@ -2149,6 +2159,112 @@ static void assertBindIdentifierTargets(InMethodBinder? inMethodBinder, Concurre
 #endif
         }
 
+        /// <summary>
+        /// Report a diagnostic for any 'field' or 'value' identifier in the bound tree where the
+        /// meaning will change when the identifier is considered a contextual keyword.
+        /// </summary>
+        private static void ReportFieldOrValueContextualKeywordConflicts(MethodSymbol method, BoundNode node, BindingDiagnosticBag diagnostics)
+        {
+            Debug.Assert(method.MethodKind is MethodKind.PropertyGet or MethodKind.PropertySet or MethodKind.EventAdd or MethodKind.EventRemove);
+            Debug.Assert(method.AssociatedSymbol is PropertySymbol or EventSymbol);
+
+            PooledDictionary<SyntaxNode, SyntaxToken>? valueIdentifiers = null;
+
+            foreach (var token in node.Syntax.DescendantTokens())
+            {
+                Debug.Assert(token.Parent is { });
+                if (token.Kind() != SyntaxKind.IdentifierToken)
+                {
+                    continue;
+                }
+                var syntax = token.Parent;
+                switch (syntax)
+                {
+                    case IdentifierNameSyntax identifierName when identifierName.Identifier == token:
+                    case GenericNameSyntax genericName when genericName.Identifier == token:
+                    case TupleElementSyntax tupleElement when tupleElement.Identifier == token:
+                    case FromClauseSyntax fromClause when fromClause.Identifier == token:
+                    case LetClauseSyntax letClause when letClause.Identifier == token:
+                    case JoinClauseSyntax joinClause when joinClause.Identifier == token:
+                    case JoinIntoClauseSyntax joinIntoClause when joinIntoClause.Identifier == token:
+                    case QueryContinuationSyntax queryContinuation when queryContinuation.Identifier == token:
+                    case LocalFunctionStatementSyntax localFunctionStatement when localFunctionStatement.Identifier == token:
+                    case VariableDeclaratorSyntax variableDeclarator when variableDeclarator.Identifier == token:
+                    case SingleVariableDesignationSyntax singleVariable when singleVariable.Identifier == token:
+                    case LabeledStatementSyntax labeledStatement when labeledStatement.Identifier == token:
+                    case ForEachStatementSyntax forEachStatement when forEachStatement.Identifier == token:
+                    case CatchDeclarationSyntax catchDeclaration when catchDeclaration.Identifier == token:
+                    case TypeParameterSyntax typeParameter when typeParameter.Identifier == token:
+                    case ParameterSyntax parameter when parameter.Identifier == token:
+                    case AttributeTargetSpecifierSyntax targetSpecifier when targetSpecifier.Identifier == token:
+                        switch (token.Text)
+                        {
+                            case "field":
+                                if (method.AssociatedSymbol is PropertySymbol { IsIndexer: false })
+                                {
+                                    // Report "field" conflict with keyword.
+                                    reportConflict(syntax, token, diagnostics);
+                                }
+                                break;
+                            case "value":
+                                if (method.MethodKind is MethodKind.PropertySet or MethodKind.EventAdd or MethodKind.EventRemove)
+                                {
+                                    // Record the potential "value" conflict, and report conflicts later,
+                                    // after dropping any that refer to the implicit parameter.
+                                    valueIdentifiers ??= PooledDictionary<SyntaxNode, SyntaxToken>.GetInstance();
+                                    valueIdentifiers.Add(syntax, token);
+                                }
+                                break;
+                        }
+                        break;
+                    default:
+                        // The cases above should be the complete set of identifiers
+                        // expected in an accessor with -langversion:12 or earlier.
+                        Debug.Assert(false);
+                        break;
+                }
+            }
+
+            if (valueIdentifiers is { })
+            {
+                // Remove references to the implicit "value" parameter.
+                var checker = new ValueIdentifierChecker(valueIdentifiers);
+                checker.Visit(node);
+                // Report "value" conflicts.
+                foreach (var pair in valueIdentifiers)
+                {
+                    reportConflict(pair.Key, pair.Value, diagnostics);
+                }
+                valueIdentifiers.Free();
+            }
+
+            static void reportConflict(SyntaxNode syntax, SyntaxToken identifierToken, BindingDiagnosticBag diagnostics)
+            {
+                var requiredVersion = MessageID.IDS_FeatureFieldAndValueKeywords.RequiredVersion();
+                diagnostics.Add(ErrorCode.INF_IdentifierConflictWithContextualKeyword, syntax, identifierToken.Text, requiredVersion.ToDisplayString());
+            }
+        }
+
+        private sealed class ValueIdentifierChecker : BoundTreeWalkerWithStackGuardWithoutRecursionOnTheLeftOfBinaryOperator
+        {
+            private readonly Dictionary<SyntaxNode, SyntaxToken> _valueIdentifiers;
+
+            public ValueIdentifierChecker(Dictionary<SyntaxNode, SyntaxToken> valueIdentifiers)
+            {
+                _valueIdentifiers = valueIdentifiers;
+            }
+
+            public override BoundNode? VisitParameter(BoundParameter node)
+            {
+                if (node.ParameterSymbol is SynthesizedAccessorValueParameterSymbol { Name: "value" })
+                {
+                    _valueIdentifiers.Remove(node.Syntax);
+                }
+
+                return base.VisitParameter(node);
+            }
+        }
+
 #if DEBUG
         private static bool IsEmptyRewritePossible(BoundNode node)
         {

src/Compilers/CSharp/Portable/Errors/ErrorCode.cs

@@ -2324,6 +2324,7 @@ internal enum ErrorCode
         ERR_RefStructDoesNotSupportDefaultInterfaceImplementationForMember = 9245,
         ERR_BadNonVirtualInterfaceMemberAccessOnAllowsRefLike = 9246,
         ERR_BadAllowByRefLikeEnumerator = 9247,
+        INF_IdentifierConflictWithContextualKeyword = 9248,
 
         // Note: you will need to do the following after adding errors:
         //  1) Update ErrorFacts.IsBuildOnlyDiagnostic (src/Compilers/CSharp/Portable/Errors/ErrorFacts.cs)

src/Compilers/CSharp/Portable/Errors/ErrorFacts.cs

@@ -2450,6 +2450,7 @@ or ErrorCode.ERR_NotRefStructConstraintNotSatisfied
                 or ErrorCode.ERR_RefStructDoesNotSupportDefaultInterfaceImplementationForMember
                 or ErrorCode.ERR_BadNonVirtualInterfaceMemberAccessOnAllowsRefLike
                 or ErrorCode.ERR_BadAllowByRefLikeEnumerator
+                or ErrorCode.INF_IdentifierConflictWithContextualKeyword
                     => false,
             };
 #pragma warning restore CS8524 // The switch expression does not handle some values of its input type (it is not exhaustive) involving an unnamed enum value.

src/Compilers/CSharp/Portable/Errors/MessageID.cs

@@ -286,6 +286,7 @@ internal enum MessageID
         IDS_FeatureRefUnsafeInIteratorAsync = MessageBase + 12843,
 
         IDS_FeatureRefStructInterfaces = MessageBase + 12844,
+        IDS_FeatureFieldAndValueKeywords = MessageBase + 12845,
     }
 
     // Message IDs may refer to strings that need to be localized.
@@ -472,6 +473,7 @@ internal static LanguageVersion RequiredVersion(this MessageID feature)
                 case MessageID.IDS_FeatureParamsCollections:
                 case MessageID.IDS_FeatureRefUnsafeInIteratorAsync:
                 case MessageID.IDS_FeatureRefStructInterfaces:
+                case MessageID.IDS_FeatureFieldAndValueKeywords:
                     return LanguageVersion.Preview;
 
                 // C# 12.0 features.