Update documentation for DeclaringSyntaxReferences and Locations to clarify partial members behavior

src/Compilers/CSharp/Test/Symbol/Symbols/Source/MethodTests.cs

@@ -2576,5 +2576,57 @@ public partial void M<T>() { }
             Assert.False(partialImpl.IsPartialDefinition);
             Assert.False(partialImplConstructed.IsPartialDefinition);
         }
+
+        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/13456")]
+        public void PartialMethodsLocationsAndSyntaxReferences()
+        {
+            var source1 = """
+                namespace N1
+                {
+                    partial class C1
+                    {
+                        partial void PartialM();
+                    }
+                }
+                """;
+
+            var source2 = """
+                namespace N1
+                {
+                    partial class C1
+                    {
+                        partial void PartialM() { }
+                    }
+                }
+                """;
+
+            var comp = CreateCompilation([(source1, "source1"), (source2, "source2")]);
+            comp.VerifyDiagnostics();
+
+            var methodSymbols = comp.GetSymbolsWithName("PartialM");
+
+            var method = (IMethodSymbol)methodSymbols.Single();
+            Assert.NotNull(method);
+
+            // For partial methods, Locations and DeclaringSyntaxReferences contain only one location
+            Assert.Equal(1, method.Locations.Length);
+            Assert.Equal(1, method.DeclaringSyntaxReferences.Length);
+
+            // The single location is the definition part
+            Assert.True(method.IsPartialDefinition);
+            Assert.Null(method.PartialDefinitionPart);
+            Assert.NotNull(method.PartialImplementationPart);
+
+            // To get all locations, you need to use PartialImplementationPart
+            var implementationPart = method.PartialImplementationPart;
+            Assert.Equal(1, implementationPart.Locations.Length);
+            Assert.Equal(1, implementationPart.DeclaringSyntaxReferences.Length);
+
+            // Verify the locations are different
+            Assert.NotEqual(method.Locations[0], implementationPart.Locations[0]);
+
+            Assert.Equal("source1", method.Locations[0].SourceTree.FilePath);
+            Assert.Equal("source2", implementationPart.Locations[0].SourceTree.FilePath);
+        }
     }
 }

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

@@ -165,18 +165,28 @@ public interface ISymbol : IEquatable<ISymbol?>
 
         /// <summary>
         /// Gets the locations where the symbol was originally defined, either in source or
-        /// metadata. Some symbols (for example, partial classes) may be defined in more than one
-        /// location.
+        /// metadata. Some symbols (for example, partial types such as classes, structs, and interfaces) may be defined in more than one
+        /// location. Note that for partial members (methods, properties, events), this property returns
+        /// only one location. To get all locations for a partial member, use the <c>PartialDefinitionPart</c> and
+        /// <c>PartialImplementationPart</c> properties on <see cref="IMethodSymbol"/>, <see cref="IPropertySymbol"/>, or
+        /// <see cref="IEventSymbol"/>.
         /// </summary>
         ImmutableArray<Location> Locations { get; }
 
         /// <summary>
         /// Get the syntax node(s) where this symbol was declared in source. Some symbols (for example,
-        /// partial classes) may be defined in more than one location. This property should return
+        /// partial types such as classes, structs, and interfaces) may be defined in more than one location. This property should return
         /// one or more syntax nodes only if the symbol was declared in source code and also was
         /// not implicitly declared (see the IsImplicitlyDeclared property). 
         /// 
         /// <para>
+        /// Note that for partial members (methods, properties, events), this property returns only one
+        /// syntax node. To get all syntax nodes for a partial member, use the <c>PartialDefinitionPart</c> and
+        /// <c>PartialImplementationPart</c> properties on <see cref="IMethodSymbol"/>, <see cref="IPropertySymbol"/>, or
+        /// <see cref="IEventSymbol"/>.
+        /// </para>
+        /// 
+        /// <para>
         /// Note that for namespace symbol, the declaring syntax might be declaring a nested namespace.
         /// For example, the declaring syntax node for N1 in "namespace N1.N2 {...}" is the entire
         /// NamespaceDeclarationSyntax for N1.N2. For the global namespace, the declaring syntax will