src/Compilers/CSharp/Test/Symbol/Symbols/RelaxedShiftOperatorTests.cs - main - githubmirror/roslyn

src/Compilers/CSharp/Test/Symbol/Symbols/RelaxedShiftOperatorTests.cs
328 строк11 KB
Julien Couvreur
Warn for multiple blank lines in source (#65451)
17 ноя 2022, 22:55
17 ноя 2022, 22:55a8824e8
// 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 System.Linq;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
using Microsoft.CodeAnalysis.Test.Utilities;
using Roslyn.Test.Utilities;
using Xunit;

namespace Microsoft.CodeAnalysis.CSharp.UnitTests.Symbols
{
    public class RelaxedShiftOperatorTests : CSharpTestBase
    {
        [Theory]
        [InlineData("<<")]
        [InlineData(">>")]
        [InlineData(">>>")]
        public void Relaxed_01(string op)
        {
            var source0 = @"
public class C1
{
    public static C1 operator " + op + @"(C1 x, C1 y)
    {
        System.Console.WriteLine(""" + op + @""");
        return x;
    }
}
";

            var source1 =
@"
class C
{
    static void Main()
    {
        Test1(new C1(), new C1());
    }

    static C1 Test1(C1 x, C1 y) => x " + op + @" y; 
}
";
            var compilation1 = CreateCompilation(source0 + source1, options: TestOptions.DebugExe,
                                                 parseOptions: TestOptions.RegularPreview);
            CompileAndVerify(compilation1, expectedOutput: op).VerifyDiagnostics();

            var compilation0 = CreateCompilation(source0, options: TestOptions.DebugDll,
                                                 parseOptions: TestOptions.RegularPreview);

            var compilation2 = CreateCompilation(source1, options: TestOptions.DebugExe, references: new[] { compilation0.ToMetadataReference() },
                                                 parseOptions: TestOptions.RegularPreview);

            CompileAndVerify(compilation2, expectedOutput: op).VerifyDiagnostics();

            var compilation3 = CreateCompilation(source1, options: TestOptions.DebugExe, references: new[] { compilation0.EmitToImageReference() },
                                                 parseOptions: TestOptions.RegularPreview);
            CompileAndVerify(compilation3, expectedOutput: op).VerifyDiagnostics();
        }

        [Theory]
        [InlineData("<<")]
        [InlineData(">>")]
        [InlineData(">>>")]
        public void OverloadResolution_01(string op)
        {
            var source1 = @"
public class C1
{
    public static C1 operator " + op + @"(C1 x, C2 y)
    {
        return x;
    }
}

public class C2
{
    public static C1 operator " + op + @"(C1 x, C2 y)
    {
        return x;
    }
}

class C
{
    static C1 Test1(C1 x, C2 y) => x " + op + @" y; 
}
";
            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll,
                                                 parseOptions: TestOptions.RegularPreview);
            compilation1.VerifyDiagnostics(
                // (12,31): error CS0564: The first operand of an overloaded shift operator must have the same type as the containing type
                //     public static C1 operator >>>(C1 x, C2 y)
                Diagnostic(ErrorCode.ERR_BadShiftOperatorSignature, op).WithLocation(12, 31)
                );

            var tree = compilation1.SyntaxTrees.Single();
            var model = compilation1.GetSemanticModel(tree);
            var shift = tree.GetRoot().DescendantNodes().OfType<BinaryExpressionSyntax>().Single();

            Assert.Equal("x " + op + " y", shift.ToString());
            Assert.Equal("C1.operator " + op + "(C1, C2)", model.GetSymbolInfo(shift).Symbol.ToDisplayString());
        }

        [Theory]
        [InlineData("<<")]
        [InlineData(">>")]
        [InlineData(">>>")]
        public void OverloadResolution_02(string op)
        {
            var source1 = @"
public interface C1
{
    public static C1 operator " + op + @"(C1 x, C2 y)
    {
        return x;
    }
}

public interface C2
{
    public static C1 operator " + op + @"(C1 x, C2 y)
    {
        return x;
    }
}

class C
{
    static C1 Test1(C1 x, C2 y) => x " + op + @" y; 
}
";
            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll, targetFramework: TargetFramework.NetCoreApp,
                                                 parseOptions: TestOptions.RegularPreview);
            compilation1.VerifyDiagnostics(
                // (12,31): error CS0564: The first operand of an overloaded shift operator must have the same type as the containing type
                //     public static C1 operator >>>(C1 x, C2 y)
                Diagnostic(ErrorCode.ERR_BadShiftOperatorSignature, op).WithLocation(12, 31)
                );

            var tree = compilation1.SyntaxTrees.Single();
            var model = compilation1.GetSemanticModel(tree);
            var shift = tree.GetRoot().DescendantNodes().OfType<BinaryExpressionSyntax>().Single();

            Assert.Equal("x " + op + " y", shift.ToString());
            Assert.Equal("C1.operator " + op + "(C1, C2)", model.GetSymbolInfo(shift).Symbol.ToDisplayString());
        }

        [Theory]
        [InlineData("<<")]
        [InlineData(">>")]
        [InlineData(">>>")]
        public void OverloadResolution_03(string op)
        {
            var source1 = @"
public interface C1
{
    public static C1 operator " + op + @"(C1 x, C2 y)
    {
        return x;
    }
}

public interface C2
{
    public static C1 operator " + op + @"(C1 x, C2 y)
    {
        return x;
    }
}

class C
{
    static C1 Test1<T>(T x, C2 y) where T : C1 => x " + op + @" y; 
}
";
            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll, targetFramework: TargetFramework.NetCoreApp,
                                                 parseOptions: TestOptions.RegularPreview);
            compilation1.VerifyDiagnostics(
                // (12,31): error CS0564: The first operand of an overloaded shift operator must have the same type as the containing type
                //     public static C1 operator >>>(C1 x, C2 y)
                Diagnostic(ErrorCode.ERR_BadShiftOperatorSignature, op).WithLocation(12, 31)
                );

            var tree = compilation1.SyntaxTrees.Single();
            var model = compilation1.GetSemanticModel(tree);
            var shift = tree.GetRoot().DescendantNodes().OfType<BinaryExpressionSyntax>().Single();

            Assert.Equal("x " + op + " y", shift.ToString());
            Assert.Equal("C1.operator " + op + "(C1, C2)", model.GetSymbolInfo(shift).Symbol.ToDisplayString());
        }

        [Theory]
        [InlineData("<<")]
        [InlineData(">>")]
        [InlineData(">>>")]
        public void OverloadResolution_04(string op)
        {
            var source1 = @"
public interface C1
{
    public static C1 operator " + op + @"(C1 x, C2 y)
    {
        return x;
    }
}

public interface C2
{
    public static C1 operator " + op + @"(C1 x, C2 y)
    {
        return x;
    }
}

class C
{
    static C1 Test1<T>(C1 x, T y) where T : C2 => x " + op + @" y; 
}
";
            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll, targetFramework: TargetFramework.NetCoreApp,
                                                 parseOptions: TestOptions.RegularPreview);
            compilation1.VerifyDiagnostics(
                // (12,31): error CS0564: The first operand of an overloaded shift operator must have the same type as the containing type
                //     public static C1 operator >>>(C1 x, C2 y)
                Diagnostic(ErrorCode.ERR_BadShiftOperatorSignature, op).WithLocation(12, 31)
                );

            var tree = compilation1.SyntaxTrees.Single();
            var model = compilation1.GetSemanticModel(tree);
            var shift = tree.GetRoot().DescendantNodes().OfType<BinaryExpressionSyntax>().Single();

            Assert.Equal("x " + op + " y", shift.ToString());
            Assert.Equal("C1.operator " + op + "(C1, C2)", model.GetSymbolInfo(shift).Symbol.ToDisplayString());
        }

        [Theory]
        [InlineData("<<")]
        [InlineData(">>")]
        [InlineData(">>>")]
        public void OverloadResolution_05(string op)
        {
            var source1 = @"
public interface C1
{
    public static C1 operator " + op + @"(C1 x, C2 y)
    {
        return x;
    }
}

public class C2
{
    public static C1 operator " + op + @"(C1 x, C2 y)
    {
        return x;
    }
}

class C
{
    static C1 Test1(C1 x, C2 y) => x " + op + @" y; 
}
";
            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll, targetFramework: TargetFramework.NetCoreApp,
                                                 parseOptions: TestOptions.RegularPreview);
            compilation1.VerifyDiagnostics(
                // (12,31): error CS0564: The first operand of an overloaded shift operator must have the same type as the containing type
                //     public static C1 operator >>>(C1 x, C2 y)
                Diagnostic(ErrorCode.ERR_BadShiftOperatorSignature, op).WithLocation(12, 31)
                );

            var tree = compilation1.SyntaxTrees.Single();
            var model = compilation1.GetSemanticModel(tree);
            var shift = tree.GetRoot().DescendantNodes().OfType<BinaryExpressionSyntax>().Single();

            Assert.Equal("x " + op + " y", shift.ToString());
            Assert.Equal("C1.operator " + op + "(C1, C2)", model.GetSymbolInfo(shift).Symbol.ToDisplayString());
        }

        [Theory]
        [InlineData("<<")]
        [InlineData(">>")]
        [InlineData(">>>")]
        public void OverloadResolution_06(string op)
        {
            var source1 = @"
public class C1
{
    public static C1 operator " + op + @"(C1 x, C2 y)
    {
        return x;
    }
}

public interface C2
{
    public static C1 operator " + op + @"(C1 x, C2 y)
    {
        return x;
    }
}

class C
{
    static C1 Test1(C1 x, C2 y) => x " + op + @" y; 
}
";
            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll, targetFramework: TargetFramework.NetCoreApp,
                                                 parseOptions: TestOptions.RegularPreview);
            compilation1.VerifyDiagnostics(
                // (12,31): error CS0564: The first operand of an overloaded shift operator must have the same type as the containing type
                //     public static C1 operator >>>(C1 x, C2 y)
                Diagnostic(ErrorCode.ERR_BadShiftOperatorSignature, op).WithLocation(12, 31)
                );

            var tree = compilation1.SyntaxTrees.Single();
            var model = compilation1.GetSemanticModel(tree);
            var shift = tree.GetRoot().DescendantNodes().OfType<BinaryExpressionSyntax>().Single();

            Assert.Equal("x " + op + " y", shift.ToString());
            Assert.Equal("C1.operator " + op + "(C1, C2)", model.GetSymbolInfo(shift).Symbol.ToDisplayString());
        }
    }
}