src/Compilers/CSharp/Test/Emit/CodeGen/PropertyTests.cs - main - githubmirror/roslyn

src/Compilers/CSharp/Test/Emit/CodeGen/PropertyTests.cs

93 строки3 KB

AlekseyTs

PropertySymbol.IsReadOnly/IsWriteOnly: use helpers that compiler uses itself to check for existence of a setter/getter (#82390)

14 фев 2026, 01:43

Не верифицирован

14 фев 2026, 01:439c30fcc

// 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.

#nullable disable

using Microsoft.CodeAnalysis.CSharp.Symbols;
using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
using Microsoft.CodeAnalysis.Test.Utilities;
using Roslyn.Test.Utilities;
using Xunit;

namespace Microsoft.CodeAnalysis.CSharp.UnitTests.CodeGen
{
    public class PropertyTests : EmitMetadataTestBase
    {
        [Fact, WorkItem(14438, "https://github.com/dotnet/roslyn/issues/14438")]
        [CompilerTrait(CompilerFeature.ExpressionBody)]
        public void ExpressionBodedProperty()
        {
            var source = @"
class C
{
    public int x;
    public int X
    {
        set => x = value;
        get => x;
    }
}";
            var compilation = CreateCompilation(source, options: TestOptions.DebugDll);
            var verifier = CompileAndVerify(compilation);
            verifier.VerifyIL("C.X.get", @"
{
  // Code size        7 (0x7)
  .maxstack  1
  IL_0000:  ldarg.0
  IL_0001:  ldfld      ""int C.x""
  IL_0006:  ret
}
");
            verifier.VerifyIL("C.X.set", @"
{
  // Code size        8 (0x8)
  .maxstack  2
  IL_0000:  ldarg.0
  IL_0001:  ldarg.1
  IL_0002:  stfld      ""int C.x""
  IL_0007:  ret
}
");
        }

        [Fact]
        [WorkItem("https://github.com/dotnet/roslyn/issues/82122")]
        public void PropertyIsReadOnly_WithTypeArgumentFromUnrelatedAssembly()
        {
            string source1 = """
                public class C0<T>
                {
                    public virtual int P { get; set; }
                }

                public class C1<T> : C0<T>
                {
                    public override int P { get; set; }
                }
                """;
            var comp1 = CreateCompilation(source1);
            comp1.VerifyDiagnostics();

            string source2 = """
                internal class C2 { }

                internal class C3 : C1<C2>
                {
                    public override int P { get; set; }
                }
                """;

            var comp2 = CreateCompilation(source2, references: [comp1.ToMetadataReference()]);
            comp2.VerifyDiagnostics();

            // Get the property symbol and check IsReadOnly
            var c3 = comp2.GlobalNamespace.GetTypeMember("C3");
            var property = c3.BaseTypeNoUseSiteDiagnostics.GetMember<PropertySymbol>("P");

            // These should not throw an assertion
            Assert.False(property.IsReadOnly);
            Assert.False(property.IsWriteOnly);
        }
    }
}