Handling of references in ECore TraceNodes and Nodes in general #61

Author: alessiostalla

CHANGELOG.md

@@ -2,6 +2,20 @@
 All notable changes to this project from version 1.2.0 upwards are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## [1.6.13] – 2024-03-14
+
+### Added
+- `Node.getReference` method as in Kolasu
+
+### Changed
+- Renamed `Node.getAttribute` to `getAttributeValue` in accordance with Kolasu
+
+### Fixed
+- Proper handling of references in ECore
+
+### Removed
+- The `ParserNode` class, replaced by its superclass `TraceNode` that's now a concrete class.
+
 ## [1.6.12] – 2024-03-07
 
 ### Added

package.json

@@ -3,7 +3,7 @@
 	"description": "AST building blocks for TypeScript/JavaScript, part of the *lasu family, with optional integrations with ANTLR4 and Ecore.",
 	"author": "Strumenta s.r.l.",
 	"publisher": "strumenta",
-	"version": "1.6.12",
+	"version": "1.6.13",
 	"license": "Apache-2.0",
 	"keywords": [
 		"antlr",
@@ -82,7 +82,7 @@
 		"reflect-metadata": "^0.1.13"
 	},
 	"peerDependencies": {
-		"@lionweb/core": "^0.6.1",
+		"@lionweb/core": "^0.6.2",
 		"antlr4ng": "^2.0.3",
 		"cmd-ts": "^0.11.0",
 		"ecore": "^0.12.0"

src/interop/ecore.ts

@@ -42,6 +42,7 @@ import {KOLASU_URI_V1, THE_NODE_ECLASS as THE_NODE_ECLASS_V1} from "./kolasu-v1-
 import {EBigDecimal, EBigInteger} from "./ecore-patching";
 import {NodeAdapter} from "../trace/trace-node";
 import {EClassifier} from "ecore";
+import {PossiblyNamed, ReferenceByName} from "../model/naming";
 
 export * as starlasu_v2 from "./starlasu-v2-metamodel";
 export * as kolasu_v1 from "./kolasu-v1-metamodel";
@@ -518,7 +519,7 @@ export function loadEPackages(data: any, resource: ECore.Resource): ECore.EPacka
 }
 
 interface PostponedReference {
-    eObject: ECore.EObject, feature: any, refValue: any
+    eObject: ECore.EObject, feature: any, refName: string | undefined, refValue: any
 }
 
 /**
@@ -530,19 +531,24 @@ class ReferencesTracker {
     constructor(public resource: ECore.Resource) {
     }
 
-    trackReference(eObject: ECore.EObject, feature: any, refValue: any) : void {
-        this.postponedReferences.push({eObject, feature, refValue});
+    trackReference(eObject: ECore.EObject, feature: any, refName: string | undefined, refValue: any) : void {
+        this.postponedReferences.push({eObject, feature, refName: refName, refValue});
     }
 
     resolveAllReferences() : void {
-        this.postponedReferences.forEach((pr)=>{
+        this.postponedReferences.forEach((pr)=> {
             this.resolveReference(pr);
         });
         this.postponedReferences = [];
     }
 
     resolveReference(pr: PostponedReference) {
-        if (pr.feature.get('upperBound') !== 1) {
+        if (pr.refName) {
+            pr.eObject.set(pr.feature, THE_REFERENCE_BY_NAME_ECLASS.create({
+                name: pr.refName,
+                referenced: pr.refValue ? this.getReferredObject(pr.refValue["$ref"]) : undefined
+            }));
+        } else if (pr.feature.get('upperBound') !== 1) {
             const list = pr.eObject.get(pr.feature);
             pr.refValue.forEach(ref => {
                 list.add(this.getReferredObject(ref.$ref));
@@ -770,20 +776,15 @@ function importJsonObject(
                         if (eGenericType) {
                             eType = eGenericType.get("eClassifier");
                             if (eType == THE_REFERENCE_BY_NAME_ECLASS) {
-                                //eType = eGenericType.get("eTypeArguments").at(0).get("eClassifier");
-                                const refValue = obj[key].referenced;
-                                if (refValue) {
-                                    referencesTracker.trackReference(eObject, feature, refValue);
-                                }
+                                referencesTracker.trackReference(eObject, feature, obj[key].name, obj[key].referenced);
                                 continue;
                             }
                         }
                     }
                     if (feature.get("containment") === true) {
                         setChild(feature, obj, key, eObject, resource, eType, strict, referencesTracker, eClass);
                     } else if (feature.isKindOf(ECore.EReference)) {
-                        const refValue = obj[key];
-                        referencesTracker.trackReference(eObject, feature, refValue);
+                        referencesTracker.trackReference(eObject, feature, undefined, obj[key]);
                     } else {
                         throw featureError("The feature is neither a containment nor a reference", key, eClass, resource);
                     }
@@ -824,7 +825,7 @@ export interface EcoreMetamodelSupport {
     generateMetamodel(resource: ECore.Resource, includingKolasuMetamodel: boolean): void;
 }
 
-export class ECoreNode extends NodeAdapter {
+export class ECoreNode extends NodeAdapter implements PossiblyNamed {
 
     parent?: ECoreNode;
 
@@ -838,6 +839,10 @@ export class ECoreNode extends NodeAdapter {
         }
     }
 
+    get name(): string | undefined {
+        return this.getAttributeValue("name");
+    }
+
     private _nodeDefinition?: NodeDefinition;
 
     get nodeDefinition() {
@@ -863,7 +868,7 @@ export class ECoreNode extends NodeAdapter {
         }
     }
 
-    getAttribute(name: string): any {
+    getAttributeValue(name: string): any {
         return this.eo.get(name);
     }
 
@@ -885,6 +890,36 @@ export class ECoreNode extends NodeAdapter {
         return this._children!.filter(c => !role || c.getRole() == role);
     }
 
+    protected doGetChildOrChildren(name: string | symbol): ECoreNode | ECoreNode[] | undefined {
+        const containment = this.containment(name);
+        const children = this.getChildren(name.toString());
+        if (!containment?.multiple) {
+            if (children) {
+                return children[0];
+            } else {
+                return undefined;
+            }
+        } else {
+            return children;
+        }
+    }
+
+    getReference(name: string | symbol): ReferenceByName<ECoreNode> | undefined {
+        const ref = this.eo.get(name.toString());
+        if (ref) {
+            if (ref.isKindOf(THE_REFERENCE_BY_NAME_ECLASS)) {
+                const referred = ref.get("referenced");
+                return new ReferenceByName<any>(ref.get("name"), referred ? new ECoreNode(referred) : undefined);
+            } else {
+                const error = new Error(`Not a reference: ${name.toString()}`) as any;
+                error.object = ref;
+                throw error;
+            }
+        } else {
+            return undefined;
+        }
+    }
+
     getId(): string {
         return this.eo.fragment();
     }

src/interop/lionweb.ts

@@ -89,7 +89,7 @@ export class TylasuInstantiationFacade implements InstantiationFacade<TylasuNode
                 node.node.setChild(feature.name, (value as TylasuNodeWrapper)?.node);
             }
         } else {
-            node.node.setAttribute(feature.name, value);
+            node.node.setAttributeValue(feature.name, value);
         }
     }
 }
@@ -166,7 +166,7 @@ export class LionwebNode extends NodeAdapter {
         const attributes = {};
         for (const p in this.nodeDefinition.properties) {
             if (!this.nodeDefinition.properties[p].child) {
-                attributes[p] = this.getAttribute(p);
+                attributes[p] = this.getAttributeValue(p);
             }
         }
         return attributes;

src/interop/strumenta-playground.ts

@@ -68,7 +68,7 @@ export class ParserTrace {
     }
 
     get name(): string | undefined {
-        return this.node.getAttribute("name");
+        return this.node.getAttributeValue("name");
     }
 }
 
@@ -178,7 +178,7 @@ export class TranspilationTrace extends AbstractTranspilationTrace {
     }
 
     get name(): string | undefined {
-        return this.wrappedNode.getAttribute("name");
+        return this.wrappedNode.getAttributeValue("name");
     }
 }
 
@@ -206,19 +206,19 @@ export class WorkspaceTranspilationTrace extends AbstractTranspilationTrace {
     }
 
     get name(): string | undefined {
-        return this.wrappedNode.getAttribute("name");
+        return this.wrappedNode.getAttributeValue("name");
     }
 }
 
 abstract class AbstractWorkspaceFile<N> {
     protected constructor(protected wrappedNode: NodeAdapter, protected trace: AbstractTranspilationTrace) {}
 
     get path(): string {
-        return this.wrappedNode.getAttribute("path");
+        return this.wrappedNode.getAttributeValue("path");
     }
 
     get code(): string {
-        return this.wrappedNode.getAttribute("code");
+        return this.wrappedNode.getAttributeValue("code");
     }
 
     get issues(): Issue[] {

src/model/model.ts

@@ -1,5 +1,6 @@
 import {Position} from "./position";
 import "reflect-metadata";
+import {ReferenceByName} from "./naming";
 
 export const NODE_DEFINITION_SYMBOL = Symbol("nodeDefinition");
 
@@ -163,7 +164,7 @@ export abstract class Node extends Origin implements Destination {
         return Object.getOwnPropertyNames(props).map(p => {
             const value = props[p].child ?
                 (props[p].multiple ? this.getChildren(p) : this.getChild(p)) :
-                this.getAttribute(p);
+                this.getAttributeValue(p);
             return { name: p, value };
         });
     }
@@ -270,42 +271,46 @@ export abstract class Node extends Origin implements Destination {
         }
     }
 
-    getAttribute(name: string | symbol): any {
+    getAttributeValue(name: string | symbol): any {
         const props = this.nodeDefinition?.properties || {};
         const prop = props[name];
         if(prop) {
             if (prop.child) {
                 throw new Error(name.toString() + " is a containment, please use getChild");
             } else {
-                return this.doGetAttribute(name);
+                return this.doGetAttributeValue(name);
             }
         } else {
             throw new Error(`${name.toString()} is not a feature of ${this} (${this.nodeDefinition}).`);
         }
     }
 
-    setAttribute(name: string | symbol, value: any) {
+    setAttributeValue(name: string | symbol, value: any) {
         const props = this.nodeDefinition?.properties || {};
         const prop = props[name];
         if(prop) {
             if (prop.child) {
                 throw new Error(name.toString() + " is a containment, please use setChild/addChild");
             } else {
-                this.doSetAttribute(name, value);
+                this.doSetAttributeValue(name, value);
             }
         } else {
             throw new Error(`${name.toString()} is not a feature of ${this} (${this.nodeDefinition}).`);
         }
     }
 
-    protected doSetAttribute(name: string | symbol, value: any) {
+    protected doSetAttributeValue(name: string | symbol, value: any) {
         this[name] = value;
     }
 
-    protected doGetAttribute(name: string | symbol) {
+    protected doGetAttributeValue(name: string | symbol) {
         return this[name];
     }
 
+    getReference(name: string | symbol): ReferenceByName<any> | undefined {
+        return this[name] as ReferenceByName<any>;
+    }
+
     withParent(parent?: Node): this {
         this.parent = parent;
         return this;