Information about references in node metadata, bump version

Author: alessiostalla

CHANGELOG.md

@@ -2,6 +2,11 @@
 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.15] – 2024-03-21
+
+### Added
+- Information about references in node metadata
+
 ## [1.6.14] – 2024-03-21
 
 ### Fixed

jest.config.js

@@ -88,7 +88,7 @@ const config = {
   ],
   globals: {
     "ts-jest": {
-      tsConfig: `tests/tsconfig.json`
+      tsconfig: `tests/tsconfig.json`
     }
   }
 };

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.14",
+	"version": "1.6.15",
 	"license": "Apache-2.0",
 	"keywords": [
 		"antlr",

src/index.ts

@@ -13,4 +13,5 @@ export * from "./traversing/by-position";
 export * from "./transformation/transformation";
 export * from "./validation";
 export * from "./interop/json";
+export * from "./interop/indexing";
 export * from "./trace/trace-node";

src/interop/ecore.ts

@@ -11,7 +11,7 @@ import {
     PackageDescription,
     PropertyDefinition,
     registerNodeDefinition,
-    registerNodeProperty
+    registerNodeAttribute
 } from "../model/model";
 import ECore from "ecore/dist/ecore";
 import {Point, Position} from "../model/position";
@@ -469,7 +469,7 @@ export class ${className} extends ${superClassName} {`;
         eClass.get("eStructuralFeatures").each(a => {
             const name = a.get("name");
             defineProperty(classDef, name);
-            const prop = registerNodeProperty(classDef as any, name);
+            const prop = registerNodeAttribute(classDef as any, name);
             prop.child = a.isTypeOf('EReference');
             const annotation = prop.child ? (prop.multiple ? "@Children()" : "@Child()") : "@Property()"
             classDef[SYMBOL_CLASS_DEFINITION] += `\n\t${annotation}\n\t${name};`;

src/model/model.ts

@@ -1,6 +1,6 @@
 import {Position} from "./position";
 import "reflect-metadata";
-import {ReferenceByName} from "./naming";
+import {PossiblyNamed, ReferenceByName} from "./naming";
 
 export const NODE_DEFINITION_SYMBOL = Symbol("nodeDefinition");
 
@@ -24,6 +24,7 @@ export type PropertyDefinition = {
     child?: boolean,
     multiple?: boolean,
     inherited?: boolean,
+    reference?: boolean,
     type?: any,
     arrayType?: any
 }
@@ -163,8 +164,8 @@ export abstract class Node extends Origin implements Destination {
         const props = this.nodeDefinition?.properties || {};
         return Object.getOwnPropertyNames(props).map(p => {
             const value = props[p].child ?
-                (props[p].multiple ? this.getChildren(p) : this.getChild(p)) :
-                this.getAttributeValue(p);
+                (props[p].multiple  ? this.getChildren(p)  : this.getChild(p)) :
+                (props[p].reference ? this.getReference(p) : this.getAttributeValue(p));
             return { name: p, value };
         });
     }
@@ -278,7 +279,11 @@ export abstract class Node extends Origin implements Destination {
             if (prop.child) {
                 throw new Error(name.toString() + " is a containment, please use getChild");
             } else {
-                return this.doGetAttributeValue(name);
+                const attributeValue = this.doGetAttributeValue(name);
+                if (attributeValue instanceof ReferenceByName) {
+                    throw new Error(name.toString() + " is a reference, please use getReference");
+                }
+                return attributeValue;
             }
         } else {
             throw new Error(`${name.toString()} is not a feature of ${this} (${this.nodeDefinition}).`);
@@ -308,7 +313,11 @@ export abstract class Node extends Origin implements Destination {
     }
 
     getReference(name: string | symbol): ReferenceByName<any> | undefined {
-        return this[name] as ReferenceByName<any>;
+        return this.doGetReference(name) as ReferenceByName<any>;
+    }
+
+    protected doGetReference(name: string | symbol) {
+        return this[name];
     }
 
     withParent(parent?: Node): this {
@@ -434,7 +443,7 @@ export function ensureNodeDefinition(node: Node | { new (...args: any[]): Node }
     return definition;
 }
 
-export function registerNodeProperty<T extends Node>(
+export function registerNodeAttribute<T extends Node>(
     type: { new(...args: any[]): T }, methodName: string | symbol
 ): PropertyDefinition {
     if (methodName == "parent" || methodName == "children" || methodName == "origin") {
@@ -451,12 +460,19 @@ export function registerNodeProperty<T extends Node>(
 
 export function registerNodeChild<T extends Node>(
     type: new (...args: any[]) => T, methodName: string, multiple: boolean = false): PropertyDefinition {
-    const propInfo = registerNodeProperty(type, methodName);
+    const propInfo = registerNodeAttribute(type, methodName);
     propInfo.child = true;
     propInfo.multiple = multiple;
     return propInfo;
 }
 
+export function registerNodeReference<T extends Node & PossiblyNamed>(
+    type: new (...args: any[]) => T, methodName: string): PropertyDefinition {
+    const propInfo = registerNodeAttribute(type, methodName);
+    propInfo.reference = true;
+    return propInfo;
+}
+
 //------------//
 // Decorators //
 //------------//
@@ -485,9 +501,30 @@ export function Children(): (target, methodName: string) => void {
     };
 }
 
-
+/**
+ * Declares the decorated property as an attribute.
+ * @deprecated use Attribute instead.
+ */
 export function Property(): (target, methodName: string) => void {
     return function (target, methodName: string) {
-        registerNodeProperty(target, methodName);
+        registerNodeAttribute(target, methodName);
+    };
+}
+
+/**
+ * Declares the decorated property as an attribute.
+ */
+export function Attribute(): (target, methodName: string) => void {
+    return function (target, methodName: string) {
+        registerNodeAttribute(target, methodName);
+    };
+}
+
+/**
+ * Declares the decorated property as a reference.
+ */
+export function Reference(): (target, methodName: string) => void {
+    return function (target, methodName: string) {
+        registerNodeReference(target, methodName);
     };
 }

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

@@ -126,6 +126,7 @@ describe('Workspace Transpilation traces', function() {
             expect(refTarget?.getRole()).to.equal("dataDefinitions");
             expect(refTarget?.getPathFromRoot()).to.eql(["dataDefinitions", 3]);
             expect(refTarget?.getRoot()).to.equal(sourceRoot);
+            expect(refExpr.getAttributes()["dataDefinition"]).to.be.undefined;
 
             // TODO broken expect(cus300File.node.getChildren("dataDefinition").length).to.eql(4)
             expect(sourceRoot.getChildren("mainStatements").length).to.eql(9)

tests/json.test.ts

@@ -1,8 +1,7 @@
 import {expect} from "chai";
 
-import {ASTNode, Child, Children, GenericNode, Node, PossiblyNamed, Property, ReferenceByName} from "../src";
-import {JSONGenerator} from "../src";
-import {Indexer} from "../src/interop/indexing";
+import {ASTNode, Child, Children, GenericNode, Node, PossiblyNamed, Reference, ReferenceByName} from "../src";
+import {Indexer, JSONGenerator} from "../src";
 
 describe('JSON generator', function() {
     it("Empty AST",
@@ -199,21 +198,18 @@ class DummyNamedNode extends Node implements PossiblyNamed {
 
 @ASTNode("", "NodeWithReference")
 class NodeWithReference extends Node implements PossiblyNamed {
-    constructor(
-        public name?: string,
-        public reference?: ReferenceByName<DummyNamedNode>) {
+    constructor(public name?: string, public reference?: ReferenceByName<DummyNamedNode>) {
         super();
     }
+
     @Child() namedNode?: DummyNamedNode;
 }
 
 @ASTNode("", "NodeWithSelfReference")
 class NodeWithSelfReference extends Node implements PossiblyNamed {
-    @Property() public reference?: ReferenceByName<NodeWithSelfReference>;
+    @Reference() public reference?: ReferenceByName<NodeWithSelfReference>;
 
-    constructor(
-        public name?: string,
-        reference?: ReferenceByName<NodeWithSelfReference>) {
+    constructor(public name?: string, reference?: ReferenceByName<NodeWithSelfReference>) {
         super();
         this.reference = reference;
     }

tests/metamodel.test.ts

@@ -1,9 +1,9 @@
 import {expect} from "chai";
 
 import {getNodeDefinition, NODE_TYPES} from "../src";
-import {SomeNode, SomeNodeInPackage} from "./nodes";
+import {SomeNode, SomeNodeInPackage, SomeNodeWithReferences} from "./nodes";
 
-describe('Meta model', function() {
+describe('Meta model', function () {
     it("info recorded in the default package",
         function () {
             expect(NODE_TYPES[""]).not.to.be.undefined;
@@ -27,4 +27,11 @@ describe('Meta model', function() {
             expect(def!.properties["multi"]).not.to.be.undefined;
             expect(def!.properties["multi"].multiple).to.be.true;
         });
+    it("records references",
+        function () {
+            const def = getNodeDefinition(SomeNodeWithReferences);
+            expect(def).not.to.be.undefined;
+            expect(def!.properties["a"].reference).to.be.undefined;
+            expect(def!.properties["ref"].reference).to.be.true;
+        });
 });

tests/nodes.ts

@@ -1,4 +1,15 @@
-import {ASTNode, Child, Children, ErrorNode, Node, Position, Property} from "../src";
+import {
+    ASTNode,
+    Attribute,
+    Child,
+    Children,
+    ErrorNode,
+    Node,
+    Position,
+    PossiblyNamed,
+    Reference,
+    ReferenceByName
+} from "../src";
 
 export class Box extends Node {
     @Children()
@@ -25,21 +36,25 @@ export enum Fibo {
 }
 
 @ASTNode("", "SomeNode")
-export class SomeNode extends Node {
-    @Property()
+export class SomeNode extends Node implements PossiblyNamed {
+    @Attribute()
     a?: string;
-    @Property()
+    @Attribute()
     fib: Fibo
 
     constructor(a?: string, positionOverride?: Position) {
         super(positionOverride);
         this.a = a;
     }
+
+    get name(): string | undefined {
+        return this.a;
+    }
 }
 
 @ASTNode("some.package", "SomeNodeInPackage")
 export class SomeNodeInPackage extends Node {
-    @Property()
+    @Attribute()
     a?: string;
     @Child()
     someNode: SomeNode;
@@ -54,7 +69,7 @@ export class SomeNodeInPackage extends Node {
 
 @ASTNode("some.package", "NodeSubclass")
 export class NodeSubclass extends SomeNodeInPackage {
-    @Property()
+    @Attribute()
     b: string;
     @Child()
     anotherChild: SomeNodeInPackage;
@@ -68,3 +83,16 @@ export class NodeWithError extends SomeNodeInPackage {
 
 @ASTNode("another.package", "SomeNodeInPackage")
 export class SomeNodeInAnotherPackage extends Node {}
+
+@ASTNode("", "SomeNodeWithReferences")
+export class SomeNodeWithReferences extends Node {
+    @Attribute()
+    a?: string;
+    @Reference()
+    ref: ReferenceByName<SomeNode> = new ReferenceByName<SomeNode>("a")
+
+    constructor(a?: string, positionOverride?: Position) {
+        super(positionOverride);
+        this.a = a;
+    }
+}