while ((currentType = getSubType(currentType)) != 0)
allocateSymbolTableEntry (currentType);

As I said, a similar construct compiles fine when using C# or C++. I suspect it works in C# because generics are instantiated at runtime by the CLR, whereas the Delphi compiler has to resolve every instantiation during compile time. In C++ it works because the compiler doesn’t need more than a forward declaration for a certain type in order to use pointers to that type, so it doesn’t attempt to actually instantiate the template.

It should be possible to fix without the Halting problem getting in the way – I guess you would just check whether an instantiation of TFoo<SomethingElse<T, …>, …> was triggered by TFoo<T, …> – but given the work and the compile-time overhead involved, it’s probably not worth the effort.

Barry: I see. Any way to fix this without having to solve the Halting Problem? Also, I’m a bit surprised that this infinite recursion dies from Out Of Memory (heap exhaustion) and not Stack Overflow. Isn’t that what usually happens to infinite recursion?

The problem type is TNodeList = THierarchyTreeList<THierarchyTreeNode<T>> – it should be TNodeList = THierarchyTreeList<T>.

The ancestor of THierarchyTreeList`1 calls the type constructor of TObjectList`1, but not after first calling the type constructor THierarchyTreeNode`1. But the argument to THierarchyTreeList`1 from TNodeList already included the call to THierarchyTreeNode`1. The instantiation of THierarchyTreeNode`1 will trigger another, different THierarchyTreeList`1, and so on and so forth.

I guess my reluctance to use templated types should be explained the same way that a guy who is scared of arrays would explain himself. It’s not one array that scares me, he would say, it’s an array of array of arrays of arrays. And so on. And a list of trees of lists of all templated types. Well, lots of brackets is one problem there.

I changed the code to make a forward declaration of TEnumerator that is not necessarily a templated type, just so TEnumerator (without ) resolves:

TEnumerator = class;

THierarchyTreeNode = class
// private type
// TEnumerator = class(TEnumerator)

No more crash. So that private type appears to be one item on the path of the compiler’s endless recursion or looping.

W

you say “even though the definition is not infinitely recursive” – I’d give that statement another thought.

THierarchyTreeNode has a list of descendent nodes, FList. This is supposed to be a list of THierarchyTreeNode objects. You declare FList with the type THierarchyTreeList<THierarchyTreeNode>. But THierarchyTreeList inherits from TObjectList<THierarchyTreeNode> – which effectively gives you a list of nodes of type THierarchyTreeNode<THierarchyTreeNode>, which is both recursive and probably not what you’re longing for.

You should be able to get it to work as expected if you define TNodeList = THierarchyTreeList. This will give you a list of descendent nodes of same type, just as you described.

“I believe the dev team have such a suite to test out the compiler”

Maybe so, but if they do one of the following MUST pertain:

1) They knew of the bug but chose to release anyway

2) Their test suite doesn’t provide full coverage of all supported syntax – and if it doesn’t cover this case what other cases doesn’t it cover?

3) Their test suite provides 100% coverage but wasn’t part of the QA process subsequent to this syntax change/extension but prior to release

Like Nick Hodges once reported, the compiler is under heavy redesign and reimplementation to achieve C++Builder/Delphi parity and multi-platform support. The opportunity is that such a new compiler architecture should make C++ 0x and Delphi generics support complete.

Bryden: Yeah, that’s about how I had it figured too. The question is, why? According to Moritz Beutel, this concept works just fine with C++ templates and C# generics, and the concept itself isn’t inherently recursive, so it shouldn’t throw the compiler into an infinite loop. I think it just doesn’t quite realize that it doesn’t have a type for T yet, so it keeps going around in circles looking for it.