Invalid `expected type, but got: Raising(Future[void], E)` on macro returning type (regression from 1.6)

[arnetheduck]

Description

import std/[sequtils, macros]

type
  Future[T] = object
  InternalRaisesFuture[T, E] = object

macro Raising*[T](F: typedesc[Future[T]], E: varargs[typedesc]): untyped =
  ## Given a Future type instance, return a type storing `{.raises.}`
  ## information
  ##
  ## Note; this type may change in the future
  E.expectKind(nnkBracket)

  let raises = nnkTupleConstr.newTree(E.mapIt(it))
  nnkBracketExpr.newTree(
    ident "InternalRaisesFuture",
    nnkDotExpr.newTree(F, ident"T"),
    raises
  )

type X[E] = Future[void].Raising(E)

proc f(x: X) = discard


var v: Future[void].Raising([ValueError])
f(v)

Nim Version

works in 1.6, broken in 2.0, devel

Current Output

testit.nim(21, 25) Error: expected type, but got: Raising(Future[void], E)

Expected Output

No response

Possible Solution

No response

Additional Information

No response

[metagn]

Changing varargs[typedesc] to varargs[untyped] (and expecting nnkArgList and not nnkBracket) works, E probably doesn't match typedesc and something goes wrong trying to delay the macro evaluation. This is new behavior in 2.0, previously generic parameters matched every type including typedesc.

You probably don't want the macro evaluation delayed anyway because then we would have to explicitly instantiate X every time since we don't know anything about its structure to match it to anything. The error message is still weird.

This also works without the last 2 lines in the example which forces the delayed macro evaluation because of #23406:

type X[E] = Raising(Future[void], E)

But then actually calling f fails because delaying is bad, this also gives a worse error message.

The reason we don't want unresolved generic parameters to match typedesc is because of stuff like:

proc foo(x: typedesc): int =
  sizeof(x)

[arnetheduck]

My expectation would have been that varargs[typedesc] would give a better error message if one does something like ...Raising([42]), a situation we want to avoid.

Btw, like so?

import std/[sequtils, macros]

type
  Future[T] = object
  InternalRaisesFuture[T, E] = object

macro Raising2*[T](F: typedesc[Future[T]], E: varargs[untyped]): untyped =
  E.expectKind(nnkArgList)

  let raises = nnkTupleConstr.newTree(E.mapIt(it))
  nnkBracketExpr.newTree(
    ident "InternalRaisesFuture",
    nnkDotExpr.newTree(F, ident"T"),
    raises
  )

type Abc = object
  field: Future[void].Raising2([ValueError])

gives:

testit.nim(46, 3) Error: '(array[0..0, typedesc[ValueError]],)' is not a concrete type

[metagn]

testit.nim(46, 3) Error: '(array[0..0, typedesc[ValueError]],)' is not a concrete type

Because of [ValueError], removing the brackets works. Could also unwrap the bracket in the macro.

Also varargs[typed] instead of varargs[untyped] doesn't use nnkArgList but also doesn't unwrap the brackets.

[beef331]

A workaround could be using varargs[typed] and just checking the type of Nodes manually, like so:

import std/[sequtils, macros]

type
  Future[T] = object
  InternalRaisesFuture[T, E] = object

macro Raising*[T](F: typedesc[Future[T]], E: varargs[typed]): untyped =
  ## Given a Future type instance, return a type storing `{.raises.}`
  ## information
  ##
  ## Note; this type may change in the future
  E.expectKind(nnkBracket)
  
  for typ in E:
    if typ.getTypeInst.typeKind != ntyTypeDesc:
      error("Expected typedesc, but got: '" & typ.repr & "'.", typ)

  let raises = nnkTupleConstr.newTree(E.mapIt(it))
  nnkBracketExpr.newTree(
    ident "InternalRaisesFuture",
    nnkDotExpr.newTree(F, ident"T"),
    raises
  )

type X[E] = Future[void].Raising(E)

proc f(x: X) = discard


var v: Future[void].Raising(ValueError, 42)
f(v)

[arnetheduck]

@beef331 thanks for the workaround, the final version ended up looking like this: status-im/nim-chronos#526 - there are some limitations but the outcome is more or less consistent with how it worked in 1.6, at least for the use cases we had already.

Of course, it's sad to have to manually implement a poor version of what the compiler should be doing already better - worth considering in the next round of macro changes ;)

[ringabout]

!nim c

import std/[sequtils, macros]

type
  Future[T] = object
  InternalRaisesFuture[T, E] = object

macro Raising*[T](F: typedesc[Future[T]], E: varargs[typedesc]): untyped =
  ## Given a Future type instance, return a type storing `{.raises.}`
  ## information
  ##
  ## Note; this type may change in the future
  E.expectKind(nnkBracket)

  let raises = nnkTupleConstr.newTree(E.mapIt(it))
  nnkBracketExpr.newTree(
    ident "InternalRaisesFuture",
    nnkDotExpr.newTree(F, ident"T"),
    raises
  )

type X[E] = Future[void].Raising(E)

proc f(x: X) = discard


var v: Future[void].Raising([ValueError])
f(v)

[github-actions]

🐧 Linux bisect by @ringabout (member)

devel 👎 FAIL

Output

Error: Command failed: nim c --run  -d:nimDebug -d:nimDebugDlOpen -d:ssl -d:nimDisableCertificateValidation --forceBuild:on --colors:off --verbosity:0 --hints:off --lineTrace:off --nimcache:/home/runner/work/Nim/Nim --out:/home/runner/work/Nim/Nim/temp /home/runner/work/Nim/Nim/temp.nim
/home/runner/work/Nim/Nim/temp.nim(17, 25) Error: expected type, but got: Raising(Future[void], E)
assertions.nim(34)       raiseAssert
Error: unhandled exception: errGenerated [AssertionDefect]

IR

Compiled filesize 0 bytes (0 bytes)

Stats

• Started 2024-03-25T10:23:34
• Finished 2024-03-25T10:23:34
• Duration

AST

nnkStmtList.newTree(
  nnkImportStmt.newTree(
    nnkInfix.newTree(
      newIdentNode("/"),
      newIdentNode("std"),
      nnkBracket.newTree(
        newIdentNode("sequtils"),
        newIdentNode("macros")
      )
    )
  ),
  nnkTypeSection.newTree(
    nnkTypeDef.newTree(
      newIdentNode("Future"),
      nnkGenericParams.newTree(
        nnkIdentDefs.newTree(
          newIdentNode("T"),
          newEmptyNode(),
          newEmptyNode()
        )
      ),
      nnkObjectTy.newTree(
        newEmptyNode(),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkTypeDef.newTree(
      newIdentNode("InternalRaisesFuture"),
      nnkGenericParams.newTree(
        nnkIdentDefs.newTree(
          newIdentNode("T"),
          newIdentNode("E"),
          newEmptyNode(),
          newEmptyNode()
        )
      ),
      nnkObjectTy.newTree(
        newEmptyNode(),
        newEmptyNode(),
        newEmptyNode()
      )
    )
  ),
  nnkMacroDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("Raising")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      newIdentNode("untyped"),
      nnkIdentDefs.newTree(
        newIdentNode("F"),
        nnkBracketExpr.newTree(
          newIdentNode("typedesc"),
          nnkBracketExpr.newTree(
            newIdentNode("Future"),
            newIdentNode("T")
          )
        ),
        newEmptyNode()
      ),
      nnkIdentDefs.newTree(
        newIdentNode("E"),
        nnkBracketExpr.newTree(
          newIdentNode("varargs"),
          newIdentNode("typedesc")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      newCommentStmtNode("Given a Future type instance, return a type storing `{.raises.}`\ninformation\n\nNote; this type may change in the future"),
      nnkCall.newTree(
        nnkDotExpr.newTree(
          newIdentNode("E"),
          newIdentNode("expectKind")
        ),
        newIdentNode("nnkBracket")
      ),
      nnkLetSection.newTree(
        nnkIdentDefs.newTree(
          newIdentNode("raises"),
          newEmptyNode(),
          nnkCall.newTree(
            nnkDotExpr.newTree(
              newIdentNode("nnkTupleConstr"),
              newIdentNode("newTree")
            ),
            nnkCall.newTree(
              nnkDotExpr.newTree(
                newIdentNode("E"),
                newIdentNode("mapIt")
              ),
              newIdentNode("it")
            )
          )
        )
      ),
      nnkCall.newTree(
        nnkDotExpr.newTree(
          newIdentNode("nnkBracketExpr"),
          newIdentNode("newTree")
        ),
        nnkCommand.newTree(
          newIdentNode("ident"),
          newLit("InternalRaisesFuture")
        ),
        nnkCall.newTree(
          nnkDotExpr.newTree(
            newIdentNode("nnkDotExpr"),
            newIdentNode("newTree")
          ),
          newIdentNode("F"),
          nnkCallStrLit.newTree(
            newIdentNode("ident"),
            newLit("T")
          )
        ),
        newIdentNode("raises")
      )
    )
  ),
  nnkTypeSection.newTree(
    nnkTypeDef.newTree(
      newIdentNode("X"),
      nnkGenericParams.newTree(
        nnkIdentDefs.newTree(
          newIdentNode("E"),
          newEmptyNode(),
          newEmptyNode()
        )
      ),
      nnkCall.newTree(
        nnkDotExpr.newTree(
          nnkBracketExpr.newTree(
            newIdentNode("Future"),
            newIdentNode("void")
          ),
          newIdentNode("Raising")
        ),
        newIdentNode("E")
      )
    )
  ),
  nnkProcDef.newTree(
    newIdentNode("f"),
    newEmptyNode(),
    newEmptyNode(),
    nnkFormalParams.newTree(
      newEmptyNode(),
      nnkIdentDefs.newTree(
        newIdentNode("x"),
        newIdentNode("X"),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkVarSection.newTree(
    nnkIdentDefs.newTree(
      newIdentNode("v"),
      nnkCall.newTree(
        nnkDotExpr.newTree(
          nnkBracketExpr.newTree(
            newIdentNode("Future"),
            newIdentNode("void")
          ),
          newIdentNode("Raising")
        ),
        nnkBracket.newTree(
          newIdentNode("ValueError")
        )
      ),
      newEmptyNode()
    )
  ),
  nnkCall.newTree(
    newIdentNode("f"),
    newIdentNode("v")
  )
)

stable 👎 FAIL

Output

Error: Command failed: nim c --run  -d:nimDebug -d:nimDebugDlOpen -d:ssl -d:nimDisableCertificateValidation --forceBuild:on --colors:off --verbosity:0 --hints:off --lineTrace:off --nimcache:/home/runner/work/Nim/Nim --out:/home/runner/work/Nim/Nim/temp /home/runner/work/Nim/Nim/temp.nim
/home/runner/work/Nim/Nim/temp.nim(17, 25) Error: expected type, but got: Raising(Future[void], E)
assertions.nim(34)       raiseAssert
Error: unhandled exception: options.nim(681, 5) `false` errGenerated [AssertionDefect]

IR

Compiled filesize 0 bytes (0 bytes)

Stats

• Started 2024-03-25T10:23:35
• Finished 2024-03-25T10:23:35
• Duration

AST

nnkStmtList.newTree(
  nnkImportStmt.newTree(
    nnkInfix.newTree(
      newIdentNode("/"),
      newIdentNode("std"),
      nnkBracket.newTree(
        newIdentNode("sequtils"),
        newIdentNode("macros")
      )
    )
  ),
  nnkTypeSection.newTree(
    nnkTypeDef.newTree(
      newIdentNode("Future"),
      nnkGenericParams.newTree(
        nnkIdentDefs.newTree(
          newIdentNode("T"),
          newEmptyNode(),
          newEmptyNode()
        )
      ),
      nnkObjectTy.newTree(
        newEmptyNode(),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkTypeDef.newTree(
      newIdentNode("InternalRaisesFuture"),
      nnkGenericParams.newTree(
        nnkIdentDefs.newTree(
          newIdentNode("T"),
          newIdentNode("E"),
          newEmptyNode(),
          newEmptyNode()
        )
      ),
      nnkObjectTy.newTree(
        newEmptyNode(),
        newEmptyNode(),
        newEmptyNode()
      )
    )
  ),
  nnkMacroDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("Raising")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      newIdentNode("untyped"),
      nnkIdentDefs.newTree(
        newIdentNode("F"),
        nnkBracketExpr.newTree(
          newIdentNode("typedesc"),
          nnkBracketExpr.newTree(
            newIdentNode("Future"),
            newIdentNode("T")
          )
        ),
        newEmptyNode()
      ),
      nnkIdentDefs.newTree(
        newIdentNode("E"),
        nnkBracketExpr.newTree(
          newIdentNode("varargs"),
          newIdentNode("typedesc")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      newCommentStmtNode("Given a Future type instance, return a type storing `{.raises.}`\ninformation\n\nNote; this type may change in the future"),
      nnkCall.newTree(
        nnkDotExpr.newTree(
          newIdentNode("E"),
          newIdentNode("expectKind")
        ),
        newIdentNode("nnkBracket")
      ),
      nnkLetSection.newTree(
        nnkIdentDefs.newTree(
          newIdentNode("raises"),
          newEmptyNode(),
          nnkCall.newTree(
            nnkDotExpr.newTree(
              newIdentNode("nnkTupleConstr"),
              newIdentNode("newTree")
            ),
            nnkCall.newTree(
              nnkDotExpr.newTree(
                newIdentNode("E"),
                newIdentNode("mapIt")
              ),
              newIdentNode("it")
            )
          )
        )
      ),
      nnkCall.newTree(
        nnkDotExpr.newTree(
          newIdentNode("nnkBracketExpr"),
          newIdentNode("newTree")
        ),
        nnkCommand.newTree(
          newIdentNode("ident"),
          newLit("InternalRaisesFuture")
        ),
        nnkCall.newTree(
          nnkDotExpr.newTree(
            newIdentNode("nnkDotExpr"),
            newIdentNode("newTree")
          ),
          newIdentNode("F"),
          nnkCallStrLit.newTree(
            newIdentNode("ident"),
            newLit("T")
          )
        ),
        newIdentNode("raises")
      )
    )
  ),
  nnkTypeSection.newTree(
    nnkTypeDef.newTree(
      newIdentNode("X"),
      nnkGenericParams.newTree(
        nnkIdentDefs.newTree(
          newIdentNode("E"),
          newEmptyNode(),
          newEmptyNode()
        )
      ),
      nnkCall.newTree(
        nnkDotExpr.newTree(
          nnkBracketExpr.newTree(
            newIdentNode("Future"),
            newIdentNode("void")
          ),
          newIdentNode("Raising")
        ),
        newIdentNode("E")
      )
    )
  ),
  nnkProcDef.newTree(
    newIdentNode("f"),
    newEmptyNode(),
    newEmptyNode(),
    nnkFormalParams.newTree(
      newEmptyNode(),
      nnkIdentDefs.newTree(
        newIdentNode("x"),
        newIdentNode("X"),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkVarSection.newTree(
    nnkIdentDefs.newTree(
      newIdentNode("v"),
      nnkCall.newTree(
        nnkDotExpr.newTree(
          nnkBracketExpr.newTree(
            newIdentNode("Future"),
            newIdentNode("void")
          ),
          newIdentNode("Raising")
        ),
        nnkBracket.newTree(
          newIdentNode("ValueError")
        )
      ),
      newEmptyNode()
    )
  ),
  nnkCall.newTree(
    newIdentNode("f"),
    newIdentNode("v")
  )
)

2.0.2 👎 FAIL

Output

Error: Command failed: nim c --run  -d:nimDebug -d:nimDebugDlOpen -d:ssl -d:nimDisableCertificateValidation --forceBuild:on --colors:off --verbosity:0 --hints:off --lineTrace:off --nimcache:/home/runner/work/Nim/Nim --out:/home/runner/work/Nim/Nim/temp /home/runner/work/Nim/Nim/temp.nim
/home/runner/work/Nim/Nim/temp.nim(17, 25) Error: expected type, but got: Raising(Future[void], E)
assertions.nim(34)       raiseAssert
Error: unhandled exception: options.nim(681, 5) `false` errGenerated [AssertionDefect]

IR

Compiled filesize 0 bytes (0 bytes)

Stats

• Started 2024-03-25T10:23:35
• Finished 2024-03-25T10:23:36
• Duration

AST

nnkStmtList.newTree(
  nnkImportStmt.newTree(
    nnkInfix.newTree(
      newIdentNode("/"),
      newIdentNode("std"),
      nnkBracket.newTree(
        newIdentNode("sequtils"),
        newIdentNode("macros")
      )
    )
  ),
  nnkTypeSection.newTree(
    nnkTypeDef.newTree(
      newIdentNode("Future"),
      nnkGenericParams.newTree(
        nnkIdentDefs.newTree(
          newIdentNode("T"),
          newEmptyNode(),
          newEmptyNode()
        )
      ),
      nnkObjectTy.newTree(
        newEmptyNode(),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkTypeDef.newTree(
      newIdentNode("InternalRaisesFuture"),
      nnkGenericParams.newTree(
        nnkIdentDefs.newTree(
          newIdentNode("T"),
          newIdentNode("E"),
          newEmptyNode(),
          newEmptyNode()
        )
      ),
      nnkObjectTy.newTree(
        newEmptyNode(),
        newEmptyNode(),
        newEmptyNode()
      )
    )
  ),
  nnkMacroDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("Raising")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      newIdentNode("untyped"),
      nnkIdentDefs.newTree(
        newIdentNode("F"),
        nnkBracketExpr.newTree(
          newIdentNode("typedesc"),
          nnkBracketExpr.newTree(
            newIdentNode("Future"),
            newIdentNode("T")
          )
        ),
        newEmptyNode()
      ),
      nnkIdentDefs.newTree(
        newIdentNode("E"),
        nnkBracketExpr.newTree(
          newIdentNode("varargs"),
          newIdentNode("typedesc")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      newCommentStmtNode("Given a Future type instance, return a type storing `{.raises.}`\ninformation\n\nNote; this type may change in the future"),
      nnkCall.newTree(
        nnkDotExpr.newTree(
          newIdentNode("E"),
          newIdentNode("expectKind")
        ),
        newIdentNode("nnkBracket")
      ),
      nnkLetSection.newTree(
        nnkIdentDefs.newTree(
          newIdentNode("raises"),
          newEmptyNode(),
          nnkCall.newTree(
            nnkDotExpr.newTree(
              newIdentNode("nnkTupleConstr"),
              newIdentNode("newTree")
            ),
            nnkCall.newTree(
              nnkDotExpr.newTree(
                newIdentNode("E"),
                newIdentNode("mapIt")
              ),
              newIdentNode("it")
            )
          )
        )
      ),
      nnkCall.newTree(
        nnkDotExpr.newTree(
          newIdentNode("nnkBracketExpr"),
          newIdentNode("newTree")
        ),
        nnkCommand.newTree(
          newIdentNode("ident"),
          newLit("InternalRaisesFuture")
        ),
        nnkCall.newTree(
          nnkDotExpr.newTree(
            newIdentNode("nnkDotExpr"),
            newIdentNode("newTree")
          ),
          newIdentNode("F"),
          nnkCallStrLit.newTree(
            newIdentNode("ident"),
            newLit("T")
          )
        ),
        newIdentNode("raises")
      )
    )
  ),
  nnkTypeSection.newTree(
    nnkTypeDef.newTree(
      newIdentNode("X"),
      nnkGenericParams.newTree(
        nnkIdentDefs.newTree(
          newIdentNode("E"),
          newEmptyNode(),
          newEmptyNode()
        )
      ),
      nnkCall.newTree(
        nnkDotExpr.newTree(
          nnkBracketExpr.newTree(
            newIdentNode("Future"),
            newIdentNode("void")
          ),
          newIdentNode("Raising")
        ),
        newIdentNode("E")
      )
    )
  ),
  nnkProcDef.newTree(
    newIdentNode("f"),
    newEmptyNode(),
    newEmptyNode(),
    nnkFormalParams.newTree(
      newEmptyNode(),
      nnkIdentDefs.newTree(
        newIdentNode("x"),
        newIdentNode("X"),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkVarSection.newTree(
    nnkIdentDefs.newTree(
      newIdentNode("v"),
      nnkCall.newTree(
        nnkDotExpr.newTree(
          nnkBracketExpr.newTree(
            newIdentNode("Future"),
            newIdentNode("void")
          ),
          newIdentNode("Raising")
        ),
        nnkBracket.newTree(
          newIdentNode("ValueError")
        )
      ),
      newEmptyNode()
    )
  ),
  nnkCall.newTree(
    newIdentNode("f"),
    newIdentNode("v")
  )
)

1.6.14 👍 OK

Output

IR

Compiled filesize 95.41 Kb (97,696 bytes)

#define NIM_INTBITS 64
#include "nimbase.h"
#  define nimfr_(proc, file) \
 TFrame FR_; \
 FR_.procname = proc; FR_.filename = file; FR_.line = 0; FR_.len = 0; nimFrame(&FR_);
#  define nimfrs_(proc, file, slots, length) \
 struct {TFrame* prev;NCSTRING procname;NI line;NCSTRING filename; NI len; VarSlot s[slots];} FR_; \
 FR_.procname = proc; FR_.filename = file; FR_.line = 0; FR_.len = length; nimFrame((TFrame*)&FR_);
#  define nimln_(n, file) \
 FR_.line = n; FR_.filename = file;
typedef struct tyObject_InternalRaisesFuture__joXl9brPglJfwBVacGXd5yg tyObject_InternalRaisesFuture__joXl9brPglJfwBVacGXd5yg;
struct tyObject_InternalRaisesFuture__joXl9brPglJfwBVacGXd5yg {
char dummy;
};
N_LIB_PRIVATE N_NIMCALL(void, f__temp_76)(tyObject_InternalRaisesFuture__joXl9brPglJfwBVacGXd5yg x);
static N_INLINE(void, nimFrame)(TFrame* s);
N_LIB_PRIVATE N_NOINLINE(void, callDepthLimitReached__system_2997)(void);
static N_INLINE(void, popFrame)(void);
static N_INLINE(void, initStackBottomWith)(void* locals);
N_LIB_PRIVATE N_NOINLINE(void, nimGC_setStackBottom)(void* theStackBottom);
N_LIB_PRIVATE N_NIMCALL(void, atmdotdotatsdotdotatsdotdotatsdotchoosenimatstoolchainsatsnimminus1dot6dot14atslibatssystemdotnim_DatInit000)(void);
N_LIB_PRIVATE N_NIMCALL(void, atmdotdotatsdotdotatsdotdotatsdotchoosenimatstoolchainsatsnimminus1dot6dot14atslibatssystemdotnim_Init000)(void);
N_LIB_PRIVATE N_NIMCALL(void, NimMainModule)(void);
N_LIB_PRIVATE tyObject_InternalRaisesFuture__joXl9brPglJfwBVacGXd5yg v__temp_75;
extern TFrame* framePtr__system_2564;
extern TFrame* framePtr__system_2564;
extern TFrame* framePtr__system_2564;
extern TFrame* framePtr__system_2564;
extern TFrame* framePtr__system_2564;
extern TFrame* framePtr__system_2564;
static N_INLINE(void, nimFrame)(TFrame* s) {
 {
  if (!(framePtr__system_2564 == ((TFrame*) NIM_NIL))) goto LA3_;
  (*s).calldepth = ((NI16) 0);
 }
 goto LA1_;
 LA3_: ;
 {
  (*s).calldepth = (NI16)((*framePtr__system_2564).calldepth + ((NI16) 1));
 }
 LA1_: ;
 (*s).prev = framePtr__system_2564;
 framePtr__system_2564 = s;
 {
  if (!((*s).calldepth == ((NI16) 2000))) goto LA8_;
  callDepthLimitReached__system_2997();
 }
 LA8_: ;
}
static N_INLINE(void, popFrame)(void) {
 framePtr__system_2564 = (*framePtr__system_2564).prev;
}
N_LIB_PRIVATE N_NIMCALL(void, f__temp_76)(tyObject_InternalRaisesFuture__joXl9brPglJfwBVacGXd5yg x) {
 nimfr_("f", "/home/runner/work/Nim/Nim/temp.nim");
 popFrame();
}
static N_INLINE(void, initStackBottomWith)(void* locals) {
 nimGC_setStackBottom(locals);
}
N_LIB_PRIVATE void PreMainInner(void) {
}
 N_LIB_PRIVATE int cmdCount;
 N_LIB_PRIVATE char** cmdLine;
 N_LIB_PRIVATE char** gEnv;
N_LIB_PRIVATE void PreMain(void) {
 void (*volatile inner)(void);
 inner = PreMainInner;
 atmdotdotatsdotdotatsdotdotatsdotchoosenimatstoolchainsatsnimminus1dot6dot14atslibatssystemdotnim_DatInit000();
 initStackBottomWith((void *)&inner);
 atmdotdotatsdotdotatsdotdotatsdotchoosenimatstoolchainsatsnimminus1dot6dot14atslibatssystemdotnim_Init000();
 (*inner)();
}
N_LIB_PRIVATE N_CDECL(void, NimMainInner)(void) {
 NimMainModule();
}
N_CDECL(void, NimMain)(void) {
 void (*volatile inner)(void);
 PreMain();
 inner = NimMainInner;
 initStackBottomWith((void *)&inner);
 (*inner)();
}
int main(int argc, char** args, char** env) {
 cmdLine = args;
 cmdCount = argc;
 gEnv = env;
 NimMain();
 return nim_program_result;
}
N_LIB_PRIVATE N_NIMCALL(void, NimMainModule)(void) {
{
 nimfr_("temp", "/home/runner/work/Nim/Nim/temp.nim");
 f__temp_76(v__temp_75);
 popFrame();
}
}

Stats

• Started 2024-03-25T10:23:38
• Finished 2024-03-25T10:23:39
• Duration

1.4.8 👍 OK

Output

IR

Compiled filesize 91.30 Kb (93,496 bytes)

#define NIM_INTBITS 64
#include "nimbase.h"
#  define nimfr_(proc, file) \
 TFrame FR_; \
 FR_.procname = proc; FR_.filename = file; FR_.line = 0; FR_.len = 0; nimFrame(&FR_);
#  define nimfrs_(proc, file, slots, length) \
 struct {TFrame* prev;NCSTRING procname;NI line;NCSTRING filename; NI len; VarSlot s[slots];} FR_; \
 FR_.procname = proc; FR_.filename = file; FR_.line = 0; FR_.len = length; nimFrame((TFrame*)&FR_);
#  define nimln_(n, file) \
 FR_.line = n; FR_.filename = file;
typedef struct tyObject_InternalRaisesFuture__SoZdjWYx5qf9aGd4M3pBJdg tyObject_InternalRaisesFuture__SoZdjWYx5qf9aGd4M3pBJdg;
struct tyObject_InternalRaisesFuture__SoZdjWYx5qf9aGd4M3pBJdg {
char dummy;
};
N_LIB_PRIVATE N_NIMCALL(void, f__Qr2Z0OouGgYw3QfhyalszA)(tyObject_InternalRaisesFuture__SoZdjWYx5qf9aGd4M3pBJdg x);
static N_INLINE(void, nimFrame)(TFrame* s);
N_LIB_PRIVATE N_NOINLINE(void, callDepthLimitReached__mMRdr4sgmnykA9aWeM9aDZlw)(void);
static N_INLINE(void, popFrame)(void);
static N_INLINE(void, initStackBottomWith)(void* locals);
N_LIB_PRIVATE N_NOINLINE(void, nimGC_setStackBottom)(void* theStackBottom);
N_LIB_PRIVATE N_NIMCALL(void, systemDatInit000)(void);
N_LIB_PRIVATE N_NIMCALL(void, systemInit000)(void);
N_LIB_PRIVATE N_NIMCALL(void, NimMainModule)(void);
N_LIB_PRIVATE tyObject_InternalRaisesFuture__SoZdjWYx5qf9aGd4M3pBJdg v__ZBo9advJ7u8QecSF0Bd4bHA;
extern TFrame* framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw;
extern TFrame* framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw;
extern TFrame* framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw;
extern TFrame* framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw;
extern TFrame* framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw;
extern TFrame* framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw;
static N_INLINE(void, nimFrame)(TFrame* s) {
 {
  if (!(framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw == ((TFrame*) NIM_NIL))) goto LA3_;
  (*s).calldepth = ((NI16) 0);
 }
 goto LA1_;
 LA3_: ;
 {
  (*s).calldepth = (NI16)((*framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw).calldepth + ((NI16) 1));
 }
 LA1_: ;
 (*s).prev = framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw;
 framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw = s;
 {
  if (!((*s).calldepth == ((NI16) 2000))) goto LA8_;
  callDepthLimitReached__mMRdr4sgmnykA9aWeM9aDZlw();
 }
 LA8_: ;
}
static N_INLINE(void, popFrame)(void) {
 framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw = (*framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw).prev;
}
N_LIB_PRIVATE N_NIMCALL(void, f__Qr2Z0OouGgYw3QfhyalszA)(tyObject_InternalRaisesFuture__SoZdjWYx5qf9aGd4M3pBJdg x) {
 nimfr_("f", "/home/runner/work/Nim/Nim/temp.nim");
 popFrame();
}
static N_INLINE(void, initStackBottomWith)(void* locals) {
 nimGC_setStackBottom(locals);
}
N_LIB_PRIVATE void PreMainInner(void) {
}
N_LIB_PRIVATE int cmdCount;
N_LIB_PRIVATE char** cmdLine;
N_LIB_PRIVATE char** gEnv;
N_LIB_PRIVATE void PreMain(void) {
 void (*volatile inner)(void);
 inner = PreMainInner;
 systemDatInit000();
 initStackBottomWith((void *)&inner);
 systemInit000();
 (*inner)();
}
N_LIB_PRIVATE N_CDECL(void, NimMainInner)(void) {
 NimMainModule();
}
N_CDECL(void, NimMain)(void) {
 void (*volatile inner)(void);
 PreMain();
 inner = NimMainInner;
 initStackBottomWith((void *)&inner);
 (*inner)();
}
int main(int argc, char** args, char** env) {
 cmdLine = args;
 cmdCount = argc;
 gEnv = env;
 NimMain();
 return nim_program_result;
}
N_LIB_PRIVATE N_NIMCALL(void, NimMainModule)(void) {
{
 nimfr_("temp", "/home/runner/work/Nim/Nim/temp.nim");
 f__Qr2Z0OouGgYw3QfhyalszA(v__ZBo9advJ7u8QecSF0Bd4bHA);
 popFrame();
}
}

Stats

• Started 2024-03-25T10:23:42
• Finished 2024-03-25T10:23:42
• Duration

1.2.18 👍 OK

Output

IR

Compiled filesize 87.03 Kb (89,120 bytes)

#define NIM_INTBITS 64
#include "nimbase.h"
#  define nimfr_(proc, file) \
 TFrame FR_; \
 FR_.procname = proc; FR_.filename = file; FR_.line = 0; FR_.len = 0; nimFrame(&FR_);
#  define nimfrs_(proc, file, slots, length) \
 struct {TFrame* prev;NCSTRING procname;NI line;NCSTRING filename; NI len; VarSlot s[slots];} FR_; \
 FR_.procname = proc; FR_.filename = file; FR_.line = 0; FR_.len = length; nimFrame((TFrame*)&FR_);
#  define nimln_(n, file) \
 FR_.line = n; FR_.filename = file;
typedef struct tyObject_InternalRaisesFuture__Er05yBj9atIFRAN6fCwoRwQ tyObject_InternalRaisesFuture__Er05yBj9atIFRAN6fCwoRwQ;
struct tyObject_InternalRaisesFuture__Er05yBj9atIFRAN6fCwoRwQ {
char dummy;
};
N_LIB_PRIVATE N_NIMCALL(void, f__7BqHdHV1GTsUzckBHACG6Q)(tyObject_InternalRaisesFuture__Er05yBj9atIFRAN6fCwoRwQ x);
static N_INLINE(void, nimFrame)(TFrame* s);
N_LIB_PRIVATE N_NOINLINE(void, callDepthLimitReached__mMRdr4sgmnykA9aWeM9aDZlw)(void);
static N_INLINE(void, popFrame)(void);
static N_INLINE(void, initStackBottomWith)(void* locals);
N_LIB_PRIVATE N_NOINLINE(void, nimGC_setStackBottom)(void* theStackBottom);
N_LIB_PRIVATE N_NIMCALL(void, systemDatInit000)(void);
N_LIB_PRIVATE N_NIMCALL(void, systemInit000)(void);
N_LIB_PRIVATE N_NIMCALL(void, NimMainModule)(void);
N_LIB_PRIVATE tyObject_InternalRaisesFuture__Er05yBj9atIFRAN6fCwoRwQ v__ZBo9advJ7u8QecSF0Bd4bHA;
extern TFrame* framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw;
extern TFrame* framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw;
extern TFrame* framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw;
extern TFrame* framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw;
extern TFrame* framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw;
extern TFrame* framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw;
static N_INLINE(void, nimFrame)(TFrame* s) {
 {
  if (!(framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw == NIM_NIL)) goto LA3_;
  (*s).calldepth = ((NI16) 0);
 }
 goto LA1_;
 LA3_: ;
 {
  (*s).calldepth = (NI16)((*framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw).calldepth + ((NI16) 1));
 }
 LA1_: ;
 (*s).prev = framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw;
 framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw = s;
 {
  if (!((*s).calldepth == ((NI16) (((NI) 2000))))) goto LA8_;
  callDepthLimitReached__mMRdr4sgmnykA9aWeM9aDZlw();
 }
 LA8_: ;
}
static N_INLINE(void, popFrame)(void) {
 framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw = (*framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw).prev;
}
N_LIB_PRIVATE N_NIMCALL(void, f__7BqHdHV1GTsUzckBHACG6Q)(tyObject_InternalRaisesFuture__Er05yBj9atIFRAN6fCwoRwQ x) {
 nimfr_("f", "/home/runner/work/Nim/Nim/temp.nim");
 popFrame();
}
static N_INLINE(void, initStackBottomWith)(void* locals) {
 nimGC_setStackBottom(locals);
}
N_LIB_PRIVATE void PreMainInner(void) {
}
N_LIB_PRIVATE int cmdCount;
N_LIB_PRIVATE char** cmdLine;
N_LIB_PRIVATE char** gEnv;
N_LIB_PRIVATE void PreMain(void) {
 void (*volatile inner)(void);
 inner = PreMainInner;
 systemDatInit000();
 initStackBottomWith((void *)&inner);
 systemInit000();
 (*inner)();
}
N_LIB_PRIVATE N_CDECL(void, NimMainInner)(void) {
 NimMainModule();
}
N_CDECL(void, NimMain)(void) {
 void (*volatile inner)(void);
 PreMain();
 inner = NimMainInner;
 initStackBottomWith((void *)&inner);
 (*inner)();
}
int main(int argc, char** args, char** env) {
 cmdLine = args;
 cmdCount = argc;
 gEnv = env;
 NimMain();
 return nim_program_result;
}
N_LIB_PRIVATE N_NIMCALL(void, NimMainModule)(void) {
{
 nimfr_("temp", "/home/runner/work/Nim/Nim/temp.nim");
 f__7BqHdHV1GTsUzckBHACG6Q(v__ZBo9advJ7u8QecSF0Bd4bHA);
 popFrame();
}
}

Stats

• Started 2024-03-25T10:23:44
• Finished 2024-03-25T10:23:45
• Duration

1.0.10 👍 OK

Output

IR

Compiled filesize 86.13 Kb (88,192 bytes)

#define NIM_INTBITS 64
#include "nimbase.h"
#  define nimfr_(proc, file) \
 TFrame FR_; \
 FR_.procname = proc; FR_.filename = file; FR_.line = 0; FR_.len = 0; nimFrame(&FR_);
#  define nimfrs_(proc, file, slots, length) \
 struct {TFrame* prev;NCSTRING procname;NI line;NCSTRING filename; NI len; VarSlot s[slots];} FR_; \
 FR_.procname = proc; FR_.filename = file; FR_.line = 0; FR_.len = length; nimFrame((TFrame*)&FR_);
#  define nimln_(n, file) \
 FR_.line = n; FR_.filename = file;
typedef struct tyObject_InternalRaisesFuture__Er05yBj9atIFRAN6fCwoRwQ tyObject_InternalRaisesFuture__Er05yBj9atIFRAN6fCwoRwQ;
struct tyObject_InternalRaisesFuture__Er05yBj9atIFRAN6fCwoRwQ {
char dummy;
};
N_LIB_PRIVATE N_NIMCALL(void, f__7BqHdHV1GTsUzckBHACG6Q)(tyObject_InternalRaisesFuture__Er05yBj9atIFRAN6fCwoRwQ x);
static N_INLINE(void, nimFrame)(TFrame* s);
N_LIB_PRIVATE N_NOINLINE(void, callDepthLimitReached__mMRdr4sgmnykA9aWeM9aDZlw)(void);
static N_INLINE(void, popFrame)(void);
static N_INLINE(void, initStackBottomWith)(void* locals);
N_NOINLINE(void, nimGC_setStackBottom)(void* theStackBottom);
N_LIB_PRIVATE N_NIMCALL(void, systemDatInit000)(void);
N_LIB_PRIVATE N_NIMCALL(void, systemInit000)(void);
N_LIB_PRIVATE N_NIMCALL(void, NimMainModule)(void);
tyObject_InternalRaisesFuture__Er05yBj9atIFRAN6fCwoRwQ v__ZBo9advJ7u8QecSF0Bd4bHA;
extern TFrame* framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw;
extern TFrame* framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw;
extern TFrame* framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw;
extern TFrame* framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw;
extern TFrame* framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw;
extern TFrame* framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw;
static N_INLINE(void, nimFrame)(TFrame* s) {	NI T1_;
 T1_ = (NI)0;
 {
  if (!(framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw == NIM_NIL)) goto LA4_;
  T1_ = ((NI) 0);
 }
 goto LA2_;
 LA4_: ;
 {
  T1_ = ((NI) ((NI16)((*framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw).calldepth + ((NI16) 1))));
 }
 LA2_: ;
 (*s).calldepth = ((NI16) (T1_));
 (*s).prev = framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw;
 framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw = s;
 {
  if (!((*s).calldepth == ((NI16) (((NI) 2000))))) goto LA9_;
  callDepthLimitReached__mMRdr4sgmnykA9aWeM9aDZlw();
 }
 LA9_: ;
}
static N_INLINE(void, popFrame)(void) {	framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw = (*framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw).prev;
}
N_LIB_PRIVATE N_NIMCALL(void, f__7BqHdHV1GTsUzckBHACG6Q)(tyObject_InternalRaisesFuture__Er05yBj9atIFRAN6fCwoRwQ x) {	nimfr_("f", "/home/runner/work/Nim/Nim/temp.nim");
 popFrame();
}
static N_INLINE(void, initStackBottomWith)(void* locals) {	nimGC_setStackBottom(locals);
}
void PreMainInner(void) {
}
int cmdCount;
char** cmdLine;
char** gEnv;
void PreMain(void) {
 void (*volatile inner)(void);
 inner = PreMainInner;
 systemDatInit000();
 initStackBottomWith((void *)&inner);
 systemInit000();
 (*inner)();
}
N_CDECL(void, NimMainInner)(void) {
 NimMainModule();
}
N_CDECL(void, NimMain)(void) {
 void (*volatile inner)(void);
 PreMain();
 inner = NimMainInner;
 initStackBottomWith((void *)&inner);
 (*inner)();
}
int main(int argc, char** args, char** env) {
 cmdLine = args;
 cmdCount = argc;
 gEnv = env;
 NimMain();
 return nim_program_result;
}
N_LIB_PRIVATE N_NIMCALL(void, NimMainModule)(void) {
{
 nimfr_("temp", "/home/runner/work/Nim/Nim/temp.nim");
 f__7BqHdHV1GTsUzckBHACG6Q(v__ZBo9advJ7u8QecSF0Bd4bHA);
 popFrame();
}
}

Stats

• Started 2024-03-25T10:23:46
• Finished 2024-03-25T10:23:47
• Duration

??? ➡️ 🐛

Diagnostics

The commit that introduced the bug can not be found, but the bug is in the commits:

• #b35942ef8
• #d19587761
• #427ad1716
• #9616762cf
• #ce0909f04
• #faa59b1e1
• #e422b3c86
• #d52b1d848

(Can not find the commit because Nim can not be re-built commit-by-commit to bisect).

Stats

• GCC 11.4.0
• Clang 14.0.0
• NodeJS 19.1
• Created 2024-03-25T10:23:06Z
• Comments 6
• Commands nim c --run -d:nimDebug -d:nimDebugDlOpen -d:ssl -d:nimDisableCertificateValidation --forceBuild:on --colors:off --verbosity:0 --hints:off --lineTrace:off --nimcache:/home/runner/work/Nim/Nim --out:/home/runner/work/Nim/Nim/temp /home/runner/work/Nim/Nim/temp.nim

🤖 Bug found in 49 minutes bisecting 2147 commits at 43 commits per second