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

Regression in {.borrow.} for generic type with static size #22646

Closed
Vindaar opened this issue Sep 5, 2023 · 6 comments · Fixed by #22653
Closed

Regression in {.borrow.} for generic type with static size #22646

Vindaar opened this issue Sep 5, 2023 · 6 comments · Fixed by #22653
Labels
Generics

Comments

@Vindaar
Copy link
Contributor

Vindaar commented Sep 5, 2023 •
edited
Loading

Description

After updating today for the sizeof fix (thanks!) I notice a regression in {.borrow.}. I have a distinct type based on the Vec of glm. Borrowing for them is not possible anymore. It was compiling just fine yesterday on commit c5495f4.

However, only procedures that return a type with the static size not explicitly specified are affected. As long as either the static size N is given explicitly or the return type does not contain N it works fine:

type
  Vec*[N : static[int], T: SomeNumber] = object
    arr*: array[N, T]
  Vec3*[T: SomeNumber] = Vec[3, T]

proc `[]=`*[N,T](v: var Vec[N,T]; ix:int; c:T): void {.inline.} = v.arr[ix] = c
proc `[]`*[N,T](v: Vec[N,T]; ix: int): T {.inline.} = v.arr[ix]

proc dot*[N,T](u,v: Vec[N,T]): T {. inline .} = discard
proc length*[N,T](v: Vec[N,T]): T = discard
proc cross*[T](v1,v2:Vec[3,T]): Vec[3,T] = discard
proc normalizeWorks*[T](v: Vec[3,T]): Vec[3,T] = discard ## <- Explicit size makes it work!
proc foo*[N,T](u, v: Vec[N,T]): Vec[N,T] = discard ## <- broken
proc normalize*[N,T](v: Vec[N,T]): Vec[N,T] = discard ## <- broken

type
  Color* = distinct Vec3[float]

template borrowOps(typ: typedesc): untyped =
  proc `[]=`*(v: var typ; ix: int; c: float): void {.borrow.}
  proc `[]`*(v: typ; ix: int): float {.borrow.}
  proc dot*(v, u: typ): float {.borrow.}
  proc cross*(v, u: typ): typ {.borrow.}
  proc length*(v: typ): float {.borrow.}
  proc normalizeWorks*(v: typ): typ {.borrow.} ## Up to here everything works
  proc foo*(u, v: typ): typ {.borrow.} ## Broken
  proc normalize*(v: typ): typ {.borrow.} ## Broken
borrowOps(Color)

UPDATE: This also seems to affect other things. I'm struggling to reproduce it at the moment, but just trying to convert a Vec3d to a Color using Color(foo) is broken too. Based on the error message I think the problem is the same. It seems like the compiler is confused about the type equality.

Nim Version

Nim Compiler Version 2.1.1 [Linux: amd64]
Compiled at 2023-09-05
Copyright (c) 2006-2023 by Andreas Rumpf

git hash: eb91cf9
active boot switches: -d:release -d:danger

Current Output

/tmp/bug_regression.nim(28, 10) template/generic instantiation of `borrowOps` from here
/tmp/bug_regression.nim(26, 3) Error: borrow from proc return type mismatch: 'Vec[3, system.float]'

Expected Output

Compile :)

Possible Solution

No response

Additional Information

#22069 seems related?
@juancarlospaco
Copy link
Collaborator

!nim c

type
  Vec*[N : static[int], T: SomeNumber] = object
    arr*: array[N, T]
  Vec3*[T: SomeNumber] = Vec[3, T]

proc `[]=`*[N,T](v: var Vec[N,T]; ix:int; c:T): void {.inline.} = v.arr[ix] = c
proc `[]`*[N,T](v: Vec[N,T]; ix: int): T {.inline.} = v.arr[ix]

proc dot*[N,T](u,v: Vec[N,T]): T {. inline .} = discard
proc length*[N,T](v: Vec[N,T]): T = discard
proc cross*[T](v1,v2:Vec[3,T]): Vec[3,T] = discard
proc normalizeWorks*[T](v: Vec[3,T]): Vec[3,T] = discard ## <- Explicit size makes it work!
proc foo*[N,T](u, v: Vec[N,T]): Vec[N,T] = discard ## <- broken
proc normalize*[N,T](v: Vec[N,T]): Vec[N,T] = discard ## <- broken

type
  Color* = distinct Vec3[float]

template borrowOps(typ: typedesc): untyped =
  proc `[]=`*(v: var typ; ix: int; c: float): void {.borrow.}
  proc `[]`*(v: typ; ix: int): float {.borrow.}
  proc dot*(v, u: typ): float {.borrow.}
  proc cross*(v, u: typ): typ {.borrow.}
  proc length*(v: typ): float {.borrow.}
  proc normalizeWorks*(v: typ): typ {.borrow.} ## Up to here everything works
  proc foo*(u, v: typ): typ {.borrow.} ## Broken
  proc normalize*(v: typ): typ {.borrow.} ## Broken
borrowOps(Color)

@github-actions
Copy link
Contributor

github-actions bot commented Sep 5, 2023

@juancarlospaco (collaborator)

devel 👍 $\color{green}\textbf{\large OK}$

Output

Stats

  • Started 2023-09-05T12:41:34
  • Finished 2023-09-05T12:41:35
  • Duration
stable 👍 $\color{green}\textbf{\large OK}$

Output

Stats

  • Started 2023-09-05T12:41:35
  • Finished 2023-09-05T12:41:36
  • Duration
2.0.0 👍 $\color{green}\textbf{\large OK}$

Output

Stats

  • Started 2023-09-05T12:41:36
  • Finished 2023-09-05T12:41:36
  • Duration
1.6.0 👎 FAIL

Output

Error: Command failed: nim c --run  -d:nimDebugDlOpen -d:ssl -d:nimDisableCertificateValidation --forceBuild:on --colors: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(24, 10) template/generic instantiation of `borrowOps` from here
/home/runner/work/Nim/Nim/temp.nim(19, 3) Error: no symbol to borrow from found

Stats

  • Started 2023-09-05T12:41:38
  • Finished 2023-09-05T12:41:39
  • Duration

IR

Compiled filesize 90.64 Kb (92,816 bytes) 
#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
N_LIB_PRIVATE N_NIMCALL(void, nimTestErrorFlag)(void);
N_LIB_PRIVATE N_NIMCALL(void, atmdotdotatsdotdotatsdotdotatsdotchoosenimatstoolchainsatsnimminus2dot0dot0atslibatssystemdotnim_Init000)(void);
N_LIB_PRIVATE N_NIMCALL(void, NimMainModule)(void);
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;
	atmdotdotatsdotdotatsdotdotatsdotchoosenimatstoolchainsatsnimminus2dot0dot0atslibatssystemdotnim_Init000();
	(*inner)();
#else
	atmdotdotatsdotdotatsdotdotatsdotchoosenimatstoolchainsatsnimminus2dot0dot0atslibatssystemdotnim_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) {
{
	nimTestErrorFlag();
}
}

AST

nnkStmtList.newTree(
  nnkTypeSection.newTree(
    nnkTypeDef.newTree(
      nnkPostfix.newTree(
        newIdentNode("*"),
        newIdentNode("Vec")
      ),
      nnkGenericParams.newTree(
        nnkIdentDefs.newTree(
          newIdentNode("N"),
          nnkBracketExpr.newTree(
            newIdentNode("static"),
            newIdentNode("int")
          ),
          newEmptyNode()
        ),
        nnkIdentDefs.newTree(
          newIdentNode("T"),
          newIdentNode("SomeNumber"),
          newEmptyNode()
        )
      ),
      nnkObjectTy.newTree(
        newEmptyNode(),
        newEmptyNode(),
        nnkRecList.newTree(
          nnkIdentDefs.newTree(
            nnkPostfix.newTree(
              newIdentNode("*"),
              newIdentNode("arr")
            ),
            nnkBracketExpr.newTree(
              newIdentNode("array"),
              newIdentNode("N"),
              newIdentNode("T")
            ),
            newEmptyNode()
          )
        )
      )
    ),
    nnkTypeDef.newTree(
      nnkPostfix.newTree(
        newIdentNode("*"),
        newIdentNode("Vec3")
      ),
      nnkGenericParams.newTree(
        nnkIdentDefs.newTree(
          newIdentNode("T"),
          newIdentNode("SomeNumber"),
          newEmptyNode()
        )
      ),
      nnkBracketExpr.newTree(
        newIdentNode("Vec"),
        newLit(3),
        newIdentNode("T")
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      nnkAccQuoted.newTree(
        newIdentNode("[]=")
      )
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      newIdentNode("void"),
      nnkIdentDefs.newTree(
        newIdentNode("v"),
        nnkVarTy.newTree(
          nnkBracketExpr.newTree(
            newIdentNode("Vec"),
            newIdentNode("N"),
            newIdentNode("T")
          )
        ),
        newEmptyNode()
      ),
      nnkIdentDefs.newTree(
        newIdentNode("ix"),
        newIdentNode("int"),
        newEmptyNode()
      ),
      nnkIdentDefs.newTree(
        newIdentNode("c"),
        newIdentNode("T"),
        newEmptyNode()
      )
    ),
    nnkPragma.newTree(
      newIdentNode("inline")
    ),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkAsgn.newTree(
        nnkBracketExpr.newTree(
          nnkDotExpr.newTree(
            newIdentNode("v"),
            newIdentNode("arr")
          ),
          newIdentNode("ix")
        ),
        newIdentNode("c")
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      nnkAccQuoted.newTree(
        newIdentNode("[]")
      )
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      newIdentNode("T"),
      nnkIdentDefs.newTree(
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newIdentNode("N"),
          newIdentNode("T")
        ),
        newEmptyNode()
      ),
      nnkIdentDefs.newTree(
        newIdentNode("ix"),
        newIdentNode("int"),
        newEmptyNode()
      )
    ),
    nnkPragma.newTree(
      newIdentNode("inline")
    ),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkBracketExpr.newTree(
        nnkDotExpr.newTree(
          newIdentNode("v"),
          newIdentNode("arr")
        ),
        newIdentNode("ix")
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("dot")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      newIdentNode("T"),
      nnkIdentDefs.newTree(
        newIdentNode("u"),
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newIdentNode("N"),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    nnkPragma.newTree(
      newIdentNode("inline")
    ),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("length")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      newIdentNode("T"),
      nnkIdentDefs.newTree(
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newIdentNode("N"),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("cross")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      nnkBracketExpr.newTree(
        newIdentNode("Vec"),
        newLit(3),
        newIdentNode("T")
      ),
      nnkIdentDefs.newTree(
        newIdentNode("v1"),
        newIdentNode("v2"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newLit(3),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("normalizeWorks")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      nnkBracketExpr.newTree(
        newIdentNode("Vec"),
        newLit(3),
        newIdentNode("T")
      ),
      nnkIdentDefs.newTree(
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newLit(3),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("foo")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      nnkBracketExpr.newTree(
        newIdentNode("Vec"),
        newIdentNode("N"),
        newIdentNode("T")
      ),
      nnkIdentDefs.newTree(
        newIdentNode("u"),
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newIdentNode("N"),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("normalize")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      nnkBracketExpr.newTree(
        newIdentNode("Vec"),
        newIdentNode("N"),
        newIdentNode("T")
      ),
      nnkIdentDefs.newTree(
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newIdentNode("N"),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkTypeSection.newTree(
    nnkTypeDef.newTree(
      nnkPostfix.newTree(
        newIdentNode("*"),
        newIdentNode("Color")
      ),
      newEmptyNode(),
      nnkDistinctTy.newTree(
        nnkBracketExpr.newTree(
          newIdentNode("Vec3"),
          newIdentNode("float")
        )
      )
    )
  ),
  nnkTemplateDef.newTree(
    newIdentNode("borrowOps"),
    newEmptyNode(),
    newEmptyNode(),
    nnkFormalParams.newTree(
      newIdentNode("untyped"),
      nnkIdentDefs.newTree(
        newIdentNode("typ"),
        newIdentNode("typedesc"),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          nnkAccQuoted.newTree(
            newIdentNode("[]=")
          )
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("void"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            nnkVarTy.newTree(
              newIdentNode("typ")
            ),
            newEmptyNode()
          ),
          nnkIdentDefs.newTree(
            newIdentNode("ix"),
            newIdentNode("int"),
            newEmptyNode()
          ),
          nnkIdentDefs.newTree(
            newIdentNode("c"),
            newIdentNode("float"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          nnkAccQuoted.newTree(
            newIdentNode("[]")
          )
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("float"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("typ"),
            newEmptyNode()
          ),
          nnkIdentDefs.newTree(
            newIdentNode("ix"),
            newIdentNode("int"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("dot")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("float"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("u"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("cross")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("typ"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("u"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("length")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("float"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("normalizeWorks")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("typ"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("foo")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("typ"),
          nnkIdentDefs.newTree(
            newIdentNode("u"),
            newIdentNode("v"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("normalize")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("typ"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      )
    )
  ),
  nnkCall.newTree(
    newIdentNode("borrowOps"),
    newIdentNode("Color")
  )
)
1.4.0 👎 FAIL

Output

Error: Command failed: nim c --run  -d:nimDebugDlOpen -d:ssl -d:nimDisableCertificateValidation --forceBuild:on --colors: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(24, 10) template/generic instantiation of `borrowOps` from here
/home/runner/work/Nim/Nim/temp.nim(19, 3) Error: no symbol to borrow from found

Stats

  • Started 2023-09-05T12:41:42
  • Finished 2023-09-05T12:41:42
  • Duration

IR

Compiled filesize 90.64 Kb (92,816 bytes) 
#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
N_LIB_PRIVATE N_NIMCALL(void, nimTestErrorFlag)(void);
N_LIB_PRIVATE N_NIMCALL(void, atmdotdotatsdotdotatsdotdotatsdotchoosenimatstoolchainsatsnimminus2dot0dot0atslibatssystemdotnim_Init000)(void);
N_LIB_PRIVATE N_NIMCALL(void, NimMainModule)(void);
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;
	atmdotdotatsdotdotatsdotdotatsdotchoosenimatstoolchainsatsnimminus2dot0dot0atslibatssystemdotnim_Init000();
	(*inner)();
#else
	atmdotdotatsdotdotatsdotdotatsdotchoosenimatstoolchainsatsnimminus2dot0dot0atslibatssystemdotnim_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) {
{
	nimTestErrorFlag();
}
}

AST

nnkStmtList.newTree(
  nnkTypeSection.newTree(
    nnkTypeDef.newTree(
      nnkPostfix.newTree(
        newIdentNode("*"),
        newIdentNode("Vec")
      ),
      nnkGenericParams.newTree(
        nnkIdentDefs.newTree(
          newIdentNode("N"),
          nnkBracketExpr.newTree(
            newIdentNode("static"),
            newIdentNode("int")
          ),
          newEmptyNode()
        ),
        nnkIdentDefs.newTree(
          newIdentNode("T"),
          newIdentNode("SomeNumber"),
          newEmptyNode()
        )
      ),
      nnkObjectTy.newTree(
        newEmptyNode(),
        newEmptyNode(),
        nnkRecList.newTree(
          nnkIdentDefs.newTree(
            nnkPostfix.newTree(
              newIdentNode("*"),
              newIdentNode("arr")
            ),
            nnkBracketExpr.newTree(
              newIdentNode("array"),
              newIdentNode("N"),
              newIdentNode("T")
            ),
            newEmptyNode()
          )
        )
      )
    ),
    nnkTypeDef.newTree(
      nnkPostfix.newTree(
        newIdentNode("*"),
        newIdentNode("Vec3")
      ),
      nnkGenericParams.newTree(
        nnkIdentDefs.newTree(
          newIdentNode("T"),
          newIdentNode("SomeNumber"),
          newEmptyNode()
        )
      ),
      nnkBracketExpr.newTree(
        newIdentNode("Vec"),
        newLit(3),
        newIdentNode("T")
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      nnkAccQuoted.newTree(
        newIdentNode("[]=")
      )
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      newIdentNode("void"),
      nnkIdentDefs.newTree(
        newIdentNode("v"),
        nnkVarTy.newTree(
          nnkBracketExpr.newTree(
            newIdentNode("Vec"),
            newIdentNode("N"),
            newIdentNode("T")
          )
        ),
        newEmptyNode()
      ),
      nnkIdentDefs.newTree(
        newIdentNode("ix"),
        newIdentNode("int"),
        newEmptyNode()
      ),
      nnkIdentDefs.newTree(
        newIdentNode("c"),
        newIdentNode("T"),
        newEmptyNode()
      )
    ),
    nnkPragma.newTree(
      newIdentNode("inline")
    ),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkAsgn.newTree(
        nnkBracketExpr.newTree(
          nnkDotExpr.newTree(
            newIdentNode("v"),
            newIdentNode("arr")
          ),
          newIdentNode("ix")
        ),
        newIdentNode("c")
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      nnkAccQuoted.newTree(
        newIdentNode("[]")
      )
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      newIdentNode("T"),
      nnkIdentDefs.newTree(
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newIdentNode("N"),
          newIdentNode("T")
        ),
        newEmptyNode()
      ),
      nnkIdentDefs.newTree(
        newIdentNode("ix"),
        newIdentNode("int"),
        newEmptyNode()
      )
    ),
    nnkPragma.newTree(
      newIdentNode("inline")
    ),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkBracketExpr.newTree(
        nnkDotExpr.newTree(
          newIdentNode("v"),
          newIdentNode("arr")
        ),
        newIdentNode("ix")
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("dot")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      newIdentNode("T"),
      nnkIdentDefs.newTree(
        newIdentNode("u"),
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newIdentNode("N"),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    nnkPragma.newTree(
      newIdentNode("inline")
    ),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("length")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      newIdentNode("T"),
      nnkIdentDefs.newTree(
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newIdentNode("N"),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("cross")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      nnkBracketExpr.newTree(
        newIdentNode("Vec"),
        newLit(3),
        newIdentNode("T")
      ),
      nnkIdentDefs.newTree(
        newIdentNode("v1"),
        newIdentNode("v2"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newLit(3),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("normalizeWorks")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      nnkBracketExpr.newTree(
        newIdentNode("Vec"),
        newLit(3),
        newIdentNode("T")
      ),
      nnkIdentDefs.newTree(
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newLit(3),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("foo")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      nnkBracketExpr.newTree(
        newIdentNode("Vec"),
        newIdentNode("N"),
        newIdentNode("T")
      ),
      nnkIdentDefs.newTree(
        newIdentNode("u"),
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newIdentNode("N"),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("normalize")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      nnkBracketExpr.newTree(
        newIdentNode("Vec"),
        newIdentNode("N"),
        newIdentNode("T")
      ),
      nnkIdentDefs.newTree(
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newIdentNode("N"),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkTypeSection.newTree(
    nnkTypeDef.newTree(
      nnkPostfix.newTree(
        newIdentNode("*"),
        newIdentNode("Color")
      ),
      newEmptyNode(),
      nnkDistinctTy.newTree(
        nnkBracketExpr.newTree(
          newIdentNode("Vec3"),
          newIdentNode("float")
        )
      )
    )
  ),
  nnkTemplateDef.newTree(
    newIdentNode("borrowOps"),
    newEmptyNode(),
    newEmptyNode(),
    nnkFormalParams.newTree(
      newIdentNode("untyped"),
      nnkIdentDefs.newTree(
        newIdentNode("typ"),
        newIdentNode("typedesc"),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          nnkAccQuoted.newTree(
            newIdentNode("[]=")
          )
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("void"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            nnkVarTy.newTree(
              newIdentNode("typ")
            ),
            newEmptyNode()
          ),
          nnkIdentDefs.newTree(
            newIdentNode("ix"),
            newIdentNode("int"),
            newEmptyNode()
          ),
          nnkIdentDefs.newTree(
            newIdentNode("c"),
            newIdentNode("float"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          nnkAccQuoted.newTree(
            newIdentNode("[]")
          )
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("float"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("typ"),
            newEmptyNode()
          ),
          nnkIdentDefs.newTree(
            newIdentNode("ix"),
            newIdentNode("int"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("dot")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("float"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("u"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("cross")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("typ"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("u"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("length")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("float"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("normalizeWorks")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("typ"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("foo")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("typ"),
          nnkIdentDefs.newTree(
            newIdentNode("u"),
            newIdentNode("v"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("normalize")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("typ"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      )
    )
  ),
  nnkCall.newTree(
    newIdentNode("borrowOps"),
    newIdentNode("Color")
  )
)
1.2.0 👎 FAIL

Output

Error: Command failed: nim c --run  -d:nimDebugDlOpen -d:ssl -d:nimDisableCertificateValidation --forceBuild:on --colors: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(24, 10) template/generic instantiation of `borrowOps` from here
/home/runner/work/Nim/Nim/temp.nim(19, 3) Error: no symbol to borrow from found

Stats

  • Started 2023-09-05T12:41:56
  • Finished 2023-09-05T12:41:56
  • Duration

IR

Compiled filesize 90.64 Kb (92,816 bytes) 
#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
N_LIB_PRIVATE N_NIMCALL(void, nimTestErrorFlag)(void);
N_LIB_PRIVATE N_NIMCALL(void, atmdotdotatsdotdotatsdotdotatsdotchoosenimatstoolchainsatsnimminus2dot0dot0atslibatssystemdotnim_Init000)(void);
N_LIB_PRIVATE N_NIMCALL(void, NimMainModule)(void);
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;
	atmdotdotatsdotdotatsdotdotatsdotchoosenimatstoolchainsatsnimminus2dot0dot0atslibatssystemdotnim_Init000();
	(*inner)();
#else
	atmdotdotatsdotdotatsdotdotatsdotchoosenimatstoolchainsatsnimminus2dot0dot0atslibatssystemdotnim_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) {
{
	nimTestErrorFlag();
}
}

AST

nnkStmtList.newTree(
  nnkTypeSection.newTree(
    nnkTypeDef.newTree(
      nnkPostfix.newTree(
        newIdentNode("*"),
        newIdentNode("Vec")
      ),
      nnkGenericParams.newTree(
        nnkIdentDefs.newTree(
          newIdentNode("N"),
          nnkBracketExpr.newTree(
            newIdentNode("static"),
            newIdentNode("int")
          ),
          newEmptyNode()
        ),
        nnkIdentDefs.newTree(
          newIdentNode("T"),
          newIdentNode("SomeNumber"),
          newEmptyNode()
        )
      ),
      nnkObjectTy.newTree(
        newEmptyNode(),
        newEmptyNode(),
        nnkRecList.newTree(
          nnkIdentDefs.newTree(
            nnkPostfix.newTree(
              newIdentNode("*"),
              newIdentNode("arr")
            ),
            nnkBracketExpr.newTree(
              newIdentNode("array"),
              newIdentNode("N"),
              newIdentNode("T")
            ),
            newEmptyNode()
          )
        )
      )
    ),
    nnkTypeDef.newTree(
      nnkPostfix.newTree(
        newIdentNode("*"),
        newIdentNode("Vec3")
      ),
      nnkGenericParams.newTree(
        nnkIdentDefs.newTree(
          newIdentNode("T"),
          newIdentNode("SomeNumber"),
          newEmptyNode()
        )
      ),
      nnkBracketExpr.newTree(
        newIdentNode("Vec"),
        newLit(3),
        newIdentNode("T")
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      nnkAccQuoted.newTree(
        newIdentNode("[]=")
      )
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      newIdentNode("void"),
      nnkIdentDefs.newTree(
        newIdentNode("v"),
        nnkVarTy.newTree(
          nnkBracketExpr.newTree(
            newIdentNode("Vec"),
            newIdentNode("N"),
            newIdentNode("T")
          )
        ),
        newEmptyNode()
      ),
      nnkIdentDefs.newTree(
        newIdentNode("ix"),
        newIdentNode("int"),
        newEmptyNode()
      ),
      nnkIdentDefs.newTree(
        newIdentNode("c"),
        newIdentNode("T"),
        newEmptyNode()
      )
    ),
    nnkPragma.newTree(
      newIdentNode("inline")
    ),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkAsgn.newTree(
        nnkBracketExpr.newTree(
          nnkDotExpr.newTree(
            newIdentNode("v"),
            newIdentNode("arr")
          ),
          newIdentNode("ix")
        ),
        newIdentNode("c")
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      nnkAccQuoted.newTree(
        newIdentNode("[]")
      )
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      newIdentNode("T"),
      nnkIdentDefs.newTree(
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newIdentNode("N"),
          newIdentNode("T")
        ),
        newEmptyNode()
      ),
      nnkIdentDefs.newTree(
        newIdentNode("ix"),
        newIdentNode("int"),
        newEmptyNode()
      )
    ),
    nnkPragma.newTree(
      newIdentNode("inline")
    ),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkBracketExpr.newTree(
        nnkDotExpr.newTree(
          newIdentNode("v"),
          newIdentNode("arr")
        ),
        newIdentNode("ix")
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("dot")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      newIdentNode("T"),
      nnkIdentDefs.newTree(
        newIdentNode("u"),
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newIdentNode("N"),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    nnkPragma.newTree(
      newIdentNode("inline")
    ),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("length")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      newIdentNode("T"),
      nnkIdentDefs.newTree(
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newIdentNode("N"),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("cross")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      nnkBracketExpr.newTree(
        newIdentNode("Vec"),
        newLit(3),
        newIdentNode("T")
      ),
      nnkIdentDefs.newTree(
        newIdentNode("v1"),
        newIdentNode("v2"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newLit(3),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("normalizeWorks")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      nnkBracketExpr.newTree(
        newIdentNode("Vec"),
        newLit(3),
        newIdentNode("T")
      ),
      nnkIdentDefs.newTree(
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newLit(3),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("foo")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      nnkBracketExpr.newTree(
        newIdentNode("Vec"),
        newIdentNode("N"),
        newIdentNode("T")
      ),
      nnkIdentDefs.newTree(
        newIdentNode("u"),
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newIdentNode("N"),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("normalize")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      nnkBracketExpr.newTree(
        newIdentNode("Vec"),
        newIdentNode("N"),
        newIdentNode("T")
      ),
      nnkIdentDefs.newTree(
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newIdentNode("N"),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkTypeSection.newTree(
    nnkTypeDef.newTree(
      nnkPostfix.newTree(
        newIdentNode("*"),
        newIdentNode("Color")
      ),
      newEmptyNode(),
      nnkDistinctTy.newTree(
        nnkBracketExpr.newTree(
          newIdentNode("Vec3"),
          newIdentNode("float")
        )
      )
    )
  ),
  nnkTemplateDef.newTree(
    newIdentNode("borrowOps"),
    newEmptyNode(),
    newEmptyNode(),
    nnkFormalParams.newTree(
      newIdentNode("untyped"),
      nnkIdentDefs.newTree(
        newIdentNode("typ"),
        newIdentNode("typedesc"),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          nnkAccQuoted.newTree(
            newIdentNode("[]=")
          )
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("void"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            nnkVarTy.newTree(
              newIdentNode("typ")
            ),
            newEmptyNode()
          ),
          nnkIdentDefs.newTree(
            newIdentNode("ix"),
            newIdentNode("int"),
            newEmptyNode()
          ),
          nnkIdentDefs.newTree(
            newIdentNode("c"),
            newIdentNode("float"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          nnkAccQuoted.newTree(
            newIdentNode("[]")
          )
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("float"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("typ"),
            newEmptyNode()
          ),
          nnkIdentDefs.newTree(
            newIdentNode("ix"),
            newIdentNode("int"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("dot")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("float"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("u"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("cross")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("typ"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("u"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("length")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("float"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("normalizeWorks")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("typ"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("foo")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("typ"),
          nnkIdentDefs.newTree(
            newIdentNode("u"),
            newIdentNode("v"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("normalize")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("typ"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      )
    )
  ),
  nnkCall.newTree(
    newIdentNode("borrowOps"),
    newIdentNode("Color")
  )
)
1.0.0 👎 FAIL

Output

Error: Command failed: nim c --run  -d:nimDebugDlOpen -d:ssl -d:nimDisableCertificateValidation --forceBuild:on --colors: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(24, 10) template/generic instantiation of `borrowOps` from here
/home/runner/work/Nim/Nim/temp.nim(19, 3) Error: no symbol to borrow from found

Stats

  • Started 2023-09-05T12:42:08
  • Finished 2023-09-05T12:42:08
  • Duration

IR

Compiled filesize 90.64 Kb (92,816 bytes) 
#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
N_LIB_PRIVATE N_NIMCALL(void, nimTestErrorFlag)(void);
N_LIB_PRIVATE N_NIMCALL(void, atmdotdotatsdotdotatsdotdotatsdotchoosenimatstoolchainsatsnimminus2dot0dot0atslibatssystemdotnim_Init000)(void);
N_LIB_PRIVATE N_NIMCALL(void, NimMainModule)(void);
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;
	atmdotdotatsdotdotatsdotdotatsdotchoosenimatstoolchainsatsnimminus2dot0dot0atslibatssystemdotnim_Init000();
	(*inner)();
#else
	atmdotdotatsdotdotatsdotdotatsdotchoosenimatstoolchainsatsnimminus2dot0dot0atslibatssystemdotnim_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) {
{
	nimTestErrorFlag();
}
}

AST

nnkStmtList.newTree(
  nnkTypeSection.newTree(
    nnkTypeDef.newTree(
      nnkPostfix.newTree(
        newIdentNode("*"),
        newIdentNode("Vec")
      ),
      nnkGenericParams.newTree(
        nnkIdentDefs.newTree(
          newIdentNode("N"),
          nnkBracketExpr.newTree(
            newIdentNode("static"),
            newIdentNode("int")
          ),
          newEmptyNode()
        ),
        nnkIdentDefs.newTree(
          newIdentNode("T"),
          newIdentNode("SomeNumber"),
          newEmptyNode()
        )
      ),
      nnkObjectTy.newTree(
        newEmptyNode(),
        newEmptyNode(),
        nnkRecList.newTree(
          nnkIdentDefs.newTree(
            nnkPostfix.newTree(
              newIdentNode("*"),
              newIdentNode("arr")
            ),
            nnkBracketExpr.newTree(
              newIdentNode("array"),
              newIdentNode("N"),
              newIdentNode("T")
            ),
            newEmptyNode()
          )
        )
      )
    ),
    nnkTypeDef.newTree(
      nnkPostfix.newTree(
        newIdentNode("*"),
        newIdentNode("Vec3")
      ),
      nnkGenericParams.newTree(
        nnkIdentDefs.newTree(
          newIdentNode("T"),
          newIdentNode("SomeNumber"),
          newEmptyNode()
        )
      ),
      nnkBracketExpr.newTree(
        newIdentNode("Vec"),
        newLit(3),
        newIdentNode("T")
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      nnkAccQuoted.newTree(
        newIdentNode("[]=")
      )
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      newIdentNode("void"),
      nnkIdentDefs.newTree(
        newIdentNode("v"),
        nnkVarTy.newTree(
          nnkBracketExpr.newTree(
            newIdentNode("Vec"),
            newIdentNode("N"),
            newIdentNode("T")
          )
        ),
        newEmptyNode()
      ),
      nnkIdentDefs.newTree(
        newIdentNode("ix"),
        newIdentNode("int"),
        newEmptyNode()
      ),
      nnkIdentDefs.newTree(
        newIdentNode("c"),
        newIdentNode("T"),
        newEmptyNode()
      )
    ),
    nnkPragma.newTree(
      newIdentNode("inline")
    ),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkAsgn.newTree(
        nnkBracketExpr.newTree(
          nnkDotExpr.newTree(
            newIdentNode("v"),
            newIdentNode("arr")
          ),
          newIdentNode("ix")
        ),
        newIdentNode("c")
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      nnkAccQuoted.newTree(
        newIdentNode("[]")
      )
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      newIdentNode("T"),
      nnkIdentDefs.newTree(
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newIdentNode("N"),
          newIdentNode("T")
        ),
        newEmptyNode()
      ),
      nnkIdentDefs.newTree(
        newIdentNode("ix"),
        newIdentNode("int"),
        newEmptyNode()
      )
    ),
    nnkPragma.newTree(
      newIdentNode("inline")
    ),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkBracketExpr.newTree(
        nnkDotExpr.newTree(
          newIdentNode("v"),
          newIdentNode("arr")
        ),
        newIdentNode("ix")
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("dot")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      newIdentNode("T"),
      nnkIdentDefs.newTree(
        newIdentNode("u"),
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newIdentNode("N"),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    nnkPragma.newTree(
      newIdentNode("inline")
    ),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("length")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      newIdentNode("T"),
      nnkIdentDefs.newTree(
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newIdentNode("N"),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("cross")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      nnkBracketExpr.newTree(
        newIdentNode("Vec"),
        newLit(3),
        newIdentNode("T")
      ),
      nnkIdentDefs.newTree(
        newIdentNode("v1"),
        newIdentNode("v2"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newLit(3),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("normalizeWorks")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      nnkBracketExpr.newTree(
        newIdentNode("Vec"),
        newLit(3),
        newIdentNode("T")
      ),
      nnkIdentDefs.newTree(
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newLit(3),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("foo")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      nnkBracketExpr.newTree(
        newIdentNode("Vec"),
        newIdentNode("N"),
        newIdentNode("T")
      ),
      nnkIdentDefs.newTree(
        newIdentNode("u"),
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newIdentNode("N"),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("normalize")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      nnkBracketExpr.newTree(
        newIdentNode("Vec"),
        newIdentNode("N"),
        newIdentNode("T")
      ),
      nnkIdentDefs.newTree(
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newIdentNode("N"),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkTypeSection.newTree(
    nnkTypeDef.newTree(
      nnkPostfix.newTree(
        newIdentNode("*"),
        newIdentNode("Color")
      ),
      newEmptyNode(),
      nnkDistinctTy.newTree(
        nnkBracketExpr.newTree(
          newIdentNode("Vec3"),
          newIdentNode("float")
        )
      )
    )
  ),
  nnkTemplateDef.newTree(
    newIdentNode("borrowOps"),
    newEmptyNode(),
    newEmptyNode(),
    nnkFormalParams.newTree(
      newIdentNode("untyped"),
      nnkIdentDefs.newTree(
        newIdentNode("typ"),
        newIdentNode("typedesc"),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          nnkAccQuoted.newTree(
            newIdentNode("[]=")
          )
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("void"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            nnkVarTy.newTree(
              newIdentNode("typ")
            ),
            newEmptyNode()
          ),
          nnkIdentDefs.newTree(
            newIdentNode("ix"),
            newIdentNode("int"),
            newEmptyNode()
          ),
          nnkIdentDefs.newTree(
            newIdentNode("c"),
            newIdentNode("float"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          nnkAccQuoted.newTree(
            newIdentNode("[]")
          )
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("float"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("typ"),
            newEmptyNode()
          ),
          nnkIdentDefs.newTree(
            newIdentNode("ix"),
            newIdentNode("int"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("dot")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("float"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("u"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("cross")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("typ"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("u"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("length")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("float"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("normalizeWorks")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("typ"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("foo")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("typ"),
          nnkIdentDefs.newTree(
            newIdentNode("u"),
            newIdentNode("v"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("normalize")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("typ"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      )
    )
  ),
  nnkCall.newTree(
    newIdentNode("borrowOps"),
    newIdentNode("Color")
  )
)
0.20.2 👎 FAIL

Output

Error: Command failed: nim c --run  -d:nimDebugDlOpen -d:ssl -d:nimDisableCertificateValidation --forceBuild:on --colors: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(24, 10) template/generic instantiation of `borrowOps` from here
/home/runner/work/Nim/Nim/temp.nim(19, 3) Error: no symbol to borrow from found

Stats

  • Started 2023-09-05T12:42:17
  • Finished 2023-09-05T12:42:18
  • Duration

IR

Compiled filesize 90.64 Kb (92,816 bytes) 
#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
N_LIB_PRIVATE N_NIMCALL(void, nimTestErrorFlag)(void);
N_LIB_PRIVATE N_NIMCALL(void, atmdotdotatsdotdotatsdotdotatsdotchoosenimatstoolchainsatsnimminus2dot0dot0atslibatssystemdotnim_Init000)(void);
N_LIB_PRIVATE N_NIMCALL(void, NimMainModule)(void);
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;
	atmdotdotatsdotdotatsdotdotatsdotchoosenimatstoolchainsatsnimminus2dot0dot0atslibatssystemdotnim_Init000();
	(*inner)();
#else
	atmdotdotatsdotdotatsdotdotatsdotchoosenimatstoolchainsatsnimminus2dot0dot0atslibatssystemdotnim_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) {
{
	nimTestErrorFlag();
}
}

AST

nnkStmtList.newTree(
  nnkTypeSection.newTree(
    nnkTypeDef.newTree(
      nnkPostfix.newTree(
        newIdentNode("*"),
        newIdentNode("Vec")
      ),
      nnkGenericParams.newTree(
        nnkIdentDefs.newTree(
          newIdentNode("N"),
          nnkBracketExpr.newTree(
            newIdentNode("static"),
            newIdentNode("int")
          ),
          newEmptyNode()
        ),
        nnkIdentDefs.newTree(
          newIdentNode("T"),
          newIdentNode("SomeNumber"),
          newEmptyNode()
        )
      ),
      nnkObjectTy.newTree(
        newEmptyNode(),
        newEmptyNode(),
        nnkRecList.newTree(
          nnkIdentDefs.newTree(
            nnkPostfix.newTree(
              newIdentNode("*"),
              newIdentNode("arr")
            ),
            nnkBracketExpr.newTree(
              newIdentNode("array"),
              newIdentNode("N"),
              newIdentNode("T")
            ),
            newEmptyNode()
          )
        )
      )
    ),
    nnkTypeDef.newTree(
      nnkPostfix.newTree(
        newIdentNode("*"),
        newIdentNode("Vec3")
      ),
      nnkGenericParams.newTree(
        nnkIdentDefs.newTree(
          newIdentNode("T"),
          newIdentNode("SomeNumber"),
          newEmptyNode()
        )
      ),
      nnkBracketExpr.newTree(
        newIdentNode("Vec"),
        newLit(3),
        newIdentNode("T")
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      nnkAccQuoted.newTree(
        newIdentNode("[]=")
      )
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      newIdentNode("void"),
      nnkIdentDefs.newTree(
        newIdentNode("v"),
        nnkVarTy.newTree(
          nnkBracketExpr.newTree(
            newIdentNode("Vec"),
            newIdentNode("N"),
            newIdentNode("T")
          )
        ),
        newEmptyNode()
      ),
      nnkIdentDefs.newTree(
        newIdentNode("ix"),
        newIdentNode("int"),
        newEmptyNode()
      ),
      nnkIdentDefs.newTree(
        newIdentNode("c"),
        newIdentNode("T"),
        newEmptyNode()
      )
    ),
    nnkPragma.newTree(
      newIdentNode("inline")
    ),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkAsgn.newTree(
        nnkBracketExpr.newTree(
          nnkDotExpr.newTree(
            newIdentNode("v"),
            newIdentNode("arr")
          ),
          newIdentNode("ix")
        ),
        newIdentNode("c")
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      nnkAccQuoted.newTree(
        newIdentNode("[]")
      )
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      newIdentNode("T"),
      nnkIdentDefs.newTree(
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newIdentNode("N"),
          newIdentNode("T")
        ),
        newEmptyNode()
      ),
      nnkIdentDefs.newTree(
        newIdentNode("ix"),
        newIdentNode("int"),
        newEmptyNode()
      )
    ),
    nnkPragma.newTree(
      newIdentNode("inline")
    ),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkBracketExpr.newTree(
        nnkDotExpr.newTree(
          newIdentNode("v"),
          newIdentNode("arr")
        ),
        newIdentNode("ix")
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("dot")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      newIdentNode("T"),
      nnkIdentDefs.newTree(
        newIdentNode("u"),
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newIdentNode("N"),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    nnkPragma.newTree(
      newIdentNode("inline")
    ),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("length")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      newIdentNode("T"),
      nnkIdentDefs.newTree(
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newIdentNode("N"),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("cross")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      nnkBracketExpr.newTree(
        newIdentNode("Vec"),
        newLit(3),
        newIdentNode("T")
      ),
      nnkIdentDefs.newTree(
        newIdentNode("v1"),
        newIdentNode("v2"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newLit(3),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("normalizeWorks")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      nnkBracketExpr.newTree(
        newIdentNode("Vec"),
        newLit(3),
        newIdentNode("T")
      ),
      nnkIdentDefs.newTree(
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newLit(3),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("foo")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      nnkBracketExpr.newTree(
        newIdentNode("Vec"),
        newIdentNode("N"),
        newIdentNode("T")
      ),
      nnkIdentDefs.newTree(
        newIdentNode("u"),
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newIdentNode("N"),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkProcDef.newTree(
    nnkPostfix.newTree(
      newIdentNode("*"),
      newIdentNode("normalize")
    ),
    newEmptyNode(),
    nnkGenericParams.newTree(
      nnkIdentDefs.newTree(
        newIdentNode("N"),
        newIdentNode("T"),
        newEmptyNode(),
        newEmptyNode()
      )
    ),
    nnkFormalParams.newTree(
      nnkBracketExpr.newTree(
        newIdentNode("Vec"),
        newIdentNode("N"),
        newIdentNode("T")
      ),
      nnkIdentDefs.newTree(
        newIdentNode("v"),
        nnkBracketExpr.newTree(
          newIdentNode("Vec"),
          newIdentNode("N"),
          newIdentNode("T")
        ),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkDiscardStmt.newTree(
        newEmptyNode()
      )
    )
  ),
  nnkTypeSection.newTree(
    nnkTypeDef.newTree(
      nnkPostfix.newTree(
        newIdentNode("*"),
        newIdentNode("Color")
      ),
      newEmptyNode(),
      nnkDistinctTy.newTree(
        nnkBracketExpr.newTree(
          newIdentNode("Vec3"),
          newIdentNode("float")
        )
      )
    )
  ),
  nnkTemplateDef.newTree(
    newIdentNode("borrowOps"),
    newEmptyNode(),
    newEmptyNode(),
    nnkFormalParams.newTree(
      newIdentNode("untyped"),
      nnkIdentDefs.newTree(
        newIdentNode("typ"),
        newIdentNode("typedesc"),
        newEmptyNode()
      )
    ),
    newEmptyNode(),
    newEmptyNode(),
    nnkStmtList.newTree(
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          nnkAccQuoted.newTree(
            newIdentNode("[]=")
          )
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("void"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            nnkVarTy.newTree(
              newIdentNode("typ")
            ),
            newEmptyNode()
          ),
          nnkIdentDefs.newTree(
            newIdentNode("ix"),
            newIdentNode("int"),
            newEmptyNode()
          ),
          nnkIdentDefs.newTree(
            newIdentNode("c"),
            newIdentNode("float"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          nnkAccQuoted.newTree(
            newIdentNode("[]")
          )
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("float"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("typ"),
            newEmptyNode()
          ),
          nnkIdentDefs.newTree(
            newIdentNode("ix"),
            newIdentNode("int"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("dot")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("float"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("u"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("cross")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("typ"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("u"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("length")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("float"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("normalizeWorks")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("typ"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("foo")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("typ"),
          nnkIdentDefs.newTree(
            newIdentNode("u"),
            newIdentNode("v"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      ),
      nnkProcDef.newTree(
        nnkPostfix.newTree(
          newIdentNode("*"),
          newIdentNode("normalize")
        ),
        newEmptyNode(),
        newEmptyNode(),
        nnkFormalParams.newTree(
          newIdentNode("typ"),
          nnkIdentDefs.newTree(
            newIdentNode("v"),
            newIdentNode("typ"),
            newEmptyNode()
          )
        ),
        nnkPragma.newTree(
          newIdentNode("borrow")
        ),
        newEmptyNode(),
        newEmptyNode()
      )
    )
  ),
  nnkCall.newTree(
    newIdentNode("borrowOps"),
    newIdentNode("Color")
  )
)
Stats
  • GCC 11.4.0
  • LibC 2.35
  • Valgrind 3.18.1
  • NodeJS 17.1
  • Linux 5.15.0
  • Created 2023-09-05T12:40:50Z
  • Comments 1
  • Commands nim c --run -d:nimDebugDlOpen -d:ssl -d:nimDisableCertificateValidation --forceBuild:on --colors: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

🤖 Bug found in bisecting 8 commits at 12 commits per second.

@juancarlospaco
Copy link
Collaborator

Fixed on devel ?. 🤔

@Vindaar
Copy link
Contributor Author

Vindaar commented Sep 5, 2023

Fixed on devel ?. 🤔

Does the git bisecting helper always use the latest HEAD?

@juancarlospaco
Copy link
Collaborator

juancarlospaco commented Sep 5, 2023 •
edited
Loading

Does the git bisecting helper always use the latest HEAD?

Yeah it does, maybe try compiling latest head on your local?, which platform?.

@Vindaar
Copy link
Contributor Author

Vindaar commented Sep 5, 2023

Does the git bisecting helper always use the latest HEAD?

Yeah it does, maybe try compiling latest head on your local?, which platform?.

Uh, see my Nim version above. That is the latest head.

This was referenced Sep 5, 2023
Closed
Closed
metagn added a commit to metagn/Nim that referenced this issue Sep 5, 2023
@metagn
simpler, test nim-lang#22646
653790d
metagn added a commit to metagn/Nim that referenced this issue Sep 5, 2023
@metagn
fully revert generic inst sym change, test nim-lang#22646
9e8c3bf 
reverts nim-lang#22642, reopens nim-lang#22639, closes nim-lang#22646, refs nim-lang#22640, refs alaviss/union#51
@metagn metagn mentioned this issue Sep 5, 2023
Merged
metagn added a commit that referenced this issue Sep 6, 2023
@metagn
fully revert generic inst sym change, test #22646 (#22653)
90f87bc 
reverts #22642, reopens #22639, closes #22646, refs #22650, refs
alaviss/union#51, refs #22652

The fallout is too much from #22642, we can come back to it if we can
account for all the affected code.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
Generics
Projects
None yet
Milestone
No milestone
2 participants
@juancarlospaco @Vindaar