Ambiguous overload with two structural methods with same name

[bishabosha]

Compiler version

3.0.0-RC1

Minimized code

import language.reflectiveCalls

object Foo {
  val m: ({ def foo(str: String, int: Int): Int }){ def foo(arg: Int): Int } = ???
  val m1 = m
  val n = m1.foo(23)
}

Output

-- [E051] Reference Error: tests/pos-tmp/overload-in-refined.scala:6:13 --------
6 |  val n = m1.foo(23)
  |          ^^^^^^
  |Ambiguous overload. The overloaded alternatives of method (str: String, int: Int): Int with types
  | (str: String, int: Int): Int
  | (arg: Int): Int
  |both match arguments ((23 : Int))
  |
  |Note: this happens because two or more alternatives have the same erasure,
  |      so they cannot be distinguished by overloading resolution

Explanation
===========
There are 2 methods that could be referenced as the compiler knows too little
about the expected type.
You may specify the expected type e.g. by
- assigning it to a value with a specified type, or
- adding a type ascription as in instance.myMethod: String => Int


1 error found

Expectation

edit: error with "refinements can't introduce overloads"

[smarter]

I thought we decided that structural members could not be overloaded, though I don't see it in the documentation currently: https://dotty.epfl.ch/docs/reference/changed-features/structural-types.html

[bishabosha]

this seems to be a special case that has been missed by accident - if you put them in the same refinement block you see the expected error about refinements not introducing overloads, or if foo already exists in a parent class type being refined