enable closures (#1185)

Author: Araq

src/hexer/constparams.nim

@@ -208,22 +208,25 @@ proc trCall(c: var Context; dest: var TokenBuf; n: var Cursor; targetExpectsTupl
   inc fnType
   while n.kind != ParRi:
     let previousFormalParam = fnType
-    assert fnType.kind == ParLe
-    let param = takeLocal(fnType, SkipFinalParRi)
-    let pk = param.typ.typeKind
-    if pk in {MutT, OutT, LentT}:
-      tr c, dest, n
-    elif pk == VarargsT:
-      # do not advance formal parameter:
-      fnType = previousFormalParam
-      tr c, dest, n
-    elif passByConstRef(c, param.typ, param.pragmas):
-      trConstRef c, dest, n
-    elif pk in {TypedescT, StaticT}:
-      # do not produce any code for this as it's a compile-time value:
-      skip n
+    if fnType.kind == ParRi:
+      tr c, dest, n # can happen for closure parameter
     else:
-      tr c, dest, n
+      assert fnType.kind == ParLe
+      let param = takeLocal(fnType, SkipFinalParRi)
+      let pk = param.typ.typeKind
+      if pk in {MutT, OutT, LentT}:
+        tr c, dest, n
+      elif pk == VarargsT:
+        # do not advance formal parameter:
+        fnType = previousFormalParam
+        tr c, dest, n
+      elif passByConstRef(c, param.typ, param.pragmas):
+        trConstRef c, dest, n
+      elif pk in {TypedescT, StaticT}:
+        # do not produce any code for this as it's a compile-time value:
+        skip n
+      else:
+        tr c, dest, n
   takeParRi dest, n
   if needsTuple:
     dest.addParRi() # TupconstrX

src/hexer/duplifier.nim

@@ -613,14 +613,17 @@ proc trCall(c: var Context; n: var Cursor; e: Expects) =
   inc fnType
   while n.kind != ParRi:
     let previousFormalParam = fnType
-    let param = takeLocal(fnType, SkipFinalParRi)
-    let pk = param.typ.typeKind
     var e2 = WantNonOwner
-    if pk == SinkT:
-      e2 = WantOwner
-    elif pk == VarargsT:
-      # do not advance formal parameter:
-      fnType = previousFormalParam
+    if fnType.kind == ParRi:
+      discard "this can happen for closure parameters"
+    else:
+      let param = takeLocal(fnType, SkipFinalParRi)
+      let pk = param.typ.typeKind
+      if pk == SinkT:
+        e2 = WantOwner
+      elif pk == VarargsT:
+        # do not advance formal parameter:
+        fnType = previousFormalParam
     tr c, n, e2
   takeParRi c.dest, n
   finishOwningTemp c.dest, ow

src/hexer/lambdalifting.nim

@@ -82,8 +82,18 @@ proc trLocal(c: var Context; dest: var TokenBuf; n: var Cursor) =
 proc trProc(c: var Context; dest: var TokenBuf; n: var Cursor) =
   c.typeCache.openScope(ProcScope)
   copyInto dest, n:
-    c.procStack.add(n.symId)
-    let isConcrete = c.typeCache.takeRoutineHeader(dest, n)
+    let symId = n.symId
+    c.procStack.add(symId)
+    var isConcrete = true # assume it is concrete
+    for i in 0..<BodyPos:
+      if i == ParamsPos:
+        c.typeCache.registerParams(symId, n)
+      elif i == TypeVarsPos:
+        isConcrete = n.substructureKind != TypevarsU
+      elif i == ProcPragmasPos:
+        if hasPragma(n, ClosureP):
+          c.closureProcs.incl symId
+      takeTree dest, n
     if isConcrete:
       tr(c, dest, n)
     else:
@@ -314,6 +324,16 @@ proc treProcBody(c: var Context; dest, init: var TokenBuf; n: var Cursor; sym: S
           dest.copyIntoKind NewobjX, NoLineInfo:
             dest.copyIntoKind RefT, NoLineInfo:
               dest.addSymUse c.env.typ, NoLineInfo
+        # init the environment via the `=wasMoved` hooks:
+        for _, field in c.localToEnv:
+          if field.objType == c.env.typ:
+            dest.copyIntoKind WasmovedX, NoLineInfo:
+              dest.copyIntoKind HaddrX, NoLineInfo:
+                dest.copyIntoKind DotX, NoLineInfo:
+                  dest.copyIntoKind DerefX, NoLineInfo:
+                    dest.addSymUse c.env.s, NoLineInfo
+                  dest.addSymUse field.field, NoLineInfo
+
       elif c.closureProcs.contains(sym):
         c.env = CurrentEnv(s: pool.syms.getOrIncl(EnvParamName), mode: EnvIsParam, typ: c.envTypeForProc(sym))
       else:
@@ -398,8 +418,13 @@ proc genCall(c: var Context; dest: var TokenBuf; n: var Cursor) =
     tre(c, dest, n)
   if wantsEnv:
     if isStatic:
-      # use the current environment as the last parameter:
-      untypedEnv dest, info, c.env
+      if c.env.s != SymId(0):
+        # use the current environment as the last parameter:
+        untypedEnv dest, info, c.env
+      else:
+        # can happen for toplevel closures that have been declared .closure for interop
+        # We have no environment here, so pass `nil` instead:
+        dest.copyIntoKind NilX, info: discard
     else:
       # unpack the tuple:
       assert tmp != SymId(0)

src/nimony/derefs.nim

@@ -714,7 +714,7 @@ proc trFor(c: var Context; n: var Cursor) =
 proc tr(c: var Context; n: var Cursor; e: Expects) =
   case n.kind
   of Symbol:
-    when true:
+    when false:
       # Closures are now implemented
       let localInfo = c.typeCache.getLocalInfo(n.symId)
       if localInfo.crossedProc > 0 and localInfo.kind in {VarY, LetY, ParamY, ResultY}:

src/nimony/sigmatch.nim

@@ -597,12 +597,12 @@ proc linearMatch(m: var Match; f, a: var Cursor; flags: set[LinearMatchFlag] = {
   skip a
 
 type
-  ProcProperties = object
-    cc: CallConv
-    usesRaises: bool
-    usesClosure: bool
+  ProcProperties* = object
+    cc*: CallConv
+    usesRaises*: bool
+    usesClosure*: bool
 
-proc extractCallConv(c: var Cursor): ProcProperties =
+proc extractProcProps*(c: var Cursor): ProcProperties =
   result = ProcProperties(cc: Fastcall, usesRaises: false, usesClosure: false)
   if c.substructureKind == PragmasU:
     inc c
@@ -672,8 +672,8 @@ proc procTypeMatch(m: var Match; f, a: var Cursor) =
   else:
     linearMatch m, f, a
   # match calling conventions:
-  let fcc = extractCallConv(f)
-  let acc = extractCallConv(a)
+  let fcc = extractProcProps(f)
+  let acc = extractProcProps(a)
   if fcc.cc != acc.cc:
     m.error CallConvMismatch, f, a
   elif fcc.usesRaises != acc.usesRaises:

src/nimony/vtables_frontend.nim

@@ -12,8 +12,8 @@
 
 include nifprelude
 import nifindexes, symparser, treemangler, typekeys
-import ".." / nimony / [nimony_model, decls, programs, typenav,
-  renderer, typeprops]
+import nimony_model, decls, programs, typenav,
+  renderer, typeprops, sigmatch
 
 when false:
   # maybe we can use this later to provide better error messages
@@ -40,28 +40,6 @@ when false:
     else:
       return false
 
-proc processPragmas(n: Cursor): (CallConv, string) =
-  var n = n
-  result = (NoCallConv, "0")
-  if n.substructureKind == PragmasU:
-    inc n
-    while n.kind != ParRi:
-      let pk = pragmaKind(n)
-      case pk
-      of NoPragma:
-        let cc = callConvKind(n)
-        if cc != NoCallConv:
-          result[0] = cc
-          skip n
-        else:
-          # it may be a `kv`
-          skip n
-      of RaisesP:
-        result[1] = "1"
-        skip n
-      else:
-        skip n
-
 proc methodKey*(name: string; a: Cursor): string =
   # First parameter was the class type and has already been skipped here!
   var a = a
@@ -73,5 +51,9 @@ proc methodKey*(name: string; a: Cursor): string =
   # also add return type:
   mangle b, a, Frontend
   skip a
-  let (callConv, hasRaises) = processPragmas(a)
-  result = name & ":" & b.extract() & ":" & $callConv & ":" & hasRaises
+  # handle pragmas:
+  let props = extractProcProps(a)
+  b.addKeyw $props.cc
+  b.addKeyw $props.usesRaises
+  b.addKeyw $props.usesClosure
+  result = name & ":" & b.extract()