From 82e77a13f3aef7b41986d935d4cc24497dbf613c Mon Sep 17 00:00:00 2001
From: Jason Beetham <beefers331@gmail.com>
Date: Thu, 14 Dec 2023 09:05:14 -0700
Subject: [PATCH] =?UTF-8?q?Overloads=20passed=20to=20static=20proc=20param?=
 =?UTF-8?q?eters=20now=20convert=20to=20the=20desired=E2=80=A6=20(#23063)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

… type mirroring proc params

(cherry picked from commit 91efa49550b377e677cb0ff0d10e0c1192955b63)
---
 compiler/semcall.nim                    | 14 ++++++++++----
 compiler/semexprs.nim                   |  4 ++--
 compiler/sigmatch.nim                   | 13 ++++++++++++-
 tests/statictypes/tstaticprocparams.nim |  9 ++++++++-
 4 files changed, 32 insertions(+), 8 deletions(-)

diff --git a/compiler/semcall.nim b/compiler/semcall.nim
index 3afcf025b4..0106ce3045 100644
--- a/compiler/semcall.nim
+++ b/compiler/semcall.nim
@@ -714,7 +714,7 @@ proc explicitGenericSym(c: PContext, n: PNode, s: PSym): PNode =
     # try transforming the argument into a static one before feeding it into
     # typeRel
     if formal.kind == tyStatic and arg.kind != tyStatic:
-      let evaluated = c.semTryConstExpr(c, n[i])
+      let evaluated = c.semTryConstExpr(c, n[i], n[i].typ)
       if evaluated != nil:
         arg = newTypeS(tyStatic, c)
         arg.sons = @[evaluated.typ]
@@ -728,10 +728,16 @@ proc explicitGenericSym(c: PContext, n: PNode, s: PSym): PNode =
   onUse(info, s)
   result = newSymNode(newInst, info)
 
-proc setGenericParams(c: PContext, n: PNode) =
+proc setGenericParams(c: PContext, n, expectedParams: PNode) =
   ## sems generic params in subscript expression
   for i in 1..<n.len:
-    let e = semExprWithType(c, n[i])
+    let 
+      constraint =
+        if expectedParams != nil and i <= expectedParams.len:
+          expectedParams[i - 1].typ
+        else:
+          nil
+      e = semExprWithType(c, n[i], expectedType = constraint)
     if e.typ == nil:
       n[i].typ = errorType(c)
     else:
@@ -739,7 +745,7 @@ proc setGenericParams(c: PContext, n: PNode) =
 
 proc explicitGenericInstantiation(c: PContext, n: PNode, s: PSym): PNode =
   assert n.kind == nkBracketExpr
-  setGenericParams(c, n)
+  setGenericParams(c, n, s.ast[genericParamsPos])
   var s = s
   var a = n[0]
   if a.kind == nkSym:
diff --git a/compiler/semexprs.nim b/compiler/semexprs.nim
index c26f0b2587..2ce8633caf 100644
--- a/compiler/semexprs.nim
+++ b/compiler/semexprs.nim
@@ -1063,7 +1063,7 @@ proc semIndirectOp(c: PContext, n: PNode, flags: TExprFlags; expectedType: PType
     elif n[0].kind == nkBracketExpr:
       let s = bracketedMacro(n[0])
       if s != nil:
-        setGenericParams(c, n[0])
+        setGenericParams(c, n[0], s.ast[genericParamsPos])
         return semDirectOp(c, n, flags, expectedType)
     elif isSymChoice(n[0]) and nfDotField notin n.flags:
       # overloaded generic procs e.g. newSeq[int] can end up here
@@ -3167,7 +3167,7 @@ proc semExpr(c: PContext, n: PNode, flags: TExprFlags = {}, expectedType: PType
         isSymChoice(n[0][0]):
       # indirectOp can deal with explicit instantiations; the fixes
       # the 'newSeq[T](x)' bug
-      setGenericParams(c, n[0])
+      setGenericParams(c, n[0], nil)
       result = semDirectOp(c, n, flags, expectedType)
     elif nfDotField in n.flags:
       result = semDirectOp(c, n, flags, expectedType)
diff --git a/compiler/sigmatch.nim b/compiler/sigmatch.nim
index 41bb0212f3..d801f67902 100644
--- a/compiler/sigmatch.nim
+++ b/compiler/sigmatch.nim
@@ -2341,6 +2341,17 @@ proc paramTypesMatchAux(m: var TCandidate, f, a: PType,
           result = userConvMatch(c, m, base(f), a, arg)
           if result != nil: m.baseTypeMatch = true
 
+proc staticAwareTypeRel(m: var TCandidate, f: PType, arg: var PNode): TTypeRelation =
+  if f.kind == tyStatic and f.base.kind == tyProc:
+    # The ast of the type does not point to the symbol.
+    # Without this we will never resolve a `static proc` with overloads
+    let copiedNode = copyNode(arg)
+    copiedNode.typ = exactReplica(copiedNode.typ)
+    copiedNode.typ.n = arg
+    arg = copiedNode
+  typeRel(m, f, arg.typ)
+
+
 proc paramTypesMatch*(m: var TCandidate, f, a: PType,
                       arg, argOrig: PNode): PNode =
   if arg == nil or arg.kind notin nkSymChoices:
@@ -2369,7 +2380,7 @@ proc paramTypesMatch*(m: var TCandidate, f, a: PType,
         # XXX this is still all wrong: (T, T) should be 2 generic matches
         # and  (int, int) 2 exact matches, etc. Essentially you cannot call
         # typeRel here and expect things to work!
-        let r = typeRel(z, f, arg[i].typ)
+        let r = staticAwareTypeRel(z, f, arg[i])
         incMatches(z, r, 2)
         if r != isNone:
           z.state = csMatch
diff --git a/tests/statictypes/tstaticprocparams.nim b/tests/statictypes/tstaticprocparams.nim
index f0bb6fb5fd..75d8288ac4 100644
--- a/tests/statictypes/tstaticprocparams.nim
+++ b/tests/statictypes/tstaticprocparams.nim
@@ -1,9 +1,16 @@
 proc consumer[T: static proc(i: int): int{.nimcall.}](i: int): int = T(i)
+proc consumer(T: static proc(i: int): int{.nimcall.}, i: int): int = T(i)
+
 proc addIt(i: int): int = i + i
+proc add(i: int): int = i + i # Checks if we can use overloads
 proc squareIt(i: int): int = i * i
 
 assert consumer[addIt](10) == 20
+assert consumer[add](10) == 20
 assert consumer[squareIt](30) == 900
 assert consumer[proc(i: int): int{.nimcall.} = i * i + i](10) == 110
 
-
+assert consumer(addIt, 10) == 20
+assert consumer(add, 10) == 20
+assert consumer(squareIt, 30) == 900
+assert consumer(proc(i: int): int{.nimcall.} = i * i + i, 10) == 110