sem: pass only a single AST to semOverloadedCall

Instead of handling the necessary copying at the callsite, do it in the
`semOverloadedCall`. In addition, use a shallow copy of `n` for the
accumulator, so that the intermediate results don't leak into the
input AST.

Author: zerbina

compiler/sem/pragmas.nim

@@ -1031,7 +1031,7 @@ proc semCustomPragma(c: PContext, n: PNode, invalid: InvalidPragmaHandler): PNod
     result = invalid(c, n)
     return
 
-  let r = c.semOverloadedCall(c, callNode, callNode, {skTemplate}, {efNoUndeclared})
+  let r = c.semOverloadedCall(c, callNode, {skTemplate}, {efNoUndeclared})
   if r.isError:
     return r
   elif r.isNil or sfCustomPragma notin r[0].sym.flags:

compiler/sem/semcall.nim

@@ -278,12 +278,14 @@ proc semGenericArgs(c: PContext, n: PNode): PNode =
   if hasError:
     result = c.config.wrapError(result)
 
-proc resolveOverloads(c: PContext, n, nOrig: PNode,
+proc resolveOverloads(c: PContext, nOrig: PNode,
                       filter: TSymKinds, flags: TExprFlags,
                       errors: var seq[SemCallMismatch]): TCandidate =
-  addInNimDebugUtils(c.config, "resolveOverloads", n, filter, errors, result)
+  addInNimDebugUtils(c.config, "resolveOverloads", nOrig, filter, errors, result)
   var
     alt: TCandidate
+    # `n` itself will be modified, so create a shallow copy first
+    n = copyNodeWithKids(nOrig)
     f = n[0]
 
   case f.kind
@@ -584,12 +586,12 @@ proc semResolvedCall(c: PContext, x: TCandidate,
   result.typ = finalCallee.typ[0]
   result = updateDefaultParams(c.config, result)
 
-proc semOverloadedCall(c: PContext, n, nOrig: PNode,
+proc semOverloadedCall(c: PContext, n: PNode,
                        filter: TSymKinds, flags: TExprFlags): PNode =
   addInNimDebugUtils(c.config, "semOverloadedCall", n, result)
   var errors: seq[SemCallMismatch]
 
-  var r = resolveOverloads(c, n, nOrig, filter, flags, errors)
+  var r = resolveOverloads(c, n, filter, flags, errors)
   emitDiagnostics(c, r) # always emit all captured diags for the match
   if r.state == csMatch:
     # this may be triggered, when the explain pragma is used
@@ -764,7 +766,7 @@ proc searchForBorrowProc(c: PContext, startScope: PScope, fn: PSym): PSym =
     call.add(newNodeIT(nkEmpty, fn.info, x))
   if hasDistinct:
     let filter = if fn.kind in {skProc, skFunc}: {skProc, skFunc} else: {fn.kind}
-    var resolved = semOverloadedCall(c, call, call, filter, {})
+    var resolved = semOverloadedCall(c, call, filter, {})
     if resolved != nil:
       result = resolved[0].sym
       if not compareTypes(result.typ[0], fn.typ[0], dcEqIgnoreDistinct):

compiler/sem/semdata.nim

@@ -619,7 +619,7 @@ type
     semConstBoolExpr*: proc (c: PContext, n: PNode): PNode {.nimcall.} # XXX bite the bullet
       ## read to break cyclic dependencies, init in sem during module open and
       ## read in pragmas
-    semOverloadedCall*: proc (c: PContext, n, nOrig: PNode,
+    semOverloadedCall*: proc (c: PContext, n: PNode,
                               filter: TSymKinds, flags: TExprFlags): PNode {.nimcall.}
       ## read to break cyclic dependencies, init in sem during module open and
       ## read in pragmas and semtypinst

compiler/sem/semexprs.nim

@@ -1140,10 +1140,10 @@ proc semOverloadedCallAnalyseEffects(c: PContext, n: PNode,
     # to 'skIterator' anymore; skIterator is preferred in sigmatch already
     # for typeof support.
     # for ``typeof(countup(1,3))``, see ``tests/ttoseq``.
-    result = semOverloadedCall(c, n, copyNodeWithKids(n),
+    result = semOverloadedCall(c, n,
       {skProc, skFunc, skMethod, skConverter, skMacro, skTemplate, skIterator}, flags)
   else:
-    result = semOverloadedCall(c, n, copyNodeWithKids(n),
+    result = semOverloadedCall(c, n,
       {skProc, skFunc, skMethod, skConverter, skMacro, skTemplate}, flags)
 
   if result != nil and result.kind != nkError:

compiler/sem/semstmts.nim

@@ -548,7 +548,7 @@ proc tryMacroPragma(c: PContext, pragmas: ptr PNode, i: int,
   x.add(operand) # the definition AST the pragma appears on
 
   # recursion assures that this works for multiple macro annotations too:
-  let r = semOverloadedCall(c, x, copyNodeWithKids(x), {skMacro, skTemplate}, {efNoUndeclared})
+  let r = semOverloadedCall(c, x, {skMacro, skTemplate}, {efNoUndeclared})
   if r.isNil:
     # restore the old list of pragmas since we couldn't process this one
     pragmas[] = n

compiler/sem/semtypinst.nim

@@ -287,7 +287,7 @@ proc reResolveCallsWithTypedescParams(c: PContext, n: PNode): PNode =
       if isTypeParam(n[i]): needsFixing = true
     if needsFixing:
       n[0] = newSymNode(n[0].sym.owner)
-      return c.semOverloadedCall(c, n, n, {skProc, skFunc}, {})
+      return c.semOverloadedCall(c, n, {skProc, skFunc}, {})
 
   for i in 0..<n.safeLen:
     n[i] = reResolveCallsWithTypedescParams(c, n[i])