borrow works with generics

compiler/procfind.nim

@@ -13,14 +13,6 @@
 import 
   ast, astalgo, msgs, semdata, types, trees
 
-proc SearchForProc*(c: PContext, fn: PSym, tos: int): PSym
-  # Searchs for the fn in the symbol table. If the parameter lists are exactly
-  # the same the sym in the symbol table is returned, else nil.
-proc SearchForBorrowProc*(c: PContext, fn: PSym, tos: int): PSym
-  # Searchs for the fn in the symbol table. If the parameter lists are suitable
-  # for borrowing the sym in the symbol table is returned, else nil.
-# implementation
-
 proc equalGenericParams(procA, procB: PNode): bool = 
   var a, b: PSym
   result = procA == procB
@@ -41,7 +33,9 @@ proc equalGenericParams(procA, procB: PNode): bool =
       if not ExprStructuralEquivalent(a.ast, b.ast): return 
   result = true
 
-proc SearchForProc(c: PContext, fn: PSym, tos: int): PSym = 
+proc SearchForProc*(c: PContext, fn: PSym, tos: int): PSym = 
+  # Searchs for the fn in the symbol table. If the parameter lists are exactly
+  # the same the sym in the symbol table is returned, else nil.
   var it: TIdentIter
   result = initIdentIter(it, c.tab.stack[tos], fn.Name)
   while result != nil: 
@@ -58,36 +52,30 @@ proc SearchForProc(c: PContext, fn: PSym, tos: int): PSym =
           nil
     result = NextIdentIter(it, c.tab.stack[tos])
 
-proc paramsFitBorrow(child, parent: PNode): bool = 
-  var length = sonsLen(child)
-  result = false
-  if length == sonsLen(parent): 
-    for i in countup(1, length - 1): 
-      var m = child.sons[i].sym
-      var n = parent.sons[i].sym
-      assert((m.kind == skParam) and (n.kind == skParam))
-      if not compareTypes(m.typ, n.typ, dcEqOrDistinctOf): return 
-    if not compareTypes(child.sons[0].typ, parent.sons[0].typ,
-                        dcEqOrDistinctOf): return
-    result = true
+when false:
+  proc paramsFitBorrow(child, parent: PNode): bool = 
+    var length = sonsLen(child)
+    result = false
+    if length == sonsLen(parent): 
+      for i in countup(1, length - 1): 
+        var m = child.sons[i].sym
+        var n = parent.sons[i].sym
+        assert((m.kind == skParam) and (n.kind == skParam))
+        if not compareTypes(m.typ, n.typ, dcEqOrDistinctOf): return 
+      if not compareTypes(child.sons[0].typ, parent.sons[0].typ,
+                          dcEqOrDistinctOf): return
+      result = true
 
-proc SearchForBorrowProc(c: PContext, fn: PSym, tos: int): PSym = 
-  # Searchs for the fn in the symbol table. If the parameter lists are suitable
-  # for borrowing the sym in the symbol table is returned, else nil.
-  var it: TIdentIter
-  for scope in countdown(tos, 0): 
-    result = initIdentIter(it, c.tab.stack[scope], fn.Name)
-    while result != nil: 
-      # watchout! result must not be the same as fn!
-      if (result.Kind == fn.kind) and (result.id != fn.id): 
-        if equalGenericParams(result.ast.sons[genericParamsPos], 
-                              fn.ast.sons[genericParamsPos]): 
-          if paramsFitBorrow(fn.typ.n, result.typ.n): return 
-      result = NextIdentIter(it, c.tab.stack[scope])
-
-proc SearchForBorrowProc2(c: PContext, fn: PSym, tos: int): PSym = 
-  # Searchs for the fn in the symbol table. If the parameter lists are suitable
-  # for borrowing the sym in the symbol table is returned, else nil.
-  # New approach: generate fn(x, y, z) where x, y, z have the proper types
-  # and use the overloading resolution mechanism:
-  nil
+  proc SearchForBorrowProc*(c: PContext, fn: PSym, tos: int): PSym = 
+    # Searchs for the fn in the symbol table. If the parameter lists are suitable
+    # for borrowing the sym in the symbol table is returned, else nil.
+    var it: TIdentIter
+    for scope in countdown(tos, 0): 
+      result = initIdentIter(it, c.tab.stack[scope], fn.Name)
+      while result != nil: 
+        # watchout! result must not be the same as fn!
+        if (result.Kind == fn.kind) and (result.id != fn.id): 
+          if equalGenericParams(result.ast.sons[genericParamsPos], 
+                                fn.ast.sons[genericParamsPos]): 
+            if paramsFitBorrow(fn.typ.n, result.typ.n): return 
+        result = NextIdentIter(it, c.tab.stack[scope])

compiler/semcall.nim

@@ -150,3 +150,17 @@ proc explicitGenericInstantiation(c: PContext, n: PNode, s: PSym): PNode =
   else:
     result = explicitGenericInstError(n)
 
+proc SearchForBorrowProc(c: PContext, fn: PSym, tos: int): PSym =
+  # Searchs for the fn in the symbol table. If the parameter lists are suitable
+  # for borrowing the sym in the symbol table is returned, else nil.
+  # New approach: generate fn(x, y, z) where x, y, z have the proper types
+  # and use the overloading resolution mechanism:
+  var call = newNode(nkCall)
+  call.add(newIdentNode(fn.name, fn.info))
+  for i in 1.. <fn.typ.n.len:
+    let param = fn.typ.n.sons[i]
+    let t = skipTypes(param.typ, abstractVar)
+    call.add(newNodeIT(nkEmpty, fn.info, t.baseOfDistinct))
+  var resolved = semOverloadedCall(c, call, call, {fn.kind})
+  if resolved != nil:
+    result = resolved.sons[0].sym

compiler/types.nim

@@ -1108,3 +1108,17 @@ proc containsGenericTypeIter(t: PType, closure: PObject): bool =
 
 proc containsGenericType*(t: PType): bool = 
   result = iterOverType(t, containsGenericTypeIter, nil)
+
+proc baseOfDistinct*(t: PType): PType =
+  if t.kind == tyDistinct:
+    result = t.sons[0]
+  else:
+    result = copyType(t, t.owner, false)
+    var parent: PType = nil
+    var it = result
+    while it.kind in {tyPtr, tyRef}:
+      parent = it
+      it = it.sons[0]
+    if it.kind == tyDistinct:
+      internalAssert parent != nil
+      parent.sons[0] = it.sons[0]