Compiler segfaults

[jameshfisher]

Experimenting with Nimrod today, I was able to make the compiler segfault by attempting to compile:

type Node = tuple[left: ref Node]

proc traverse(root: ref Node) =
  if root.left != nil: traverse(root.left)

This code is nonsense, but on the principle that the compiler should never segfault, I'm suggesting this is a bug. I'm not certain what in the code is causing it, but it seems to at least require: the tuple (the equivalent object does not cause a segfault), the recursive reference in the tuple, and the recursive proc.

Nimrod was compiled on Ubuntu 10.04, on an AMD-64 architecture. I'm compiling the above code like so:

james@bast:~/nim_hw$ nimrod c hw.nim
Hint: used config file '/home/james/nimrod/config/nimrod.cfg' [Conf]
Hint: system [Processing]
Hint: hw [Processing]
Segmentation fault

[dom96]

Thanks for reporting the issue, it is a known issue but still. This isn't really a major issue since recursive tuples don't make much sense anyway.
But you're right the compiler shouldn't segfault.

[jameshfisher]

I'm not sure I understand why recursive tuples shouldn't make sense. Tuples seem to be similar to C structs, which can and should be recursive. What's the difference between tuples and objects in Nimrod that means objects can contain references to themselves, but tuples can't? Why, e.g., does this not make sense:

type
  PNode = ref Node
  Node = tuple[left, right: PNode, value: int]

proc least(root: PNode): int =
  if root.left != nil: return least(root.left)
  return root.value

BTW, here's the simplest code I can find that causes the problem:

type A = tuple[B: ptr A]
proc C(D: ptr A) = C(D.B)

[Araq]

Well, tuples can be recursive, it's just that the compiler does not support them yet and thanks to objects it's easy to work around this bug for now.

[jameshfisher]

Ah, OK.