diff --git a/compiler/ast.nim b/compiler/ast.nim
index a381521a73173..1c41ae56072e2 100644
--- a/compiler/ast.nim
+++ b/compiler/ast.nim
@@ -1089,18 +1089,6 @@ proc setInfoRecursive*(n: PNode, info: TLineInfo) =
     for i in 0..<n.safeLen: setInfoRecursive(n[i], info)
     n.info = info
 
-proc getCallLineInfo*(n: PNode): TLineInfo =
-  case n.kind
-  of nkAccQuoted, nkBracketExpr, nkCall, nkCallStrLit, nkCommand:
-    if len(n) > 0:
-      return getCallLineInfo(n[0])
-  of nkDotExpr:
-    if len(n) > 1:
-      return getCallLineInfo(n[1])
-  else:
-    discard
-  result = n.info
-
 when defined(useNodeIds):
   const nodeIdToDebug* = -1 # 2322968
   var gNodeId: int
diff --git a/compiler/semcall.nim b/compiler/semcall.nim
index c5eb7c17775bb..986088fc0323d 100644
--- a/compiler/semcall.nim
+++ b/compiler/semcall.nim
@@ -668,6 +668,18 @@ proc updateDefaultParams(c: PContext, call: PNode) =
         def.typ = errorType(c)
       call[i] = def
 
+proc getCallLineInfo*(n: PNode): TLineInfo =
+  case n.kind
+  of nkAccQuoted, nkBracketExpr, nkCall, nkCallStrLit, nkCommand:
+    if len(n) > 0:
+      return getCallLineInfo(n[0])
+  of nkDotExpr:
+    if len(n) > 1:
+      return getCallLineInfo(n[1])
+  else:
+    discard
+  result = n.info
+
 proc inheritBindings(c: PContext, x: var TCandidate, expectedType: PType) =
   ## Helper proc to inherit bound generic parameters from expectedType into x.
   ## Does nothing if 'inferGenericTypes' isn't in c.features.
@@ -816,19 +828,20 @@ proc explicitGenericInstError(c: PContext; n: PNode): PNode =
   localError(c.config, getCallLineInfo(n), errCannotInstantiateX % renderTree(n))
   result = n
 
-proc explicitGenericSym(m: var TCandidate, n: PNode, s: PSym): PSym =
+proc explicitGenericSym(c: PContext, n: PNode, s: PSym): PNode =
   if s.kind in {skTemplate, skMacro}:
-    internalError m.c.config, n.info, "cannot get explicitly instantiated symbol of " &
+    internalError c.config, n.info, "cannot get explicitly instantiated symbol of " &
       (if s.kind == skTemplate: "template" else: "macro")
+  var m = newCandidate(c, s, nil)
   matchGenericParams(m, n, s)
   if m.state != csMatch:
     return nil
-  var newInst = m.c.semGenerateInstance(m.c, s, m.bindings, n.info)
+  var newInst = c.semGenerateInstance(c, s, m.bindings, n.info)
   newInst.typ.flags.excl tfUnresolved
-  result = newInst
   let info = getCallLineInfo(n)
-  markUsed(m.c, info, s)
+  markUsed(c, info, s)
   onUse(info, s)
+  result = newSymNode(newInst, info)
 
 proc setGenericParams(c: PContext, n, expectedParams: PNode) =
   ## sems generic params in subscript expression
@@ -858,16 +871,13 @@ proc explicitGenericInstantiation(c: PContext, n: PNode, s: PSym): PNode =
       localError(c.config, getCallLineInfo(n), errGenerated, "cannot instantiate: '" & renderTree(n) &
          "'; got " & $(n.len-1) & " typeof(s) but expected " & $expected)
       return n
-    var m = newCandidate(c, s, nil)
-    let x = explicitGenericSym(m, n, s)
-    if x == nil: result = explicitGenericInstError(c, n)
-    else: result = newSymNode(x, getCallLineInfo(n))
+    result = explicitGenericSym(c, n, s)
+    if result == nil: result = explicitGenericInstError(c, n)
   elif a.kind in {nkClosedSymChoice, nkOpenSymChoice}:
     # choose the generic proc with the proper number of type parameters.
     # XXX I think this could be improved by reusing sigmatch.paramTypesMatch.
     # It's good enough for now.
-    let info = getCallLineInfo(n)
-    result = newNodeI(a.kind, info)
+    result = newNodeI(a.kind, getCallLineInfo(n))
     for i in 0..<a.len:
       var candidate = a[i].sym
       if candidate.kind in {skProc, skMethod, skConverter,
@@ -875,9 +885,8 @@ proc explicitGenericInstantiation(c: PContext, n: PNode, s: PSym): PNode =
         # it suffices that the candidate has the proper number of generic
         # type parameters:
         if candidate.ast[genericParamsPos].safeLen == n.len-1:
-          var m = newCandidate(c, candidate, nil)
-          let x = explicitGenericSym(m, n, candidate)
-          if x != nil: result.add newSymNode(x, info)
+          let x = explicitGenericSym(c, n, candidate)
+          if x != nil: result.add x
     # get rid of nkClosedSymChoice if not ambiguous:
     if result.len == 1 and a.kind == nkClosedSymChoice:
       result = result[0]
diff --git a/compiler/seminst.nim b/compiler/seminst.nim
index b187f9ed8c0c7..8222330040c1c 100644
--- a/compiler/seminst.nim
+++ b/compiler/seminst.nim
@@ -277,9 +277,18 @@ proc instantiateProcType(c: PContext, pt: TypeMapping,
     # call head symbol, because this leads to infinite recursion.
     if oldParam.ast != nil:
       var def = oldParam.ast.copyTree
+      # don't know why this doesn't work:
+      #def = prepareNode(cl, def)
       if def.kind in nkCallKinds:
+        var id: PIdent = nil
+        if def[0].kind == nkBracketExpr or (def[0].kind in nkCallKinds and
+            (id = def[0][0].getPIdent; id != nil and id.s == "[]")):
+          var start = 1
+          if id != nil: inc start
+          for j in start ..< def[0].len:
+            def[0][j] = replaceTypeVarsN(cl, def[0][j])
         for i in 1..<def.len:
-          def[i] = replaceTypeVarsN(cl, def[i], 1)
+          def[i] = replaceTypeVarsN(cl, def[i])
 
       # allow symchoice since node will be fit later
       # although expectedType should cover it
diff --git a/compiler/semtypes.nim b/compiler/semtypes.nim
index 2a5b6c75170c8..ce131dd4f0e9b 100644
--- a/compiler/semtypes.nim
+++ b/compiler/semtypes.nim
@@ -1358,15 +1358,10 @@ proc semProcTypeNode(c: PContext, n, genericParams: PNode,
           "either use ';' (semicolon) or explicitly write each default value")
         message(c.config, a.info, warnImplicitDefaultValue, msg)
       block determineType:
-        var defTyp = typ
-        if isCurrentlyGeneric():
-          defTyp = nil
-          def = semGenericStmt(c, def)
-          if hasUnresolvedArgs(c, def):
-            def.typ = makeTypeFromExpr(c, def.copyTree)
-            break determineType
-
-        def = semExprWithType(c, def, {efDetermineType, efAllowSymChoice}, defTyp)
+        let isGeneric = isCurrentlyGeneric()
+        inc c.inGenericContext, ord(isGeneric)
+        def = semExprWithType(c, def, {efDetermineType, efAllowSymChoice}, typ)
+        dec c.inGenericContext, ord(isGeneric)
         if def.referencesAnotherParam(getCurrOwner(c)):
           def.flags.incl nfDefaultRefsParam
 
diff --git a/compiler/sigmatch.nim b/compiler/sigmatch.nim
index b3daf2e566391..ee55fc5df96cf 100644
--- a/compiler/sigmatch.nim
+++ b/compiler/sigmatch.nim
@@ -137,6 +137,12 @@ proc typeRel*(c: var TCandidate, f, aOrig: PType,
 
 proc matchGenericParam(m: var TCandidate, formal: PType, n: PNode) =
   var arg = n.typ
+  if m.c.inGenericContext > 0:
+    while arg != nil and arg.kind == tyGenericParam:
+      arg = idTableGet(m.bindings, arg)
+    if arg == nil or arg.containsGenericType:
+      m.state = csNoMatch
+      return
   # fix up the type to get ready to match formal:
   var formalBase = formal
   while formalBase.kind == tyGenericParam and
diff --git a/tests/proc/texplicitgenerics.nim b/tests/proc/texplicitgenerics.nim
index ffa34322e1e66..eb3e186dff648 100644
--- a/tests/proc/texplicitgenerics.nim
+++ b/tests/proc/texplicitgenerics.nim
@@ -32,11 +32,12 @@ block: # sigmatch can't handle this without pre-instantiating the type:
   proc bar[T](f: Foo[T]) = discard
   bar[int](foo)
 
-when false: # ditto, but needs #24005 to show the issue
+block: # ditto but may be wrong minimization
   # minimized from measuremancer
-  proc foo[T](): T = default(T)
+  type Foo[T] = object
+  proc foo[T](): Foo[T] = Foo[T]()
   proc bar[T](x = foo[T]()) = discard
-  bar[int](123)
+  bar[int](Foo[int]())
   # alternative version
   proc baz[T](x: typeof(foo[T]())) = discard
-  baz[int](123)
+  baz[int](Foo[int]())