fix calls to implicitly generic params in generic contexts

compiler/semexprs.nim

@@ -616,6 +616,9 @@ proc semIs(c: PContext, n: PNode, flags: TExprFlags): PNode =
 
   var lhsType = n[1].typ
   if lhsType.kind != tyTypeDesc:
+    if c.inGenericContext > 0 and lhsType.containsUnresolvedType:
+      # `x is T` where `x` is unresolved, cannot evaluate yet
+      return
     if liftLhs:
       n[1] = makeTypeSymNode(c, lhsType, n[1].info)
       lhsType = n[1].typ

compiler/sigmatch.nim

@@ -1299,6 +1299,9 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
   case a.kind
   of tyOr:
     # XXX: deal with the current dual meaning of tyGenericParam
+    if c.c.inGenericContext > 0 and not c.isNoCall:
+      # a has unresolved type, don't match call in generic context
+      return isNone
     c.typedescMatched = true
     # seq[int|string] vs seq[number]
     # both int and string must match against number
@@ -1339,6 +1342,9 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
     if f.kind == tyAnything: return isGeneric
     else: return isNone
   of tyUserTypeClass, tyUserTypeClassInst:
+    if c.c.inGenericContext > 0 and not c.isNoCall:
+      # a has unresolved type, don't match call in generic context
+      return isNone
     if c.c.matchedConcept != nil and c.c.matchedConcept.depth <= 4:
       # consider this: 'var g: Node' *within* a concept where 'Node'
       # is a concept too (tgraph)

compiler/types.nim

@@ -1500,7 +1500,8 @@ proc containsGenericType*(t: PType): bool =
   result = iterOverType(t, containsGenericTypeIter, nil)
 
 proc containsUnresolvedTypeIter(t: PType, closure: RootRef): bool =
-  if tfUnresolved in t.flags: return true
+  if {tfUnresolved, tfGenericTypeParam, tfImplicitTypeParam} * t.flags != {}:
+    return true
   case t.kind
   of tyStatic:
     return t.n == nil

tests/proc/tgenericdefaultparam.nim

@@ -96,3 +96,39 @@ block: # issue #24121
   proc baz[T: FooBar](x: T, y = foo(x)): string = y
   doAssert baz(Foo(123)) == "b"
   doAssert baz(Bar(123)) == "c"
+
+block: # using `or` type
+  template val(x: int): string = "int"
+  template val(x: string): string = "string"
+  proc foo(x: int | string, y = val(x)): string =
+    y
+
+  doAssert foo(123) == "int"
+  doAssert foo("abc") == "string"
+
+block: # using concept type
+  type Foo = concept x
+    x is int | string
+  template val(x: int): string = "int"
+  template val(x: string): string = "string"
+  proc foo(x: Foo, y = val(x)): string =
+    y
+
+  doAssert foo(123) == "int"
+  doAssert foo("abc") == "string"
+
+block: # using `or` type with direct `is`
+  proc foo(x: int | string, y = when x is int: "int" else: "string"): string =
+    y
+
+  doAssert foo(123) == "int"
+  doAssert foo("abc") == "string"
+
+block: # using concept type with direct `is`
+  type Foo = concept x
+    x is int | string
+  proc foo(x: Foo, y = when x is int: "int" else: "string"): string =
+    y
+
+  doAssert foo(123) == "int"
+  doAssert foo("abc") == "string"