Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

invalid code generation when passing closure procedure at compile time #21302

Open
hamidb80 opened this issue Jan 26, 2023 · 3 comments
Open

invalid code generation when passing closure procedure at compile time #21302

hamidb80 opened this issue Jan 26, 2023 · 3 comments
Labels
const `const x=expr` or `static: stmt` Static[T]

Comments

@hamidb80
Copy link
Contributor

hamidb80 commented Jan 26, 2023 •
edited

Description

proc wrap(fn: static proc: int): proc: int =
  fn

# --- works fine with `normal proc` ---
# proc c1: int = 1
# proc c2: int = 2

const 
  c1 = proc: int = 1
  c2 = proc: int = 2
  
  wrapped_c1 = wrap c1
  wrapped_c2 = wrap c2

when isMainModule: 
  echo c2 == c1  
  echo c2() == c1()
  echo wrapped_c2 == wrapped_c1 
  echo wrapped_c2() == wrapped_c1()
  echo wrapped_c1()
  echo wrapped_c2()

Nim Version

Nim Compiler Version 1.6.10 [Windows: amd64]
Compiled at 2022-11-21

Current Output

false
false
true
true
1
1

Expected Output

false
false
false
false
1
2

Additional Information

without static and const everything works fine.
@hamidb80 hamidb80 changed the title wrapping a static procedure at compile time, generates invalid code wrapping more than one static procedures with the same signature at compile time, generates invalid code Jan 26, 2023
@hamidb80 hamidb80 changed the title wrapping more than one static procedures with the same signature at compile time, generates invalid code invalid code generation when passing closure procedure at compile time Jan 26, 2023
@hamidb80
Copy link
Contributor Author

it's kinda related to lambda lifting at compile time

@beef331 beef331 added Static[T] const `const x=expr` or `static: stmt` labels Feb 8, 2023
@juancarlospaco
Copy link
Collaborator

!nim c

proc wrap(fn: static[proc: int]): proc: int = fn
const
  c1 = proc: int = 1
  c2 = proc: int = 2
  wrapped_c1 = wrap c1
  wrapped_c2 = wrap c2
doAssert not(c2 == c1)
doAssert not(c2() == c1())
doAssert not(wrapped_c2 == wrapped_c1)
doAssert not(wrapped_c2() == wrapped_c1())
doAssert wrapped_c1() == 1
doAssert wrapped_c2() == 2

@github-actions
Copy link
Contributor

github-actions bot commented Jul 9, 2023

@juancarlospaco (contributor)

devel :-1: FAIL

Output

Error: Command failed: nim c --run -d:strip -d:ssl -d:nimDisableCertificateValidation --forceBuild:on --colors:off --threads:off --verbosity:0 --hints:off --warnings: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 temp
/home/runner/.choosenim/toolchains/nim-#devel/lib/std/assertions.nim failedAssertImpl
/home/runner/.choosenim/toolchains/nim-#devel/lib/std/assertions.nim raiseAssert
/home/runner/.choosenim/toolchains/nim-#devel/lib/system/fatal.nim sysFatal
Error: unhandled exception: /home/runner/work/Nim/Nim/temp.nim(9, 1) `not (wrapped_c2 == wrapped_c1)`  [AssertionDefect]
Error: execution of an external program failed: '/home/runner/work/Nim/Nim/temp'

Stats

  • Created 2023-07-09T14:23:52Z
  • Started 2023-07-09T14:24:29
  • Finished 2023-07-09T14:24:29
  • Duration 1 minute
  • Commands nim c --run -d:strip -d:ssl -d:nimDisableCertificateValidation --forceBuild:on --colors:off --threads:off --verbosity:0 --hints:off --warnings:off --lineTrace:off --nimcache:/home/runner/work/Nim/Nim --out:/home/runner/work/Nim/Nim/temp /home/runner/work/Nim/Nim/temp.nim

IR

#define NIM_INTBITS 64
#include "nimbase.h"
#undef LANGUAGE_C
#undef MIPSEB
#undef MIPSEL
#undef PPC
#undef R3000
#undef R4000
#undef i386
#undef linux
#undef mips
#undef near
#undef far
#undef powerpc
#undef unix
#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) \
    FR_.line = n;
  #define nimlf_(n, file) \
    FR_.line = n; FR_.filename = file;
typedef struct NimStrPayload NimStrPayload;
typedef struct NimStringV2 NimStringV2;
struct NimStrPayload {
	NI cap;
	NIM_CHAR data[SEQ_DECL_SIZE];
};
struct NimStringV2 {
	NI len;
	NimStrPayload* p;
};
N_LIB_PRIVATE N_NIMCALL(void, failedAssertImpl__stdZassertions_u310)(NimStringV2 msg_p0);
static N_INLINE(NIM_BOOL*, nimErrorFlag)(void);
N_LIB_PRIVATE N_NIMCALL(void, nimTestErrorFlag)(void);
static N_INLINE(void, nimFrame)(TFrame* s_p0);
N_LIB_PRIVATE N_NOINLINE(void, callDepthLimitReached__system_u4483)(void);
static N_INLINE(void, popFrame)(void);
N_LIB_PRIVATE N_NIMCALL(void, atmdotdotatsdotdotatsdotdotatsdotchoosenimatstoolchainsatsnimminusathdevelatslibatssystemdotnim_Init000)(void);
N_LIB_PRIVATE N_NIMCALL(void, NimMainModule)(void);
static const struct {
  NI cap; NIM_CHAR data[58+1];
} TM__SRd76hP9cMfCzdUO857UhQQ_2 = { 58 | NIM_STRLIT_FLAG, "/home/runner/work/Nim/Nim/temp.nim(7, 1) `not (c2 == c1)` " };
static const NimStringV2 TM__SRd76hP9cMfCzdUO857UhQQ_3 = {58, (NimStrPayload*)&TM__SRd76hP9cMfCzdUO857UhQQ_2};
static const struct {
  NI cap; NIM_CHAR data[62+1];
} TM__SRd76hP9cMfCzdUO857UhQQ_4 = { 62 | NIM_STRLIT_FLAG, "/home/runner/work/Nim/Nim/temp.nim(8, 1) `not (c2() == c1())` " };
static const NimStringV2 TM__SRd76hP9cMfCzdUO857UhQQ_5 = {62, (NimStrPayload*)&TM__SRd76hP9cMfCzdUO857UhQQ_4};
static const struct {
  NI cap; NIM_CHAR data[74+1];
} TM__SRd76hP9cMfCzdUO857UhQQ_6 = { 74 | NIM_STRLIT_FLAG, "/home/runner/work/Nim/Nim/temp.nim(9, 1) `not (wrapped_c2 == wrapped_c1)` " };
static const NimStringV2 TM__SRd76hP9cMfCzdUO857UhQQ_7 = {74, (NimStrPayload*)&TM__SRd76hP9cMfCzdUO857UhQQ_6};
static const struct {
  NI cap; NIM_CHAR data[79+1];
} TM__SRd76hP9cMfCzdUO857UhQQ_8 = { 79 | NIM_STRLIT_FLAG, "/home/runner/work/Nim/Nim/temp.nim(10, 1) `not (wrapped_c2() == wrapped_c1())` " };
static const NimStringV2 TM__SRd76hP9cMfCzdUO857UhQQ_9 = {79, (NimStrPayload*)&TM__SRd76hP9cMfCzdUO857UhQQ_8};
static const struct {
  NI cap; NIM_CHAR data[62+1];
} TM__SRd76hP9cMfCzdUO857UhQQ_10 = { 62 | NIM_STRLIT_FLAG, "/home/runner/work/Nim/Nim/temp.nim(11, 1) `wrapped_c1() == 1` " };
static const NimStringV2 TM__SRd76hP9cMfCzdUO857UhQQ_11 = {62, (NimStrPayload*)&TM__SRd76hP9cMfCzdUO857UhQQ_10};
static const struct {
  NI cap; NIM_CHAR data[62+1];
} TM__SRd76hP9cMfCzdUO857UhQQ_12 = { 62 | NIM_STRLIT_FLAG, "/home/runner/work/Nim/Nim/temp.nim(12, 1) `wrapped_c2() == 2` " };
static const NimStringV2 TM__SRd76hP9cMfCzdUO857UhQQ_13 = {62, (NimStrPayload*)&TM__SRd76hP9cMfCzdUO857UhQQ_12};
extern NIM_BOOL nimInErrorMode__system_u4265;
extern TFrame* framePtr__system_u3877;
static N_INLINE(NIM_BOOL*, nimErrorFlag)(void) {
	NIM_BOOL* result;
	result = (NIM_BOOL*)0;
	result = (&nimInErrorMode__system_u4265);
	return result;
}
static N_INLINE(void, nimFrame)(TFrame* s_p0) {
	{
		if (!(framePtr__system_u3877 == ((TFrame*) NIM_NIL))) goto LA3_;
		(*s_p0).calldepth = ((NI16)0);
	}
	goto LA1_;
LA3_: ;
	{
		(*s_p0).calldepth = (NI16)((*framePtr__system_u3877).calldepth + ((NI16)1));
	}
LA1_: ;
	(*s_p0).prev = framePtr__system_u3877;
	framePtr__system_u3877 = s_p0;
	{
		if (!((*s_p0).calldepth == ((NI16)2000))) goto LA8_;
		callDepthLimitReached__system_u4483();
	}
LA8_: ;
}
static N_INLINE(void, popFrame)(void) {
	framePtr__system_u3877 = (*framePtr__system_u3877).prev;
}
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) {
#if 0
	void (*volatile inner)(void);
	inner = PreMainInner;
	atmdotdotatsdotdotatsdotdotatsdotchoosenimatstoolchainsatsnimminusathdevelatslibatssystemdotnim_Init000();
	(*inner)();
#else
	atmdotdotatsdotdotatsdotdotatsdotchoosenimatstoolchainsatsnimminusathdevelatslibatssystemdotnim_Init000();
	PreMainInner();
#endif
}
N_LIB_PRIVATE N_CDECL(void, NimMainInner)(void) {
	NimMainModule();
}
N_CDECL(void, NimMain)(void) {
#if 0
	void (*volatile inner)(void);
	PreMain();
	inner = NimMainInner;
	(*inner)();
#else
	PreMain();
	NimMainInner();
#endif
}
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) {
{
NIM_BOOL* nimErr_;
	nimfr_("temp", "/home/runner/work/Nim/Nim/temp.nim");
nimErr_ = nimErrorFlag();
	{
		if (!NIM_FALSE) goto LA3_;
		failedAssertImpl__stdZassertions_u310(TM__SRd76hP9cMfCzdUO857UhQQ_3);
		if (NIM_UNLIKELY(*nimErr_)) goto BeforeRet_;
	}
LA3_: ;
	{
		if (!NIM_FALSE) goto LA7_;
		failedAssertImpl__stdZassertions_u310(TM__SRd76hP9cMfCzdUO857UhQQ_5);
		if (NIM_UNLIKELY(*nimErr_)) goto BeforeRet_;
	}
LA7_: ;
	{
		if (!NIM_TRUE) goto LA11_;
		failedAssertImpl__stdZassertions_u310(TM__SRd76hP9cMfCzdUO857UhQQ_7);
		if (NIM_UNLIKELY(*nimErr_)) goto BeforeRet_;
	}
LA11_: ;
	{
		if (!NIM_TRUE) goto LA15_;
		failedAssertImpl__stdZassertions_u310(TM__SRd76hP9cMfCzdUO857UhQQ_9);
		if (NIM_UNLIKELY(*nimErr_)) goto BeforeRet_;
	}
LA15_: ;
	{
		if (!NIM_FALSE) goto LA19_;
		failedAssertImpl__stdZassertions_u310(TM__SRd76hP9cMfCzdUO857UhQQ_11);
		if (NIM_UNLIKELY(*nimErr_)) goto BeforeRet_;
	}
LA19_: ;
	{
		if (!NIM_TRUE) goto LA23_;
		failedAssertImpl__stdZassertions_u310(TM__SRd76hP9cMfCzdUO857UhQQ_13);
		if (NIM_UNLIKELY(*nimErr_)) goto BeforeRet_;
	}
LA23_: ;
	BeforeRet_: ;
	nimTestErrorFlag();
	popFrame();
}
}

AST

nnkStmtList.newTree(
  nnkProcDef.newTree(
    newIdentNode("wrap"),
    newEmptyNode(),
    newEmptyNode(),
    nnkFormalParams.newTree(
      nnkProcTy.newTree(
        nnkFormalParams.newTree(
          newIdentNode("int")
        ),
        newEmptyNode()
      ),
      nnkIdentDefs.newTree(
        newIdentNode("fn"),
        nnkBracketExpr.newTree(
          newIdentNode("static"),
          nnkProcTy.newTree(
            nnkFormalParams.newTree(
              newIdentNode("int")
            ),
            newEmptyNode()
          )
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      newIdentNode("fn")
    )
  ),
  nnkConstSection.newTree(
    nnkConstDef.newTree(
      newIdentNode("c1"),
      newEmptyNode(),
      nnkLambda.newTree(
        newEmptyNode(),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("int")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkStmtList.newTree(
          newLit(1)
        )
      )
    ),
    nnkConstDef.newTree(
      newIdentNode("c2"),
      newEmptyNode(),
      nnkLambda.newTree(
        newEmptyNode(),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("int")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkStmtList.newTree(
          newLit(2)
        )
      )
    ),
    nnkConstDef.newTree(
      newIdentNode("wrapped_c1"),
      newEmptyNode(),
      nnkCommand.newTree(
        newIdentNode("wrap"),
        newIdentNode("c1")
      )
    ),
    nnkConstDef.newTree(
      newIdentNode("wrapped_c2"),
      newEmptyNode(),
      nnkCommand.newTree(
        newIdentNode("wrap"),
        newIdentNode("c2")
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkPrefix.newTree(
      newIdentNode("not"),
      nnkPar.newTree(
        nnkInfix.newTree(
          newIdentNode("=="),
          newIdentNode("c2"),
          newIdentNode("c1")
        )
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkPrefix.newTree(
      newIdentNode("not"),
      nnkPar.newTree(
        nnkInfix.newTree(
          newIdentNode("=="),
          nnkCall.newTree(
            newIdentNode("c2")
          ),
          nnkCall.newTree(
            newIdentNode("c1")
          )
        )
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkPrefix.newTree(
      newIdentNode("not"),
      nnkPar.newTree(
        nnkInfix.newTree(
          newIdentNode("=="),
          newIdentNode("wrapped_c2"),
          newIdentNode("wrapped_c1")
        )
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkPrefix.newTree(
      newIdentNode("not"),
      nnkPar.newTree(
        nnkInfix.newTree(
          newIdentNode("=="),
          nnkCall.newTree(
            newIdentNode("wrapped_c2")
          ),
          nnkCall.newTree(
            newIdentNode("wrapped_c1")
          )
        )
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkInfix.newTree(
      newIdentNode("=="),
      nnkCall.newTree(
        newIdentNode("wrapped_c1")
      ),
      newLit(1)
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkInfix.newTree(
      newIdentNode("=="),
      nnkCall.newTree(
        newIdentNode("wrapped_c2")
      ),
      newLit(2)
    )
  )
)
stable :-1: FAIL

Output

Error: Command failed: nim c --run -d:strip -d:ssl -d:nimDisableCertificateValidation --forceBuild:on --colors:off --threads:off --verbosity:0 --hints:off --warnings: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 temp
/home/runner/.choosenim/toolchains/nim-1.6.14/lib/system/assertions.nim failedAssertImpl
/home/runner/.choosenim/toolchains/nim-1.6.14/lib/system/assertions.nim raiseAssert
/home/runner/.choosenim/toolchains/nim-1.6.14/lib/system/fatal.nim sysFatal
Error: unhandled exception: /home/runner/work/Nim/Nim/temp.nim(9, 1) `not (wrapped_c2 == wrapped_c1)`  [AssertionDefect]
Error: execution of an external program failed: '/home/runner/work/Nim/Nim/temp '

Stats

  • Created 2023-07-09T14:23:52Z
  • Started 2023-07-09T14:24:30
  • Finished 2023-07-09T14:24:31
  • Duration 1 minute
  • Commands nim c --run -d:strip -d:ssl -d:nimDisableCertificateValidation --forceBuild:on --colors:off --threads:off --verbosity:0 --hints:off --warnings:off --lineTrace:off --nimcache:/home/runner/work/Nim/Nim --out:/home/runner/work/Nim/Nim/temp /home/runner/work/Nim/Nim/temp.nim

IR

#define NIM_INTBITS 64
#include "nimbase.h"
#undef LANGUAGE_C
#undef MIPSEB
#undef MIPSEL
#undef PPC
#undef R3000
#undef R4000
#undef i386
#undef linux
#undef mips
#undef near
#undef far
#undef powerpc
#undef unix
  #  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 NimStringDesc NimStringDesc;
typedef struct TGenericSeq TGenericSeq;
struct TGenericSeq {
NI len;
NI reserved;
};
struct NimStringDesc {
  TGenericSeq Sup;
NIM_CHAR data[SEQ_DECL_SIZE];
};
N_LIB_PRIVATE N_NIMCALL(void, failedAssertImpl__systemZassertions_56)(NimStringDesc* msg);
static N_INLINE(void, initStackBottomWith)(void* locals);
N_LIB_PRIVATE N_NOINLINE(void, nimGC_setStackBottom)(void* theStackBottom);
static N_INLINE(void, nimFrame)(TFrame* s);
N_LIB_PRIVATE N_NOINLINE(void, callDepthLimitReached__system_2997)(void);
static N_INLINE(void, popFrame)(void);
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);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_2, "/home/runner/work/Nim/Nim/temp.nim(7, 1) `not (c2 == c1)` ", 58);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_3, "/home/runner/work/Nim/Nim/temp.nim(8, 1) `not (c2() == c1())` ", 62);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_4, "/home/runner/work/Nim/Nim/temp.nim(9, 1) `not (wrapped_c2 == wrapped_c1)` ", 74);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_5, "/home/runner/work/Nim/Nim/temp.nim(10, 1) `not (wrapped_c2() == wrapped_c1())` ", 79);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_6, "/home/runner/work/Nim/Nim/temp.nim(11, 10) `wrapped_c1() == 1` ", 63);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_7, "/home/runner/work/Nim/Nim/temp.nim(12, 10) `wrapped_c2() == 2` ", 63);
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, initStackBottomWith)(void* locals) {
	nimGC_setStackBottom(locals);
}
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 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");
	{
		if (!NIM_FALSE) goto LA3_;
		failedAssertImpl__systemZassertions_56(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_2));
	}
	LA3_: ;
	{
		if (!NIM_FALSE) goto LA7_;
		failedAssertImpl__systemZassertions_56(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_3));
	}
	LA7_: ;
	{
		if (!NIM_TRUE) goto LA11_;
		failedAssertImpl__systemZassertions_56(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_4));
	}
	LA11_: ;
	{
		if (!NIM_TRUE) goto LA15_;
		failedAssertImpl__systemZassertions_56(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_5));
	}
	LA15_: ;
	{
		if (!NIM_FALSE) goto LA19_;
		failedAssertImpl__systemZassertions_56(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_6));
	}
	LA19_: ;
	{
		if (!NIM_TRUE) goto LA23_;
		failedAssertImpl__systemZassertions_56(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_7));
	}
	LA23_: ;
	popFrame();
}
}

AST

nnkStmtList.newTree(
  nnkProcDef.newTree(
    newIdentNode("wrap"),
    newEmptyNode(),
    newEmptyNode(),
    nnkFormalParams.newTree(
      nnkProcTy.newTree(
        nnkFormalParams.newTree(
          newIdentNode("int")
        ),
        newEmptyNode()
      ),
      nnkIdentDefs.newTree(
        newIdentNode("fn"),
        nnkBracketExpr.newTree(
          newIdentNode("static"),
          nnkProcTy.newTree(
            nnkFormalParams.newTree(
              newIdentNode("int")
            ),
            newEmptyNode()
          )
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      newIdentNode("fn")
    )
  ),
  nnkConstSection.newTree(
    nnkConstDef.newTree(
      newIdentNode("c1"),
      newEmptyNode(),
      nnkLambda.newTree(
        newEmptyNode(),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("int")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkStmtList.newTree(
          newLit(1)
        )
      )
    ),
    nnkConstDef.newTree(
      newIdentNode("c2"),
      newEmptyNode(),
      nnkLambda.newTree(
        newEmptyNode(),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("int")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkStmtList.newTree(
          newLit(2)
        )
      )
    ),
    nnkConstDef.newTree(
      newIdentNode("wrapped_c1"),
      newEmptyNode(),
      nnkCommand.newTree(
        newIdentNode("wrap"),
        newIdentNode("c1")
      )
    ),
    nnkConstDef.newTree(
      newIdentNode("wrapped_c2"),
      newEmptyNode(),
      nnkCommand.newTree(
        newIdentNode("wrap"),
        newIdentNode("c2")
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkPrefix.newTree(
      newIdentNode("not"),
      nnkPar.newTree(
        nnkInfix.newTree(
          newIdentNode("=="),
          newIdentNode("c2"),
          newIdentNode("c1")
        )
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkPrefix.newTree(
      newIdentNode("not"),
      nnkPar.newTree(
        nnkInfix.newTree(
          newIdentNode("=="),
          nnkCall.newTree(
            newIdentNode("c2")
          ),
          nnkCall.newTree(
            newIdentNode("c1")
          )
        )
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkPrefix.newTree(
      newIdentNode("not"),
      nnkPar.newTree(
        nnkInfix.newTree(
          newIdentNode("=="),
          newIdentNode("wrapped_c2"),
          newIdentNode("wrapped_c1")
        )
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkPrefix.newTree(
      newIdentNode("not"),
      nnkPar.newTree(
        nnkInfix.newTree(
          newIdentNode("=="),
          nnkCall.newTree(
            newIdentNode("wrapped_c2")
          ),
          nnkCall.newTree(
            newIdentNode("wrapped_c1")
          )
        )
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkInfix.newTree(
      newIdentNode("=="),
      nnkCall.newTree(
        newIdentNode("wrapped_c1")
      ),
      newLit(1)
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkInfix.newTree(
      newIdentNode("=="),
      nnkCall.newTree(
        newIdentNode("wrapped_c2")
      ),
      newLit(2)
    )
  )
)
1.6.0 :-1: FAIL

Output

Error: Command failed: nim c --run -d:strip -d:ssl -d:nimDisableCertificateValidation --forceBuild:on --colors:off --threads:off --verbosity:0 --hints:off --warnings: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 temp
/home/runner/.choosenim/toolchains/nim-1.6.0/lib/system/assertions.nim failedAssertImpl
/home/runner/.choosenim/toolchains/nim-1.6.0/lib/system/assertions.nim raiseAssert
/home/runner/.choosenim/toolchains/nim-1.6.0/lib/system/fatal.nim sysFatal
Error: unhandled exception: /home/runner/work/Nim/Nim/temp.nim(9, 1) `not (wrapped_c2 == wrapped_c1)`  [AssertionDefect]
Error: execution of an external program failed: '/home/runner/work/Nim/Nim/temp '

Stats

  • Created 2023-07-09T14:23:52Z
  • Started 2023-07-09T14:24:33
  • Finished 2023-07-09T14:24:34
  • Duration 1 minute
  • Commands nim c --run -d:strip -d:ssl -d:nimDisableCertificateValidation --forceBuild:on --colors:off --threads:off --verbosity:0 --hints:off --warnings:off --lineTrace:off --nimcache:/home/runner/work/Nim/Nim --out:/home/runner/work/Nim/Nim/temp /home/runner/work/Nim/Nim/temp.nim

IR

#define NIM_INTBITS 64
#include "nimbase.h"
#undef LANGUAGE_C
#undef MIPSEB
#undef MIPSEL
#undef PPC
#undef R3000
#undef R4000
#undef i386
#undef linux
#undef mips
#undef near
#undef far
#undef powerpc
#undef unix
  #  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 NimStringDesc NimStringDesc;
typedef struct TGenericSeq TGenericSeq;
struct TGenericSeq {
NI len;
NI reserved;
};
struct NimStringDesc {
  TGenericSeq Sup;
NIM_CHAR data[SEQ_DECL_SIZE];
};
N_LIB_PRIVATE N_NIMCALL(void, failedAssertImpl_systemZassertions_56)(NimStringDesc* msg);
static N_INLINE(void, initStackBottomWith)(void* locals);
N_LIB_PRIVATE N_NOINLINE(void, nimGC_setStackBottom)(void* theStackBottom);
static N_INLINE(void, nimFrame)(TFrame* s);
N_LIB_PRIVATE N_NOINLINE(void, callDepthLimitReached_system_2997)(void);
static N_INLINE(void, popFrame)(void);
N_LIB_PRIVATE N_NIMCALL(void, systemDatInit000)(void);
N_LIB_PRIVATE N_NIMCALL(void, systemInit000)(void);
N_LIB_PRIVATE N_NIMCALL(void, NimMainModule)(void);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_2, "/home/runner/work/Nim/Nim/temp.nim(7, 1) `not (c2 == c1)` ", 58);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_3, "/home/runner/work/Nim/Nim/temp.nim(8, 1) `not (c2() == c1())` ", 62);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_4, "/home/runner/work/Nim/Nim/temp.nim(9, 1) `not (wrapped_c2 == wrapped_c1)` ", 74);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_5, "/home/runner/work/Nim/Nim/temp.nim(10, 1) `not (wrapped_c2() == wrapped_c1())` ", 79);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_6, "/home/runner/work/Nim/Nim/temp.nim(11, 10) `wrapped_c1() == 1` ", 63);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_7, "/home/runner/work/Nim/Nim/temp.nim(12, 10) `wrapped_c2() == 2` ", 63);
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, initStackBottomWith)(void* locals) {
	nimGC_setStackBottom(locals);
}
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 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");
	{
		if (!NIM_FALSE) goto LA3_;
		failedAssertImpl_systemZassertions_56(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_2));
	}
	LA3_: ;
	{
		if (!NIM_FALSE) goto LA7_;
		failedAssertImpl_systemZassertions_56(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_3));
	}
	LA7_: ;
	{
		if (!NIM_TRUE) goto LA11_;
		failedAssertImpl_systemZassertions_56(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_4));
	}
	LA11_: ;
	{
		if (!NIM_TRUE) goto LA15_;
		failedAssertImpl_systemZassertions_56(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_5));
	}
	LA15_: ;
	{
		if (!NIM_FALSE) goto LA19_;
		failedAssertImpl_systemZassertions_56(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_6));
	}
	LA19_: ;
	{
		if (!NIM_TRUE) goto LA23_;
		failedAssertImpl_systemZassertions_56(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_7));
	}
	LA23_: ;
	popFrame();
}
}

AST

nnkStmtList.newTree(
  nnkProcDef.newTree(
    newIdentNode("wrap"),
    newEmptyNode(),
    newEmptyNode(),
    nnkFormalParams.newTree(
      nnkProcTy.newTree(
        nnkFormalParams.newTree(
          newIdentNode("int")
        ),
        newEmptyNode()
      ),
      nnkIdentDefs.newTree(
        newIdentNode("fn"),
        nnkBracketExpr.newTree(
          newIdentNode("static"),
          nnkProcTy.newTree(
            nnkFormalParams.newTree(
              newIdentNode("int")
            ),
            newEmptyNode()
          )
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      newIdentNode("fn")
    )
  ),
  nnkConstSection.newTree(
    nnkConstDef.newTree(
      newIdentNode("c1"),
      newEmptyNode(),
      nnkLambda.newTree(
        newEmptyNode(),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("int")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkStmtList.newTree(
          newLit(1)
        )
      )
    ),
    nnkConstDef.newTree(
      newIdentNode("c2"),
      newEmptyNode(),
      nnkLambda.newTree(
        newEmptyNode(),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("int")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkStmtList.newTree(
          newLit(2)
        )
      )
    ),
    nnkConstDef.newTree(
      newIdentNode("wrapped_c1"),
      newEmptyNode(),
      nnkCommand.newTree(
        newIdentNode("wrap"),
        newIdentNode("c1")
      )
    ),
    nnkConstDef.newTree(
      newIdentNode("wrapped_c2"),
      newEmptyNode(),
      nnkCommand.newTree(
        newIdentNode("wrap"),
        newIdentNode("c2")
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkPrefix.newTree(
      newIdentNode("not"),
      nnkPar.newTree(
        nnkInfix.newTree(
          newIdentNode("=="),
          newIdentNode("c2"),
          newIdentNode("c1")
        )
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkPrefix.newTree(
      newIdentNode("not"),
      nnkPar.newTree(
        nnkInfix.newTree(
          newIdentNode("=="),
          nnkCall.newTree(
            newIdentNode("c2")
          ),
          nnkCall.newTree(
            newIdentNode("c1")
          )
        )
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkPrefix.newTree(
      newIdentNode("not"),
      nnkPar.newTree(
        nnkInfix.newTree(
          newIdentNode("=="),
          newIdentNode("wrapped_c2"),
          newIdentNode("wrapped_c1")
        )
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkPrefix.newTree(
      newIdentNode("not"),
      nnkPar.newTree(
        nnkInfix.newTree(
          newIdentNode("=="),
          nnkCall.newTree(
            newIdentNode("wrapped_c2")
          ),
          nnkCall.newTree(
            newIdentNode("wrapped_c1")
          )
        )
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkInfix.newTree(
      newIdentNode("=="),
      nnkCall.newTree(
        newIdentNode("wrapped_c1")
      ),
      newLit(1)
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkInfix.newTree(
      newIdentNode("=="),
      nnkCall.newTree(
        newIdentNode("wrapped_c2")
      ),
      newLit(2)
    )
  )
)
1.4.0 :-1: FAIL

Output

Error: Command failed: nim c --run -d:strip -d:ssl -d:nimDisableCertificateValidation --forceBuild:on --colors:off --threads:off --verbosity:0 --hints:off --warnings: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 temp
/home/runner/.choosenim/toolchains/nim-1.4.0/lib/system/assertions.nim failedAssertImpl
/home/runner/.choosenim/toolchains/nim-1.4.0/lib/system/assertions.nim raiseAssert
/home/runner/.choosenim/toolchains/nim-1.4.0/lib/system/fatal.nim sysFatal
Error: unhandled exception: /home/runner/work/Nim/Nim/temp.nim(9, 1) `not (wrapped_c2 == wrapped_c1)`  [AssertionDefect]
Error: execution of an external program failed: '/home/runner/work/Nim/Nim/temp '

Stats

  • Created 2023-07-09T14:23:52Z
  • Started 2023-07-09T14:24:37
  • Finished 2023-07-09T14:24:38
  • Duration 1 minute
  • Commands nim c --run -d:strip -d:ssl -d:nimDisableCertificateValidation --forceBuild:on --colors:off --threads:off --verbosity:0 --hints:off --warnings:off --lineTrace:off --nimcache:/home/runner/work/Nim/Nim --out:/home/runner/work/Nim/Nim/temp /home/runner/work/Nim/Nim/temp.nim

IR

#define NIM_INTBITS 64

#include "nimbase.h"
#undef LANGUAGE_C
#undef MIPSEB
#undef MIPSEL
#undef PPC
#undef R3000
#undef R4000
#undef i386
#undef linux
#undef mips
#undef near
#undef far
#undef powerpc
#undef unix

  #  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 NimStringDesc NimStringDesc;
typedef struct TGenericSeq TGenericSeq;

struct TGenericSeq {
NI len;
NI reserved;
};
struct NimStringDesc {
  TGenericSeq Sup;
NIM_CHAR data[SEQ_DECL_SIZE];
};

N_LIB_PRIVATE N_NIMCALL(void, failedAssertImpl__W9cjVocn1tjhW7p7xohJj6A)(NimStringDesc* msg);
static N_INLINE(void, initStackBottomWith)(void* locals);
N_LIB_PRIVATE N_NOINLINE(void, nimGC_setStackBottom)(void* theStackBottom);
static N_INLINE(void, nimFrame)(TFrame* s);
N_LIB_PRIVATE N_NOINLINE(void, callDepthLimitReached__mMRdr4sgmnykA9aWeM9aDZlw)(void);
static N_INLINE(void, popFrame)(void);
N_LIB_PRIVATE N_NIMCALL(void, systemDatInit000)(void);
N_LIB_PRIVATE N_NIMCALL(void, systemInit000)(void);
N_LIB_PRIVATE N_NIMCALL(void, NimMainModule)(void);

STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_2, "/home/runner/work/Nim/Nim/temp.nim(7, 1) `not (c2 == c1)` ", 58);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_3, "/home/runner/work/Nim/Nim/temp.nim(8, 1) `not (c2() == c1())` ", 62);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_4, "/home/runner/work/Nim/Nim/temp.nim(9, 1) `not (wrapped_c2 == wr"
"apped_c1)` ", 74);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_5, "/home/runner/work/Nim/Nim/temp.nim(10, 1) `not (wrapped_c2() =="
" wrapped_c1())` ", 79);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_6, "/home/runner/work/Nim/Nim/temp.nim(11, 10) `wrapped_c1() == 1` ", 63);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_7, "/home/runner/work/Nim/Nim/temp.nim(12, 10) `wrapped_c2() == 2` ", 63);

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, initStackBottomWith)(void* locals) {
	nimGC_setStackBottom(locals);
}
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) 2000))) goto LA8_;
		callDepthLimitReached__mMRdr4sgmnykA9aWeM9aDZlw();
	}
	LA8_: ;
}
static N_INLINE(void, popFrame)(void) {
	framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw = (*framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw).prev;
}
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");
	{
		if (!NIM_FALSE) goto LA3_;
		failedAssertImpl__W9cjVocn1tjhW7p7xohJj6A(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_2));
	}
	LA3_: ;
	{
		if (!NIM_FALSE) goto LA7_;
		failedAssertImpl__W9cjVocn1tjhW7p7xohJj6A(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_3));
	}
	LA7_: ;
	{
		if (!NIM_TRUE) goto LA11_;
		failedAssertImpl__W9cjVocn1tjhW7p7xohJj6A(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_4));
	}
	LA11_: ;
	{
		if (!NIM_TRUE) goto LA15_;
		failedAssertImpl__W9cjVocn1tjhW7p7xohJj6A(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_5));
	}
	LA15_: ;
	{
		if (!NIM_FALSE) goto LA19_;
		failedAssertImpl__W9cjVocn1tjhW7p7xohJj6A(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_6));
	}
	LA19_: ;
	{
		if (!NIM_TRUE) goto LA23_;
		failedAssertImpl__W9cjVocn1tjhW7p7xohJj6A(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_7));
	}
	LA23_: ;
	popFrame();
}
}

AST

nnkStmtList.newTree(
  nnkProcDef.newTree(
    newIdentNode("wrap"),
    newEmptyNode(),
    newEmptyNode(),
    nnkFormalParams.newTree(
      nnkProcTy.newTree(
        nnkFormalParams.newTree(
          newIdentNode("int")
        ),
        newEmptyNode()
      ),
      nnkIdentDefs.newTree(
        newIdentNode("fn"),
        nnkBracketExpr.newTree(
          newIdentNode("static"),
          nnkProcTy.newTree(
            nnkFormalParams.newTree(
              newIdentNode("int")
            ),
            newEmptyNode()
          )
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      newIdentNode("fn")
    )
  ),
  nnkConstSection.newTree(
    nnkConstDef.newTree(
      newIdentNode("c1"),
      newEmptyNode(),
      nnkLambda.newTree(
        newEmptyNode(),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("int")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkStmtList.newTree(
          newLit(1)
        )
      )
    ),
    nnkConstDef.newTree(
      newIdentNode("c2"),
      newEmptyNode(),
      nnkLambda.newTree(
        newEmptyNode(),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("int")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkStmtList.newTree(
          newLit(2)
        )
      )
    ),
    nnkConstDef.newTree(
      newIdentNode("wrapped_c1"),
      newEmptyNode(),
      nnkCommand.newTree(
        newIdentNode("wrap"),
        newIdentNode("c1")
      )
    ),
    nnkConstDef.newTree(
      newIdentNode("wrapped_c2"),
      newEmptyNode(),
      nnkCommand.newTree(
        newIdentNode("wrap"),
        newIdentNode("c2")
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkPrefix.newTree(
      newIdentNode("not"),
      nnkPar.newTree(
        nnkInfix.newTree(
          newIdentNode("=="),
          newIdentNode("c2"),
          newIdentNode("c1")
        )
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkPrefix.newTree(
      newIdentNode("not"),
      nnkPar.newTree(
        nnkInfix.newTree(
          newIdentNode("=="),
          nnkCall.newTree(
            newIdentNode("c2")
          ),
          nnkCall.newTree(
            newIdentNode("c1")
          )
        )
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkPrefix.newTree(
      newIdentNode("not"),
      nnkPar.newTree(
        nnkInfix.newTree(
          newIdentNode("=="),
          newIdentNode("wrapped_c2"),
          newIdentNode("wrapped_c1")
        )
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkPrefix.newTree(
      newIdentNode("not"),
      nnkPar.newTree(
        nnkInfix.newTree(
          newIdentNode("=="),
          nnkCall.newTree(
            newIdentNode("wrapped_c2")
          ),
          nnkCall.newTree(
            newIdentNode("wrapped_c1")
          )
        )
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkInfix.newTree(
      newIdentNode("=="),
      nnkCall.newTree(
        newIdentNode("wrapped_c1")
      ),
      newLit(1)
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkInfix.newTree(
      newIdentNode("=="),
      nnkCall.newTree(
        newIdentNode("wrapped_c2")
      ),
      newLit(2)
    )
  )
)
1.2.0 :-1: FAIL

Output

Error: Command failed: nim c --run -d:strip -d:ssl -d:nimDisableCertificateValidation --forceBuild:on --colors:off --threads:off --verbosity:0 --hints:off --warnings: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 temp
/home/runner/.choosenim/toolchains/nim-1.2.0/lib/system/assertions.nim failedAssertImpl
/home/runner/.choosenim/toolchains/nim-1.2.0/lib/system/assertions.nim raiseAssert
/home/runner/.choosenim/toolchains/nim-1.2.0/lib/system/fatal.nim sysFatal
Error: unhandled exception: /home/runner/work/Nim/Nim/temp.nim(9, 1) `not (wrapped_c2 == wrapped_c1)`  [AssertionError]
Error: execution of an external program failed: '/home/runner/work/Nim/Nim/temp '

Stats

  • Created 2023-07-09T14:23:52Z
  • Started 2023-07-09T14:24:53
  • Finished 2023-07-09T14:24:54
  • Duration now
  • Commands nim c --run -d:strip -d:ssl -d:nimDisableCertificateValidation --forceBuild:on --colors:off --threads:off --verbosity:0 --hints:off --warnings:off --lineTrace:off --nimcache:/home/runner/work/Nim/Nim --out:/home/runner/work/Nim/Nim/temp /home/runner/work/Nim/Nim/temp.nim

IR

#define NIM_INTBITS 64
#include "nimbase.h"
#undef LANGUAGE_C
#undef MIPSEB
#undef MIPSEL
#undef PPC
#undef R3000
#undef R4000
#undef i386
#undef linux
#undef mips
#undef near
#undef far
#undef powerpc
#undef unix
  #  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 NimStringDesc NimStringDesc;
typedef struct TGenericSeq TGenericSeq;
struct TGenericSeq {
NI len;
NI reserved;
};
struct NimStringDesc {
  TGenericSeq Sup;
NIM_CHAR data[SEQ_DECL_SIZE];
};
N_LIB_PRIVATE N_NIMCALL(void, failedAssertImpl__W9cjVocn1tjhW7p7xohJj6A)(NimStringDesc* msg);
static N_INLINE(void, initStackBottomWith)(void* locals);
N_LIB_PRIVATE N_NOINLINE(void, nimGC_setStackBottom)(void* theStackBottom);
static N_INLINE(void, nimFrame)(TFrame* s);
N_LIB_PRIVATE N_NOINLINE(void, callDepthLimitReached__mMRdr4sgmnykA9aWeM9aDZlw)(void);
static N_INLINE(void, popFrame)(void);
N_LIB_PRIVATE N_NIMCALL(void, systemDatInit000)(void);
N_LIB_PRIVATE N_NIMCALL(void, systemInit000)(void);
N_LIB_PRIVATE N_NIMCALL(void, NimMainModule)(void);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_2, "/home/runner/work/Nim/Nim/temp.nim(7, 1) `not (c2 == c1)` ", 58);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_3, "/home/runner/work/Nim/Nim/temp.nim(8, 1) `not (c2() == c1())` ", 62);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_4, "/home/runner/work/Nim/Nim/temp.nim(9, 1) `not (wrapped_c2 == wr"
"apped_c1)` ", 74);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_5, "/home/runner/work/Nim/Nim/temp.nim(10, 1) `not (wrapped_c2() =="
" wrapped_c1())` ", 79);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_6, "/home/runner/work/Nim/Nim/temp.nim(11, 10) `wrapped_c1() == 1` ", 63);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_7, "/home/runner/work/Nim/Nim/temp.nim(12, 10) `wrapped_c2() == 2` ", 63);
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, initStackBottomWith)(void* locals) {
	nimGC_setStackBottom(locals);
}
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 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");
	{
		if (!NIM_FALSE) goto LA3_;
		failedAssertImpl__W9cjVocn1tjhW7p7xohJj6A(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_2));
	}
	LA3_: ;
	{
		if (!NIM_FALSE) goto LA7_;
		failedAssertImpl__W9cjVocn1tjhW7p7xohJj6A(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_3));
	}
	LA7_: ;
	{
		if (!NIM_TRUE) goto LA11_;
		failedAssertImpl__W9cjVocn1tjhW7p7xohJj6A(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_4));
	}
	LA11_: ;
	{
		if (!NIM_TRUE) goto LA15_;
		failedAssertImpl__W9cjVocn1tjhW7p7xohJj6A(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_5));
	}
	LA15_: ;
	{
		if (!NIM_FALSE) goto LA19_;
		failedAssertImpl__W9cjVocn1tjhW7p7xohJj6A(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_6));
	}
	LA19_: ;
	{
		if (!NIM_TRUE) goto LA23_;
		failedAssertImpl__W9cjVocn1tjhW7p7xohJj6A(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_7));
	}
	LA23_: ;
	popFrame();
}
}

AST

nnkStmtList.newTree(
  nnkProcDef.newTree(
    newIdentNode("wrap"),
    newEmptyNode(),
    newEmptyNode(),
    nnkFormalParams.newTree(
      nnkProcTy.newTree(
        nnkFormalParams.newTree(
          newIdentNode("int")
        ),
        newEmptyNode()
      ),
      nnkIdentDefs.newTree(
        newIdentNode("fn"),
        nnkBracketExpr.newTree(
          newIdentNode("static"),
          nnkProcTy.newTree(
            nnkFormalParams.newTree(
              newIdentNode("int")
            ),
            newEmptyNode()
          )
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      newIdentNode("fn")
    )
  ),
  nnkConstSection.newTree(
    nnkConstDef.newTree(
      newIdentNode("c1"),
      newEmptyNode(),
      nnkLambda.newTree(
        newEmptyNode(),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("int")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkStmtList.newTree(
          newLit(1)
        )
      )
    ),
    nnkConstDef.newTree(
      newIdentNode("c2"),
      newEmptyNode(),
      nnkLambda.newTree(
        newEmptyNode(),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("int")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkStmtList.newTree(
          newLit(2)
        )
      )
    ),
    nnkConstDef.newTree(
      newIdentNode("wrapped_c1"),
      newEmptyNode(),
      nnkCommand.newTree(
        newIdentNode("wrap"),
        newIdentNode("c1")
      )
    ),
    nnkConstDef.newTree(
      newIdentNode("wrapped_c2"),
      newEmptyNode(),
      nnkCommand.newTree(
        newIdentNode("wrap"),
        newIdentNode("c2")
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkPrefix.newTree(
      newIdentNode("not"),
      nnkPar.newTree(
        nnkInfix.newTree(
          newIdentNode("=="),
          newIdentNode("c2"),
          newIdentNode("c1")
        )
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkPrefix.newTree(
      newIdentNode("not"),
      nnkPar.newTree(
        nnkInfix.newTree(
          newIdentNode("=="),
          nnkCall.newTree(
            newIdentNode("c2")
          ),
          nnkCall.newTree(
            newIdentNode("c1")
          )
        )
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkPrefix.newTree(
      newIdentNode("not"),
      nnkPar.newTree(
        nnkInfix.newTree(
          newIdentNode("=="),
          newIdentNode("wrapped_c2"),
          newIdentNode("wrapped_c1")
        )
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkPrefix.newTree(
      newIdentNode("not"),
      nnkPar.newTree(
        nnkInfix.newTree(
          newIdentNode("=="),
          nnkCall.newTree(
            newIdentNode("wrapped_c2")
          ),
          nnkCall.newTree(
            newIdentNode("wrapped_c1")
          )
        )
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkInfix.newTree(
      newIdentNode("=="),
      nnkCall.newTree(
        newIdentNode("wrapped_c1")
      ),
      newLit(1)
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkInfix.newTree(
      newIdentNode("=="),
      nnkCall.newTree(
        newIdentNode("wrapped_c2")
      ),
      newLit(2)
    )
  )
)
1.0.0 :-1: FAIL

Output

Error: Command failed: nim c --run -d:strip -d:ssl -d:nimDisableCertificateValidation --forceBuild:on --colors:off --threads:off --verbosity:0 --hints:off --warnings: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 temp
/home/runner/.choosenim/toolchains/nim-1.0.0/lib/system/assertions.nim failedAssertImpl
/home/runner/.choosenim/toolchains/nim-1.0.0/lib/system/assertions.nim raiseAssert
/home/runner/.choosenim/toolchains/nim-1.0.0/lib/system/fatal.nim sysFatal
Error: unhandled exception: /home/runner/work/Nim/Nim/temp.nim(9, 1) `not (wrapped_c2 == wrapped_c1)`  [AssertionError]
Error: execution of an external program failed: '/home/runner/work/Nim/Nim/temp '

Stats

  • Created 2023-07-09T14:23:52Z
  • Started 2023-07-09T14:25:07
  • Finished 2023-07-09T14:25:07
  • Duration now
  • Commands nim c --run -d:strip -d:ssl -d:nimDisableCertificateValidation --forceBuild:on --colors:off --threads:off --verbosity:0 --hints:off --warnings:off --lineTrace:off --nimcache:/home/runner/work/Nim/Nim --out:/home/runner/work/Nim/Nim/temp /home/runner/work/Nim/Nim/temp.nim

IR

#define NIM_INTBITS 64
#include "nimbase.h"
#undef LANGUAGE_C
#undef MIPSEB
#undef MIPSEL
#undef PPC
#undef R3000
#undef R4000
#undef i386
#undef linux
#undef mips
#undef near
#undef far
#undef powerpc
#undef unix
  #  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 NimStringDesc NimStringDesc;
typedef struct TGenericSeq TGenericSeq;
struct TGenericSeq {
NI len;
NI reserved;
};
struct NimStringDesc {
  TGenericSeq Sup;
NIM_CHAR data[SEQ_DECL_SIZE];
};
N_LIB_PRIVATE N_NIMCALL(void, failedAssertImpl__W9cjVocn1tjhW7p7xohJj6A)(NimStringDesc* msg);
static N_INLINE(void, initStackBottomWith)(void* locals);
N_NOINLINE(void, nimGC_setStackBottom)(void* theStackBottom);
static N_INLINE(void, nimFrame)(TFrame* s);
N_LIB_PRIVATE N_NOINLINE(void, callDepthLimitReached__mMRdr4sgmnykA9aWeM9aDZlw)(void);
static N_INLINE(void, popFrame)(void);
N_LIB_PRIVATE N_NIMCALL(void, systemDatInit000)(void);
N_LIB_PRIVATE N_NIMCALL(void, systemInit000)(void);
N_LIB_PRIVATE N_NIMCALL(void, NimMainModule)(void);
extern TFrame* framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw;
extern TFrame* framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw;
extern TFrame* framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw;
extern TFrame* framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw;
extern TFrame* framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw;
extern TFrame* framePtr__HRfVMH3jYeBJz6Q6X9b6Ptw;
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_2, "/home/runner/work/Nim/Nim/temp.nim(7, 1) `not (c2 == c1)` ", 58);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_3, "/home/runner/work/Nim/Nim/temp.nim(8, 1) `not (c2() == c1())` ", 62);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_4, "/home/runner/work/Nim/Nim/temp.nim(9, 1) `not (wrapped_c2 == wr"
"apped_c1)` ", 74);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_5, "/home/runner/work/Nim/Nim/temp.nim(10, 1) `not (wrapped_c2() =="
" wrapped_c1())` ", 79);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_6, "/home/runner/work/Nim/Nim/temp.nim(11, 10) `wrapped_c1() == 1` ", 63);
STRING_LITERAL(TM__SRd76hP9cMfCzdUO857UhQQ_7, "/home/runner/work/Nim/Nim/temp.nim(12, 10) `wrapped_c2() == 2` ", 63);
static N_INLINE(void, initStackBottomWith)(void* locals) {
	nimGC_setStackBottom(locals);
}
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;
}
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");
	{
		if (!NIM_FALSE) goto LA3_;
		failedAssertImpl__W9cjVocn1tjhW7p7xohJj6A(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_2));
	}
	LA3_: ;
	{
		if (!NIM_FALSE) goto LA7_;
		failedAssertImpl__W9cjVocn1tjhW7p7xohJj6A(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_3));
	}
	LA7_: ;
	{
		if (!NIM_TRUE) goto LA11_;
		failedAssertImpl__W9cjVocn1tjhW7p7xohJj6A(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_4));
	}
	LA11_: ;
	{
		if (!NIM_TRUE) goto LA15_;
		failedAssertImpl__W9cjVocn1tjhW7p7xohJj6A(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_5));
	}
	LA15_: ;
	{
		if (!NIM_FALSE) goto LA19_;
		failedAssertImpl__W9cjVocn1tjhW7p7xohJj6A(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_6));
	}
	LA19_: ;
	{
		if (!NIM_TRUE) goto LA23_;
		failedAssertImpl__W9cjVocn1tjhW7p7xohJj6A(((NimStringDesc*) &TM__SRd76hP9cMfCzdUO857UhQQ_7));
	}
	LA23_: ;
	popFrame();
}
}

AST

nnkStmtList.newTree(
  nnkProcDef.newTree(
    newIdentNode("wrap"),
    newEmptyNode(),
    newEmptyNode(),
    nnkFormalParams.newTree(
      nnkProcTy.newTree(
        nnkFormalParams.newTree(
          newIdentNode("int")
        ),
        newEmptyNode()
      ),
      nnkIdentDefs.newTree(
        newIdentNode("fn"),
        nnkBracketExpr.newTree(
          newIdentNode("static"),
          nnkProcTy.newTree(
            nnkFormalParams.newTree(
              newIdentNode("int")
            ),
            newEmptyNode()
          )
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      newIdentNode("fn")
    )
  ),
  nnkConstSection.newTree(
    nnkConstDef.newTree(
      newIdentNode("c1"),
      newEmptyNode(),
      nnkLambda.newTree(
        newEmptyNode(),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("int")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkStmtList.newTree(
          newLit(1)
        )
      )
    ),
    nnkConstDef.newTree(
      newIdentNode("c2"),
      newEmptyNode(),
      nnkLambda.newTree(
        newEmptyNode(),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("int")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkStmtList.newTree(
          newLit(2)
        )
      )
    ),
    nnkConstDef.newTree(
      newIdentNode("wrapped_c1"),
      newEmptyNode(),
      nnkCommand.newTree(
        newIdentNode("wrap"),
        newIdentNode("c1")
      )
    ),
    nnkConstDef.newTree(
      newIdentNode("wrapped_c2"),
      newEmptyNode(),
      nnkCommand.newTree(
        newIdentNode("wrap"),
        newIdentNode("c2")
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkPrefix.newTree(
      newIdentNode("not"),
      nnkPar.newTree(
        nnkInfix.newTree(
          newIdentNode("=="),
          newIdentNode("c2"),
          newIdentNode("c1")
        )
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkPrefix.newTree(
      newIdentNode("not"),
      nnkPar.newTree(
        nnkInfix.newTree(
          newIdentNode("=="),
          nnkCall.newTree(
            newIdentNode("c2")
          ),
          nnkCall.newTree(
            newIdentNode("c1")
          )
        )
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkPrefix.newTree(
      newIdentNode("not"),
      nnkPar.newTree(
        nnkInfix.newTree(
          newIdentNode("=="),
          newIdentNode("wrapped_c2"),
          newIdentNode("wrapped_c1")
        )
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkPrefix.newTree(
      newIdentNode("not"),
      nnkPar.newTree(
        nnkInfix.newTree(
          newIdentNode("=="),
          nnkCall.newTree(
            newIdentNode("wrapped_c2")
          ),
          nnkCall.newTree(
            newIdentNode("wrapped_c1")
          )
        )
      )
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkInfix.newTree(
      newIdentNode("=="),
      nnkCall.newTree(
        newIdentNode("wrapped_c1")
      ),
      newLit(1)
    )
  ),
  nnkCommand.newTree(
    newIdentNode("doAssert"),
    nnkInfix.newTree(
      newIdentNode("=="),
      nnkCall.newTree(
        newIdentNode("wrapped_c2")
      ),
      newLit(2)
    )
  )
)
🤖 Bug found in 43 minutes bisecting 6 commits at 0 commits per second.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
const `const x=expr` or `static: stmt` Static[T]
Projects
None yet
Milestone
No milestone
Development

No branches or pull requests
3 participants
@juancarlospaco @beef331 @hamidb80