Ensure we can use Lionweb nodes as parser traces. Improve coverage of ECore support functions.

alessiostalla · alessiostalla · commit 25f7febf72d7 · 2024-03-07T11:50:13.000+01:00
diff --git a/src/interop/ecore.ts b/src/interop/ecore.ts
@@ -552,7 +552,7 @@ class ReferencesTracker {
         }
     }
 
-    getReferredObject(uri: string) {
+    getReferredObject(uri?: string) {
         if (uri === undefined) {
             return undefined;
         }
@@ -621,7 +621,7 @@ export function findEClass(name: string, resource: ECore.Resource): ECore.EClass
         const packageName = name.substring(0, index);
         const ePackage = ECore.EPackage.Registry.getEPackage(packageName);
         if(!ePackage) {
-            throw new Error("Package not found: " + packageName+ " while loading for class " + name);
+            throw new Error("Package not found: " + packageName + " while loading class " + name);
         }
         const className = name.substring(name.lastIndexOf("/") + 1);
         if (ePackage.get("nsURI") == KOLASU_URI_V1) {
diff --git a/src/interop/lionweb.ts b/src/interop/lionweb.ts
@@ -165,10 +165,6 @@ export class LionwebNode extends NodeAdapter {
         return undefined;
     }
 
-    getRole(): string | undefined {
-        return undefined;
-    }
-
     isDeclaration(): boolean {
         return false;
     }
@@ -180,4 +176,8 @@ export class LionwebNode extends NodeAdapter {
     isStatement(): boolean {
         return false;
     }
+
+    equals(other: NodeAdapter | undefined): boolean {
+        return other instanceof LionwebNode && other.lwnode == this.lwnode;
+    }
 }
diff --git a/src/interop/strumenta-playground.ts b/src/interop/strumenta-playground.ts
@@ -92,7 +92,7 @@ export class ParserNode extends TraceNode {
     }
 
     getChildren(role?: string): ParserNode[] {
-        return this.wrappedNode.getChildren(role).map((c) => new ParserNode(c, this, this.trace));
+        return this.nodeAdapter.getChildren(role).map((c) => new ParserNode(c, this, this.trace));
     }
 
     get children(): Node[] {
@@ -165,7 +165,7 @@ abstract class AbstractTranspilationTrace {
     protected constructor(protected wrappedNode: NodeAdapter) {}
 
     getDestinationNodes(sourceNode: SourceNode): TargetNode[] {
-        return this.sourceToTarget.get(sourceNode.wrappedNode.getId()) || [];
+        return this.sourceToTarget.get(sourceNode.nodeAdapter.getId()) || [];
     }
 
     protected examineTargetNode(
@@ -294,7 +294,7 @@ export class SourceNode extends TraceNode {
     }
 
     getChildren(role?: string): SourceNode[] {
-        return this.wrappedNode.getChildren(role).map((c) => new SourceNode(c, this.trace, this.file).withParent(this));
+        return this.nodeAdapter.getChildren(role).map((c) => new SourceNode(c, this.trace, this.file).withParent(this));
     }
 
     get children(): Node[] {
@@ -313,7 +313,7 @@ export class TargetNode extends TraceNode {
     }
 
     getPosition(): Position | undefined {
-        return this.wrappedNode.getPosition("destination");
+        return this.nodeAdapter.getPosition("destination");
     }
 
     getDestination(): Position | undefined {
@@ -327,8 +327,8 @@ export class TargetNode extends TraceNode {
     getSourceNode(): SourceNode | undefined {
         if (!this.origin) {
             // TODO
-            if (this.wrappedNode instanceof ECoreNode) {
-                let rawOrigin = this.wrappedNode.eo.get("origin");
+            if (this.nodeAdapter instanceof ECoreNode) {
+                let rawOrigin = this.nodeAdapter.eo.get("origin");
                 if (rawOrigin?.eClass == THE_NODE_ORIGIN_ECLASS) {
                     rawOrigin = rawOrigin.get("node");
                 }
@@ -352,7 +352,7 @@ export class TargetNode extends TraceNode {
     }
 
     getChildren(role?: string): TargetNode[] {
-        return this.wrappedNode.getChildren(role).map((c) => new TargetNode(c, this.trace, this.file));
+        return this.nodeAdapter.getChildren(role).map((c) => new TargetNode(c, this.trace, this.file));
     }
 
     get children(): Node[] {
diff --git a/src/mapping.ts b/src/mapping.ts
@@ -25,16 +25,18 @@ export class ParseTreeToASTTransformer extends ASTTransformer {
 
     getSource(node: Node, source: any): any {
         const origin = node.origin;
-        if (origin instanceof ParseTreeOrigin)
+        if (origin instanceof ParseTreeOrigin) {
             return origin.parseTree;
-        else
+        } else {
             return source;
+        }
     }
 
     asOrigin(source: any): Origin | undefined {
-        if (source instanceof ParserRuleContext || source instanceof TerminalNode)
+        if (source instanceof ParserRuleContext || source instanceof TerminalNode) {
             return new ParseTreeOrigin(source);
-        else
+        } else {
             return undefined;
+        }
     }
 }
diff --git a/src/model/model.ts b/src/model/model.ts
@@ -205,21 +205,21 @@ export abstract class Node extends Origin implements Destination {
         this[name].push(child.withParent(this));
     }
 
-    getChild(name: string, index?: number): Node | undefined {
+    getChild(name: string | symbol, index?: number): Node | undefined {
         const containment = this.containment(name);
         if(!containment) {
-            throw new Error("Not a containment: " + name);
+            throw new Error("Not a containment: " + name.toString());
         }
         const raw = this.doGetChildOrChildren(name);
         if (containment.multiple) {
             if (index !== undefined) {
                 return (raw as Node[])[index];
             } else {
-                throw new Error(name + " is a collection, an index is required");
+                throw new Error(name.toString() + " is a collection, an index is required");
             }
         } else {
             if (index) {
-                throw new Error(name + " is not a collection, index " + index + " is invalid");
+                throw new Error(name.toString() + " is not a collection, index " + index + " is invalid");
             } else {
                 return raw as Node;
             }
diff --git a/src/trace/trace-node.ts b/src/trace/trace-node.ts
@@ -20,15 +20,33 @@ export abstract class NodeAdapter extends Node {
 
     abstract getPosition(property?: string): Position | undefined;
 
-    abstract getRole(): string | undefined;
+    getRole(): string | symbol | undefined {
+        if (this.parent) { // Inefficient default implementation, searching in the parent's children
+            const props = this.parent.nodeDefinition?.properties || {};
+            for (const p in props) {
+                const prop = props[p];
+                if (prop.child) {
+                    if (prop.multiple) {
+                        if (this.parent.getChildren(prop.name)?.find(c => c.equals(this))) {
+                            return prop.name;
+                        }
+                    } else if (this.equals(this.parent.getChild(prop.name) as NodeAdapter)) {
+                        return prop.name;
+                    }
+                }
+            }
+        } else {
+            return undefined;
+        }
+    }
 
     abstract isDeclaration(): boolean;
 
     abstract isExpression(): boolean;
 
     abstract isStatement(): boolean;
 
-    equals(other: NodeAdapter) {
+    equals(other: NodeAdapter | undefined) {
         return other == this;
     }
 }
@@ -84,10 +102,6 @@ export class AugmentedNode extends NodeAdapter {
         return this.node.position;
     }
 
-    getRole(): string | undefined {
-        return undefined;
-    }
-
     isDeclaration(): boolean {
         return false;
     }
@@ -99,13 +113,17 @@ export class AugmentedNode extends NodeAdapter {
     isStatement(): boolean {
         return false;
     }
+
+    equals(other: NodeAdapter | undefined): boolean {
+        return other instanceof AugmentedNode && this.node == other.node;
+    }
 }
 
 export abstract class TraceNode extends Node {
 
     abstract parent?: TraceNode;
 
-    protected constructor(public wrappedNode: NodeAdapter) {
+    protected constructor(public nodeAdapter: NodeAdapter) {
         super();
     }
 
@@ -121,28 +139,28 @@ export abstract class TraceNode extends Node {
         return this.nodeDefinition.name!;
     }
 
-    getRole(): string | undefined {
-        return this.wrappedNode.getRole();
+    getRole(): string | symbol | undefined {
+        return this.nodeAdapter.getRole();
     }
 
     getPosition(): Position | undefined {
-        return this.wrappedNode.getPosition();
+        return this.nodeAdapter.getPosition();
     }
 
     get position(): Position | undefined {
         return this.getPosition();
     }
 
     get nodeDefinition(): NodeDefinition {
-        return this.wrappedNode.nodeDefinition;
+        return this.nodeAdapter.nodeDefinition;
     }
 
     getAttributes(): { [name: string]: any } {
-        return this.wrappedNode.getAttributes();
+        return this.nodeAdapter.getAttributes();
     }
 
     doGetAttribute(attrName: string): any {
-        return this.wrappedNode.getAttribute(attrName);
+        return this.nodeAdapter.getAttribute(attrName);
     }
 
     getPathFromRoot(): (string | number)[] {
@@ -167,18 +185,18 @@ export abstract class TraceNode extends Node {
     }
 
     equals(node: TraceNode) {
-        return node === this || node.wrappedNode.equals(this.wrappedNode);
+        return node === this || node.nodeAdapter.equals(this.nodeAdapter);
     }
 
     isDeclaration(): boolean {
-        return this.wrappedNode.isDeclaration();
+        return this.nodeAdapter.isDeclaration();
     }
 
     isExpression(): boolean {
-        return this.wrappedNode.isExpression();
+        return this.nodeAdapter.isExpression();
     }
 
     isStatement(): boolean {
-        return this.wrappedNode.isStatement();
+        return this.nodeAdapter.isStatement();
     }
 }
diff --git a/tests/ecore.test.ts b/tests/ecore.test.ts
@@ -14,6 +14,7 @@ import ECore from "ecore/dist/ecore";
 import * as fs from "fs";
 import {KOLASU_URI_V1} from "../src/interop/kolasu-v1-metamodel";
 import {THE_POSITION_ECLASS, THE_AST_RESOURCE} from "../src/interop/kolasu-v1-metamodel";
+import {STARLASU_URI_V2} from "../src/interop/starlasu-v2-metamodel";
 
 describe('Metamodel', function() {
     it("Base metamodel", function () {
@@ -141,6 +142,19 @@ describe("Import/export", function () {
             // console.log(string);
         });
     });
+    it("fails on unknown eClass", function () {
+        const resourceSet = ECore.ResourceSet.create();
+        const resource = resourceSet.create({ uri: 'file:dummy.json' });
+        expect(() => loadEObject({ eClass: "DoesNotExist" }, resource)).to.throw(
+            Error, "Unsupported class name: DoesNotExist"
+        );
+        expect(() => loadEObject({ eClass: "unknown.pkg#DoesNotExist" }, resource)).to.throw(
+            Error, "Package not found: unknown.pkg while loading class unknown.pkg#DoesNotExist"
+        );
+        expect(() => loadEObject({ eClass: `${STARLASU_URI_V2}#DoesNotExist` }, resource)).to.throw(
+            Error, "Unknown EClass: https://strumenta.com/starlasu/v2#DoesNotExist"
+        );
+    });
     it("importing using API", function () {
         const resourceSet = ECore.ResourceSet.create();
         const resource = resourceSet.create({ uri: 'file:data/sas.metamodel.json' });
diff --git a/tests/interop/lionweb.test.ts b/tests/interop/lionweb.test.ts
@@ -105,18 +105,20 @@ describe('Lionweb integration', function() {
             const root = nodes[0];
             expect(root.node).to.be.instanceof(LionwebNode);
             let dir = new ParserNode(root.node as LionwebNode, undefined, new ParserTrace(PARSER_TRACE_ECLASS.create({}))); // TODO
+            expect(dir.getRole()).to.be.undefined;
             expect(dir.nodeDefinition.name).to.equal("Directory");
             expect(dir.getAttribute("name")).to.equal("resources.zip");
             expect(dir.getChildren("files").length).to.equal(1);
             dir = dir.getChildren("files")[0];
             expect(dir.nodeDefinition.name).to.equal("Directory");
             expect(dir.getAttribute("name")).to.equal("resources");
             expect(dir.getChildren("files").length).to.equal(15);
-            const file = dir.getChildren("files")[0];
+            const file = dir.getChildren("files")[1];
             expect(file.nodeDefinition.name).to.equal("TextFile");
-            expect(file.getAttribute("name")).to.equal("delegate.egl");
-            expect(file.getAttribute("contents").substring(0, 10)).to.equal("Delegate F");
-            expect(file.getPathFromRoot()).to.equal([]);
+            expect(file.getAttribute("name")).to.equal("rosetta-code-count-examples-2.egl");
+            expect(file.getAttribute("contents").substring(0, 10)).to.equal("package co");
+            expect(file.getRole()).to.equal("files");
+            expect(file.getPathFromRoot()).to.eql(["files", 0, "files", 1]);
 
             expect(printSequence(walk(root.node))).to.equal(
                 "resources.zip, resources, delegate.egl, rosetta-code-count-examples-2.egl, " +

Original file line number	Diff line number	Diff line change
`@@ -552,7 +552,7 @@ class ReferencesTracker {`
`552`	`552`	`}`
`553`	`553`	`}`
`554`	`554`
`555`		`- getReferredObject(uri: string) {`
	`555`	`+ getReferredObject(uri?: string) {`
`556`	`556`	`if (uri === undefined) {`
`557`	`557`	`return undefined;`
`558`	`558`	`}`
`@@ -621,7 +621,7 @@ export function findEClass(name: string, resource: ECore.Resource): ECore.EClass`
`621`	`621`	`const packageName = name.substring(0, index);`
`622`	`622`	`const ePackage = ECore.EPackage.Registry.getEPackage(packageName);`
`623`	`623`	`if(!ePackage) {`
`624`		`- throw new Error("Package not found: " + packageName+ " while loading for class " + name);`
	`624`	`+ throw new Error("Package not found: " + packageName + " while loading class " + name);`
`625`	`625`	`}`
`626`	`626`	`const className = name.substring(name.lastIndexOf("/") + 1);`
`627`	`627`	`if (ePackage.get("nsURI") == KOLASU_URI_V1) {`
Original file line number	Diff line number	Diff line change
`@@ -165,10 +165,6 @@ export class LionwebNode extends NodeAdapter {`
`165`	`165`	`return undefined;`
`166`	`166`	`}`
`167`	`167`
`168`		`- getRole(): string \| undefined {`
`169`		`- return undefined;`
`170`		`- }`
`171`		`-`
`172`	`168`	`isDeclaration(): boolean {`
`173`	`169`	`return false;`
`174`	`170`	`}`
`@@ -180,4 +176,8 @@ export class LionwebNode extends NodeAdapter {`
`180`	`176`	`isStatement(): boolean {`
`181`	`177`	`return false;`
`182`	`178`	`}`
	`179`	`+`
	`180`	`+ equals(other: NodeAdapter \| undefined): boolean {`
	`181`	`+ return other instanceof LionwebNode && other.lwnode == this.lwnode;`
	`182`	`+ }`
`183`	`183`	`}`
Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ export class ParserNode extends TraceNode {`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`getChildren(role?: string): ParserNode[] {`
`95`		`- return this.wrappedNode.getChildren(role).map((c) => new ParserNode(c, this, this.trace));`
	`95`	`+ return this.nodeAdapter.getChildren(role).map((c) => new ParserNode(c, this, this.trace));`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`get children(): Node[] {`
`@@ -165,7 +165,7 @@ abstract class AbstractTranspilationTrace {`
`165`	`165`	`protected constructor(protected wrappedNode: NodeAdapter) {}`
`166`	`166`
`167`	`167`	`getDestinationNodes(sourceNode: SourceNode): TargetNode[] {`
`168`		`- return this.sourceToTarget.get(sourceNode.wrappedNode.getId()) \|\| [];`
	`168`	`+ return this.sourceToTarget.get(sourceNode.nodeAdapter.getId()) \|\| [];`
`169`	`169`	`}`
`170`	`170`
`171`	`171`	`protected examineTargetNode(`
`@@ -294,7 +294,7 @@ export class SourceNode extends TraceNode {`
`294`	`294`	`}`
`295`	`295`
`296`	`296`	`getChildren(role?: string): SourceNode[] {`
`297`		`- return this.wrappedNode.getChildren(role).map((c) => new SourceNode(c, this.trace, this.file).withParent(this));`
	`297`	`+ return this.nodeAdapter.getChildren(role).map((c) => new SourceNode(c, this.trace, this.file).withParent(this));`
`298`	`298`	`}`
`299`	`299`
`300`	`300`	`get children(): Node[] {`
`@@ -313,7 +313,7 @@ export class TargetNode extends TraceNode {`
`313`	`313`	`}`
`314`	`314`
`315`	`315`	`getPosition(): Position \| undefined {`
`316`		`- return this.wrappedNode.getPosition("destination");`
	`316`	`+ return this.nodeAdapter.getPosition("destination");`
`317`	`317`	`}`
`318`	`318`
`319`	`319`	`getDestination(): Position \| undefined {`
`@@ -327,8 +327,8 @@ export class TargetNode extends TraceNode {`
`327`	`327`	`getSourceNode(): SourceNode \| undefined {`
`328`	`328`	`if (!this.origin) {`
`329`	`329`	`// TODO`
`330`		`- if (this.wrappedNode instanceof ECoreNode) {`
`331`		`- let rawOrigin = this.wrappedNode.eo.get("origin");`
	`330`	`+ if (this.nodeAdapter instanceof ECoreNode) {`
	`331`	`+ let rawOrigin = this.nodeAdapter.eo.get("origin");`
`332`	`332`	`if (rawOrigin?.eClass == THE_NODE_ORIGIN_ECLASS) {`
`333`	`333`	`rawOrigin = rawOrigin.get("node");`
`334`	`334`	`}`
`@@ -352,7 +352,7 @@ export class TargetNode extends TraceNode {`
`352`	`352`	`}`
`353`	`353`
`354`	`354`	`getChildren(role?: string): TargetNode[] {`
`355`		`- return this.wrappedNode.getChildren(role).map((c) => new TargetNode(c, this.trace, this.file));`
	`355`	`+ return this.nodeAdapter.getChildren(role).map((c) => new TargetNode(c, this.trace, this.file));`
`356`	`356`	`}`
`357`	`357`
`358`	`358`	`get children(): Node[] {`
Original file line number	Diff line number	Diff line change
`@@ -20,15 +20,33 @@ export abstract class NodeAdapter extends Node {`
`20`	`20`
`21`	`21`	`abstract getPosition(property?: string): Position \| undefined;`
`22`	`22`
`23`		`- abstract getRole(): string \| undefined;`
	`23`	`+ getRole(): string \| symbol \| undefined {`
	`24`	`+ if (this.parent) { // Inefficient default implementation, searching in the parent's children`
	`25`	`+ const props = this.parent.nodeDefinition?.properties \|\| {};`
	`26`	`+ for (const p in props) {`
	`27`	`+ const prop = props[p];`
	`28`	`+ if (prop.child) {`
	`29`	`+ if (prop.multiple) {`
	`30`	`+ if (this.parent.getChildren(prop.name)?.find(c => c.equals(this))) {`
	`31`	`+ return prop.name;`
	`32`	`+ }`
	`33`	`+ } else if (this.equals(this.parent.getChild(prop.name) as NodeAdapter)) {`
	`34`	`+ return prop.name;`
	`35`	`+ }`
	`36`	`+ }`
	`37`	`+ }`
	`38`	`+ } else {`
	`39`	`+ return undefined;`
	`40`	`+ }`
	`41`	`+ }`
`24`	`42`
`25`	`43`	`abstract isDeclaration(): boolean;`
`26`	`44`
`27`	`45`	`abstract isExpression(): boolean;`
`28`	`46`
`29`	`47`	`abstract isStatement(): boolean;`
`30`	`48`
`31`		`- equals(other: NodeAdapter) {`
	`49`	`+ equals(other: NodeAdapter \| undefined) {`
`32`	`50`	`return other == this;`
`33`	`51`	`}`
`34`	`52`	`}`
`@@ -84,10 +102,6 @@ export class AugmentedNode extends NodeAdapter {`
`84`	`102`	`return this.node.position;`
`85`	`103`	`}`
`86`	`104`
`87`		`- getRole(): string \| undefined {`
`88`		`- return undefined;`
`89`		`- }`
`90`		`-`
`91`	`105`	`isDeclaration(): boolean {`
`92`	`106`	`return false;`
`93`	`107`	`}`
`@@ -99,13 +113,17 @@ export class AugmentedNode extends NodeAdapter {`
`99`	`113`	`isStatement(): boolean {`
`100`	`114`	`return false;`
`101`	`115`	`}`
	`116`	`+`
	`117`	`+ equals(other: NodeAdapter \| undefined): boolean {`
	`118`	`+ return other instanceof AugmentedNode && this.node == other.node;`
	`119`	`+ }`
`102`	`120`	`}`
`103`	`121`
`104`	`122`	`export abstract class TraceNode extends Node {`
`105`	`123`
`106`	`124`	`abstract parent?: TraceNode;`
`107`	`125`
`108`		`- protected constructor(public wrappedNode: NodeAdapter) {`
	`126`	`+ protected constructor(public nodeAdapter: NodeAdapter) {`
`109`	`127`	`super();`
`110`	`128`	`}`
`111`	`129`
`@@ -121,28 +139,28 @@ export abstract class TraceNode extends Node {`
`121`	`139`	`return this.nodeDefinition.name!;`
`122`	`140`	`}`
`123`	`141`
`124`		`- getRole(): string \| undefined {`
`125`		`- return this.wrappedNode.getRole();`
	`142`	`+ getRole(): string \| symbol \| undefined {`
	`143`	`+ return this.nodeAdapter.getRole();`
`126`	`144`	`}`
`127`	`145`
`128`	`146`	`getPosition(): Position \| undefined {`
`129`		`- return this.wrappedNode.getPosition();`
	`147`	`+ return this.nodeAdapter.getPosition();`
`130`	`148`	`}`
`131`	`149`
`132`	`150`	`get position(): Position \| undefined {`
`133`	`151`	`return this.getPosition();`
`134`	`152`	`}`
`135`	`153`
`136`	`154`	`get nodeDefinition(): NodeDefinition {`
`137`		`- return this.wrappedNode.nodeDefinition;`
	`155`	`+ return this.nodeAdapter.nodeDefinition;`
`138`	`156`	`}`
`139`	`157`
`140`	`158`	`getAttributes(): { [name: string]: any } {`
`141`		`- return this.wrappedNode.getAttributes();`
	`159`	`+ return this.nodeAdapter.getAttributes();`
`142`	`160`	`}`
`143`	`161`
`144`	`162`	`doGetAttribute(attrName: string): any {`
`145`		`- return this.wrappedNode.getAttribute(attrName);`
	`163`	`+ return this.nodeAdapter.getAttribute(attrName);`
`146`	`164`	`}`
`147`	`165`
`148`	`166`	`getPathFromRoot(): (string \| number)[] {`
`@@ -167,18 +185,18 @@ export abstract class TraceNode extends Node {`
`167`	`185`	`}`
`168`	`186`
`169`	`187`	`equals(node: TraceNode) {`
`170`		`- return node === this \|\| node.wrappedNode.equals(this.wrappedNode);`
	`188`	`+ return node === this \|\| node.nodeAdapter.equals(this.nodeAdapter);`
`171`	`189`	`}`
`172`	`190`
`173`	`191`	`isDeclaration(): boolean {`
`174`		`- return this.wrappedNode.isDeclaration();`
	`192`	`+ return this.nodeAdapter.isDeclaration();`
`175`	`193`	`}`
`176`	`194`
`177`	`195`	`isExpression(): boolean {`
`178`		`- return this.wrappedNode.isExpression();`
	`196`	`+ return this.nodeAdapter.isExpression();`
`179`	`197`	`}`
`180`	`198`
`181`	`199`	`isStatement(): boolean {`
`182`		`- return this.wrappedNode.isStatement();`
	`200`	`+ return this.nodeAdapter.isStatement();`
`183`	`201`	`}`
`184`	`202`	`}`