Test type reduction

compiler/semcall.nim

@@ -590,6 +590,38 @@ proc inheritBindings(c: PContext, x: TCandidate, expectedType: PType): TIdTable
     if result.idTableGet(y[0].typ) == nil:
       # pass it along directly
       result.idTablePut(y[0].typ, expectedType)
+  elif resNode.kind in {nkTupleConstr, nkTupleTy}:
+    var
+      flatSyms: seq[PSym]
+      flatBinds: seq[PType]
+    var typeStack = @[(resNode.typ, expectedType)]
+    # TODO: Use this type reduction for the entire inheritance structure instead of just tuples
+    #  Probably put into a proc
+    block outer:
+      while typeStack.len() > 0:
+        let (t, u) = typeStack.pop()
+        case t.kind
+        of tyTuple, tyGenericInvocation:
+          # nested, add all the types to stack
+          for i in countdown(t.sons.len() - 1, 0):
+            if i >= t.sons.len() or i >= u.sons.len():
+              break outer
+            typeStack.add((t.sons[i], u.sons[i]))
+        of tyGenericParam:
+          # fully reduced generic param
+          if t.sym notin flatSyms:
+            flatSyms.add(t.sym)
+            flatBinds.add(u)
+        of tyGenericBody:
+          discard # TODO: Combine into else later?
+        else:
+          # TODO: Remove/replace
+          doAssert false # for debugging
+      for i in 0 ..< flatSyms.len():
+        result.idTablePut(flatSyms[i].typ, flatBinds[i])
+  else:
+    # TODO: Remove/replace
+    doAssert false # for debugging
 
 proc semResolvedCall(c: PContext, x: TCandidate,
                      n: PNode, flags: TExprFlags;

tests/generics/treturn_inference.nim

@@ -81,24 +81,23 @@ block:
   var x: array[2, int] = giveArray()
   doAssert x == [0, 1]
 
-# Tuples are quite tough and don't work
-#[
 # tuples
 block:
   proc giveTuple[T, Z]: (T, Z, T) = discard
   let x: (int, float, int) = giveTuple()
-  doAssert x is (int, float)
-  doAssert x[0] == 0 and x[1] == 0.0
+  doAssert x is (int, float, int)
+  doAssert x == (0, 0.0, 0)
 
   proc giveNamedTuple[T, Z]: tuple[a: T, b: Z] = discard
-  let y: tuple[a: int, b: float] = giveTuple()
+  let y: tuple[a: int, b: float] = giveNamedTuple()
   doAssert y is (int, float)
   doAssert y is tuple[a: int, b: float]
-  doAssert y.a == 0 and y.b == 0.0
+  doAssert y == (0, 0.0)
 
   proc giveNestedTuple[T, Z]: ((T, Z), Z) = discard
   let z: ((int, float), float) = giveNestedTuple()
-]#
+  doAssert z is ((int, float), float)
+  doAssert z == ((0, 0.0), 0.0)
 
 
 # basic constructors