Inheriting more interfaces results to ambiguous warning

[hpetriffer]

The following code

interface ITest inherit ITest1, ITest2
end interface

interface ITest1
   property Caption as string get set

	method Start() as void
end interface

interface ITest2
   property Caption as string get set
	method Start() as void
end interface



class TestClass implements ITest
	property Caption as string auto get set := "Test"
	method Start() as void
		return
end class

function Start() as void strict
	var test := (ITest)TestClass{}

	test.Start()
	test.Caption := "New Caption"

	return

When compiling this code I get in the line with test.Start() and test.Caption errors and warnings:

C:\Projects\Tests\XSharpSlowTests\XSharpTests\Program.prg(31,2): error XS0121: The call is ambiguous between the following methods or properties: 'ITest1.Start()' and 'ITest2.Start()'
C:\Projects\Tests\XSharpSlowTests\XSharpTests\Program.prg(32,2): warning XS9043: 'Caption' is ambiguous. Could be Property 'ITest1.Caption' in XSharpTests or Property 'ITest2.Caption' in XSharpTests. Using the first one.

[hpetriffer]

It looks like #1742

[RobertvanderHulst]

The same code in C# gives the same errors.
You need to make the interface explicit:

((ITest1)test).Start()
or
((ITest2)test).Start()

You can also declare 2 different Start methods inside the class

method ITest1.Start() as void
? "ITest1.Start()"
return
method ITest2.Start() as void
? "ITest2.Start()"
return

But then you still need to make explicit which interface you use when calling Start

[cpyrgas]

Confirmed

[hpetriffer]

For me this case in C# is working fine:

namespace CSharpTests
{
    interface ITest : ITest1, ITest2
    {

    }

    interface ITest1
    {
        public string Caption { get; set; }
        public void Start();
    }

    interface ITest2
    {
        public string Caption { get; set; }
        public void Start();
    }


    class TestClass : ITest
    {
        public string Caption { get; set; } = "Test";

        public void Start()
        {
            return;
        }
    }


    internal class Program
    {
        static void Main(string[] args)
        {
            var testClass = new TestClass();
            testClass.Start();

            Console.ReadLine();
        }
    }
}

[cpyrgas]

Ah, right, in my c# test I had used explicit interface implementation, which required the cast, but with implicit implementation as in the sample, then the cast is not needed.

It sounds a little strange to me to allow implicit implementation for 2 different interfaces with the same method, but also c# allows it, so I guess it's legal.