Unused opens false positive: extension method is preferred to instance method

[auduchinok]

During checking open ... statements, extension method is chosen instead of instance one, which differs from actual name resolution during the type check phase.
A guess before looking into: It may be another getting declaring vs apparent entity bug.

using System;

namespace Ns1
{
    public class Extended
    {
        public void M(Action<string> a)
        {
        }
    }
}

namespace Ns2
{
    public static class Extension
    {
        public static void M(this  Ns1.Extended b, Action<string> a)
        {
        }
    }
}

namespace ClassLibrary13

open Ns1
open Ns2

type T() =
    member x.Foo(s: string) = ()

    member x.Bar() =
        Extended().M(x.Foo)
        Extended().M(fun s -> x.Foo(s))

[vasily-kirichenko]

I cannot run Unused Open analyser tests in any way (VS, cmd, Rider), see #5308, hence no fix for this.

[vasily-kirichenko]

I think the bug is in the type checker, because the generated IL contains calls to the class method, not the extension one.

[vasily-kirichenko]

If the method is cast to Action'1, Ns2 is not needed to be opened:

[TysonMN]

My impression is that this issue is more serious than "just" an unused open. I will restate the example code and explain how I think about it.

This code compiles and the reference to M resolves to the instance method.

using System;
namespace Ns1 {
  public class Extended {
    public void M(Action<string> _) { }
  }
}
namespace Ns2 {
  public static class ExtensionMethods {
    public static void M(this Ns1.Extended a, Action<string> b) { }
  }
}

module Top
open Ns1
open Ns2 // marked as an unused open
type T() =
  member _.Foo(_: string) = ()
  member x.Bar() =
    Extended().M(x.Foo) // M resolves to the instance method with that name

I expect to be able to rename the instance method. I manually rename the definition and the one reference to it. However, the resulting code doesn't compile.

using System;
namespace Ns1 {
  public class Extended {
    public void M1(Action<string> _) { }
  }
}
namespace Ns2 {
  public static class ExtensionMethods {
    public static void M(this Ns1.Extended a, Action<string> b) { }
  }
}

module Top
open Ns1
open Ns2
type T() =
  member _.Foo(_: string) = ()
  member x.Bar() =
    Extended().M1(x.Foo) // FS0002 This function takes too many arguments, or is used in a context where a function is not expected