From 672c24e4b8fcfc07cdba6a36a2fc0445cdc3d9e9 Mon Sep 17 00:00:00 2001
From: Zahary Karadjov <zahary@gmail.com>
Date: Sat, 13 May 2017 20:48:33 +0300
Subject: [PATCH] fix affecting templates with explicit generic params

---
 compiler/semexprs.nim                | 31 +++++-----------------------
 compiler/vm.nim                      |  5 +++--
 doc/manual/type_rel.txt              |  4 ++--
 tests/template/tgenerictemplates.nim | 13 ++++++++++++
 4 files changed, 23 insertions(+), 30 deletions(-)
 create mode 100644 tests/template/tgenerictemplates.nim

diff --git a/compiler/semexprs.nim b/compiler/semexprs.nim
index 4baef53851..a435917841 100644
--- a/compiler/semexprs.nim
+++ b/compiler/semexprs.nim
@@ -683,27 +683,9 @@ proc bracketedMacro(n: PNode): PSym =
     if result.kind notin {skMacro, skTemplate}:
       result = nil
 
-proc semBracketedMacro(c: PContext; outer, inner: PNode; s: PSym;
-                       flags: TExprFlags): PNode =
-  # We received untransformed bracket expression coming from macroOrTmpl[].
-  # Transform it to macro or template call, where first come normal
-  # arguments, next come generic template arguments.
-  var sons = newSeq[PNode]()
-  sons.add inner.sons[0]
-  # Normal arguments:
-  for i in 1..<outer.len:
-    sons.add outer.sons[i]
-  # Generic template arguments from bracket expression:
-  for i in 1..<inner.len:
-    sons.add inner.sons[i]
-  shallowCopy(outer.sons, sons)
-  # FIXME: Shouldn't we check sfImmediate and call semDirectOp?
-  # However passing to semDirectOp doesn't work here.
-  case s.kind
-  of skMacro: result = semMacroExpr(c, outer, outer, s, flags)
-  of skTemplate: result = semTemplateExpr(c, outer, s, flags)
-  else: assert(false)
-  return
+proc setGenericParams(c: PContext, n: PNode) =
+  for i in 1 .. <n.len:
+    n[i].typ = semTypeNode(c, n[i], nil)
 
 proc afterCallActions(c: PContext; n, orig: PNode, flags: TExprFlags): PNode =
   result = n
@@ -745,7 +727,8 @@ proc semIndirectOp(c: PContext, n: PNode, flags: TExprFlags): PNode =
     elif n.sons[0].kind == nkBracketExpr:
       let s = bracketedMacro(n.sons[0])
       if s != nil:
-        return semBracketedMacro(c, n, n.sons[0], s, flags)
+        setGenericParams(c, n[0])
+        return semDirectOp(c, n, flags)
 
   let nOrig = n.copyTree
   semOpAux(c, n)
@@ -2164,10 +2147,6 @@ proc shouldBeBracketExpr(n: PNode): bool =
           n.sons[0] = be
           return true
 
-proc setGenericParams(c: PContext, n: PNode) =
-  for i in 1 .. <n.len:
-    n[i].typ = semTypeNode(c, n[i], nil)
-
 proc semExpr(c: PContext, n: PNode, flags: TExprFlags = {}): PNode =
   result = n
   if gCmd == cmdIdeTools: suggestExpr(c, n)
diff --git a/compiler/vm.nim b/compiler/vm.nim
index 14800fb13f..40c1f3914e 100644
--- a/compiler/vm.nim
+++ b/compiler/vm.nim
@@ -1609,8 +1609,9 @@ proc setupMacroParam(x: PNode, typ: PType): TFullReg =
 iterator genericParamsInMacroCall*(macroSym: PSym, call: PNode): (PSym, PNode) =
   let gp = macroSym.ast[genericParamsPos]
   for i in 0 .. <gp.len:
-    let idx = macroSym.typ.len + i
-    yield (gp[i].sym, call.sons[idx])
+    let genericParam = gp[i].sym
+    let posInCall = macroSym.typ.len + i
+    yield (genericParam, call[posInCall])
 
 var evalMacroCounter: int
 
diff --git a/doc/manual/type_rel.txt b/doc/manual/type_rel.txt
index 0c49f4e7f7..1d14259346 100644
--- a/doc/manual/type_rel.txt
+++ b/doc/manual/type_rel.txt
@@ -147,7 +147,7 @@ also have pointer-like covariance:
 
 .. code-block:: nim
   type
-    GuiWidget = object of TObject
+    GuiWidget = object of RootObj
     Button = object of GuiWidget
     ComboBox = object of GuiWidget
 
@@ -184,7 +184,7 @@ sequence (i.e. it will be covariant only when instantiated with ``ptr`` and
 .. code-block:: nim
 
   type
-    Base = object of TObject
+    Base = object of RootObj
     Derived = object of Base
 
   proc consumeBaseValues(b: RingBuffer[Base]) = ...
diff --git a/tests/template/tgenerictemplates.nim b/tests/template/tgenerictemplates.nim
new file mode 100644
index 0000000000..2c83bc0ecb
--- /dev/null
+++ b/tests/template/tgenerictemplates.nim
@@ -0,0 +1,13 @@
+type
+  SomeObj = object of RootObj
+
+  Foo[T, U] = object
+    x: T
+    y: U
+
+template someTemplate[T](): tuple[id: int32, obj: T] =
+  var result: tuple[id: int32, obj: T] = (0'i32, T())
+  result
+
+let ret = someTemplate[SomeObj]()
+