Simplify: remove ParserNode

Author: alessiostalla

src/interop/strumenta-playground.ts

@@ -14,7 +14,7 @@ import {
 } from "./transpilation-package";
 import {TRANSPILATION_EPACKAGE_V1} from "./transpilation-package-v1";
 import {ensureEcoreContainsAllDataTypes} from "./ecore-patching";
-import {NodeAdapter, ParserNode, TraceNode} from "../trace/trace-node";
+import {NodeAdapter, TraceNode} from "../trace/trace-node";
 
 export function saveForStrumentaPlayground<R extends Node>(
     result: ParsingResult<R>, name: string,
@@ -52,15 +52,15 @@ export class ParserTrace {
         }
     }
 
-    get rootNode(): ParserNode {
+    get rootNode(): TraceNode {
         let root;
         const ast = this.node.get("ast");
         if (ast?.nodeDefinition?.name == "Result") {
             root = ast.get("root");
         } else {
             root = ast;
         }
-        return new ParserNode(root);
+        return new TraceNode(root);
     }
 
     get issues(): Issue[] {
@@ -247,15 +247,17 @@ export class TargetWorkspaceFile extends AbstractWorkspaceFile<TargetNode> {
 }
 
 export class SourceNode extends TraceNode {
-    parent?: SourceNode;
+
+    parent?: SourceNode = undefined;
     protected _destinations?: TargetNode[];
 
     constructor(wrappedNode: NodeAdapter, protected trace: AbstractTranspilationTrace,
                 public readonly file?: SourceWorkspaceFile) {
         super(wrappedNode);
-        if (wrappedNode.parent) {
-            this.parent = new SourceNode(wrappedNode.parent, this.trace, file);
-        }
+    }
+
+    protected make(node: NodeAdapter): SourceNode {
+        return new SourceNode(node, this.trace, this.file);
     }
 
     getDestinationNodes(): TargetNode[] {
@@ -265,23 +267,21 @@ export class SourceNode extends TraceNode {
         return this._destinations;
     }
 
-    getChildren(role?: string): SourceNode[] {
-        return this.nodeAdapter.getChildren(role).map((c) => new SourceNode(c, this.trace, this.file).withParent(this));
-    }
-
-    get children(): Node[] {
-        return this.getChildren();
+    getChildren(role?: string | symbol): SourceNode[] {
+        return super.getChildren(role) as SourceNode[];
     }
 }
 
 export class TargetNode extends TraceNode {
-    parent?: TargetNode;
+
+    parent?: TargetNode = undefined;
 
     constructor(wrapped: NodeAdapter, protected trace: AbstractTranspilationTrace, public file?: TargetWorkspaceFile) {
         super(wrapped);
-        if (wrapped.parent) {
-            this.parent = new TargetNode(wrapped.parent, this.trace, this.file);
-        }
+    }
+
+    protected make(node: NodeAdapter): TargetNode {
+        return new TargetNode(node, this.trace, this.file);
     }
 
     getPosition(): Position | undefined {
@@ -317,18 +317,23 @@ export class TargetNode extends TraceNode {
                         parent = parent.eContainer;
                     }
                 }
-                this.origin = new SourceNode(new ECoreNode(rawOrigin), this.trace, file);
+                const eCoreNode = new ECoreNode(rawOrigin);
+                this.origin = this.makeSourceNode(eCoreNode, file);
             }
         }
         return this.origin as SourceNode;
     }
 
-    getChildren(role?: string): TargetNode[] {
-        return this.nodeAdapter.getChildren(role).map((c) => new TargetNode(c, this.trace, this.file));
+    protected makeSourceNode(eCoreNode: ECoreNode, file: SourceWorkspaceFile | undefined) {
+        const sourceNode = new SourceNode(eCoreNode, this.trace, file);
+        if (eCoreNode.parent) {
+            sourceNode.withParent(this.makeSourceNode(eCoreNode.parent, file));
+        }
+        return sourceNode;
     }
 
-    get children(): Node[] {
-        return this.getChildren();
+    getChildren(role?: string | symbol): TargetNode[] {
+        return super.getChildren(role) as TargetNode[];
     }
 }
 

src/trace/trace-node.ts

@@ -119,11 +119,11 @@ export class AugmentedNode extends NodeAdapter {
     }
 }
 
-export abstract class TraceNode extends Node {
+export class TraceNode extends Node {
 
-    abstract parent?: TraceNode;
+    parent?: TraceNode = undefined;
 
-    protected constructor(public nodeAdapter: NodeAdapter) {
+    constructor(public nodeAdapter: NodeAdapter) {
         super();
     }
 
@@ -184,6 +184,18 @@ export abstract class TraceNode extends Node {
         }
     }
 
+    protected make(node: NodeAdapter): TraceNode {
+        return new TraceNode(node);
+    }
+
+    getChildren(role?: string | symbol): TraceNode[] {
+        return this.nodeAdapter.getChildren(role).map((c) => this.make(c).withParent(this));
+    }
+
+    get children(): TraceNode[] {
+        return this.getChildren();
+    }
+
     equals(node: TraceNode) {
         return node === this || node.nodeAdapter.equals(this.nodeAdapter);
     }
@@ -200,23 +212,3 @@ export abstract class TraceNode extends Node {
         return this.nodeAdapter.isStatement();
     }
 }
-
-export class ParserNode extends TraceNode {
-
-    parent?: ParserNode;
-
-    constructor(inner: NodeAdapter) {
-        super(inner);
-        if (inner.parent) {
-            this.parent = new ParserNode(inner.parent);
-        }
-    }
-
-    getChildren(role?: string): ParserNode[] {
-        return this.nodeAdapter.getChildren(role).map((c) => new ParserNode(c));
-    }
-
-    get children(): ParserNode[] {
-        return this.getChildren();
-    }
-}

tests/interop/lionweb.test.ts

@@ -2,7 +2,7 @@ import FS_LANGUAGE_JSON from "./fs-language.json";
 import FS_MODEL from "./fs-model.json";
 import {expect} from "chai";
 import {deserializeChunk, deserializeLanguages, SerializationChunk} from "@lionweb/core";
-import {Children, Node, ParserNode, Property, walk} from "../../src";
+import {Children, Node, Property, TraceNode, walk} from "../../src";
 import {
     findClassifier,
     LanguageMapping, LionwebNode,
@@ -11,8 +11,6 @@ import {
 } from "../../src/interop/lionweb";
 import {map, pipe, reduce} from "iter-ops";
 import {STARLASU_LANGUAGE} from "../../src/interop/lionweb-starlasu-language";
-import {ParserTrace} from "../../src/interop/strumenta-playground";
-import {PARSER_TRACE_ECLASS} from "../../src/interop/parser-package";
 
 abstract class File extends Node {
     @Property()
@@ -104,7 +102,7 @@ describe('Lionweb integration', function() {
             expect(nodes.length).to.equal(1);
             const root = nodes[0];
             expect(root.node).to.be.instanceof(LionwebNode);
-            let dir = new ParserNode(root.node as LionwebNode);
+            let dir = new TraceNode(root.node as LionwebNode);
             expect(dir.getRole()).to.be.undefined;
             expect(dir.nodeDefinition.name).to.equal("Directory");
             expect(dir.getAttribute("name")).to.equal("resources.zip");

tests/interop/parser-trace.test.ts

@@ -1,8 +1,7 @@
 import {expect} from "chai";
 import * as fs from "fs";
-import {findByPosition, IssueSeverity, IssueType, ParserNode, Point, pos, Position} from "../../src";
+import {findByPosition, IssueSeverity, IssueType, TraceNode, Point, pos, Position} from "../../src";
 import {ParserTraceLoader} from "../../src/interop/strumenta-playground";
-import {TraceNode} from "../../src/trace/trace-node";
 
 describe('Parser traces – Kolasu metamodel V1', function() {
 
@@ -81,10 +80,10 @@ describe('Parser traces – Starlasu metamodel V2', function() {
             expect(rootNode.getType()).to.eql("com.strumenta.sas.ast.SourceFile");
             expect(rootNode.getSimpleType()).to.eql("SourceFile");
             expect(rootNode.getPosition()).to.eql(pos(12, 0,369, 0));
-            let foundNode = findByPosition(rootNode, pos(12, 0,369, 0)) as ParserNode;
+            let foundNode = findByPosition(rootNode, pos(12, 0,369, 0)) as TraceNode;
             expect(foundNode.equals(rootNode)).to.be.true;
-            const descNode = rootNode.children[10].children[7] as ParserNode;
-            foundNode = findByPosition(descNode, descNode.position!) as ParserNode;
+            const descNode = rootNode.children[10].children[7] as TraceNode;
+            foundNode = findByPosition(descNode, descNode.position!) as TraceNode;
             expect(foundNode.equals(descNode)).to.be.true;
             expect(rootNode.getChildren().length).to.equal(18);
             expect(rootNode.getChildren("statementsAndDeclarations").length).to.equal(18);