Use the type system to resolve ambiguity between symbols from different modules

[exelotl]

Something I've encountered recently while trying to share code between modules:

Across various modules I have some exported symbols which happen to have the same name. When I import these modules and try to pass one of the symbols as an argument, the compiler is unable to disambiguate between them, even when the type system should clearly only allow one of them to be used.

I can of course fix this by explicitly qualifying the symbol, but it feels like this is something that the compiler should be able to figure out.

Example

foo.nim

proc count*(s: string): int = 
  s.len

bar.nim

var count*: int = 10

baz.nim

const count* = 3.142

main.nim

import foo, bar, baz

proc twice(n: int): int =
  n*2

echo twice(count)   # `bar.count` is the only symbol that would allow the program to compile.

Current Output

...
Hint: main [Processing]
Hint: foo [Processing]
Hint: bar [Processing]
Hint: baz [Processing]
/home/exelotl/nim/test/main.nim(6, 12) Error: ambiguous identifier: 'count' -- use one of the following:
  foo.count: proc (s: string): int{.noSideEffect, gcsafe, locks: 0.}
  bar.count: int
  baz.count: float64

Expected Output

Program compiles and prints 20.

Additional Information

Besides explicitly qualifying the symbol, a workaround is to create a local template or const which the compiler will always prefer to use where possible.

import foo, bar, baz

template count: int = bar.count

proc twice(n: int): int =
  n*2

echo twice(count)

---

$ nim -v
Nim Compiler Version 1.2.6 [Linux: amd64]

[ghost]

Not really sure, but doesn't this fall into the same category as inferring generics by the assigned value type for example? So it probably needs something like an HM type system.

[RSDuck]

that's basically overloading by return type

[Araq]

This is not overloading by return type, it's "smarter disambiguation rules for sym choices", something which I'm fine with. ;-)

[jibal]

I think this is begging for trouble. Change a type or add a converter or overload, and the program silently changes what value it uses.

[metagn]

Implemented in #23123