genericsOpenSym not working when additional generally non-matching symbol with same name is present

[arnetheduck]

Description

This is the same example as in #23091, but this time there's an additional func error symbol present (as happens in nim-result) - the presence of this function causes the warning to disappear even though it should be there, and {.experimental:"genericsOpenSym".} stops working..

Removing func error from here makes the warning appear:

type Xxx = enum
  error
  value

type
  Result[T, E] = object
    when T is void:
      when E is void:
        oResultPrivate*: bool
      else:
        case oResultPrivate*: bool
        of false:
          eResultPrivate*: E
        of true:
          discard
    else:
      when E is void:
        case oResultPrivate*: bool
        of false:
          discard
        of true:
          vResultPrivate*: T
      else:
        case oResultPrivate*: bool
        of false:
          eResultPrivate*: E
        of true:
          vResultPrivate*: T

func error*[T, E](self: Result[T, E]): E =
  ## Fetch error of result if set, or raise Defect
  case self.oResultPrivate
  of true:
    when T isnot void:
      raiseResultDefect("Trying to access error when value is set", self.vResultPrivate)
    else:
      raiseResultDefect("Trying to access error when value is set")
  of false:
    when E isnot void:
      self.eResultPrivate

template valueOr[T: not void, E](self: Result[T, E], def: untyped): untyped =
  let s = (self) # TODO avoid copy
  case s.oResultPrivate
  of true:
    s.vResultPrivate
  of false:
    when E isnot void:
      template error: untyped {.used, inject.} = s.eResultPrivate
    def

proc f(): Result[int, cstring] =
  Result[int, cstring](oResultPrivate: false, eResultPrivate: "f")

proc g(T: type): string =
  let x = f().valueOr:
    return $error #[tt.Warning
            ^ a new symbol 'error' has been injected during instantiation of g, however 'error' [enumField declared in tmacroinjectedsymwarning.nim(2, 3)] captured at the proc declaration will be used instead; either enable --experimental:genericsOpenSym to use the injected symbol or `bind` this captured symbol explicitly [GenericsIgnoredInjection]]#

  "ok"


assert g(int) == "error"

Removing func error from here makes the triggering of the assert go away:

{.experimental:"genericsOpenSym".}
type Xxx = enum
  error
  value

type
  Result[T, E] = object
    when T is void:
      when E is void:
        oResultPrivate*: bool
      else:
        case oResultPrivate*: bool
        of false:
          eResultPrivate*: E
        of true:
          discard
    else:
      when E is void:
        case oResultPrivate*: bool
        of false:
          discard
        of true:
          vResultPrivate*: T
      else:
        case oResultPrivate*: bool
        of false:
          eResultPrivate*: E
        of true:
          vResultPrivate*: T

func error*[T, E](self: Result[T, E]): E =
  ## Fetch error of result if set, or raise Defect
  case self.oResultPrivate
  of true:
    when T isnot void:
      raiseResultDefect("Trying to access error when value is set", self.vResultPrivate)
    else:
      raiseResultDefect("Trying to access error when value is set")
  of false:
    when E isnot void:
      self.eResultPrivate

template valueOr[T: not void, E](self: Result[T, E], def: untyped): untyped =
  let s = (self) # TODO avoid copy
  case s.oResultPrivate
  of true:
    s.vResultPrivate
  of false:
    when E isnot void:
      template error: untyped {.used, inject.} = s.eResultPrivate
    def

proc f(): Result[int, cstring] =
  Result[int, cstring](oResultPrivate: false, eResultPrivate: "f")

proc g(T: type): string =
  let x = f().valueOr:
    return $error #[tt.Warning
            ^ a new symbol 'error' has been injected during instantiation of g, however 'error' [enumField declared in tmacroinjectedsymwarning.nim(2, 3)] captured at the proc declaration will be used instead; either enable --experimental:genericsOpenSym to use the injected symbol or `bind` this captured symbol explicitly [GenericsIgnoredInjection]]#

  "ok"


assert g(int) == "f"

Nim Version

2.0.8, devel

Current Output

No response

Expected Output

No response

Possible Solution

No response

Additional Information

No response

[metagn]

genericsOpenSym works on nkSym but here we get nkOpenSymChoice which only looks for other overloadable symbols, we need to check if a new non-overloadable symbol was introduced (not an overloadable one, and it must be the latest introduced symbol)

[metagn]

Not actually fixed #23873 (comment)

The problem is that we check for non-overloadable syms to replace the open sym when the new sym is a template (that is still used in a nonoverloadable way), but working on just any sym would lose the information of the captured sym choices. Don't mean to sound like a broken record but I think we need something like #23104 for the proper logic here, or special case the nullary template symbol usage to treat it as nonoverloaded

Also due to the compilier complaining I didn't make it set the type of the symchoice to nil when marking it opensym, only sym nodes, which means the symchoice never gets sem'd, but #23892 doesn't have this problem

Unfortunately I can't look into it much right now, will look möre later