fix(sort): skip non-hierarchical refs in topological sort

The topological sort in nodeRefsReady() previously blocked on ALL
inverse non-HasTypeDefinition references. This caused deadlocks
when two nodes in the same nodeset referenced each other via a
non-hierarchical reference type (e.g. HasSubStateMachine i=117).

Non-hierarchical references do not establish parent-child ordering
dependencies. Only inverse hierarchical references (subtypes of
HierarchicalReferences i=33) and forward HasTypeDefinition require
ordering constraints.

Add isHierarchicalRef() to identify well-known ns0 hierarchical
reference types and update nodeRefsReady() to only block on inverse
hierarchical references. Non-ns0 reference types are conservatively
treated as hierarchical.

Fixes loading of the Glass companion specification, which uses
HasSubStateMachine between StateMachine objects in the same nodeset.

Author: andreasebner

src/Nodeset.c

@@ -136,6 +136,41 @@ Nodeset_findByNodeId(Nodeset *nodeset, const UA_NodeId *key) {
 
 static UA_NodeId hasTypeDef = {0, UA_NODEIDTYPE_NUMERIC, {40}};
 
+/* Check whether a ns0 reference type is hierarchical (subtype of
+ * HierarchicalReferences i=33). Only inverse hierarchical references
+ * create ordering dependencies for node creation. Non-hierarchical
+ * references (e.g. HasSubStateMachine i=117, HasCondition i=9006) do
+ * not create ordering dependencies and must be ignored. Otherwise
+ * they can cause deadlocks in the topological sort when two nodes in
+ * the same nodeset reference each other via a non-hierarchical
+ * reference type.
+ *
+ * For non-ns0 reference types, conservatively assume hierarchical.
+ * This list covers the well-known hierarchical subtypes from OPC UA
+ * Part 3 / Part 5. */
+static bool
+isHierarchicalRef(const UA_NodeId *refType) {
+    if(refType->namespaceIndex != 0 ||
+       refType->identifierType != UA_NODEIDTYPE_NUMERIC)
+        return true; /* Unknown: conservatively treat as hierarchical */
+    switch(refType->identifier.numeric) {
+    case 33: /* HierarchicalReferences */
+    case 34: /* HasChild */
+    case 35: /* Organizes */
+    case 36: /* HasEventSource */
+    case 44: /* Aggregates */
+    case 45: /* HasSubtype */
+    case 46: /* HasProperty */
+    case 47: /* HasComponent */
+    case 48: /* HasNotifier */
+    case 49: /* HasOrderedComponent */
+    case 56: /* HasHistoricalConfiguration */
+        return true;
+    default:
+        return false; /* ns0 type not in the hierarchical set */
+    }
+}
+
 static bool
 nodeRefsReady(NL_Node *node) {
     for(NL_Reference *ref = node->refs; ref != NULL; ref = ref->next) {
@@ -144,11 +179,12 @@ nodeRefsReady(NL_Node *node) {
         if(ref->targetPtr->isDone)
             continue;
         if(UA_NodeId_equal(&hasTypeDef, &ref->refType)) {
+            /* Forward HasTypeDefinition: the type must exist first */
             if(ref->isForward)
                 return false;
-        } else {
-            if(!ref->isForward)
-                return false;
+        } else if(!ref->isForward && isHierarchicalRef(&ref->refType)) {
+            /* Inverse hierarchical reference: the parent must exist first */
+            return false;
         }
     }
     return true;