Handle cases where 'field' keyword shouldn't generate a field

src/Compilers/CSharp/Portable/Binder/Binder.cs

@@ -194,10 +194,10 @@ internal virtual ImmutableArray<LocalFunctionSymbol> GetDeclaredLocalFunctionsFo
             return this.Next.GetDeclaredLocalFunctionsForScope(scopeDesignator);
         }
 
-        internal virtual FieldSymbol? GetSymbolForPossibleFieldKeyword()
+        internal virtual FieldSymbol? GetSymbolForPossibleFieldKeyword(BindingDiagnosticBag diagnostics)
         {
             RoslynDebug.Assert(Next is object);
-            return this.Next.GetSymbolForPossibleFieldKeyword();
+            return this.Next.GetSymbolForPossibleFieldKeyword(diagnostics);
         }
 
         /// <summary>

src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs

@@ -1563,7 +1563,7 @@ private BoundExpression BindIdentifier(
                     else if (node.Identifier.ContextualKind() == SyntaxKind.FieldKeyword &&
                         ContainingMember().CanHaveFieldKeywordBackingField())
                     {
-                        if (GetSymbolForPossibleFieldKeyword() is { } backingField)
+                        if (GetSymbolForPossibleFieldKeyword(diagnostics) is { } backingField)
                         {
                             expression = BindNonMethod(node, backingField, diagnostics, LookupResultKind.Viable, indexed: false, isError: false);
                             if (IsInsideNameof)

src/Compilers/CSharp/Portable/Binder/BuckStopsHereBinder.cs

@@ -239,7 +239,7 @@ internal override BoundStatement BindLockStatementParts(BindingDiagnosticBag dia
             throw ExceptionUtilities.Unreachable;
         }
 
-        internal override FieldSymbol? GetSymbolForPossibleFieldKeyword()
+        internal override FieldSymbol? GetSymbolForPossibleFieldKeyword(BindingDiagnosticBag diagnostics)
         {
             // There's supposed to either be a FieldKeywordBinder or a SpeculativeFieldKEywordBinder in the chain.
             throw ExceptionUtilities.Unreachable;

src/Compilers/CSharp/Portable/Binder/FieldKeywordBinder.cs

@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
@@ -19,9 +19,9 @@ internal FieldKeywordBinder(SourcePropertyAccessorSymbol accessor, Binder next)
             _accessor = accessor;
         }
 
-        internal override FieldSymbol? GetSymbolForPossibleFieldKeyword()
+        internal override FieldSymbol? GetSymbolForPossibleFieldKeyword(BindingDiagnosticBag diagnostics)
         {
-            return _accessor.Property.GetOrCreateBackingFieldForFieldKeyword();
+            return _accessor.Property.GetOrCreateBackingFieldForFieldKeyword(diagnostics);
         }
     }
 }

src/Compilers/CSharp/Portable/Binder/SpeculativeFieldKeywordBinder.cs

@@ -1,4 +1,4 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
@@ -19,7 +19,7 @@ internal SpeculativeFieldKeywordBinder(SourcePropertyAccessorSymbol accessor, Bi
             _accessor = accessor;
         }
 
-        internal override FieldSymbol? GetSymbolForPossibleFieldKeyword()
+        internal override FieldSymbol? GetSymbolForPossibleFieldKeyword(BindingDiagnosticBag diagnostics)
         {
             // field in the speculative model does not bind to a backing field if the original location was not a semi-auto property
             return _accessor.Property.FieldKeywordBackingField;

src/Compilers/CSharp/Portable/Symbols/Source/SourcePropertySymbolBase.cs

@@ -185,7 +185,7 @@ protected SourcePropertySymbolBase(
                 Debug.Assert(!IsIndexer);
                 // PROTOTYPE(semi-auto-props): Make sure that TestSemiAutoPropertyWithInitializer (when enabled back) is affected by this.
                 // That is, if we removed "hasInitializer", the test should fail, or any other test should get affected.
-                GetOrCreateBackingField(isCreatedForFieldKeyword: hasInitializer && !isAutoProperty, isEarlyConstructed: true);
+                GetOrCreateBackingField(isCreatedForFieldKeyword: hasInitializer && !isAutoProperty, isEarlyConstructed: true, diagnostics);
             }
 
             if (hasGetAccessor)
@@ -198,7 +198,7 @@ protected SourcePropertySymbolBase(
             }
         }
 
-        private SynthesizedBackingFieldSymbol? GetOrCreateBackingField(bool isCreatedForFieldKeyword, bool isEarlyConstructed)
+        private SynthesizedBackingFieldSymbol? GetOrCreateBackingField(bool isCreatedForFieldKeyword, bool isEarlyConstructed, BindingDiagnosticBag diagnostics)
         {
             Debug.Assert(!IsIndexer);
             if (_lazyBackingFieldSymbol == _lazyBackingFieldSymbolSentinel)
@@ -209,16 +209,17 @@ protected SourcePropertySymbolBase(
                                               this.IsStatic,
                                               hasInitializer: (_propertyFlags & Flags.HasInitializer) != 0,
                                               isCreatedForFieldKeyword: isCreatedForFieldKeyword,
-                                              isEarlyConstructed: isEarlyConstructed);
+                                              isEarlyConstructed: isEarlyConstructed,
+                                              diagnostics);
                 Interlocked.CompareExchange(ref _lazyBackingFieldSymbol, backingField, _lazyBackingFieldSymbolSentinel);
             }
 
             return (SynthesizedBackingFieldSymbol?)_lazyBackingFieldSymbol;
         }
 
-        internal SynthesizedBackingFieldSymbol? GetOrCreateBackingFieldForFieldKeyword()
+        internal SynthesizedBackingFieldSymbol? GetOrCreateBackingFieldForFieldKeyword(BindingDiagnosticBag diagnostics)
         {
-            return GetOrCreateBackingField(isCreatedForFieldKeyword: true, isEarlyConstructed: false);
+            return GetOrCreateBackingField(isCreatedForFieldKeyword: true, isEarlyConstructed: false, diagnostics);
         }
 
         private void EnsureSignatureGuarded(BindingDiagnosticBag diagnostics)

src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedBackingFieldSymbol.cs

@@ -44,7 +44,8 @@ public SynthesizedBackingFieldSymbol(
             bool isStatic,
             bool hasInitializer,
             bool isCreatedForFieldKeyword,
-            bool isEarlyConstructed)
+            bool isEarlyConstructed,
+            BindingDiagnosticBag diagnostics)
         {
             Debug.Assert(!string.IsNullOrEmpty(name));
 
@@ -65,12 +66,16 @@ public SynthesizedBackingFieldSymbol(
                 _backingFieldFlags |= Flags.IsCreatedForFieldKeyword;
             }
 
-
             if (isEarlyConstructed)
             {
                 _backingFieldFlags |= Flags.IsEarlyConstructed;
             }
 
+            if (ContainingType.IsInterface && !isStatic)
+            {
+                diagnostics.Add(ErrorCode.ERR_InterfacesCantContainFields, ErrorLocation);
+            }
+
             // If it's not early constructed, it must have been created for field keyword.
             Debug.Assert(IsEarlyConstructed || IsCreatedForFieldKeyword);
         }

src/Compilers/CSharp/Test/Semantic/Semantics/PropertyFieldKeywordTests.cs

@@ -82,6 +82,142 @@ private void VerifyTypeIL(CSharpCompilation compilation, string typeName, string
             CompileAndVerify(compilation).VerifyTypeIL(typeName, expected);
         }
 
+        [Fact] // PROTOTYPE(semi-auto-props): Test with initializer when they're supported.
+        public void TestInInterface()
+        {
+            var comp = CreateCompilation(@"
+public interface I
+{
+    public int P { get => field; }
+}
+", targetFramework: TargetFramework.NetCoreApp); // setting TargetFramework for DefaultImplementationsOfInterfaces to exist.
+
+            var accessorBindingData = new SourcePropertySymbolBase.AccessorBindingData();
+            comp.TestOnlyCompilationData = accessorBindingData;
+            comp.VerifyDiagnostics(
+                // (4,16): error CS0525: Interfaces cannot contain instance fields
+                //     public int P { get => field; }
+                Diagnostic(ErrorCode.ERR_InterfacesCantContainFields, "P").WithLocation(4, 16)
+                );
+            var @interface = comp.GetTypeByMetadataName("I");
+            Assert.Empty(@interface.GetMembers().OfType<FieldSymbol>());
+            Assert.Equal("System.Int32 I.<P>k__BackingField", @interface.GetFieldsToEmit().Single().ToTestDisplayString());
+            Assert.Equal(0, accessorBindingData.NumberOfPerformedAccessorBinding);
+        }
+
+        [Fact]
+        public void TestStaticInInterface()
+        {
+            var comp = CreateCompilation(@"
+public interface I
+{
+    public static int P { get => field; }
+}
+", targetFramework: TargetFramework.NetCoreApp); // setting TargetFramework for DefaultImplementationsOfInterfaces to exist.
+
+            var accessorBindingData = new SourcePropertySymbolBase.AccessorBindingData();
+            comp.TestOnlyCompilationData = accessorBindingData;
+            comp.VerifyDiagnostics();
+            VerifyTypeIL(comp, "I", @"
+.class interface public auto ansi abstract I
+{
+    // Fields
+    .field private static initonly int32 '<P>k__BackingField'
+    .custom instance void [System.Runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = (
+    	01 00 00 00
+    )
+    // Methods
+    .method public hidebysig specialname static 
+    	int32 get_P () cil managed 
+    {
+    	// Method begins at RVA 0x2050
+    	// Code size 6 (0x6)
+    	.maxstack 8
+    	IL_0000: ldsfld int32 I::'<P>k__BackingField'
+    	IL_0005: ret
+    } // end of method I::get_P
+    // Properties
+    .property int32 P()
+    {
+    	.get int32 I::get_P()
+    }
+} // end of class I
+");
+            var @interface = comp.GetTypeByMetadataName("I");
+            Assert.Equal("System.Int32 I.<P>k__BackingField", @interface.GetFieldsToEmit().Single().ToTestDisplayString());
+            Assert.Empty(@interface.GetMembers().OfType<FieldSymbol>());
+            Assert.Equal(0, accessorBindingData.NumberOfPerformedAccessorBinding);
+        }
+
+        [Fact]
+        public void TestStaticInInterface_DefaultImplementationsOfInterfacesIsMissing()
+        {
+            var comp = CreateCompilation(@"
+public interface I
+{
+    public static int P { get => field; }
+}
+");
+            comp.MakeMemberMissing(SpecialMember.System_Runtime_CompilerServices_RuntimeFeature__DefaultImplementationsOfInterfaces);
+            var accessorBindingData = new SourcePropertySymbolBase.AccessorBindingData();
+            comp.TestOnlyCompilationData = accessorBindingData;
+            comp.VerifyDiagnostics(
+                // (4,27): error CS8701: Target runtime doesn't support default interface implementation.
+                //     public static int P { get => field; }
+                Diagnostic(ErrorCode.ERR_RuntimeDoesNotSupportDefaultInterfaceImplementation, "get").WithLocation(4, 27)
+                );
+            var @interface = comp.GetTypeByMetadataName("I");
+            Assert.Equal("System.Int32 I.<P>k__BackingField", @interface.GetFieldsToEmit().Single().ToTestDisplayString());
+            Assert.Empty(@interface.GetMembers().OfType<FieldSymbol>());
+            Assert.Equal(0, accessorBindingData.NumberOfPerformedAccessorBinding);
+        }
+
+        [Fact]
+        public void TestAbstract()
+        {
+            var comp = CreateCompilation(@"
+public abstract class C
+{
+    public abstract int P { get => field; }
+}
+"); // setting TargetFramework for DefaultImplementationsOfInterfaces to exist.
+
+            var accessorBindingData = new SourcePropertySymbolBase.AccessorBindingData();
+            comp.TestOnlyCompilationData = accessorBindingData;
+            comp.VerifyDiagnostics(
+                // (4,29): error CS0500: 'C.P.get' cannot declare a body because it is marked abstract
+                //     public abstract int P { get => field; }
+                Diagnostic(ErrorCode.ERR_AbstractHasBody, "get").WithArguments("C.P.get").WithLocation(4, 29)
+                );
+            var @class = comp.GetTypeByMetadataName("C");
+            Assert.Empty(@class.GetMembers().OfType<FieldSymbol>());
+            Assert.Empty(@class.GetFieldsToEmit());
+            Assert.Equal(0, accessorBindingData.NumberOfPerformedAccessorBinding);
+        }
+
+        [Fact]
+        public void TestExtern()
+        {
+            var comp = CreateCompilation(@"
+public class C
+{
+    public extern int P { get => field; }
+}
+");
+
+            var accessorBindingData = new SourcePropertySymbolBase.AccessorBindingData();
+            comp.TestOnlyCompilationData = accessorBindingData;
+            comp.VerifyDiagnostics(
+                // (4,27): error CS0179: 'C.P.get' cannot be extern and declare a body
+                //     public extern int P { get => field; }
+                Diagnostic(ErrorCode.ERR_ExternHasBody, "get").WithArguments("C.P.get").WithLocation(4, 27)
+                );
+            var @class = comp.GetTypeByMetadataName("C");
+            Assert.Empty(@class.GetMembers().OfType<FieldSymbol>());
+            Assert.Empty(@class.GetFieldsToEmit());
+            Assert.Equal(0, accessorBindingData.NumberOfPerformedAccessorBinding);
+        }
+
         [Fact]
         public void TestNameOfFieldInAttribute()
         {