Expose IPropertySymbol.BackingField and IEventSymbol.BackingField

src/Compilers/CSharp/Portable/Symbols/PublicModel/EventSymbol.cs

@@ -62,6 +62,14 @@ ITypeSymbol IEventSymbol.Type
             }
         }
 
+        IFieldSymbol? IEventSymbol.BackingField
+        {
+            get
+            {
+                return _underlying.AssociatedField.GetPublicSymbol();
+            }
+        }
+
         IEventSymbol IEventSymbol.OriginalDefinition
         {
             get

src/Compilers/CSharp/Portable/Symbols/PublicModel/PropertySymbol.cs

@@ -58,6 +58,11 @@ IMethodSymbol IPropertySymbol.SetMethod
             get { return _underlying.SetMethod.GetPublicSymbol(); }
         }
 
+        IFieldSymbol IPropertySymbol.BackingField
+        {
+            get { return (_underlying as SourcePropertySymbolBase)?.BackingField.GetPublicSymbol(); }
+        }
+
         IPropertySymbol IPropertySymbol.OriginalDefinition
         {
             get

src/Compilers/CSharp/Test/Symbol/Compilation/SemanticModelGetDeclaredSymbolAPITests.cs

@@ -360,6 +360,8 @@ public void TestGetDeclaredSymbolFromIndexer()
             Assert.Equal(MethodKind.PropertySet, setterSymbol.MethodKind);
             Assert.Equal(propertySymbol.SetMethod, setterSymbol);
             Assert.Equal("void C.this[System.Int32 x, System.Int32 y].set", setterSymbol.ToTestDisplayString());
+
+            Assert.Null(propertySymbol.BackingField);
         }
 
         [Fact]
@@ -389,6 +391,7 @@ event System.Action E
             Assert.Equal(2, accessorList.Count);
             Assert.Same(eventSymbol.AddMethod, model.GetDeclaredSymbol(accessorList[0]));
             Assert.Same(eventSymbol.RemoveMethod, model.GetDeclaredSymbol(accessorList[1]));
+            Assert.Null(eventSymbol.BackingField);
         }
 
         [WorkItem(543494, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543494")]
@@ -406,11 +409,13 @@ public void TestGetDeclaredSymbolFromFieldLikeEvent()
             var typeDecl = (TypeDeclarationSyntax)root.Members[0];
             var eventDecl = (EventFieldDeclarationSyntax)typeDecl.Members[0];
             var model = compilation.GetSemanticModel(tree);
-            var eventSymbol = model.GetDeclaredSymbol(eventDecl.Declaration.Variables[0]);
+            var eventSymbol = (IEventSymbol)model.GetDeclaredSymbol(eventDecl.Declaration.Variables[0]);
             Assert.NotNull(eventSymbol);
             Assert.Null(model.GetDeclaredSymbol(eventDecl)); // the event decl may have multiple variable declarators, the result for GetDeclaredSymbol will always be null
             Assert.Equal("E", eventSymbol.Name);
             Assert.IsType<SourceFieldLikeEventSymbol>(eventSymbol.GetSymbol());
+            Assert.NotNull(eventSymbol.BackingField);
+            Assert.Equal(eventSymbol, eventSymbol.BackingField.AssociatedSymbol);
         }
 
         [WorkItem(543574, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543574")]
@@ -2883,6 +2888,8 @@ void I.M() {}
             Assert.Equal("I.set_P", explicitPropertySetterSymbol.Name);
             Assert.Equal(1, explicitPropertySetterSymbol.ExplicitInterfaceImplementations.Length);
             Assert.Same(explicitPropertySymbol.SetMethod, explicitPropertySetterSymbol);
+
+            Assert.NotNull(explicitPropertySymbol.BackingField);
         }
 
         [WorkItem(527284, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/527284")]

src/Compilers/Core/Portable/PublicAPI.Unshipped.txt

@@ -1,5 +1,7 @@
 Microsoft.CodeAnalysis.GeneratorAttribute.GeneratorAttribute(string firstLanguage, params string[] additionalLanguages) -> void
 Microsoft.CodeAnalysis.GeneratorAttribute.Languages.get -> string[]
+Microsoft.CodeAnalysis.IEventSymbol.BackingField.get -> Microsoft.CodeAnalysis.IFieldSymbol
+Microsoft.CodeAnalysis.IPropertySymbol.BackingField.get -> Microsoft.CodeAnalysis.IFieldSymbol
 Microsoft.CodeAnalysis.ITypeSymbol.IsRecord.get -> bool
 Microsoft.CodeAnalysis.SymbolDisplayPartKind.RecordName = 31 -> Microsoft.CodeAnalysis.SymbolDisplayPartKind
 const Microsoft.CodeAnalysis.WellKnownDiagnosticTags.CompilationEnd = "CompilationEnd" -> string

src/Compilers/Core/Portable/Symbols/IEventSymbol.cs

@@ -46,6 +46,11 @@ public interface IEventSymbol : ISymbol
         /// </summary>
         IMethodSymbol? RaiseMethod { get; }
 
+        /// <summary>
+        /// The backing field of the event, or null if the event does not use a backing field.
+        /// </summary>
+        IFieldSymbol? BackingField { get; }
+
         /// <summary>
         /// The original definition of the event. If the event is constructed from another
         /// symbol by type substitution, OriginalDefinition gets the original symbol, as it was 

src/Compilers/Core/Portable/Symbols/IPropertySymbol.cs

@@ -76,6 +76,11 @@ public interface IPropertySymbol : ISymbol
         /// </summary>
         IMethodSymbol? SetMethod { get; }
 
+        /// <summary>
+        /// The backing field of the property, or null if the property does not use a backing field.
+        /// </summary>
+        IFieldSymbol? BackingField { get; }
+
         /// <summary>
         /// The original definition of the property. If the property is constructed from another
         /// symbol by type substitution, OriginalDefinition gets the original symbol, as it was 

src/Compilers/VisualBasic/Portable/Symbols/EventSymbol.vb

@@ -302,6 +302,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
             End Get
         End Property
 
+        Private ReadOnly Property IEventSymbol_BackingField As IFieldSymbol Implements IEventSymbol.BackingField
+            Get
+                Return Me.AssociatedField
+            End Get
+        End Property
+
         Private ReadOnly Property IEventSymbol_OriginalDefinition As IEventSymbol Implements IEventSymbol.OriginalDefinition
             Get
                 Return Me.OriginalDefinition

src/Compilers/VisualBasic/Portable/Symbols/PropertySymbol.vb

@@ -503,6 +503,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
             End Get
         End Property
 
+        Private ReadOnly Property IPropertySymbol_BackingField As IFieldSymbol Implements IPropertySymbol.BackingField
+            Get
+                Return Me.AssociatedField
+            End Get
+        End Property
+
         Private ReadOnly Property IPropertySymbol_ReturnsByRef As Boolean Implements IPropertySymbol.ReturnsByRef
             Get
                 Return Me.ReturnsByRef

src/Compilers/VisualBasic/Test/Semantic/Compilation/SemanticModelGetDeclaredSymbolAPITests.vb

@@ -1098,9 +1098,12 @@ End Class
 
             propertySymbol = GetPropertySymbol(compilation, bindings, "c.vb", "Property P As Integer", propertySyntax)
             Assert.NotNull(propertySymbol)
+            Assert.Null(propertySymbol.BackingField)
 
             propertySymbol = GetPropertySymbol(compilation, bindings, "c.vb", "Property Q As Object", propertySyntax)
             Assert.NotNull(propertySymbol)
+            Assert.NotNull(propertySymbol.BackingField)
+            Assert.Equal(propertySymbol, propertySymbol.BackingField.AssociatedSymbol)
 
             propertySymbol = GetPropertySymbol(compilation, bindings, "c.vb", "Property R(index As Integer)", propertySyntax)
             Assert.NotNull(propertySymbol)

src/Features/Core/Portable/MetadataAsSource/AbstractMetadataAsSourceService.WrappedEventSymbol.cs

@@ -36,6 +36,7 @@ public ImmutableArray<IEventSymbol> ExplicitInterfaceImplementations
             public IEventSymbol? OverriddenEvent => _symbol.OverriddenEvent;
             public IMethodSymbol? RaiseMethod => _symbol.RaiseMethod;
             public IMethodSymbol? RemoveMethod => _symbol.RemoveMethod;
+            public IFieldSymbol? BackingField => _symbol.BackingField;
             public ITypeSymbol Type => _symbol.Type;
             public NullableAnnotation NullableAnnotation => _symbol.NullableAnnotation;
         }

src/Features/Core/Portable/MetadataAsSource/AbstractMetadataAsSourceService.WrappedPropertySymbol.cs

@@ -53,6 +53,8 @@ public ImmutableArray<IPropertySymbol> ExplicitInterfaceImplementations
 
             public IMethodSymbol SetMethod => _symbol.SetMethod;
 
+            public IFieldSymbol BackingField => _symbol.BackingField;
+
             public ITypeSymbol Type => _symbol.Type;
 
             public NullableAnnotation NullableAnnotation => _symbol.NullableAnnotation;

src/Workspaces/Core/Portable/CodeGeneration/Symbols/CodeGenerationEventSymbol.cs

@@ -62,5 +62,7 @@ public override void Accept(SymbolVisitor visitor)
         public IEventSymbol? OverriddenEvent => null;
 
         public static ImmutableArray<CustomModifier> TypeCustomModifiers => ImmutableArray.Create<CustomModifier>();
+
+        public IFieldSymbol BackingField => null;
     }
 }

src/Workspaces/Core/Portable/CodeGeneration/Symbols/CodeGenerationPropertySymbol.cs

@@ -88,5 +88,7 @@ public override TResult Accept<TResult>(SymbolVisitor<TResult> visitor)
         public ImmutableArray<CustomModifier> RefCustomModifiers => ImmutableArray<CustomModifier>.Empty;
 
         public ImmutableArray<CustomModifier> TypeCustomModifiers => ImmutableArray<CustomModifier>.Empty;
+
+        public IFieldSymbol BackingField => null;
     }
 }