Model class hierarchy change for select nodes

bit_select, and other select classes use the vpiParent pointer (as refobj) to
provide parent and actual_group access. bit_select.vpiParent.vpiParent is the
"true" parent of the bit_select and bit_select.vpiParent.actual_group is
access to the actual. However, vpiParent edges in the graph are weak
references and ignored for all traversals (including VpiListener,
UhdmListener, and vpi_visitor). Tail of parent edges are missing in the UHDM
output since the nodes are ignored. The traversal mode also generate
unexpected results during runtime because of the ignored edges.

Changing the hierarchy so that ref_obj works as a base (intermediate class in
the class hierarchy, yet instantiable) and other select classes (including
bit_select, indexed_part_select, part_select, and var_select) are subclasses
of ref_obj. This gives access to ref_obj.actual_group and ref.vpiParent can be
used for the usual parenting purposes.

* Updated class file generation logic to support generating class files for
  intermediate nodes in the class hierarchy.
* Updated vpi_visitor, ExprEval, and clone_tree logic to compensate for the
  model hierarchy change.

* Few code improvements in ElaboratorListener and BaseClass
* Moved UhdmId, VpiFile, and VpiParent to BaseClass since these are required
  properties for all models in the class hierarchy

Author: hs-apotell

CMakeLists.txt

@@ -5,7 +5,7 @@ cmake_minimum_required(VERSION 3.20 FATAL_ERROR)
 # Version changes whenever some new features accumulated, or the
 # grammar or the cache format changes to make sure caches
 # are invalidated.
-project(SURELOG VERSION 1.59)
+project(SURELOG VERSION 1.60)
 
 # Detect build type, fallback to release and throw a warning if use didn't
 # specify any

include/Surelog/DesignCompile/CompileHelper.h

@@ -154,7 +154,8 @@ class CompileHelper final {
                           ValuedComponentI* instance);
 
   UHDM::any* compileTfCall(DesignComponent* component, const FileContent* fC,
-                           NodeId Tf_call_stmt, CompileDesign* compileDesign);
+                           NodeId Tf_call_stmt, CompileDesign* compileDesign,
+                           UHDM::any* pexpr);
 
   UHDM::VectorOfany* compileTfCallArguments(
       DesignComponent* component, const FileContent* fC, NodeId Arg_list_node,

src/DesignCompile/CompileExpression.cpp

@@ -1101,6 +1101,7 @@ UHDM::any *CompileHelper::compileSelectExpression(
     VectorOfexpr *exprs = s.MakeExprVec();
     var_select->Exprs(exprs);
     var_select->VpiName(name);
+    var_select->VpiParent(pexpr);
     result = var_select;
   }
   NodeId lastBitExp;
@@ -1132,27 +1133,26 @@ UHDM::any *CompileHelper::compileSelectExpression(
 
           if (result) {
             UHDM::var_select *var_select = (UHDM::var_select *)result;
+            var_select->VpiParent(pexpr);
             VectorOfexpr *exprs = var_select->Exprs();
             exprs->push_back(sel);
-            if (sel->VpiParent() == nullptr) sel->VpiParent(var_select);
+            sel->VpiParent(var_select);
           } else if (fC->Child(Bit_select) && fC->Sibling(Bit_select)) {
             UHDM::var_select *var_select = s.MakeVar_select();
             VectorOfexpr *exprs = s.MakeExprVec();
             var_select->Exprs(exprs);
             var_select->VpiName(name);
+            var_select->VpiParent(pexpr);
+            sel->VpiParent(var_select);
             exprs->push_back(sel);
             result = var_select;
-            if (sel->VpiParent() == nullptr) sel->VpiParent(var_select);
           } else {
             bit_select *bit_select = s.MakeBit_select();
             bit_select->VpiName(name);
             bit_select->VpiIndex(sel);
+            bit_select->VpiParent(pexpr);
+            sel->VpiParent(bit_select);
             result = bit_select;
-            if (sel->VpiParent() == nullptr) sel->VpiParent(bit_select);
-            ref_obj *ref = s.MakeRef_obj();
-            bit_select->VpiParent(ref);
-            ref->VpiName(name);
-            ref->VpiParent(pexpr);
           }
           lastBitExp = bitexp;
           if (advanceBitSelect) Bit_select = bitexp;
@@ -1176,6 +1176,7 @@ UHDM::any *CompileHelper::compileSelectExpression(
         VectorOfexpr *exprs = s.MakeExprVec();
         var_select->Exprs(exprs);
         var_select->VpiName(name);
+        var_select->VpiParent(pexpr);
         exprs->push_back(sel);
         sel->VpiParent(var_select);
       } else {
@@ -1218,52 +1219,18 @@ UHDM::any *CompileHelper::compileSelectExpression(
                 compileExpression(component, fC, Bit_select, compileDesign,
                                   reduce, pexpr, instance, muteErrors);
             if (sel) {
+              hname.append(".")
+                  .append(sel->VpiName())
+                  .append(decompileHelper(sel));
               if (sel->UhdmType() == uhdmhier_path) {
                 hier_path *p = (hier_path *)sel;
                 for (auto el : *p->Path_elems()) {
+                  el->VpiParent(path);
                   elems->push_back(el);
-                  std::string n(el->VpiName());
-                  if (el->UhdmType() == uhdmbit_select) {
-                    bit_select *bs = (bit_select *)el;
-                    const expr *index = bs->VpiIndex();
-                    std::string_view ind = index->VpiDecompile();
-                    if (ind.empty()) ind = index->VpiName();
-                    n.append("[").append(ind).append("]");
-                    hname += "." + n;
-                    ref_obj *r = nullptr;
-                    if ((bs->VpiParent() != nullptr) &&
-                        (bs->VpiParent()->UhdmType() == uhdmref_obj)) {
-                      r = (ref_obj *)bs->VpiParent();
-                    } else {
-                      r = s.MakeRef_obj();
-                      bs->VpiParent(r);
-                    }
-                    r->VpiName(hname);
-                    r->VpiParent(path);
-                  } else {
-                    hname += "." + n;
-                    el->VpiParent(path);
-                  }
                 }
                 break;
               } else {
-                hname.append(".")
-                    .append(sel->VpiName())
-                    .append(decompileHelper(sel));
-                if (sel->UhdmType() == uhdmbit_select) {
-                  ref_obj *r = nullptr;
-                  if ((sel->VpiParent() != nullptr) &&
-                      (sel->VpiParent()->UhdmType() == uhdmref_obj)) {
-                    r = (ref_obj *)sel->VpiParent();
-                  } else {
-                    r = s.MakeRef_obj();
-                    sel->VpiParent(r);
-                  }
-                  r->VpiName(hname);
-                  r->VpiParent(path);
-                } else {
-                  sel->VpiParent(path);
-                }
+                sel->VpiParent(path);
                 elems->push_back(sel);
               }
             }
@@ -1972,7 +1939,7 @@ UHDM::any *CompileHelper::compileExpression(
           operation->VpiParent(pexpr);
           operation->Attributes(attributes);
           if (opL) {
-            setParentNoOverride(opL, operation);
+            opL->VpiParent(operation);
             operands->push_back(opL);
           }
           if (vopType == 0) {
@@ -2043,7 +2010,7 @@ UHDM::any *CompileHelper::compileExpression(
               compileExpression(component, fC, rval, compileDesign, reduce,
                                 operation, instance, muteErrors);
           if (opR) {
-            setParentNoOverride(opR, operation);
+            opR->VpiParent(operation);
             operands->push_back(opR);
           }
           if (opType == VObjectType::slQmark ||
@@ -3674,54 +3641,43 @@ UHDM::any *CompileHelper::compilePartSelectRange(
   UHDM::any *result = nullptr;
   NodeId Constant_expression = fC->Child(Constant_range);
   if (fC->Type(Constant_range) == VObjectType::slConstant_range) {
-    UHDM::expr *lexp =
-        (expr *)compileExpression(component, fC, Constant_expression,
-                                  compileDesign, Reduce::No, pexpr, instance);
+    UHDM::part_select *part_select = s.MakePart_select();
+    UHDM::expr *lexp = (expr *)compileExpression(
+        component, fC, Constant_expression, compileDesign, Reduce::No,
+        part_select, instance);
     UHDM::expr *rexp = (expr *)compileExpression(
         component, fC, fC->Sibling(Constant_expression), compileDesign,
-        Reduce::No, pexpr, instance);
-    UHDM::part_select *part_select = s.MakePart_select();
+        Reduce::No, part_select, instance);
     part_select->Left_range(lexp);
     part_select->Right_range(rexp);
-    if (name == "CREATE_UNNAMED_PARENT") {
-      UHDM::ref_obj *ref = s.MakeRef_obj();
-      part_select->VpiParent(ref);
-    } else if (!name.empty()) {
-      UHDM::ref_obj *ref = s.MakeRef_obj();
-      ref->VpiName(name);
-      ref->VpiDefName(name);
-      ref->VpiParent(pexpr);
-      part_select->VpiParent(ref);
+    if (!name.empty() && (name != "CREATE_UNNAMED_PARENT")) {
+      part_select->VpiName(name);
+      part_select->VpiDefName(name);
     }
+    part_select->VpiParent(pexpr);
     part_select->VpiConstantSelect(true);
     result = part_select;
   } else {
     // constant_indexed_range
+    UHDM::indexed_part_select *part_select = s.MakeIndexed_part_select();
     UHDM::expr *lexp = (expr *)compileExpression(
-        component, fC, Constant_expression, compileDesign, reduce, pexpr,
+        component, fC, Constant_expression, compileDesign, reduce, part_select,
         instance, muteErrors);
     NodeId op = fC->Sibling(Constant_expression);
     UHDM::expr *rexp =
         (expr *)compileExpression(component, fC, fC->Sibling(op), compileDesign,
-                                  reduce, pexpr, instance, muteErrors);
-
-    UHDM::indexed_part_select *part_select = s.MakeIndexed_part_select();
+                                  reduce, part_select, instance, muteErrors);
     part_select->Base_expr(lexp);
     part_select->Width_expr(rexp);
     if (fC->Type(op) == VObjectType::slIncPartSelectOp)
       part_select->VpiIndexedPartSelectType(vpiPosIndexed);
     else
       part_select->VpiIndexedPartSelectType(vpiNegIndexed);
-    if (name == "CREATE_UNNAMED_PARENT") {
-      UHDM::ref_obj *ref = s.MakeRef_obj();
-      part_select->VpiParent(ref);
-    } else if (!name.empty()) {
-      UHDM::ref_obj *ref = s.MakeRef_obj();
-      ref->VpiName(name);
-      ref->VpiDefName(name);
-      ref->VpiParent(pexpr);
-      part_select->VpiParent(ref);
+    if (!name.empty() && (name != "CREATE_UNNAMED_PARENT")) {
+      part_select->VpiName(name);
+      part_select->VpiDefName(name);
     }
+    part_select->VpiParent(pexpr);
     part_select->VpiConstantSelect(true);
     result = part_select;
 
@@ -4187,6 +4143,7 @@ UHDM::any *CompileHelper::compileBits(
   } else if (sizeMode) {
     UHDM::sys_func_call *sys = s.MakeSys_func_call();
     sys->VpiName("$size");
+    sys->VpiParent(pexpr);
     VectorOfany *arguments =
         compileTfCallArguments(component, fC, List_of_arguments, compileDesign,
                                reduce, sys, instance, muteErrors);
@@ -4195,6 +4152,7 @@ UHDM::any *CompileHelper::compileBits(
   } else {
     UHDM::sys_func_call *sys = s.MakeSys_func_call();
     sys->VpiName("$bits");
+    sys->VpiParent(pexpr);
     VectorOfany *arguments =
         compileTfCallArguments(component, fC, List_of_arguments, compileDesign,
                                reduce, sys, instance, muteErrors);
@@ -4433,6 +4391,7 @@ UHDM::any *CompileHelper::compileClog2(
   } else {
     UHDM::sys_func_call *sys = s.MakeSys_func_call();
     sys->VpiName("$clog2");
+    sys->VpiParent(pexpr);
     VectorOfany *arguments =
         compileTfCallArguments(component, fC, List_of_arguments, compileDesign,
                                reduce, sys, instance, muteErrors);
@@ -4497,14 +4456,15 @@ UHDM::any *CompileHelper::compileComplexFuncCall(
       } else if (fC->Type(nameId) == VObjectType::slConstant_expression) {
         NodeId Constant_expresion = fC->Child(nameId);
         if (Constant_expresion) {
-          name += "[";
+          bit_select *sel = s.MakeBit_select();
           expr *select = (expr *)compileExpression(
-              component, fC, Constant_expresion, compileDesign, reduce, pexpr,
+              component, fC, Constant_expresion, compileDesign, reduce, sel,
               instance, muteErrors);
-          name += select->VpiDecompile();
-          name += "]";
-          bit_select *sel = s.MakeBit_select();
+          std::string bsname = decompileHelper(select);
+          name += bsname;
+          sel->VpiName(bsname);
           sel->VpiIndex(select);
+          sel->VpiParent(path);
           elems->push_back(sel);
         }
       } else {
@@ -4513,6 +4473,7 @@ UHDM::any *CompileHelper::compileComplexFuncCall(
       nameId = fC->Sibling(nameId);
     }
     path->VpiName(name);
+    path->VpiParent(pexpr);
     result = path;
   } else if (fC->Type(name) == VObjectType::slDollar_keyword) {
     NodeId Dollar_keyword = name;
@@ -4539,6 +4500,7 @@ UHDM::any *CompileHelper::compileComplexFuncCall(
       NodeId List_of_arguments = fC->Sibling(nameId);
       UHDM::sys_func_call *sys = s.MakeSys_func_call();
       sys->VpiName(StrCat("$", name));
+      sys->VpiParent(pexpr);
       VectorOfany *arguments = compileTfCallArguments(
           component, fC, List_of_arguments, compileDesign, reduce, sys,
           instance, muteErrors);
@@ -4718,15 +4680,15 @@ UHDM::any *CompileHelper::compileComplexFuncCall(
               ref->VpiName(StrCat(packagename, "::", functionname));
               ref->VpiFullName(StrCat(packagename, "::", functionname));
               ref->Actual_group(param);
-              ref->VpiParent(pexpr);
+              ref->VpiParent(path);
               fC->populateCoreMembers(name, name, ref);
               elems->push_back(ref);
               while (List_of_arguments) {
                 if ((fC->Type(List_of_arguments) ==
                      VObjectType::slStringConst)) {
                   ref_obj *ref = s.MakeRef_obj();
                   ref->VpiName(fC->SymName(List_of_arguments));
-                  ref->VpiParent(pexpr);
+                  ref->VpiParent(path);
                   fC->populateCoreMembers(List_of_arguments, List_of_arguments,
                                           ref);
                   elems->push_back(ref);
@@ -4787,11 +4749,6 @@ UHDM::any *CompileHelper::compileComplexFuncCall(
                                            instance, muteErrors);
           if (result && (result->UhdmType() == UHDM::uhdmpart_select)) {
             fC->populateCoreMembers(name, dotedName, result);
-            if ((result->VpiParent() != nullptr) &&
-                (result->VpiParent()->UhdmType() == UHDM::uhdmref_obj)) {
-              ref_obj *const parent = (ref_obj *)result->VpiParent();
-              fC->populateCoreMembers(name, name, parent);
-            }
           }
           return result;
         } else if ((!selectName) &&
@@ -4808,6 +4765,7 @@ UHDM::any *CompileHelper::compileComplexFuncCall(
                                               instance);
           if (index) {
             bit_select *select = s.MakeBit_select();
+            index->VpiParent(select);
             select->VpiIndex(index);
             the_name += "[" + decompileHelper(index) + "]";
             select->VpiFullName(the_name);
@@ -4922,10 +4880,8 @@ UHDM::any *CompileHelper::compileComplexFuncCall(
                   compileDesign, reduce, nullptr, instance, muteErrors);
               // Fix start/end to include the name
               select->VpiColumnNo(fC->Column(name));
-              ref_obj *parent = (ref_obj *)select->VpiParent();
-              if (parent) parent->VpiName(tmpName);
-              if (tmpName.empty()) {
-                select->VpiParent(nullptr);
+              if (ref_obj *ro = any_cast<ref_obj *>(select)) {
+                ro->VpiName(tmpName);
               }
               elems->push_back(select);
               the_name += decompileHelper(select);
@@ -4938,8 +4894,9 @@ UHDM::any *CompileHelper::compileComplexFuncCall(
                   compileDesign, reduce, nullptr, instance, muteErrors);
               // Fix start/end to include the name
               select->VpiColumnNo(fC->Column(name));
-              ref_obj *parent = (ref_obj *)select->VpiParent();
-              if (parent) parent->VpiDefName(tmpName);
+              if (ref_obj *ro = any_cast<ref_obj *>(select)) {
+                ro->VpiDefName(tmpName);
+              }
               elems->push_back(select);
               the_name += decompileHelper(select);
             } else if (Expression) {
@@ -4948,24 +4905,17 @@ UHDM::any *CompileHelper::compileComplexFuncCall(
                   instance, muteErrors);
               if (index) {
                 bit_select *select = s.MakeBit_select();
-                elems->push_back(select);
-                ref_obj *ref = s.MakeRef_obj();
-                ref->VpiName(tmpName);
-                ref->VpiParent(path);
-                if (!tmpName.empty()) select->VpiParent(ref);
                 select->VpiIndex(index);
                 select->VpiName(tmpName);
-                select->VpiFullName(tmpName);
+                select->VpiParent(path);
                 fC->populateCoreMembers(name, name, select);
-                std::string indexName = "[" + decompileHelper(index) + "]";
-                the_name += indexName;
-                if (!tmpName.empty()) ref->VpiName(tmpName + indexName);
+                elems->push_back(select);
+                the_name += decompileHelper(index);
               }
             } else {
               ref_obj *ref = s.MakeRef_obj();
               elems->push_back(ref);
               ref->VpiName(tmpName);
-              ref->VpiFullName(tmpName);
               ref->VpiParent(path);
               fC->populateCoreMembers(name, name, ref);
             }
@@ -5152,7 +5102,8 @@ UHDM::any *CompileHelper::compileComplexFuncCall(
       result = ref;
     }
   } else if (fC->Type(dotedName) == VObjectType::slList_of_arguments) {
-    result = compileTfCall(component, fC, fC->Parent(name), compileDesign);
+    result =
+        compileTfCall(component, fC, fC->Parent(name), compileDesign, pexpr);
   } else if (fC->Type(name) == VObjectType::slStringConst) {
     const std::string_view n = fC->SymName(name);
     ref_obj *ref = s.MakeRef_obj();