Mirror of forum.nim-lang.org

9481 :: internal error: cannot map the empty seq type to a C type

• drkameleon (orginal) [2022-09-20T18:09:33+02:00] view original

  I have a proc with several params, some of them with default values (most of them bool types, one or two of them containing with a seq, initialized to = @[].

  When I attempt to add a couple of when..`else` clauses inside (based on static params - totally, known beforehand), I keep getting the error below:

  
  Error: internal error: cannot map the empty seq type to a C type
  No stack traceback available
  To create a stacktrace, rerun compilation with './koch temp c <file>', see https://nim-lang.github.io/Nim/intern.html#debugging-the-compiler for details
  Run

  I know I'm doing something template-ish (that should probably be done with a template - I guess, in these cases, the compiler would create like 2, or more, versions of the same proc). However, it would be quite practical if it did work.

  Is there any workaround to that? Should I open an issue?

---

• shirleyquirk (orginal) [2022-09-20T20:29:10+02:00] view original

  I'd be interested to see a mre if you can cook one up.

---

• drkameleon (orginal) [2022-09-21T10:29:39+02:00] view original

  I'm trying to create a totally-minimal example of the above in order to reproduce the error.

  I haven't managed to reproduce it exactly, but I've still managed to make another one appear (I guess there is some bug with static vars and procs).

  For example, this works fine:

  type
      myType = (seq[string],seq[byte])
  
  const
      NoValues = @[]
      NoType = (@[],@[])
  
  proc doSth*(b: bool, k: seq[string] = NoValues, s: myType = NoType) =
      echo $(k)
      if b:
          echo "b is true"
      else:
          echo "b is false"
  
  when isMainModule:
      doSth(true, k = @["one"])
      doSth(false)
  Run

  When I change the first parameter to a static one (b) and the if b clause to when b, I get an error (but this time not from Nim; from C):

  type
      myType = (seq[string],seq[byte])
  
  const
      NoValues = @[]
      NoType = (@[],@[])
  
  proc doSth*(b: static bool, k: seq[string] = NoValues, s: myType = NoType) =
      echo $(k)
      when b:
          echo "b is true"
      else:
          echo "b is false"
  
  when isMainModule:
      doSth(true, k = @["one"])
      doSth(false)
  Run

  And here's the error:

  
  error: too few arguments to function call, expected 2, have 1
          doSth__testproc_340((&TM__bVh71eSz1HejpWnlwyn4pQ_6));
          ~~~~~~~~~~~~~~~~~~~                                ^
  
  ....
  
  note: 'doSth__testproc_340' declared here
  N_LIB_PRIVATE N_NIMCALL(void, doSth__testproc_340)(tySequence__sM4lkSb7zS6F7OVMvW9cffQ k, tyTuple__Ke6S9bQtTdrMuzhn9a2ct9bXQ* s) {
                                ^
  1 error generated.
  Run

  And that's the complete generated code:

  #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_(x, y)
  #define nimln_(x, y)
  typedef struct tySequence__sM4lkSb7zS6F7OVMvW9cffQ tySequence__sM4lkSb7zS6F7OVMvW9cffQ;
  typedef struct tySequence__sM4lkSb7zS6F7OVMvW9cffQ_Content tySequence__sM4lkSb7zS6F7OVMvW9cffQ_Content;
  typedef struct tyTuple__Ke6S9bQtTdrMuzhn9a2ct9bXQ tyTuple__Ke6S9bQtTdrMuzhn9a2ct9bXQ;
  typedef struct NimStrPayload NimStrPayload;
  typedef struct NimStringV2 NimStringV2;
  typedef struct tySequence__6H5Oh5UUvVCLiakt9aTwtUQ tySequence__6H5Oh5UUvVCLiakt9aTwtUQ;
  typedef struct tySequence__6H5Oh5UUvVCLiakt9aTwtUQ_Content tySequence__6H5Oh5UUvVCLiakt9aTwtUQ_Content;
  struct tySequence__sM4lkSb7zS6F7OVMvW9cffQ {
    NI len; tySequence__sM4lkSb7zS6F7OVMvW9cffQ_Content* p;
  };
  struct NimStrPayload {
  NI cap;
  NIM_CHAR data[SEQ_DECL_SIZE];
  };
  struct NimStringV2 {
  NI len;
  NimStrPayload* p;
  };
  typedef NimStringV2 tyArray__nHXaesL0DJZHyVS07ARPRA[1];
  struct tySequence__6H5Oh5UUvVCLiakt9aTwtUQ {
    NI len; tySequence__6H5Oh5UUvVCLiakt9aTwtUQ_Content* p;
  };
  struct tyTuple__Ke6S9bQtTdrMuzhn9a2ct9bXQ {
  tySequence__sM4lkSb7zS6F7OVMvW9cffQ Field0;
  tySequence__6H5Oh5UUvVCLiakt9aTwtUQ Field1;
  };
  
  
  #ifndef tySequence__sM4lkSb7zS6F7OVMvW9cffQ_Content_PP
  #define tySequence__sM4lkSb7zS6F7OVMvW9cffQ_Content_PP
  struct tySequence__sM4lkSb7zS6F7OVMvW9cffQ_Content { NI cap; NimStringV2 data[SEQ_DECL_SIZE];};
  #endif
  
  
  
  #ifndef tySequence__6H5Oh5UUvVCLiakt9aTwtUQ_Content_PP
  #define tySequence__6H5Oh5UUvVCLiakt9aTwtUQ_Content_PP
  struct tySequence__6H5Oh5UUvVCLiakt9aTwtUQ_Content { NI cap; NU8 data[SEQ_DECL_SIZE];};
  #endif
  
  
  
  #ifndef tySequence__sM4lkSb7zS6F7OVMvW9cffQ_Content_PP
  #define tySequence__sM4lkSb7zS6F7OVMvW9cffQ_Content_PP
  struct tySequence__sM4lkSb7zS6F7OVMvW9cffQ_Content { NI cap; NimStringV2 data[SEQ_DECL_SIZE];};
  #endif
  
  
  
  #ifndef tySequence__sM4lkSb7zS6F7OVMvW9cffQ_Content_PP
  #define tySequence__sM4lkSb7zS6F7OVMvW9cffQ_Content_PP
  struct tySequence__sM4lkSb7zS6F7OVMvW9cffQ_Content { NI cap; NimStringV2 data[SEQ_DECL_SIZE];};
  #endif
  
  
  
  #ifndef tySequence__sM4lkSb7zS6F7OVMvW9cffQ_Content_PP
  #define tySequence__sM4lkSb7zS6F7OVMvW9cffQ_Content_PP
  struct tySequence__sM4lkSb7zS6F7OVMvW9cffQ_Content { NI cap; NimStringV2 data[SEQ_DECL_SIZE];};
  #endif
        
        N_LIB_PRIVATE N_NIMCALL(void, doSth__testproc_16)(NIM_BOOL b, tySequence__sM4lkSb7zS6F7OVMvW9cffQ k, tyTuple__Ke6S9bQtTdrMuzhn9a2ct9bXQ* s);
  N_LIB_PRIVATE N_NIMCALL(NimStringV2, dollar___testproc_20)(tySequence__sM4lkSb7zS6F7OVMvW9cffQ x);
  N_LIB_PRIVATE N_NIMCALL(void, echoBinSafe)(NimStringV2* args, NI argsLen_0);
  N_LIB_PRIVATE N_NIMCALL(void, eqdestroy___system_3263)(NimStringV2* dest);
  static N_INLINE(NIM_BOOL*, nimErrorFlag)(void);
  N_LIB_PRIVATE N_NIMCALL(void*, newSeqPayload)(NI cap, NI elemSize, NI elemAlign);
  N_LIB_PRIVATE N_NIMCALL(void, eqdestroy___system_3756)(tySequence__sM4lkSb7zS6F7OVMvW9cffQ* dest);
  N_LIB_PRIVATE N_NIMCALL(void, nimTestErrorFlag)(void);
  static N_INLINE(void, initStackBottomWith)(void* locals);
  N_LIB_PRIVATE N_NIMCALL(void, systemInit000)(void);
  N_LIB_PRIVATE N_NIMCALL(void, NimMainModule)(void);
  static const struct {
    NI cap; NIM_CHAR data[9+1];
  } TM__bVh71eSz1HejpWnlwyn4pQ_3 = { 9 | NIM_STRLIT_FLAG, "b is true" };
  static NIM_CONST tyArray__nHXaesL0DJZHyVS07ARPRA TM__bVh71eSz1HejpWnlwyn4pQ_2 = {{9, (NimStrPayload*)&TM__bVh71eSz1HejpWnlwyn4pQ_3}}
  ;
  static const struct {
    NI cap; NIM_CHAR data[10+1];
  } TM__bVh71eSz1HejpWnlwyn4pQ_5 = { 10 | NIM_STRLIT_FLAG, "b is false" };
  static NIM_CONST tyArray__nHXaesL0DJZHyVS07ARPRA TM__bVh71eSz1HejpWnlwyn4pQ_4 = {{10, (NimStrPayload*)&TM__bVh71eSz1HejpWnlwyn4pQ_5}}
  ;
  static const struct {
    NI cap; NIM_CHAR data[3+1];
  } TM__bVh71eSz1HejpWnlwyn4pQ_6 = { 3 | NIM_STRLIT_FLAG, "one" };
  static const NimStringV2 TM__bVh71eSz1HejpWnlwyn4pQ_7 = {3, (NimStrPayload*)&TM__bVh71eSz1HejpWnlwyn4pQ_6};
  static const struct {
    NI cap; NimStringV2 data[0];
  } TM__bVh71eSz1HejpWnlwyn4pQ_9 = {0 | NIM_STRLIT_FLAG, {}};
  static const struct {
    NI cap; NU8 data[0];
  } TM__bVh71eSz1HejpWnlwyn4pQ_10 = {0 | NIM_STRLIT_FLAG, {}};
  static NIM_CONST tyTuple__Ke6S9bQtTdrMuzhn9a2ct9bXQ TM__bVh71eSz1HejpWnlwyn4pQ_8 = {{0, (tySequence__sM4lkSb7zS6F7OVMvW9cffQ_Content*)&TM__bVh71eSz1HejpWnlwyn4pQ_9},
  {0, (tySequence__6H5Oh5UUvVCLiakt9aTwtUQ_Content*)&TM__bVh71eSz1HejpWnlwyn4pQ_10}}
  ;
  extern NIM_BOOL nimInErrorMode__system_4237;
  static N_INLINE(NIM_BOOL*, nimErrorFlag)(void) {
          NIM_BOOL* result;
          result = (NIM_BOOL*)0;
          result = (&nimInErrorMode__system_4237);
          return result;
  }
  N_LIB_PRIVATE N_NIMCALL(void, doSth__testproc_16)(NIM_BOOL b, tySequence__sM4lkSb7zS6F7OVMvW9cffQ k, tyTuple__Ke6S9bQtTdrMuzhn9a2ct9bXQ* s) {
          NimStringV2 colontmpD_;
          tyArray__nHXaesL0DJZHyVS07ARPRA T2_;
  NIM_BOOL* nimErr_;
  {nimErr_ = nimErrorFlag();
          colontmpD_.len = 0; colontmpD_.p = NIM_NIL;
          colontmpD_ = dollar___testproc_20(k);
          if (NIM_UNLIKELY(*nimErr_)) goto LA1_;
          T2_[0] = colontmpD_;
          echoBinSafe(T2_, 1);
          {
                  if (!b) goto LA5_;
                  echoBinSafe(TM__bVh71eSz1HejpWnlwyn4pQ_2, 1);
          }
          goto LA3_;
          LA5_: ;
          {
                  echoBinSafe(TM__bVh71eSz1HejpWnlwyn4pQ_4, 1);
          }
          LA3_: ;
          {
                  LA1_:;
          }
          {
                  eqdestroy___system_3263((&colontmpD_));
          }
          if (NIM_UNLIKELY(*nimErr_)) goto BeforeRet_;
          }BeforeRet_: ;
  }
  static N_INLINE(void, initStackBottomWith)(void* locals) {
  }
  
  N_LIB_PRIVATE void PreMainInner(void) {
  }
  
  N_LIB_PRIVATE int cmdCount;
  N_LIB_PRIVATE char** cmdLine;
  N_LIB_PRIVATE char** gEnv;
  N_LIB_PRIVATE void PreMain(void) {
          void (*volatile inner)(void);
          inner = PreMainInner;
          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) {
  {
          tySequence__sM4lkSb7zS6F7OVMvW9cffQ colontmpD_;
          tySequence__sM4lkSb7zS6F7OVMvW9cffQ T1_;
  NIM_BOOL* nimErr_;
  nimErr_ = nimErrorFlag();
          colontmpD_.len = 0; colontmpD_.p = NIM_NIL;
          colontmpD_.len = 1; colontmpD_.p = (tySequence__sM4lkSb7zS6F7OVMvW9cffQ_Content*) newSeqPayload(1, sizeof(NimStringV2), NIM_ALIGNOF(NimStringV2));
          colontmpD_.p->data[0] = TM__bVh71eSz1HejpWnlwyn4pQ_7;
          doSth__testproc_16(NIM_TRUE, colontmpD_, (&TM__bVh71eSz1HejpWnlwyn4pQ_8));
          if (NIM_UNLIKELY(*nimErr_)) goto BeforeRet_;
          T1_.len = 0; T1_.p = NIM_NIL;
          T1_.len = 0; T1_.p = (tySequence__sM4lkSb7zS6F7OVMvW9cffQ_Content*) newSeqPayload(0, sizeof(NimStringV2), NIM_ALIGNOF(NimStringV2));
          doSth__testproc_16(NIM_FALSE, T1_, (&TM__bVh71eSz1HejpWnlwyn4pQ_8));
          if (NIM_UNLIKELY(*nimErr_)) goto BeforeRet_;
          eqdestroy___system_3756((&colontmpD_));
          BeforeRet_: ;
          nimTestErrorFlag();
  }
  }
  
  Run

---

• shirleyquirk (orginal) [2022-09-21T12:49:15+02:00] view original

  First thought, before reading deeper: const NoValues = @[] has no type and shouldn't compile. template NoValues = @[] might work

---

• drkameleon (orginal) [2022-09-21T13:31:24+02:00] view original

  Well, I kind of agree with you that it shouldn't have compiled. But since it's quite early code and was left there as-is, I can assure you it was compiling just fine.

  But yes, the culprit is there I guess.

  ---

  P.S. I have - obviously - come up with a workaround to all this, but involved changing quite a few things...

---

• Araq (orginal) [2022-09-29T17:16:32+02:00] view original

  What about a real bug report with a reduced example that reproduces the problem?

---