requested pull-request changes

compiler/semexprs.nim

@@ -857,6 +857,7 @@ proc semIndirectOp(c: PContext, n: PNode, flags: TExprFlags): PNode =
     else:
       result = m.call
       instGenericConvertersSons(c, result, m)
+
   elif t != nil and t.kind == tyTypeDesc:
     if n.len == 1: return semObjConstr(c, n, flags)
     return semConv(c, n)

compiler/semtypes.nim

@@ -863,7 +863,7 @@ proc liftParamType(c: PContext, procKind: TSymKind, genericParams: PNode,
 
   of tyStatic:
     if paramType.base.kind != tyNone and paramType.n != nil:
-      # this is a concrete type
+      # this is a concrete static value
       return
     if tfUnresolved in paramType.flags: return # already lifted
     let base = paramType.base.maybeLift
@@ -1048,7 +1048,12 @@ proc semProcTypeNode(c: PContext, n, genericParams: PNode,
       if typ == nil:
         typ = def.typ
         if typ.kind == tyTypeDesc:
-          # default typedesc values are mapped to the unbound typedesc type:
+          # consider a proc such as:
+          # proc takesType(T = int)
+          # a naive analysis may conclude that the proc type is type[int]
+          # which will prevent other types from matching - clearly a very
+          # surprising behavior. We must instead fix the expected type of
+          # the proc to be the unbound typedesc type:
           typ = newTypeWithSons(c, tyTypeDesc, @[newTypeS(tyNone, c)])
 
       else:

compiler/semtypinst.nim

@@ -223,8 +223,9 @@ proc replaceTypeVarsS(cl: var TReplTypeVars, s: PSym): PSym =
 
   # XXX: Bound symbols in default parameter expressions may reach here.
   # We cannot process them, becase `sym.n` may point to a proc body with
-  # cyclic references that will lead to an infinite recursion. Perhaps we
-  # should not use a black-list here, but a whitelist instead.
+  # cyclic references that will lead to an infinite recursion.
+  # Perhaps we should not use a black-list here, but a whitelist instead
+  # (e.g. skGenericParam and skType).
   # Note: `s.magic` may be `mType` in an example such as:
   # proc foo[T](a: T, b = myDefault(type(a)))
   if s.kind == skProc or s.magic != mNone:

compiler/sigmatch.nim

@@ -1089,13 +1089,8 @@ proc typeRelImpl(c: var TCandidate, f, aOrig: PType,
              else: isNone
 
   of tyAnything:
-    if f.kind in {tyAnything}:
-      return isGeneric
-
-    if tfWildCard in a.flags and f.kind == tyTypeDesc:
-      return isGeneric
-
-    return isNone
+    if f.kind == tyAnything: return isGeneric
+    else: return isNone
 
   of tyUserTypeClass, tyUserTypeClassInst:
     if c.c.matchedConcept != nil and c.c.matchedConcept.depth <= 4:
@@ -2366,6 +2361,14 @@ proc matches*(c: PContext, n, nOrig: PNode, m: var TCandidate) =
           m.firstMismatch = f
           break
       else:
+        if formal.ast.kind == nkEmpty:
+          # The default param value is set to empty in `instantiateProcType`
+          # when the type of the default expression doesn't match the type
+          # of the instantiated proc param:
+          localError(c.config, m.call.info,
+                     ("The default parameter '$1' has incompatible type " &
+                      "with the explicitly requested proc instantiation") %
+                      formal.name.s)
         if nfDefaultRefsParam in formal.ast.flags:
           m.call.flags.incl nfDefaultRefsParam
         var def = copyTree(formal.ast)
@@ -2375,9 +2378,6 @@ proc matches*(c: PContext, n, nOrig: PNode, m: var TCandidate) =
           put(m, formal.typ, def.typ)
         def.flags.incl nfDefaultParam
         setSon(m.call, formal.position + 1, def)
-        # XXX: Instead of setting a default value here, we may place a special
-        # marker value instead. Later, we will replace it in `semResolvedCall`.
-        # Unfortunately, this causes some breakage at the moment.
     inc(f)
   # forget all inferred types if the overload matching failed
   if m.state == csNoMatch: