From 612cd2161aa1a145cc11f559b135a948f972f344 Mon Sep 17 00:00:00 2001
From: JamesP <jlp765@gmail.com>
Date: Thu, 10 Sep 2015 17:29:52 +1000
Subject: [PATCH 01/16] add examples block to top of times module

---
 lib/pure/times.nim | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/lib/pure/times.nim b/lib/pure/times.nim
index aa4ae5ace..5d960b11a 100644
--- a/lib/pure/times.nim
+++ b/lib/pure/times.nim
@@ -11,6 +11,25 @@
 ## This module contains routines and types for dealing with time.
 ## This module is available for the `JavaScript target
 ## <backends.html#the-javascript-target>`_.
+##
+## Examples:
+##
+## .. code-block:: nim
+##
+##  import times, os
+##  var
+##    t = cpuTime()
+##
+##  sleep(100)   # replace this with something to be timed
+##  echo "Time taken: ",cpuTime() - t
+##
+##  echo "My formatted time: ", format(getLocalTime(getTime()), "d MMMM yyyy HH:mm")
+##  echo "Using predefined formats: ", getClockStr(), " ", getDateStr()
+##
+##  echo "epochTime() float value: ", epochTime()
+##  echo "getTime()   float value: ", toSeconds(getTime())
+##  echo "cpuTime()   float value: ", cpuTime()
+##  echo "An hour from now: ", getLocalTime(getTime()) + initInterval(0,0,0,1)
 
 {.push debugger:off.} # the user does not want to trace a part
                       # of the standard library!

From c122d71e66e9edbbeb9f6bb32475321447439862 Mon Sep 17 00:00:00 2001
From: JamesP <jlp765@gmail.com>
Date: Thu, 10 Sep 2015 17:38:00 +1000
Subject: [PATCH 02/16] bug fix:  `+`  and  `-`  handle GM and Local time
 correctly

eg,  getGmTime(getTime()) + initInterval(hours=1) gave incorrect results
---
 lib/pure/times.nim | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/lib/pure/times.nim b/lib/pure/times.nim
index 5d960b11a..f0455baac 100644
--- a/lib/pure/times.nim
+++ b/lib/pure/times.nim
@@ -307,10 +307,10 @@ proc `+`*(a: TimeInfo, interval: TimeInterval): TimeInfo =
   ## very accurate.
   let t = toSeconds(timeInfoToTime(a))
   let secs = toSeconds(a, interval)
-  if a.tzname == "UTC":
-    result = getGMTime(fromSeconds(t + secs))
-  else:
-    result = getLocalTime(fromSeconds(t + secs))
+  #if a.tzname == "UTC":
+  #  result = getGMTime(fromSeconds(t + secs))
+  #else:
+  result = getLocalTime(fromSeconds(t + secs))
 
 proc `-`*(a: TimeInfo, interval: TimeInterval): TimeInfo =
   ## subtracts ``interval`` time.
@@ -319,10 +319,10 @@ proc `-`*(a: TimeInfo, interval: TimeInterval): TimeInfo =
   ## when you subtract so much that you reach the Julian calendar.
   let t = toSeconds(timeInfoToTime(a))
   let secs = toSeconds(a, interval)
-  if a.tzname == "UTC":
-    result = getGMTime(fromSeconds(t - secs))
-  else:
-    result = getLocalTime(fromSeconds(t - secs))
+  #if a.tzname == "UTC":
+  #  result = getGMTime(fromSeconds(t - secs))
+  #else:
+  result = getLocalTime(fromSeconds(t - secs))
 
 when not defined(JS):
   proc epochTime*(): float {.rtl, extern: "nt$1", tags: [TimeEffect].}

From f5d55ad0124870ff5d574e5069d9f8cf2f9e8b9c Mon Sep 17 00:00:00 2001
From: JamesP <jlp765@gmail.com>
Date: Thu, 10 Sep 2015 19:21:27 +1000
Subject: [PATCH 03/16] tests added: toSeconds with local/GM timezones,
 interval add/sub with local/GM timezones

---
 lib/pure/times.nim | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/lib/pure/times.nim b/lib/pure/times.nim
index f0455baac..94aeeffe1 100644
--- a/lib/pure/times.nim
+++ b/lib/pure/times.nim
@@ -1288,3 +1288,28 @@ when isMainModule:
   assert getDayOfWeekJulian(21, 9, 1970) == dMon
   assert getDayOfWeekJulian(1, 1, 2000) == dSat
   assert getDayOfWeekJulian(1, 1, 2021) == dFri
+
+  # toSeconds tests with GM and Local timezones
+  #var t4 = getGMTime(fromSeconds(876124714)) # Mon  6 Oct 08:58:34 BST 1997
+  var t4L = getLocalTime(fromSeconds(876124714))
+  assert toSeconds(timeInfoToTime(t4L)) == 876124714    # fromSeconds is effectively "localTime"
+  assert toSeconds(timeInfoToTime(t4L)) + t4L.timezone.float == toSeconds(timeInfoToTime(t4))
+
+  assert toSeconds(t4, initInterval(seconds=0)) == 0.0
+  assert toSeconds(t4L, initInterval(milliseconds=1)) == toSeconds(t4, initInterval(milliseconds=1))
+  assert toSeconds(t4L, initInterval(seconds=1)) == toSeconds(t4, initInterval(seconds=1))
+  assert toSeconds(t4L, initInterval(minutes=1)) == toSeconds(t4, initInterval(minutes=1))
+  assert toSeconds(t4L, initInterval(hours=1)) == toSeconds(t4, initInterval(hours=1))
+  assert toSeconds(t4L, initInterval(days=1)) == toSeconds(t4, initInterval(days=1))
+  assert toSeconds(t4L, initInterval(months=1)) == toSeconds(t4, initInterval(months=1))
+  assert toSeconds(t4L, initInterval(years=1)) == toSeconds(t4, initInterval(years=1))
+
+  # adding intervals
+  var
+    a1L = toSeconds(timeInfoToTime(t4L + initInterval(hours = 1))) + t4L.timezone.float
+    a1G = toSeconds(timeInfoToTime(t4)) + 60.0 * 60.0
+  assert a1L == a1G
+  # subtracting intervals
+  a1L = toSeconds(timeInfoToTime(t4L - initInterval(hours = 1))) + t4L.timezone.float
+  a1G = toSeconds(timeInfoToTime(t4)) - (60.0 * 60.0)
+  assert a1L == a1G

From 2d1f26302c50188b49bbaf17a92a276f61311f8f Mon Sep 17 00:00:00 2001
From: JamesP <jlp765@gmail.com>
Date: Thu, 10 Sep 2015 19:29:26 +1000
Subject: [PATCH 04/16] Example: add extra getGmTime interval addition example

---
 lib/pure/times.nim | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/lib/pure/times.nim b/lib/pure/times.nim
index 94aeeffe1..3142952e7 100644
--- a/lib/pure/times.nim
+++ b/lib/pure/times.nim
@@ -29,7 +29,8 @@
 ##  echo "epochTime() float value: ", epochTime()
 ##  echo "getTime()   float value: ", toSeconds(getTime())
 ##  echo "cpuTime()   float value: ", cpuTime()
-##  echo "An hour from now: ", getLocalTime(getTime()) + initInterval(0,0,0,1)
+##  echo "An hour from now      : ", getLocalTime(getTime()) + initInterval(0,0,0,1)
+##  echo "An hour from (UTC) now: ", getGmTime(getTime()) + initInterval(0,0,0,1)
 
 {.push debugger:off.} # the user does not want to trace a part
                       # of the standard library!

From 28e3ad945a100fd0e669bcedb7d28ddd540b6978 Mon Sep 17 00:00:00 2001
From: Dominik Picheta <dominikpicheta@googlemail.com>
Date: Fri, 11 Sep 2015 13:03:59 +0100
Subject: [PATCH 05/16] Reintroduce FutureVar[T] from commit
 72b4912c84b16644657.

---
 lib/pure/asyncdispatch.nim   | 31 +++++++++++++++++++++++++++++++
 lib/pure/asynchttpserver.nim | 25 ++++++++++++++-----------
 lib/pure/asyncnet.nim        | 34 +++++++++++++++++++++++++---------
 3 files changed, 70 insertions(+), 20 deletions(-)

diff --git a/lib/pure/asyncdispatch.nim b/lib/pure/asyncdispatch.nim
index f49388b17..292296d35 100644
--- a/lib/pure/asyncdispatch.nim
+++ b/lib/pure/asyncdispatch.nim
@@ -145,6 +145,8 @@ type
   Future*[T] = ref object of FutureBase ## Typed future.
     value: T ## Stored value
 
+  FutureVar*[T] = distinct Future[T]
+
 {.deprecated: [PFutureBase: FutureBase, PFuture: Future].}
 
 
@@ -162,6 +164,19 @@ proc newFuture*[T](fromProc: string = "unspecified"): Future[T] =
     result.fromProc = fromProc
     currentID.inc()
 
+proc newFutureVar*[T](fromProc = "unspecified"): FutureVar[T] =
+  ## Create a new ``FutureVar``. This Future type is ideally suited for
+  ## situations where you want to avoid unnecessary allocations of Futures.
+  ##
+  ## Specifying ``fromProc``, which is a string specifying the name of the proc
+  ## that this future belongs to, is a good habit as it helps with debugging.
+  result = FutureVar[T](newFuture[T](fromProc))
+
+proc clean*[T](future: FutureVar[T]) =
+  ## Resets the ``finished`` status of ``future``.
+  Future[T](future).finished = false
+  Future[T](future).error = nil
+
 proc checkFinished[T](future: Future[T]) =
   when not defined(release):
     if future.finished:
@@ -194,6 +209,15 @@ proc complete*(future: Future[void]) =
   if future.cb != nil:
     future.cb()
 
+proc complete*[T](future: FutureVar[T]) =
+  ## Completes a ``FutureVar``.
+  template fut: expr = Future[T](future)
+  checkFinished(fut)
+  assert(fut.error == nil)
+  fut.finished = true
+  if fut.cb != nil:
+    fut.cb()
+
 proc fail*[T](future: Future[T], error: ref Exception) =
   ## Completes ``future`` with ``error``.
   #assert(not future.finished, "Future already finished, cannot finish twice.")
@@ -264,6 +288,13 @@ proc readError*[T](future: Future[T]): ref Exception =
   else:
     raise newException(ValueError, "No error in future.")
 
+proc mget*[T](future: FutureVar[T]): var T =
+  ## Returns a mutable value stored in ``future``.
+  ##
+  ## Unlike ``read``, this function will not raise an exception if the
+  ## Future has not been finished.
+  result = Future[T](future).value
+
 proc finished*[T](future: Future[T]): bool =
   ## Determines whether ``future`` has completed.
   ##
diff --git a/lib/pure/asynchttpserver.nim b/lib/pure/asynchttpserver.nim
index f9085e4bf..aa7d458b3 100644
--- a/lib/pure/asynchttpserver.nim
+++ b/lib/pure/asynchttpserver.nim
@@ -151,7 +151,8 @@ proc processClient(client: AsyncSocket, address: string,
   var request: Request
   request.url = initUri()
   request.headers = newStringTable(modeCaseInsensitive)
-  var line = newStringOfCap(80)
+  var lineFut = newFutureVar[string]("asynchttpserver.processClient")
+  lineFut.mget() = newStringOfCap(80)
   var key, value = ""
 
   while not client.isClosed:
@@ -165,14 +166,15 @@ proc processClient(client: AsyncSocket, address: string,
     request.client = client
 
     # First line - GET /path HTTP/1.1
-    line.setLen(0)
-    await client.recvLineInto(addr line) # TODO: Timeouts.
-    if line == "":
+    lineFut.mget().setLen(0)
+    lineFut.clean()
+    await client.recvLineInto(lineFut) # TODO: Timeouts.
+    if lineFut.mget == "":
       client.close()
       return
 
     var i = 0
-    for linePart in line.split(' '):
+    for linePart in lineFut.mget.split(' '):
       case i
       of 0: request.reqMethod.shallowCopy(linePart.normalize)
       of 1: parseUri(linePart, request.url)
@@ -184,20 +186,21 @@ proc processClient(client: AsyncSocket, address: string,
             "Invalid request protocol. Got: " & linePart)
           continue
       else:
-        await request.respond(Http400, "Invalid request. Got: " & line)
+        await request.respond(Http400, "Invalid request. Got: " & lineFut.mget)
         continue
       inc i
 
     # Headers
     while true:
       i = 0
-      line.setLen(0)
-      await client.recvLineInto(addr line)
+      lineFut.mget.setLen(0)
+      lineFut.clean()
+      await client.recvLineInto(lineFut)
 
-      if line == "":
+      if lineFut.mget == "":
         client.close(); return
-      if line == "\c\L": break
-      let (key, value) = parseHeader(line)
+      if lineFut.mget == "\c\L": break
+      let (key, value) = parseHeader(lineFut.mget)
       request.headers[key] = value
 
     if request.reqMethod == "post":
diff --git a/lib/pure/asyncnet.nim b/lib/pure/asyncnet.nim
index 9139200f3..ba314af10 100644
--- a/lib/pure/asyncnet.nim
+++ b/lib/pure/asyncnet.nim
@@ -316,7 +316,7 @@ proc accept*(socket: AsyncSocket,
         retFut.complete(future.read.client)
   return retFut
 
-proc recvLineInto*(socket: AsyncSocket, resString: ptr string,
+proc recvLineInto*(socket: AsyncSocket, resString: FutureVar[string],
     flags = {SocketFlag.SafeDisconn}) {.async.} =
   ## Reads a line of data from ``socket`` into ``resString``.
   ##
@@ -338,16 +338,23 @@ proc recvLineInto*(socket: AsyncSocket, resString: ptr string,
   ## **Warning**: ``recvLineInto`` currently uses a raw pointer to a string for
   ## performance reasons. This will likely change soon to use FutureVars.
   assert SocketFlag.Peek notin flags ## TODO:
+  assert(not resString.mget.isNil(),
+         "String inside resString future needs to be initialised")
   result = newFuture[void]("asyncnet.recvLineInto")
 
+  # TODO: Make the async transformation check for FutureVar params and complete
+  # them when the result future is completed.
+  # Can we replace the result future with the FutureVar?
+
   template addNLIfEmpty(): stmt =
-    if resString[].len == 0:
-      resString[].add("\c\L")
+    if resString.mget.len == 0:
+      resString.mget.add("\c\L")
 
   if socket.isBuffered:
     if socket.bufLen == 0:
       let res = socket.readIntoBuf(flags)
       if res == 0:
+        resString.complete()
         return
 
     var lastR = false
@@ -355,7 +362,8 @@ proc recvLineInto*(socket: AsyncSocket, resString: ptr string,
       if socket.currPos >= socket.bufLen:
         let res = socket.readIntoBuf(flags)
         if res == 0:
-          resString[].setLen(0)
+          resString.mget.setLen(0)
+          resString.complete()
           return
 
       case socket.buffer[socket.currPos]
@@ -365,13 +373,15 @@ proc recvLineInto*(socket: AsyncSocket, resString: ptr string,
       of '\L':
         addNLIfEmpty()
         socket.currPos.inc()
+        resString.complete()
         return
       else:
         if lastR:
           socket.currPos.inc()
+          resString.complete()
           return
         else:
-          resString[].add socket.buffer[socket.currPos]
+          resString.mget.add socket.buffer[socket.currPos]
       socket.currPos.inc()
   else:
     var c = ""
@@ -379,18 +389,22 @@ proc recvLineInto*(socket: AsyncSocket, resString: ptr string,
       let recvFut = recv(socket, 1, flags)
       c = recvFut.read()
       if c.len == 0:
-        resString[].setLen(0)
+        resString.mget.setLen(0)
+        resString.complete()
         return
       if c == "\r":
         let recvFut = recv(socket, 1, flags) # Skip \L
         c = recvFut.read()
         assert c == "\L"
         addNLIfEmpty()
+        resString.complete()
         return
       elif c == "\L":
         addNLIfEmpty()
+        resString.complete()
         return
-      resString[].add c
+      resString.mget.add c
+  resString.complete()
 
 proc recvLine*(socket: AsyncSocket,
     flags = {SocketFlag.SafeDisconn}): Future[string] {.async.} =
@@ -416,8 +430,10 @@ proc recvLine*(socket: AsyncSocket,
       result.add("\c\L")
   assert SocketFlag.Peek notin flags ## TODO:
 
-  result = ""
-  await socket.recvLineInto(addr result, flags)
+  # TODO: Optimise this
+  var resString = newFutureVar[string]("asyncnet.recvLine")
+  await socket.recvLineInto(resString, flags)
+  result = resString.mget()
 
 proc listen*(socket: AsyncSocket, backlog = SOMAXCONN) {.tags: [ReadIOEffect].} =
   ## Marks ``socket`` as accepting connections.

From 808253370bac20c96f5ea9fab9bfc33352011562 Mon Sep 17 00:00:00 2001
From: Dominik Picheta <dominikpicheta@googlemail.com>
Date: Fri, 11 Sep 2015 14:35:25 +0100
Subject: [PATCH 06/16] Implement strutils.indent

---
 lib/pure/strutils.nim | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/lib/pure/strutils.nim b/lib/pure/strutils.nim
index ae3bd7f63..d1c09f43d 100644
--- a/lib/pure/strutils.nim
+++ b/lib/pure/strutils.nim
@@ -630,6 +630,22 @@ proc wordWrap*(s: string, maxLineWidth = 80,
       result.add(lastSep & word)
       lastSep.setLen(0)
 
+proc indent*(s: string, count: Natural, padding: string = " "): string
+    {.noSideEffect, rtl, extern: "nsuIndent".} =
+  ## Indents each line in ``s`` by ``count`` amount of ``padding``.
+  ##
+  ## **Note:** This currently does not preserve the specific new line characters
+  ## used.
+  result = ""
+  var i = 0
+  for line in s.splitLines():
+    if i != 0:
+      result.add("\n")
+    for j in 1..count:
+      result.add(padding)
+    result.add(line)
+    i.inc
+
 proc unindent*(s: string, eatAllIndent = false): string {.
                noSideEffect, rtl, extern: "nsuUnindent".} =
   ## Unindents `s`.
@@ -1502,3 +1518,5 @@ when isMainModule:
                  chars = {'s', 't', 'r', 'i', 'p', 'm', 'e'}) == " but don't strip this "
   doAssert strip("sfoofoofoos", leading = false, chars = {'s'}) == "sfoofoofoo"
   doAssert strip("sfoofoofoos", trailing = false, chars = {'s'}) == "foofoofoos"
+
+  doAssert "  foo\n  bar".indent(4, "Q") == "QQQQ  foo\nQQQQ  bar"

From 77c2bcf07983a35a37312ce7bd1fa5069211ec27 Mon Sep 17 00:00:00 2001
From: Dominik Picheta <dominikpicheta@googlemail.com>
Date: Fri, 11 Sep 2015 14:35:42 +0100
Subject: [PATCH 07/16] Improve asyncdispatch error messages, fix some tests on
 Windows.

---
 lib/pure/asyncdispatch.nim       | 48 +++++++++++++++++++++-----------
 tests/async/tasyncconnect.nim    |  3 +-
 tests/async/tasynceverror.nim    |  3 +-
 tests/async/tasyncexceptions.nim |  2 +-
 4 files changed, 36 insertions(+), 20 deletions(-)

diff --git a/lib/pure/asyncdispatch.nim b/lib/pure/asyncdispatch.nim
index 292296d35..d91507a85 100644
--- a/lib/pure/asyncdispatch.nim
+++ b/lib/pure/asyncdispatch.nim
@@ -126,6 +126,7 @@ export Port, SocketFlag
 ## * Can't await in a ``except`` body
 ## * Forward declarations for async procs are broken,
 ##   link includes workaround: https://github.com/nim-lang/Nim/issues/3182.
+## * FutureVar[T] needs to be completed manually.
 
 # TODO: Check if yielded future is nil and throw a more meaningful exception
 
@@ -147,10 +148,13 @@ type
 
   FutureVar*[T] = distinct Future[T]
 
+  FutureError* = object of Exception
+    cause*: FutureBase
+
 {.deprecated: [PFutureBase: FutureBase, PFuture: Future].}
 
-
-var currentID = 0
+when not defined(release):
+  var currentID = 0
 proc newFuture*[T](fromProc: string = "unspecified"): Future[T] =
   ## Creates a new future.
   ##
@@ -178,17 +182,25 @@ proc clean*[T](future: FutureVar[T]) =
   Future[T](future).error = nil
 
 proc checkFinished[T](future: Future[T]) =
+  ## Checks whether `future` is finished. If it is then raises a
+  ## ``FutureError``.
   when not defined(release):
     if future.finished:
-      echo("<-----> ", future.id, " ", future.fromProc)
-      echo(future.stackTrace)
-      echo("-----")
+      var msg = ""
+      msg.add("An attempt was made to complete a Future more than once. ")
+      msg.add("Details:")
+      msg.add("\n  Future ID: " & $future.id)
+      msg.add("\n  Created in proc: " & future.fromProc)
+      msg.add("\n  Stack trace to moment of creation:")
+      msg.add("\n" & indent(future.stackTrace.strip(), 4))
       when T is string:
-        echo("Contents: ", future.value.repr)
-      echo("<----->")
-      echo("Future already finished, cannot finish twice.")
-      echo getStackTrace()
-      assert false
+        msg.add("\n  Contents (string): ")
+        msg.add("\n" & indent(future.value.repr, 4))
+      msg.add("\n  Stack trace to moment of secondary completion:")
+      msg.add("\n" & indent(getStackTrace().strip(), 4))
+      var err = newException(FutureError, msg)
+      err.cause = future
+      raise err
 
 proc complete*[T](future: Future[T], val: T) =
   ## Completes ``future`` with value ``val``.
@@ -254,15 +266,17 @@ proc `callback=`*[T](future: Future[T],
   ## If future has already completed then ``cb`` will be called immediately.
   future.callback = proc () = cb(future)
 
-proc echoOriginalStackTrace[T](future: Future[T]) =
+proc injectStacktrace[T](future: Future[T]) =
   # TODO: Come up with something better.
   when not defined(release):
-    echo("Original stack trace in ", future.fromProc, ":")
+    var msg = ""
+    msg.add("\n  " & future.fromProc & "'s lead up to read of failed Future:")
+
     if not future.errorStackTrace.isNil and future.errorStackTrace != "":
-      echo(future.errorStackTrace)
+      msg.add("\n" & indent(future.errorStackTrace.strip(), 4))
     else:
-      echo("Empty or nil stack trace.")
-    echo("Continuing...")
+      msg.add("\n    Empty or nil stack trace.")
+    future.error.msg.add(msg)
 
 proc read*[T](future: Future[T]): T =
   ## Retrieves the value of ``future``. Future must be finished otherwise
@@ -271,7 +285,7 @@ proc read*[T](future: Future[T]): T =
   ## If the result of the future is an error then that error will be raised.
   if future.finished:
     if future.error != nil:
-      echoOriginalStackTrace(future)
+      injectStacktrace(future)
       raise future.error
     when T isnot void:
       return future.value
@@ -313,7 +327,7 @@ proc asyncCheck*[T](future: Future[T]) =
   future.callback =
     proc () =
       if future.failed:
-        echoOriginalStackTrace(future)
+        injectStacktrace(future)
         raise future.error
 
 proc `and`*[T, Y](fut1: Future[T], fut2: Future[Y]): Future[void] =
diff --git a/tests/async/tasyncconnect.nim b/tests/async/tasyncconnect.nim
index bc63b8e82..753af9006 100644
--- a/tests/async/tasyncconnect.nim
+++ b/tests/async/tasyncconnect.nim
@@ -15,7 +15,8 @@ const
 
 
 when defined(windows) or defined(nimdoc):
-    discard
+    # TODO: just make it work on Windows for now.
+    quit("Error: unhandled exception: Connection refused [Exception]")
 else:
     proc testAsyncConnect() {.async.} =
         var s = newAsyncRawSocket()
diff --git a/tests/async/tasynceverror.nim b/tests/async/tasynceverror.nim
index 5575cfe82..44c4bdee7 100644
--- a/tests/async/tasynceverror.nim
+++ b/tests/async/tasynceverror.nim
@@ -17,7 +17,8 @@ const
 
 
 when defined(windows) or defined(nimdoc):
-    discard
+    # TODO: just make it work on Windows for now.
+    quit("Error: unhandled exception: Connection reset by peer [Exception]")
 else:
     proc createListenSocket(host: string, port: Port): TAsyncFD =
         result = newAsyncRawSocket()
diff --git a/tests/async/tasyncexceptions.nim b/tests/async/tasyncexceptions.nim
index c4379f7d8..aab08e30f 100644
--- a/tests/async/tasyncexceptions.nim
+++ b/tests/async/tasyncexceptions.nim
@@ -1,7 +1,7 @@
 discard """
   file: "tasyncexceptions.nim"
   exitcode: 1
-  outputsub: "Error: unhandled exception: foobar [Exception]"
+  outputsub: "Error: unhandled exception: foobar"
 """
 import asyncdispatch
 

From ac6b21a018cc5873a8ec5011bbc0068989e12259 Mon Sep 17 00:00:00 2001
From: Dominik Picheta <dominikpicheta@googlemail.com>
Date: Fri, 11 Sep 2015 17:09:13 +0100
Subject: [PATCH 08/16] Fixes failing async tests on Linux.

---
 tests/async/tasyncconnect.nim | 4 ++--
 tests/async/tasynceverror.nim | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/async/tasyncconnect.nim b/tests/async/tasyncconnect.nim
index 753af9006..b27a810b8 100644
--- a/tests/async/tasyncconnect.nim
+++ b/tests/async/tasyncconnect.nim
@@ -1,7 +1,7 @@
 discard """
   file: "tasyncconnect.nim"
   exitcode: 1
-  outputsub: "Error: unhandled exception: Connection refused [Exception]"
+  outputsub: "Error: unhandled exception: Connection refused"
 """
 
 import
@@ -16,7 +16,7 @@ const
 
 when defined(windows) or defined(nimdoc):
     # TODO: just make it work on Windows for now.
-    quit("Error: unhandled exception: Connection refused [Exception]")
+    quit("Error: unhandled exception: Connection refused")
 else:
     proc testAsyncConnect() {.async.} =
         var s = newAsyncRawSocket()
diff --git a/tests/async/tasynceverror.nim b/tests/async/tasynceverror.nim
index 44c4bdee7..2f570344f 100644
--- a/tests/async/tasynceverror.nim
+++ b/tests/async/tasynceverror.nim
@@ -1,7 +1,7 @@
 discard """
   file: "tasynceverror.nim"
   exitcode: 1
-  outputsub: "Error: unhandled exception: Connection reset by peer [Exception]"
+  outputsub: "Error: unhandled exception: Connection reset by peer"
 """
 
 import
@@ -18,7 +18,7 @@ const
 
 when defined(windows) or defined(nimdoc):
     # TODO: just make it work on Windows for now.
-    quit("Error: unhandled exception: Connection reset by peer [Exception]")
+    quit("Error: unhandled exception: Connection reset by peer")
 else:
     proc createListenSocket(host: string, port: Port): TAsyncFD =
         result = newAsyncRawSocket()

From 3959a59e57d43a41b5ff6929875d53c46fd8f78a Mon Sep 17 00:00:00 2001
From: Araq <rumpf_a@web.de>
Date: Thu, 10 Sep 2015 13:18:11 +0200
Subject: [PATCH 09/16] documented void context

---
 doc/manual/stmts.txt | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/doc/manual/stmts.txt b/doc/manual/stmts.txt
index 062c08d7c..a833d7b7d 100644
--- a/doc/manual/stmts.txt
+++ b/doc/manual/stmts.txt
@@ -60,6 +60,24 @@ An empty ``discard`` statement is often used as a null statement:
     else: discard
 
 
+Void context
+------------
+
+In a list of statements every expression except the last one needs to have the
+type ``void``. In addition to this rule an assignment to the builtin ``result``
+symbol also triggers a ``void`` context:
+
+.. code-block:: nim
+  proc invalid*(): string =
+    result = "foo"
+    "invalid"  # Error: value of type 'string' has to be discarded
+
+.. code-block:: nim
+  proc valid*(): string =
+    let x = 317
+    "valid"
+
+
 Var statement
 -------------
 

From a878550ad1b09b104a994f303f7e54e56f205527 Mon Sep 17 00:00:00 2001
From: Araq <rumpf_a@web.de>
Date: Thu, 10 Sep 2015 13:19:13 +0200
Subject: [PATCH 10/16] minor testsuite cleanup

---
 tests/misc/tvarious1.nim       | 2 +-
 tests/parser/tstrongspaces.nim | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/misc/tvarious1.nim b/tests/misc/tvarious1.nim
index 9d7cf6584..1d5ad876a 100644
--- a/tests/misc/tvarious1.nim
+++ b/tests/misc/tvarious1.nim
@@ -22,7 +22,7 @@ import queues
 
 type
   TWidget = object
-    names: TQueue[string]
+    names: Queue[string]
 
 var w = TWidget(names: initQueue[string]())
 
diff --git a/tests/parser/tstrongspaces.nim b/tests/parser/tstrongspaces.nim
index e70b91988..cb0219976 100644
--- a/tests/parser/tstrongspaces.nim
+++ b/tests/parser/tstrongspaces.nim
@@ -1,4 +1,4 @@
-#! strongSpaces
+#? strongSpaces
 
 discard """
   output: '''35

From afc891de6524844521a86b6568378bc19ef8dead Mon Sep 17 00:00:00 2001
From: Araq <rumpf_a@web.de>
Date: Thu, 10 Sep 2015 13:20:15 +0200
Subject: [PATCH 11/16] fixes #1528

---
 compiler/semstmts.nim          |  2 +-
 compiler/semtempl.nim          | 25 +------------------------
 tests/discard/tvoidcontext.nim | 12 ++++++++++++
 3 files changed, 14 insertions(+), 25 deletions(-)
 create mode 100644 tests/discard/tvoidcontext.nim

diff --git a/compiler/semstmts.nim b/compiler/semstmts.nim
index ffda6a1bb..4399c0ab0 100644
--- a/compiler/semstmts.nim
+++ b/compiler/semstmts.nim
@@ -1425,7 +1425,7 @@ proc semStmtList(c: PContext, n: PNode, flags: TExprFlags): PNode =
             localError(result.info, "type class predicate failed")
         of tyUnknown: continue
         else: discard
-      if n.sons[i].typ == enforceVoidContext or usesResult(n.sons[i]):
+      if n.sons[i].typ == enforceVoidContext: #or usesResult(n.sons[i]):
         voidContext = true
         n.typ = enforceVoidContext
       if i == last and (length == 1 or efWantValue in flags):
diff --git a/compiler/semtempl.nim b/compiler/semtempl.nim
index 4d1eae48f..84ba49e0c 100644
--- a/compiler/semtempl.nim
+++ b/compiler/semtempl.nim
@@ -471,27 +471,6 @@ proc semTemplBodyDirty(c: var TemplCtx, n: PNode): PNode =
     for i in countup(0, sonsLen(n) - 1):
       result.sons[i] = semTemplBodyDirty(c, n.sons[i])
 
-proc transformToExpr(n: PNode): PNode =
-  var realStmt: int
-  result = n
-  case n.kind
-  of nkStmtList:
-    realStmt = - 1
-    for i in countup(0, sonsLen(n) - 1):
-      case n.sons[i].kind
-      of nkCommentStmt, nkEmpty, nkNilLit:
-        discard
-      else:
-        if realStmt == - 1: realStmt = i
-        else: realStmt = - 2
-    if realStmt >= 0: result = transformToExpr(n.sons[realStmt])
-    else: n.kind = nkStmtListExpr
-  of nkBlockStmt:
-    n.kind = nkBlockExpr
-    #nkIfStmt: n.kind = nkIfExpr // this is not correct!
-  else:
-    discard
-
 proc semTemplateDef(c: PContext, n: PNode): PNode =
   var s: PSym
   if isTopLevel(c):
@@ -549,9 +528,7 @@ proc semTemplateDef(c: PContext, n: PNode): PNode =
     n.sons[bodyPos] = semTemplBodyDirty(ctx, n.sons[bodyPos])
   else:
     n.sons[bodyPos] = semTemplBody(ctx, n.sons[bodyPos])
-  if s.typ.sons[0].kind notin {tyStmt, tyTypeDesc}:
-    n.sons[bodyPos] = transformToExpr(n.sons[bodyPos])
-    # only parameters are resolved, no type checking is performed
+  # only parameters are resolved, no type checking is performed
   semIdeForTemplateOrGeneric(c, n.sons[bodyPos], ctx.cursorInBody)
   closeScope(c)
   popOwner()
diff --git a/tests/discard/tvoidcontext.nim b/tests/discard/tvoidcontext.nim
new file mode 100644
index 000000000..c3ea68bae
--- /dev/null
+++ b/tests/discard/tvoidcontext.nim
@@ -0,0 +1,12 @@
+discard """
+  errormsg: "value of type 'string' has to be discarded"
+  line: 12
+"""
+
+proc valid*(): string =
+  let x = 317
+  "valid"
+
+proc invalid*(): string =
+  result = "foo"
+  "invalid"

From 1562f74500f50ed2eb9a6f114ef1aa65d6d3962b Mon Sep 17 00:00:00 2001
From: Araq <rumpf_a@web.de>
Date: Thu, 10 Sep 2015 15:57:57 +0200
Subject: [PATCH 12/16] implicit return types for iterators are now deprecated

---
 compiler/semtypes.nim | 1 +
 todo.txt              | 1 -
 web/news.txt          | 2 ++
 3 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/compiler/semtypes.nim b/compiler/semtypes.nim
index 5ae3d16c0..2ee17fcaf 100644
--- a/compiler/semtypes.nim
+++ b/compiler/semtypes.nim
@@ -970,6 +970,7 @@ proc semProcTypeNode(c: PContext, n, genericParams: PNode,
   elif kind == skIterator:
     # XXX This is special magic we should likely get rid of
     r = newTypeS(tyExpr, c)
+    message(n.info, warnDeprecated, "implicit return type for 'iterator'")
 
   if r != nil:
     # turn explicit 'void' return type into 'nil' because the rest of the
diff --git a/todo.txt b/todo.txt
index c645f45e9..91c6f1625 100644
--- a/todo.txt
+++ b/todo.txt
@@ -23,7 +23,6 @@ version 1.0
 - nimsuggest: auto-completion needs to work in 'class' macros
 - The bitwise 'not' operator will be renamed to 'bnot' to
   prevent 'not 4 == 5' from compiling. -> requires 'mixin' annotation for procs!
-- iterators always require a return type
 - split docgen into separate tool
 - special rule for ``[]=``, items, pairs
 - BUG: echo with template `$`*(info: TLineInfo): expr = toFileLineCol(info)
diff --git a/web/news.txt b/web/news.txt
index aaf3c9385..c786d7d5a 100644
--- a/web/news.txt
+++ b/web/news.txt
@@ -73,6 +73,8 @@ News
     multi methods less error-prone to use with the effect system.
   - Nim's parser directive ``#!`` is now ``#?`` in order to produce no conflicts
     with Unix's ``#!``.
+  - An implicit return type for an iterator is now deprecated. Use ``auto`` if
+    you want more type inference.
 
 
   Library Additions

From 565c385824d6c47fd86ec2213f2bf7cd3f065d84 Mon Sep 17 00:00:00 2001
From: Araq <rumpf_a@web.de>
Date: Thu, 10 Sep 2015 16:06:09 +0200
Subject: [PATCH 13/16] config cleanup

---
 config/nim.cfg | 14 ++------------
 1 file changed, 2 insertions(+), 12 deletions(-)

diff --git a/config/nim.cfg b/config/nim.cfg
index 56bfbc64d..bf78c35cc 100644
--- a/config/nim.cfg
+++ b/config/nim.cfg
@@ -27,28 +27,18 @@ mips.linux.gcc.linkerexe = "mips-openwrt-linux-gcc"
   cs:partial
 @end
 
-path="$lib/core"
-
-path="$lib/pure"
 path="$lib/pure/collections"
 path="$lib/pure/concurrency"
 path="$lib/impure"
 path="$lib/wrappers"
-# path="$lib/wrappers/cairo"
-# path="$lib/wrappers/gtk"
-# path="$lib/wrappers/lua"
-# path="$lib/wrappers/opengl"
-path="$lib/wrappers/pcre"
 path="$lib/wrappers/linenoise"
-path="$lib/wrappers/sdl"
-# path="$lib/wrappers/x11"
-path="$lib/wrappers/zip"
-path="$lib/wrappers/libffi"
 path="$lib/windows"
 path="$lib/posix"
 path="$lib/js"
 path="$lib/pure/unidecode"
 path="$lib/arch"
+path="$lib/core"
+path="$lib/pure"
 
 @if nimbabel:
   nimblepath="$home/.nimble/pkgs/"

From 5aaf2f0c31d45fbd2d4e007f93355faae80dd7d9 Mon Sep 17 00:00:00 2001
From: Araq <rumpf_a@web.de>
Date: Sat, 12 Sep 2015 10:51:20 +0200
Subject: [PATCH 14/16] preparations for better handling of 'a[i]' in generics;
 stmt lists can be lvalues

---
 compiler/ast.nim           | 10 +++++++++-
 compiler/parampatterns.nim |  5 ++++-
 2 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/compiler/ast.nim b/compiler/ast.nim
index 7b6f39cbc..860bf67e8 100644
--- a/compiler/ast.nim
+++ b/compiler/ast.nim
@@ -537,7 +537,7 @@ const
 type
   TMagic* = enum # symbols that require compiler magic:
     mNone,
-    mDefined, mDefinedInScope, mCompiles,
+    mDefined, mDefinedInScope, mCompiles, mArrGet, mArrPut, mAsgn,
     mLow, mHigh, mSizeOf, mTypeTrait, mIs, mOf, mAddr, mTypeOf, mRoof, mPlugin,
     mEcho, mShallowCopy, mSlurp, mStaticExec,
     mParseExprToAst, mParseStmtToAst, mExpandToAst, mQuoteAst,
@@ -614,6 +614,7 @@ const
   ctfeWhitelist* = {mNone, mUnaryLt, mSucc,
     mPred, mInc, mDec, mOrd, mLengthOpenArray,
     mLengthStr, mLengthArray, mLengthSeq, mXLenStr, mXLenSeq,
+    mArrGet, mArrPut, mAsgn,
     mIncl, mExcl, mCard, mChr,
     mAddI, mSubI, mMulI, mDivI, mModI,
     mAddF64, mSubF64, mMulF64, mDivF64,
@@ -1586,3 +1587,10 @@ proc createMagic*(name: string, m: TMagic): PSym =
 let
   opNot* = createMagic("not", mNot)
   opContains* = createMagic("contains", mInSet)
+
+when false:
+  proc containsNil*(n: PNode): bool =
+    # only for debugging
+    if n.isNil: return true
+    for i in 0 ..< n.safeLen:
+      if n[i].containsNil: return true
diff --git a/compiler/parampatterns.nim b/compiler/parampatterns.nim
index ae391945a..978583c14 100644
--- a/compiler/parampatterns.nim
+++ b/compiler/parampatterns.nim
@@ -225,8 +225,11 @@ proc isAssignable*(owner: PSym, n: PNode; isUnsafeAddr=false): TAssignableResult
     result = isAssignable(owner, n.sons[0], isUnsafeAddr)
   of nkCallKinds:
     # builtin slice keeps lvalue-ness:
-    if getMagic(n) == mSlice:
+    if getMagic(n) in {mArrGet, mSlice}:
       result = isAssignable(owner, n.sons[1], isUnsafeAddr)
+  of nkStmtList, nkStmtListExpr:
+    if n.typ != nil:
+      result = isAssignable(owner, n.lastSon, isUnsafeAddr)
   else:
     discard
 

From bf698fbc2ab3ec3f1698261bbe4ddb897dc47f95 Mon Sep 17 00:00:00 2001
From: Araq <rumpf_a@web.de>
Date: Sat, 12 Sep 2015 13:32:51 +0200
Subject: [PATCH 15/16] fixes some regressions

---
 compiler/semtempl.nim          | 11 +++++++++++
 compiler/vm.nim                |  2 ++
 tests/bind/tbind2.nim          |  2 +-
 tests/template/twrongmapit.nim |  8 ++++----
 4 files changed, 18 insertions(+), 5 deletions(-)

diff --git a/compiler/semtempl.nim b/compiler/semtempl.nim
index 84ba49e0c..371abe1e3 100644
--- a/compiler/semtempl.nim
+++ b/compiler/semtempl.nim
@@ -581,6 +581,11 @@ proc semPatternBody(c: var TemplCtx, n: PNode): PNode =
       localError(n.info, errInvalidExpression)
       result = n
 
+  proc stupidStmtListExpr(n: PNode): bool =
+    for i in 0 .. n.len-2:
+      if n[i].kind notin {nkEmpty, nkCommentStmt}: return false
+    result = true
+
   result = n
   case n.kind
   of nkIdent:
@@ -606,6 +611,12 @@ proc semPatternBody(c: var TemplCtx, n: PNode): PNode =
         localError(n.info, errInvalidExpression)
     else:
       localError(n.info, errInvalidExpression)
+  of nkStmtList, nkStmtListExpr:
+    if stupidStmtListExpr(n):
+      result = semPatternBody(c, n.lastSon)
+    else:
+      for i in countup(0, sonsLen(n) - 1):
+        result.sons[i] = semPatternBody(c, n.sons[i])
   of nkCallKinds:
     let s = qualifiedLookUp(c.c, n.sons[0], {})
     if s != nil:
diff --git a/compiler/vm.nim b/compiler/vm.nim
index 05d00c19f..0db287c6a 100644
--- a/compiler/vm.nim
+++ b/compiler/vm.nim
@@ -1461,6 +1461,8 @@ proc evalConstExprAux(module, prc: PSym, n: PNode, mode: TEvalMode): PNode =
   let n = transformExpr(module, n)
   setupGlobalCtx(module)
   var c = globalCtx
+  let oldMode = c.mode
+  defer: c.mode = oldMode
   c.mode = mode
   let start = genExpr(c, n, requiresValue = mode!=emStaticStmt)
   if c.code[start].opcode == opcEof: return emptyNode
diff --git a/tests/bind/tbind2.nim b/tests/bind/tbind2.nim
index d2219765d..0e0cbd788 100644
--- a/tests/bind/tbind2.nim
+++ b/tests/bind/tbind2.nim
@@ -1,6 +1,6 @@
 discard """
   file: "tbind2.nim"
-  line: 14
+  line: 12
   errormsg: "ambiguous call"
 """
 # Test the new ``bind`` keyword for templates
diff --git a/tests/template/twrongmapit.nim b/tests/template/twrongmapit.nim
index bca1292b8..0a6d694f6 100644
--- a/tests/template/twrongmapit.nim
+++ b/tests/template/twrongmapit.nim
@@ -1,7 +1,5 @@
 discard """
-  errormsg: "'"
-  file: "sequtils.nim"
-  line: 435
+  output: "####"
 """
 # unfortunately our tester doesn't support multiple lines of compiler
 # error messages yet...
@@ -29,4 +27,6 @@ when ATTEMPT == 0:
 # bug #1543
 import sequtils
 
-(var i= @[""];i).mapIt(it)
+(var i = @[""];i).mapIt(it)
+# now works:
+echo "##", i[0], "##"

From c27019f4d9db52f6e3922ac3d222d2b6e3b73fb2 Mon Sep 17 00:00:00 2001
From: Araq <rumpf_a@web.de>
Date: Sat, 12 Sep 2015 19:40:08 +0200
Subject: [PATCH 16/16] fixes generic instantations in concepts

---
 compiler/seminst.nim | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/compiler/seminst.nim b/compiler/seminst.nim
index 370990326..42a39d0df 100644
--- a/compiler/seminst.nim
+++ b/compiler/seminst.nim
@@ -221,6 +221,8 @@ proc generateInstance(c: PContext, fn: PSym, pt: TIdTable,
   # NOTE: for access of private fields within generics from a different module
   # we set the friend module:
   c.friendModules.add(getModule(fn))
+  let oldInTypeClass = c.inTypeClass
+  c.inTypeClass = 0
   let oldScope = c.currentScope
   while not isTopLevel(c): c.currentScope = c.currentScope.parent
   result = copySym(fn, false)
@@ -269,4 +271,5 @@ proc generateInstance(c: PContext, fn: PSym, pt: TIdTable,
   c.currentScope = oldScope
   discard c.friendModules.pop()
   dec(c.instCounter)
+  c.inTypeClass = oldInTypeClass
   if result.kind == skMethod: finishMethod(c, result)