Inconsisten Symbol Binding Rules in Templates/Generics

[krux02]

The issue that I want to talk about is the following for both templates and generic function implementations:

When a function symbol can't be resolved in the template definition, it stays as an identifier. Thi identifier will then be resolved in the context where the template is expanded. So the identifier can be resolved to a symbol from expansion context.

When a function symbol has soveral overloads, the identifier becomes an open sym choice. Open sym choice means the identifier can be resolved to a symbol from the euxpansion context.

The surprising and therefore problematic behavior happens when a symbol is resolved to a single symbol. Then the identifier becomes a node of nnkSym , that
means it cannot be resolved to a symbol from the expansion context anymore.

Example

file1.nim

# foo0 has 0 overloads

template myTemplate0() =
  foo0(bar)

# foo1 has 1 overload

proc foo1(arg: int) =
  discard

template myTemplate1() =
  foo1(bar)

# foo2 has 2 overloads

proc foo2(arg: int) =
  discard

proc foo2(arg: string) =
  discard

template myTemplate2() =
  foo2(bar)

file2.nim

import file1

type
  MyType = object

proc foo0(arg: MyType) =
  echo "foo0"

proc foo1(arg: MyType) =
  echo "foo1"

proc foo2(arg: MyType) =
  echo "foo2"

proc test() =
  var bar: MyType

  myTemplate0()
  myTemplate1() # this template is the exception that doesn't work.
  myTemplate2()

test()

Possible Solution

Everything should be an OpenSymChoice for consistent behavior. Since nim currently really gets confused with empty open sym choices I think the empty open sym choice can remain a ident node. But I like to think about an identifier like an open sym choice with no elements. This is currently the generated AST from the templates.

echo treeRepr getAst(myTemplate0())
Call
  Ident "foo0" # with 0 overloads it is an identifier
  Ident "bar"

echo treeRepr getAst(myTemplate0())
Call
  Sym "foo1" # with 1 overload it is a symbol (closed)
  Ident "bar"

echo treeRepr getAst(myTemplate0())
Call
  OpenSymChoice # with more than one overloads it is an open sym choice
    Sym "foo2"
    Sym "foo2"
  Ident "bar"

Additional Information

• This problem is true for overloads in generics as well.
• This is the root cause of Identical AST succeeds, but fails when produced by a macro, with "cannot use symbol of kind 'proc' as a 'field'" #11182
• There are probably other issues related to the same behavior that I will add here.

[krux02]

comment from Araq: This should work, and private sort should not bind to anything from instantiation context.

proc privateSort(...)
proc sort[T]() = privateSort(...) # delegate
    bind privateSort <- this is not necessary

[metagn]

With the potential design described in #22605 (comment), each foo would become:

Ident "foo0"

OpenSymChoice
  Sym "foo1" {preferred}

OpenSymChoice
  Sym "foo2"
  Sym "foo2"
  # neither preferred because name is ambiguous at template declaration

Technically just OpenSymChoice(Sym "foo1") would be fine too if the necessary logic was in the compiler (it would always get overriden) but the preferred would also allow non-overloadable sym kinds to receive the same treatment.

Related/same issue #3542

[Varriount]

I would prefer the original solution where everything is open by default. It's easier to understand, and less likely to break just because a template definition was moved around.