Correctly compute the parent of TraceNodes referred to by ReferenceByName instances.

Author: alessiostalla

src/interop/starlasu-v2-metamodel.ts

@@ -131,7 +131,7 @@ THE_REFERENCE_BY_NAME_ECLASS.get("eStructuralFeatures").add(ECore.EAttribute.cre
 }));
 THE_REFERENCE_BY_NAME_ECLASS.get("eStructuralFeatures").add(ECore.EReference.create({
     name: "referenced",
-    containment: true
+    containment: false
 }));
 THE_REFERENCE_BY_NAME_ECLASS.get("eStructuralFeatures").at(1).set("eGenericType", ECore.EGenericType.create({
     eTypeParameter: THE_REFERENCE_BY_NAME_ECLASS.get("eTypeParameters").at(0)

src/trace/trace-node.ts

@@ -184,15 +184,38 @@ export class TraceNode extends Node implements PossiblyNamed {
         const innerRef = this.nodeAdapter.getReference(name);
         if (innerRef) {
             const reference = new ReferenceByName<TraceNode>(innerRef.name);
-            if (innerRef?.referred) {
-                reference.referred = this.make(innerRef.referred);
+            const refTarget = innerRef?.referred;
+            if (refTarget instanceof NodeAdapter) {
+                const referred = this.make(innerRef.referred);
+                reference.referred = referred.withParent(this.computeParentForReference(refTarget));
             }
             return reference;
         } else {
             return undefined;
         }
     }
 
+    private computeParentForReference(refTarget: NodeAdapter) {
+        let node: TraceNode | undefined = undefined;
+        let tempParent: TraceNode | undefined = undefined;
+        while (refTarget.parent) {
+            const parent = this.make(refTarget.parent);
+            if (node) {
+                node.parent = parent;
+            } else {
+                tempParent = parent;
+            }
+            node = parent;
+            refTarget = refTarget.parent;
+        }
+        if (tempParent) {
+            const newParent = this.getRoot().get(tempParent.getPathFromRoot());
+            if (newParent instanceof Node) {
+                return newParent;
+            }
+        }
+    }
+
     private makeChild(child: Node | undefined | NodeAdapter, name: string | symbol) {
         if (child instanceof NodeAdapter) {
             return this.make(child).withParent(this);
@@ -259,4 +282,23 @@ export class TraceNode extends Node implements PossiblyNamed {
     isStatement(): boolean {
         return this.nodeAdapter.isStatement();
     }
+
+    get(path: (string | number)[]) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let node: Node | Node[] | undefined = this;
+        for (const elem of path) {
+            if (typeof elem == "string") {
+                if (node instanceof Node) {
+                    node = node.getChild(elem);
+                } else {
+                    throw new Error("Invalid path at " + elem + ", expected node, got " + node);
+                }
+            } else if (Array.isArray(node)) {
+                node = node[elem];
+            } else {
+                throw new Error("Invalid path at " + elem + ", expected children, got " + node);
+            }
+        }
+        return node;
+    }
 }

tests/interop/workspace-transpilation-trace.test.ts

@@ -115,12 +115,17 @@ describe('Workspace Transpilation traces', function() {
                 filter((node: TraceNode) => node.getType() == "com.strumenta.rpgparser.model.ReferenceExpr"),
                 first()).first as TraceNode;
             expect(refExpr).not.to.be.undefined;
+            expect(refExpr.getPathFromRoot()).to.eql(["mainStatements", 0, "expression", "target"]);
             const reference = refExpr.getReference("dataDefinition");
             expect(reference).to.be.instanceof(ReferenceByName);
             expect(reference?.name).to.equal("CNT");
-            expect(reference?.referred).to.be.instanceof(TraceNode);
-            expect(reference?.referred?.getType()).to.equal("com.strumenta.rpgparser.model.StandaloneField");
-            expect(reference?.referred?.name).to.equal("CNT");
+            const refTarget = reference?.referred;
+            expect(refTarget).to.be.instanceof(TraceNode);
+            expect(refTarget?.getType()).to.equal("com.strumenta.rpgparser.model.StandaloneField");
+            expect(refTarget?.name).to.equal("CNT");
+            expect(refTarget?.getRole()).to.equal("dataDefinitions");
+            expect(refTarget?.getPathFromRoot()).to.eql(["dataDefinitions", 3]);
+            expect(refTarget?.getRoot()).to.equal(sourceRoot);
 
             // TODO broken expect(cus300File.node.getChildren("dataDefinition").length).to.eql(4)
             expect(sourceRoot.getChildren("mainStatements").length).to.eql(9)